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

Forsterkende læring (RL) er en kraftig gren av maskinlæring som fokuserer på å trene intelligente agenter gjennom interaksjon med sitt miljø. I dette kurset lærer du hvordan agenter gradvis oppdager effektive atferder gjennom prøving og feiling. Kurset starter med kjernebegreper som Markov beslutningsprosesser og multi-armede banditter, og fortsetter med dynamisk programmering, Monte Carlo-metoder og temporær differanselæring.

Denne delen introduserer kjerneprinsippene i forsterkningslæring, med fokus på dets definerende egenskaper, matematiske grunnlag og hvordan agenter lærer gjennom interaksjon og tilbakemelding. Du får også praktisk erfaring med essensielle verktøy for å forberede deg på å bygge og trene dine første RL-agenter.

Denne delen utforsker multi-armet bandittproblem — et utmerket utgangspunkt for å forstå dilemmaet mellom utforskning og utnyttelse. Du vil lære om og implementere algoritmer som hjelper agenter med å ta beslutninger under usikkerhet, og balansere maksimalisering av belønning med behovet for utforskning.

Dette avsnittet introduserer dynamisk programmering som en kraftig metode for å løse forsterkende læringsproblemer når en fullstendig modell av miljøet er tilgjengelig. Du vil lære hvordan man evaluerer og forbedrer policyer ved hjelp av Bellman-likninger og utforske sentrale teknikker som policyiterasjon, verdiiterasjon og generalisert policyiterasjon — og bygger det teoretiske grunnlaget for fremtidige modellfrie metoder.

Dette avsnittet introduserer Monte Carlo-metoder for å lære verdifunksjoner og policyer fra komplette episoder av erfaring. Du vil utforske både on-policy og off-policy tilnærminger, forstå hvordan utforskning påvirker læring, og implementere inkrementelle teknikker for effektiv estimering av avkastning — alt uten behov for en modell av miljøet.

Denne delen introduserer temporal difference (TD) læring, en grunnleggende metode innenfor forsterkende læring som kombinerer ideer fra Monte Carlo og dynamisk programmering. Du vil lære hvordan man estimerer verdifunksjoner fra ufullstendige episoder, utforske både on-policy (SARSA) og off-policy (Q-learning) tilnærminger, og oppdage hvordan Monte Carlo-metoder og TD-læring kan kombineres.

Utfordring: Oppsett av et Miljø

Løsning

Awesome!

Utfordring: Oppsett av et Miljø

Løsning

Awesome!