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(failure_message)  # 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
    test_case.assertTrue(True, success_message)  # Pass the test with a success message
  else:
    test_case._testMethodName = failure_message  # Rename the test with a failure description
    test_case.fail(failure_message)  # 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"
    )
    _require_success(
      self,
      isinstance(user_code.gym, types.ModuleType),
      "`gym` is declared, but it's not a module"
    )
    _check_success(
      self,
      user_code.gym.__name__ == "gymnasium",
      "`gymnasium` is imported",
      "`gymnasium` is not imported under the `gym` alias"
    )
    
  # 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

Reinforcement Learning (RL) is a powerful branch of machine learning focused on training intelligent agents through interaction with their environment. In this course, you'll learn how agents gradually discover effective behaviors through trial and error. Beginning with core concepts like Markov decision processes and multi-armed bandits, you'll work your way through dynamic programming, Monte Carlo methods, and temporal difference learning.

This section introduces the core principles of reinforcement learning, covering its defining features, mathematical foundations, and how agents learn from interaction and feedback. You'll also get hands-on with essential tools to prepare for building and training your first RL agents.

This section explores the multi-armed bandit problem — a great setting for understanding the exploration-exploitation dilemma. You'll learn and implement algorithms that help agents make decisions under uncertainty, balancing reward maximization with the need to explore.

This section introduces dynamic programming as a powerful method for solving reinforcement learning problems when a complete model of the environment is available. You'll learn how to evaluate and improve policies using Bellman equations and explore core techniques like policy iteration, value iteration, and generalized policy iteration — building the theoretical foundation for future model-free methods.

This section introduces Monte Carlo methods for learning value functions and policies from complete episodes of experience. You'll explore both on-policy and off-policy approaches, understand how exploration affects learning, and implement incremental techniques to efficiently estimate returns — all without needing a model of the environment.

This section introduces temporal difference (TD) learning, a fundamental method in reinforcement learning that blends ideas from Monte Carlo and dynamic programming. You'll learn how to estimate value functions from incomplete episodes, explore both on-policy (SARSA) and off-policy (Q-learning) approaches, and discover how Monte Carlo methods and TD learning can be combined.

Challenge: Setting Up an Environment

Soluzione

Challenge: Setting Up an Environment

Soluzione