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

Vahvistusoppiminen (RL) on koneoppimisen tehokas osa-alue, joka keskittyy älykkäiden agenttien kouluttamiseen vuorovaikutuksessa ympäristönsä kanssa. Tällä kurssilla opit, kuinka agentit löytävät vähitellen tehokkaita toimintatapoja kokeilun ja erehdyksen kautta. Aloitat keskeisistä käsitteistä, kuten Markovin päätösprosesseista ja monikäsivarsisista peliautomaateista, ja etenet dynaamiseen ohjelmointiin, Monte Carlo -menetelmiin ja ajallisen eron oppimiseen.

Tässä osiossa esitellään vahvistusoppimisen keskeiset periaatteet, mukaan lukien sen määrittelevät ominaisuudet, matemaattiset perusteet sekä se, miten agentit oppivat vuorovaikutuksen ja palautteen kautta. Lisäksi tutustutaan keskeisiin työkaluihin, jotka valmistavat ensimmäisten RL-agenttien rakentamiseen ja kouluttamiseen.

Tässä osiossa tarkastellaan moniaseista bandiittiongelmaa, joka tarjoaa erinomaisen ympäristön tutkimus-hyödyntämisdilemman ymmärtämiseen. Opit algoritmeja, jotka auttavat agentteja tekemään päätöksiä epävarmuuden vallitessa, tasapainottaen palkkion maksimointia ja tutkimisen tarvetta.

Tässä osiossa esitellään dynaaminen ohjelmointi tehokkaana menetelmänä vahvistusoppimisen ongelmien ratkaisemiseksi, kun ympäristön täydellinen malli on käytettävissä. Opit arvioimaan ja parantamaan politiikkoja Bellmanin yhtälöiden avulla sekä tutustut keskeisiin tekniikoihin, kuten politiikkaiteraatioon, arvoiteraatioon ja yleistettyyn politiikkaiteraatioon — muodostaen teoreettisen perustan tuleville mallittomille menetelmille.

Tässä osiossa esitellään Monte Carlo -menetelmät arvofunktioiden ja politiikkojen oppimiseen täydellisistä kokemusepisodeista. Tutustut sekä on-policy- että off-policy-lähestymistapoihin, ymmärrät, miten eksploraatio vaikuttaa oppimiseen, ja toteutat inkrementaalisia tekniikoita tuottojen tehokkaaseen estimointiin — ilman ympäristön mallia.

Tässä osiossa esitellään aikaisen eron (TD) oppiminen, joka on vahvistusoppimisen keskeinen menetelmä ja yhdistää Monte Carlo -menetelmien ja dynaamisen ohjelmoinnin ideoita. Opit arvioimaan arvofunktioita keskeneräisistä episodeista, tutustumaan sekä on-policy (SARSA) että off-policy (Q-learning) -lähestymistapoihin sekä siihen, miten Monte Carlo -menetelmät ja TD-oppiminen voidaan yhdistää.

Haaste: Ympäristön Määrittäminen

Ratkaisu

Awesome!

Haaste: Ympäristön Määrittäminen

Ratkaisu

Awesome!