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

Il Reinforcement Learning (RL) è un ramo avanzato del machine learning che si concentra sull'addestramento di agenti intelligenti tramite l'interazione con l'ambiente. In questo corso verrà illustrato come gli agenti scoprono progressivamente comportamenti efficaci attraverso il metodo del tentativo ed errore. A partire da concetti fondamentali come i processi decisionali di Markov e i multi-armed bandit, si proseguirà con la programmazione dinamica, i metodi Monte Carlo e l'apprendimento per differenza temporale.

Questa sezione introduce i principi fondamentali dell'apprendimento per rinforzo, trattando le sue caratteristiche distintive, le basi matematiche e il modo in cui gli agenti apprendono tramite interazione e feedback. Verranno inoltre presentati strumenti essenziali per prepararsi alla costruzione e all'addestramento dei primi agenti RL.

Questa sezione esplora il problema del multi-armed bandit, un contesto ideale per comprendere il dilemma esplorazione-sfruttamento. Verranno appresi e implementati algoritmi che aiutano gli agenti a prendere decisioni in condizioni di incertezza, bilanciando la massimizzazione della ricompensa con la necessità di esplorare.

Questa sezione introduce la programmazione dinamica come un metodo potente per risolvere problemi di reinforcement learning quando è disponibile un modello completo dell'ambiente. Verrà illustrato come valutare e migliorare le politiche utilizzando le equazioni di Bellman ed esplorate tecniche fondamentali come l'iterazione delle politiche, l'iterazione dei valori e l'iterazione generalizzata delle politiche, costruendo la base teorica per futuri metodi senza modello.

Questa sezione introduce i metodi Monte Carlo per apprendere funzioni di valore e politiche a partire da episodi completi di esperienza. Verranno esplorati sia approcci on-policy che off-policy, analizzato come l'esplorazione influisce sull'apprendimento e implementate tecniche incrementali per stimare in modo efficiente i ritorni, il tutto senza la necessità di un modello dell'ambiente.

Questa sezione introduce l'apprendimento a differenza temporale (TD), un metodo fondamentale nell'apprendimento per rinforzo che combina concetti dal metodo Monte Carlo e dalla programmazione dinamica. Verrà illustrato come stimare le funzioni di valore da episodi incompleti, esplorare sia gli approcci on-policy (SARSA) che off-policy (Q-learning), e scoprire come i metodi Monte Carlo e l'apprendimento TD possano essere combinati.

Sfida: Configurazione di un Ambiente

Soluzione

Awesome!

Sfida: Configurazione di un Ambiente

Soluzione

Awesome!