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) ist ein leistungsstarker Zweig des maschinellen Lernens, der sich auf das Training intelligenter Agenten durch Interaktion mit ihrer Umgebung konzentriert. In diesem Kurs lernen Sie, wie Agenten durch Versuch und Irrtum schrittweise effektive Verhaltensweisen entdecken. Beginnend mit grundlegenden Konzepten wie Markov-Entscheidungsprozessen und Multi-Armed Bandits arbeiten Sie sich durch dynamische Programmierung, Monte-Carlo-Methoden und Temporal-Difference-Lernen.

Erfahren Sie, wie Agenten durch Versuch und Irrtum optimale Entscheidungen treffen. Erkunden Sie die Grundlagen der Theorie des Reinforcement Learning. Praktische Erfahrung mit der Einrichtung und Ausführung einer Gymnasium-Umgebung.

Beherrschung des Erkundungs-Ausnutzungs-Dilemmas anhand des Multi-Armed-Bandit-Problems. Implementierung von Aktionswertschätzung, ε-gierigen, Upper-Confidence-Bound- und Gradient-Bandit-Methoden. Bewertung der Leistungsfähigkeit von Algorithmen bei simulierten Aufgaben zur Belohnungsmaximierung.

Dynamische Programmierung für modellbasiertes RL beherrschen. Entdecken, wie Bellman-Gleichungen zur Bewertung und Verbesserung von Policies eingesetzt werden können. Implementierung von Policy- und Value-Iteration-Algorithmen. Untersuchung der generalisierten Policy-Iteration als theoretische Grundlage für modellfreie Methoden.

Monte-Carlo-Methoden für modellfreies RL beherrschen.
Schätzverfahren für Wertfunktionen und Ableitung optimaler Politiken aus vollständigen Episoden.
Implementierung von On-Policy- und Off-Policy-Monte-Carlo-Kontrollalgorithmen.
Erkundungsstrategien zur Optimierung des modellfreien Lernens entdecken.

Beherrschung des Zeitdifferenzlernens für modellfreies RL. Schätzung von Wertfunktionen aus Teilfolgen mithilfe von TD(0)-Aktualisierungen. Implementierung der On-Policy-SARSA- und Off-Policy-Q-Learning-Algorithmen. Kombination von Monte-Carlo-Methoden und Zeitdifferenzlernen in n-Schritt-TD und TD(λ) entdecken.

Herausforderung: Einrichtung Einer Umgebung

Lösung

Awesome!

Herausforderung: Einrichtung Einer Umgebung

Lösung