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 deras 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 genom dynamisk programmering, Monte Carlo-metoder och temporär differensinlärning.

Detta avsnitt introducerar de grundläggande principerna för förstärkningsinlärning, inklusive dess kännetecknande egenskaper, matematiska grunder och hur agenter lär sig genom interaktion och återkoppling. Du får även praktisk erfarenhet av viktiga verktyg för att förbereda dig inför att bygga och träna dina första RL-agenter.

Detta avsnitt utforskar multi-armed bandit-problemet — en utmärkt miljö för att förstå utforsknings- och exploateringsdilemmat. Du kommer att lära dig och implementera algoritmer som hjälper agenter att fatta beslut under osäkerhet, genom att balansera belöningsmaximering med behovet av utforskning.

Detta avsnitt introducerar dynamisk programmering som en kraftfull metod för att lösa problem inom förstärkningsinlärning när en fullständig modell av miljön är tillgänglig. Du får lära dig hur man utvärderar och förbättrar policies med hjälp av Bellman-ekvationer samt utforskar centrala tekniker såsom policyiteration, värdeiteration och generaliserad policyiteration — vilket bygger den teoretiska grunden för framtida modellfria metoder.

Detta avsnitt introducerar Monte Carlo-metoder för att lära värdefunktioner och policies från kompletta episoder av erfarenhet. Du kommer att utforska både on-policy och off-policy tillvägagångssätt, förstå hur utforskning påverkar inlärning samt implementera inkrementella tekniker för att effektivt uppskatta avkastning — allt utan att behöva en modell av miljön.

Detta avsnitt introducerar temporär differensinlärning (TD), en grundläggande metod inom förstärkningsinlärning som kombinerar idéer från Monte Carlo och dynamisk programmering. Du får lära dig hur man uppskattar värdefunktioner från ofullständiga episoder, utforskar både on-policy (SARSA) och off-policy (Q-learning) tillvägagångssätt samt upptäcker hur Monte Carlo-metoder och TD-inlärning kan kombineras.

Utmaning: Konfigurera en Miljö

Lösning

Awesome!

Utmaning: Konfigurera en Miljö

Lösning

Awesome!