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

El aprendizaje por refuerzo (RL) es una rama poderosa del aprendizaje automático enfocada en entrenar agentes inteligentes mediante la interacción con su entorno. En este curso, aprenderá cómo los agentes descubren gradualmente comportamientos efectivos a través del ensayo y error. Comenzando con conceptos fundamentales como los procesos de decisión de Markov y los bandidos de varios brazos, avanzará por programación dinámica, métodos de Monte Carlo y aprendizaje por diferencia temporal.

Esta sección presenta los principios fundamentales del aprendizaje por refuerzo, abarcando sus características definitorias, fundamentos matemáticos y el modo en que los agentes aprenden a partir de la interacción y la retroalimentación. También se trabajará con herramientas esenciales para prepararse en la construcción y entrenamiento de los primeros agentes de RL.

Esta sección explora el problema del bandido de varios brazos, un excelente escenario para comprender el dilema entre exploración y explotación. Aprenderá e implementará algoritmos que ayudan a los agentes a tomar decisiones bajo incertidumbre, equilibrando la maximización de recompensas con la necesidad de explorar.

Esta sección presenta la programación dinámica como un método potente para resolver problemas de aprendizaje por refuerzo cuando se dispone de un modelo completo del entorno. Aprenderá a evaluar y mejorar políticas utilizando las ecuaciones de Bellman y explorará técnicas fundamentales como la iteración de políticas, la iteración de valores y la iteración generalizada de políticas, construyendo la base teórica para futuros métodos sin modelo.

Esta sección introduce los métodos de Monte Carlo para aprender funciones de valor y políticas a partir de episodios completos de experiencia. Se explorarán enfoques tanto en política como fuera de política, se analizará cómo la exploración afecta el aprendizaje y se implementarán técnicas incrementales para estimar retornos de manera eficiente, todo ello sin necesidad de un modelo del entorno.

Esta sección presenta el aprendizaje por diferencia temporal (TD), un método fundamental en el aprendizaje por refuerzo que combina ideas de Monte Carlo y programación dinámica. Aprenderá a estimar funciones de valor a partir de episodios incompletos, explorará enfoques tanto en política (SARSA) como fuera de política (Q-learning), y descubrirá cómo se pueden combinar los métodos de Monte Carlo y el aprendizaje TD.

Desafío: Configuración de un Entorno

Solución

Awesome!

Desafío: Configuración de un Entorno

Solución

Awesome!