import unittest
import importlib
import re
import types
import gymnasium as gym
import numpy as np

# Helper function to require a successful test
def _require_success(test_case, condition, failure_message):
  if not condition:
    test_case._testMethodName = failure_message  # Rename the test with a failure description
    test_case.fail()  # Fail the test with a failure message

# Helper function to check if test is successful
def _check_success(test_case, condition, success_message, failure_message):
  if condition:
    test_case._testMethodName = success_message  # Rename the test for better readability in test reports
  else:
    test_case._testMethodName = failure_message  # Rename the test with a failure description
    test_case.fail()  # Fail the test with a failure message

class TestUserCode(unittest.TestCase):
  # Test that gymnasium is imported
  def test_gymnasium_imported(self):
    import user_code
    _require_success(
      self,
      hasattr(user_code, "gym"),
      "`gym` is not declared"
    )
    _check_success(
      self,
      user_code.gym == gym,
      "`gymnasium` is imported",
      "`gym` is declared, but it's not `gymnasium` library"
    )
    
  # Test that environment is created
  def test_env_created(self):
    import user_code
    _require_success(
      self,
      hasattr(user_code, "env"),
      "`env` is not declared"
    )
    _check_success(
      self,
      isinstance(user_code.env, gym.Env),
      "`env` is created",
      "`env` is declared, but it's not a gymnasium environment"
    )

  # Test that environment was reset
  def test_env_reset(self):
    with open("user_code.py", "r") as f:
      user_code_text = f.read()
      _check_success(
        self,
        re.search(r"observation *, *info *= *env *\. *reset *\( *\)", user_code_text),
        "`reset` was called",
        "`reset` was not called"
      )
    
  # Test that step was performed, and values were saved
  def test_step_performed(self):
    import user_code
    _require_success(
      self,
      hasattr(user_code, "observation"),
      "`observation` is not declared"
    )
    _require_success(
      self,
      isinstance(user_code.observation, np.ndarray),
      "`observation` is not saved after step"
    )
    _require_success(
      self,
      hasattr(user_code, "reward"),
      "`reward` is not declared"
    )
    _require_success(
      self,
      isinstance(user_code.reward, float),
      "`reward` is not saved after step"
    )
    _require_success(
      self,
      hasattr(user_code, "terminated"),
      "`terminated` is not declared"
    )
    _require_success(
      self,
      isinstance(user_code.terminated, bool),
      "`terminated` is not saved after step"
    )
    _require_success(
      self,
      hasattr(user_code, "truncated"),
      "`truncated` is not declared"
    )
    _require_success(
      self,
      isinstance(user_code.truncated, bool),
      "`truncated` is not saved after step"
    )
    _require_success(
      self,
      hasattr(user_code, "info"),
      "`info` is not declared"
    )
    _require_success(
      self,
      isinstance(user_code.info, dict),
      "`info` is not saved after step"
    )
    self._testMethodName = "`step` performed successfully"

  # Test that environment was closed
  def test_env_closed(self):
    with open("user_code.py", "r") as f:
      user_code_text = f.read()
      _check_success(
        self,
        re.search(r"env *\. *close *\( *\)", user_code_text),
        "`close` was called",
        "`close` was not called"
      )

# Run the tests when executing the script
if __name__ == '__main__':
  unittest.main()

test_main.py

Forstærkningslæring (RL) er en kraftfuld gren af maskinlæring, der fokuserer på at træne intelligente agenter gennem interaktion med deres omgivelser. I dette kursus lærer du, hvordan agenter gradvist opdager effektive adfærdsmønstre gennem forsøg og fejl. Med udgangspunkt i kernebegreber som Markov beslutningsprocesser og multi-armede banditter, arbejder du dig igennem dynamisk programmering, Monte Carlo-metoder og tidsdifferenslæring.

Opdag, hvordan man træner agenter til at træffe optimale beslutninger gennem trial and error. Udforsk det grundlæggende i reinforcement learning teori. Få praktisk erfaring med opsætning og kørsel af et Gymnasium-miljø.

Behersk udfordringen med udforskning kontra udnyttelse gennem multi-armed bandit-problemet. Implementering af handlingsværdiestimering, ε-grådig, øvre konfidensgrænse og gradient-bandit-metoder. Evaluering af algoritmers ydeevne på simulerede opgaver med belønningsmaksimering.

Behersk dynamisk programmering til modelbaseret RL. Opdag, hvordan Bellman-ligninger kan bruges til at evaluere og forbedre politikker. Implementer algoritmer til politik- og værdiforløb. Udforsk generaliseret politikforløb som det teoretiske grundlag for modelfrie metoder.

Behersk Monte Carlo-metoder til modellfri RL. Estimer værdifunktioner og udled optimale politikker fra fuldstændige episoder. Implementer on-policy og off-policy Monte Carlo-kontrolalgoritmer. Udforsk strategier for udforskning til optimering af modellfri læring.

Behersk temporal difference learning til model-fri RL. Estimer værdifunktioner ud fra delvise episoder ved hjælp af TD(0)-opdateringer. Implementer on-policy SARSA og off-policy Q-Learning algoritmer. Undersøg hvordan Monte Carlo-metoder og TD learning kombineres i n-step TD og TD(λ).

Udfordring: Opsætning af et Miljø

Løsning

Awesome!

Udfordring: Opsætning af et Miljø

Løsning