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 verder door dynamisch programmeren, Monte Carlo-methoden en temporeel verschil leren.

Deze sectie introduceert de kernprincipes van reinforcement learning, met aandacht voor de bepalende kenmerken, wiskundige grondslagen en de manier waarop agenten leren door interactie en feedback. U maakt tevens kennis met essentiële hulpmiddelen ter voorbereiding op het bouwen en trainen van uw eerste RL-agenten.

Deze sectie behandelt het multi-armed bandit probleem — een uitstekend kader om het exploratie-exploitatie dilemma te begrijpen. U leert en implementeert algoritmen die agenten helpen beslissingen te nemen onder onzekerheid, waarbij het maximaliseren van de beloning wordt afgewogen tegen de noodzaak tot exploratie.

Deze sectie introduceert dynamisch programmeren als een krachtige methode voor het oplossen van reinforcement learning-problemen wanneer een volledig model van de omgeving beschikbaar is. U leert hoe u beleidsregels kunt evalueren en verbeteren met behulp van Bellman-vergelijkingen en maakt kennis met kerntechnieken zoals beleiditeratie, waarde-iteratie en gegeneraliseerde beleiditeratie — waarmee de theoretische basis wordt gelegd voor toekomstige modelvrije methoden.

Deze sectie introduceert Monte Carlo-methoden voor het leren van waardefuncties en beleidslijnen op basis van volledige episodes van ervaring. U verkent zowel on-policy als off-policy benaderingen, begrijpt hoe exploratie het leerproces beïnvloedt en implementeert incrementele technieken om rendementen efficiënt te schatten — dit alles zonder een model van de omgeving nodig te hebben.

Deze sectie introduceert temporale verschil (TD) leren, een fundamentele methode in reinforcement learning die ideeën uit Monte Carlo en dynamisch programmeren combineert. U leert hoe waarde-functies kunnen worden geschat op basis van onvolledige episodes, verkent zowel on-policy (SARSA) als off-policy (Q-learning) benaderingen, en ontdekt hoe Monte Carlo-methoden en TD-leren gecombineerd kunnen worden.

Uitdaging: Het Opzetten van een Omgeving

Oplossing

Awesome!

Uitdaging: Het Opzetten van een Omgeving

Oplossing

Awesome!