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

L'apprentissage par renforcement (RL) est une branche puissante de l'apprentissage automatique axée sur la formation d'agents intelligents par l'interaction avec leur environnement. Dans ce cours, vous découvrirez comment les agents identifient progressivement des comportements efficaces par essais et erreurs. En commençant par des concepts fondamentaux tels que les processus de décision de Markov et les bandits manchots, vous explorerez la programmation dynamique, les méthodes de Monte Carlo et l'apprentissage par différence temporelle.

Cette section présente les principes fondamentaux de l'apprentissage par renforcement, en abordant ses caractéristiques distinctives, ses bases mathématiques et la manière dont les agents apprennent par interaction et retour d'information. Vous manipulerez également des outils essentiels pour vous préparer à la conception et à l'entraînement de vos premiers agents RL.

Cette section explore le problème du bandit manchot — un excellent cadre pour comprendre le dilemme exploration-exploitation. Vous étudierez et mettrez en œuvre des algorithmes qui aident les agents à prendre des décisions dans l'incertitude, en équilibrant la maximisation de la récompense avec la nécessité d'explorer.

Cette section présente la programmation dynamique comme une méthode puissante pour résoudre les problèmes d'apprentissage par renforcement lorsqu'un modèle complet de l'environnement est disponible. Vous apprendrez à évaluer et à améliorer les politiques à l'aide des équations de Bellman et à explorer des techniques fondamentales telles que l'itération de politique, l'itération de valeur et l'itération de politique généralisée — établissant ainsi la base théorique pour les futures méthodes sans modèle.

Cette section présente les méthodes de Monte Carlo pour l'apprentissage des fonctions de valeur et des politiques à partir d'épisodes complets d'expérience. Vous explorerez les approches sur politique et hors politique, comprendrez comment l'exploration influence l'apprentissage, et mettrez en œuvre des techniques incrémentales pour estimer efficacement les retours — le tout sans nécessiter de modèle de l'environnement.

Cette section présente l'apprentissage par différence temporelle (TD), une méthode fondamentale en apprentissage par renforcement qui combine des concepts issus de Monte Carlo et de la programmation dynamique. Vous apprendrez à estimer des fonctions de valeur à partir d'épisodes incomplets, à explorer les approches sur politique (SARSA) et hors politique (Q-learning), et à découvrir comment les méthodes Monte Carlo et l'apprentissage TD peuvent être combinées.

Défi : Configuration d’un Environnement

Solution

Awesome!

Défi : Configuration d’un Environnement

Solution

Awesome!