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) is een krachtige tak van machine learning die zich richt op het trainen van intelligente agenten door interactie met hun omgeving. In deze cursus leer je hoe agenten geleidelijk effectieve gedragingen ontdekken via trial-and-error. Beginnend met kernconcepten zoals Markov-beslissingsprocessen en multi-armed bandits, werk je toe naar dynamisch programmeren, Monte Carlo-methoden en temporal difference learning.

Ontdek hoe agenten getraind kunnen worden om optimale beslissingen te nemen via trial-and-error. Verken de essentiële theorie van reinforcement learning. Praktische ervaring met het opzetten en uitvoeren van een Gymnasium-omgeving.

Beheers de afweging tussen exploratie en exploitatie via het multi-armed bandit probleem. Implementeer actie-waarde schatting, ε-greedy, upper confidence bound en gradient-bandit methoden. Evalueer de prestaties van algoritmen op gesimuleerde beloningsmaximalisatie taken.

Beheers dynamisch programmeren voor modelgebaseerde RL. Ontdek hoe Bellman-vergelijkingen kunnen worden gebruikt om beleid te evalueren en te verbeteren. Implementeer algoritmen voor beleid- en waarde-iteratie. Verken gegeneraliseerde beleid-iteratie als de theoretische basis voor modelvrije methoden.

Beheers Monte Carlo-methoden voor modelvrije RL. Waardefuncties schatten en optimale beleidslijnen afleiden uit volledige episodes. Implementatie van on-policy en off-policy Monte Carlo-controle-algoritmen. Ontdek verkenningsstrategieën om modelvrij leren te optimaliseren.

Beheers temporale verschilmethoden voor modelvrije RL. Waarde-functies schatten op basis van gedeeltelijke episodes met behulp van TD(0)-updates. Implementatie van on-policy SARSA- en off-policy Q-Learning-algoritmen. Inzicht in de combinatie van Monte Carlo-methoden en TD-leren in n-staps TD en TD(λ).

Uitdaging: Het Opzetten van een Omgeving

Oplossing

Awesome!

Uitdaging: Het Opzetten van een Omgeving

Oplossing

Awesome!