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ás cómo los agentes descubren gradualmente comportamientos efectivos a través de la prueba y error. Comenzando con conceptos fundamentales como los procesos de decisión de Markov y los bandidos de múltiples brazos, avanzarás por programación dinámica, métodos de Monte Carlo y aprendizaje por diferencia temporal.

Descubra cómo entrenar agentes para tomar decisiones óptimas mediante prueba y error.
Explore los conceptos esenciales de la teoría de aprendizaje por refuerzo.
Obtenga experiencia práctica configurando y ejecutando un entorno Gymnasium.

Domina el equilibrio entre exploración y explotación mediante el problema del bandido de varios brazos. Implementación de estimación de valor de acción, métodos ε-greedy, límite superior de confianza y bandido de gradiente. Evaluación del rendimiento de los algoritmos en tareas simuladas de maximización de recompensas.

Dominio de la programación dinámica para RL basado en modelos.
Descubrimiento de cómo las ecuaciones de Bellman pueden utilizarse para evaluar y mejorar políticas.
Implementación de algoritmos de iteración de políticas y de valores.
Exploración de la iteración generalizada de políticas como fundamento teórico para métodos sin modelo.

Domina los métodos de Monte Carlo para RL sin modelo. Estimación de funciones de valor y derivación de políticas óptimas a partir de episodios completos. Implementación de algoritmos de control Monte Carlo en política y fuera de política. Descubrimiento de estrategias de exploración para optimizar el aprendizaje sin modelo.

Dominio del aprendizaje por diferencia temporal para RL sin modelo. Estimación de funciones de valor a partir de episodios parciales utilizando actualizaciones TD(0). Implementación de los algoritmos SARSA en política y Q-Learning fuera de política. Exploración de la combinación de métodos Monte Carlo y aprendizaje TD en TD de n pasos y TD(λ).

Desafío: Configuración de un Entorno

Solución

Awesome!

Desafío: Configuración de un Entorno

Solución