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

Förstärkningsinlärning (RL) är en kraftfull gren av maskininlärning som fokuserar på att träna intelligenta agenter genom interaktion med sin omgivning. I denna kurs lär du dig hur agenter gradvis upptäcker effektiva beteenden genom försök och misstag. Med början i grundläggande begrepp som Markovbeslutsprocesser och multiarmade banditer, går du vidare till dynamisk programmering, Monte Carlo-metoder och temporär differensinlärning.

Upptäck hur agenter tränas att fatta optimala beslut genom trial and error. Utforska grunderna i förstärkningsinlärningens teori. Få praktisk erfarenhet av att konfigurera och köra en Gymnasium-miljö.

Bemästra utforsknings- och exploateringsavvägningen genom multi-armed bandit-problemet. Implementera åtgärdsvärdesuppskattning, ε-girig, övre konfidensgräns och gradient-banditmetoder. Utvärdera algoritmers prestanda på simulerade belöningsmaximeringsuppgifter.

Behärska dynamisk programmering för modellbaserad RL. Upptäck hur Bellmans ekvationer kan användas för att utvärdera och förbättra policies.
Implementera algoritmer för policy- och värdeiteration.
Utforska generaliserad policyiteration som den teoretiska grunden för modellfria metoder.

Behärska Monte Carlo-metoder för modellfri RL. Uppskatta värdefunktioner och härled optimala policies från fullständiga episoder. Implementera on-policy och off-policy Monte Carlo-kontrollalgoritmer. Utforska strategier för utforskning för att optimera modellfritt lärande.

Behärska temporär differensinlärning för modellfri RL. Skatta värdefunktioner från partiella episoder med hjälp av TD(0)-uppdateringar. Implementera on-policy SARSA och off-policy Q-Learning-algoritmer. Utforska hur Monte Carlo-metoder och TD-inlärning kombineras i n-stegs TD och TD(λ).

Utmaning: Konfigurera en Miljö

Lösning

Awesome!

Utmaning: Konfigurera en Miljö

Lösning