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 Markow-Entscheidungsprozessen und Multi-Armed Bandits arbeiten Sie sich durch dynamische Programmierung, Monte-Carlo-Methoden und Temporal-Difference-Lernen.

In diesem Abschnitt werden die grundlegenden Prinzipien des Reinforcement Learning vorgestellt, einschließlich seiner charakteristischen Merkmale, mathematischen Grundlagen und der Art und Weise, wie Agenten durch Interaktion und Rückmeldung lernen. Zudem erfolgt eine praktische Einführung in wichtige Werkzeuge zur Vorbereitung auf die Entwicklung und das Training erster RL-Agenten.

In diesem Abschnitt wird das Multi-Armed-Bandit-Problem behandelt – ein hervorragendes Beispiel zur Veranschaulichung des Dilemmas zwischen Exploration und Exploitation. Es werden Algorithmen vorgestellt und implementiert, die Agenten bei Entscheidungen unter Unsicherheit unterstützen, indem sie die Maximierung der Belohnung mit dem Erfordernis der Exploration ausbalancieren.

Dieser Abschnitt führt die dynamische Programmierung als leistungsstarke Methode zur Lösung von Reinforcement-Learning-Problemen ein, wenn ein vollständiges Modell der Umgebung verfügbar ist. Sie lernen, wie Politiken mithilfe der Bellman-Gleichungen bewertet und verbessert werden, und erkunden zentrale Techniken wie Policy Iteration, Value Iteration und Generalized Policy Iteration – als theoretische Grundlage für zukünftige modellfreie Methoden.

In diesem Abschnitt werden Monte-Carlo-Methoden zur Erlernung von Wertfunktionen und Strategien aus vollständigen Episoden von Erfahrungen vorgestellt. Es werden sowohl On-Policy- als auch Off-Policy-Ansätze behandelt, der Einfluss von Exploration auf das Lernen erläutert und inkrementelle Techniken zur effizienten Schätzung von Erträgen implementiert – alles ohne ein Modell der Umgebung zu benötigen.

Dieser Abschnitt führt in das Temporal-Differenz-(TD)-Lernen ein, eine grundlegende Methode im Reinforcement Learning, die Konzepte aus Monte-Carlo-Methoden und dynamischer Programmierung vereint. Es wird erläutert, wie Wertfunktionen aus unvollständigen Episoden geschätzt werden, sowohl On-Policy- (SARSA) als auch Off-Policy-Ansätze (Q-Learning) behandelt und aufgezeigt, wie Monte-Carlo-Methoden und TD-Lernen kombiniert werden können.

Herausforderung: Einrichtung Einer Umgebung

Lösung

Awesome!

Herausforderung: Einrichtung Einer Umgebung

Lösung

Awesome!