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

Reinforcement Learning (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. Kurset starter med kernebegreber som Markov beslutningsprocesser og multi-armed bandits og fortsætter med dynamisk programmering, Monte Carlo-metoder og temporal difference learning.

Dette afsnit introducerer de grundlæggende principper for reinforcement learning, herunder dets definerende egenskaber, matematiske fundament og hvordan agenter lærer gennem interaktion og feedback. Du får også praktisk erfaring med essentielle værktøjer som forberedelse til at bygge og træne dine første RL-agenter.

Dette afsnit undersøger multi-armet bandit-problemet — en fremragende ramme for at forstå udfordringen mellem udforskning og udnyttelse. Du vil lære om og implementere algoritmer, der hjælper agenter med at træffe beslutninger under usikkerhed, hvor belønningsmaksimering afvejes mod behovet for udforskning.

Dette afsnit introducerer dynamisk programmering som en effektiv metode til at løse forstærkningslæringsproblemer, når en fuldstændig model af miljøet er tilgængelig. Du vil lære at evaluere og forbedre politikker ved hjælp af Bellman-ligninger og udforske centrale teknikker såsom politik-iteration, værdi-iteration og generaliseret politik-iteration — hvilket danner det teoretiske grundlag for fremtidige model-frie metoder.

Dette afsnit introducerer Monte Carlo-metoder til at lære værdifunktioner og politikker ud fra komplette episoder af erfaring. Du vil udforske både on-policy og off-policy tilgange, forstå hvordan udforskning påvirker læring, og implementere inkrementelle teknikker til effektivt at estimere afkast — alt sammen uden behov for en model af miljøet.

Dette afsnit introducerer temporal difference (TD) læring, en grundlæggende metode inden for reinforcement learning, der kombinerer idéer fra Monte Carlo og dynamisk programmering. Du lærer, hvordan man estimerer værdifunktioner ud fra ufuldstændige episoder, udforsker både on-policy (SARSA) og off-policy (Q-learning) tilgange, samt opdager hvordan Monte Carlo-metoder og TD-læring kan kombineres.

Udfordring: Opsætning af et Miljø

Løsning

Awesome!

Udfordring: Opsætning af et Miljø

Løsning

Awesome!