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

O Aprendizado por Reforço (RL) é um ramo poderoso do aprendizado de máquina focado no treinamento de agentes inteligentes por meio da interação com seu ambiente. Neste curso, você aprenderá como os agentes descobrem gradualmente comportamentos eficazes através de tentativa e erro. Começando com conceitos fundamentais como processos de decisão de Markov e multi-armed bandits, você avançará por programação dinâmica, métodos de Monte Carlo e aprendizado por diferença temporal.

Esta seção apresenta os princípios fundamentais do aprendizado por reforço, abordando suas características definidoras, fundamentos matemáticos e como os agentes aprendem por meio de interação e feedback. Você também terá contato prático com ferramentas essenciais para se preparar para construir e treinar seus primeiros agentes de RL.

Esta seção explora o problema do bandido de múltiplos braços — um excelente cenário para compreender o dilema entre exploração e exploração. Você aprenderá e implementará algoritmos que auxiliam agentes a tomar decisões sob incerteza, equilibrando a maximização de recompensas com a necessidade de explorar.

Esta seção apresenta a programação dinâmica como um método poderoso para resolver problemas de aprendizado por reforço quando um modelo completo do ambiente está disponível. Você aprenderá como avaliar e melhorar políticas utilizando as equações de Bellman e explorará técnicas centrais como iteração de políticas, iteração de valores e iteração generalizada de políticas — construindo a base teórica para futuros métodos sem modelo.

Esta seção apresenta os métodos de Monte Carlo para aprender funções de valor e políticas a partir de episódios completos de experiência. Você explorará abordagens on-policy e off-policy, compreenderá como a exploração afeta o aprendizado e implementará técnicas incrementais para estimar retornos de forma eficiente — tudo isso sem a necessidade de um modelo do ambiente.

Esta seção apresenta o aprendizado por diferença temporal (TD), um método fundamental em aprendizado por reforço que combina ideias de Monte Carlo e programação dinâmica. Você aprenderá como estimar funções de valor a partir de episódios incompletos, explorar abordagens on-policy (SARSA) e off-policy (Q-learning), e descobrir como métodos de Monte Carlo e aprendizado por diferença temporal podem ser combinados.

Desafio: Configurando um Ambiente

Solução

Awesome!

Desafio: Configurando um Ambiente

Solução

Awesome!