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

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 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.

Descubra como treinar agentes para tomar decisões ótimas por meio de tentativa e erro.
Explore os fundamentos da teoria de aprendizado por reforço.
Obtenha experiência prática configurando e executando um ambiente Gymnasium.

Domínio do equilíbrio entre exploração e exploração por meio do problema do bandido de múltiplos braços. Implementação de estimativa de valor de ação, métodos ε-greedy, limite superior de confiança e bandido de gradiente. Avaliação do desempenho dos algoritmos em tarefas simuladas de maximização de recompensa.

Domínio da programação dinâmica para RL baseado em modelos.
Descoberta de como as equações de Bellman podem ser utilizadas para avaliar e aprimorar políticas.
Implementação dos algoritmos de iteração de política e de valor.
Exploração da iteração generalizada de políticas como base teórica para métodos sem modelo.

Domínio dos métodos de Monte Carlo para RL sem modelo. Estimativa de funções de valor e derivação de políticas ótimas a partir de episódios completos. Implementação de algoritmos de controle de Monte Carlo on-policy e off-policy. Exploração de estratégias de exploração para otimizar o aprendizado sem modelo.

Domínio do aprendizado por diferença temporal para RL sem modelo. Estimativa de funções de valor a partir de episódios parciais utilizando atualizações TD(0). Implementação dos algoritmos SARSA on-policy e Q-Learning off-policy. Exploração da combinação entre métodos de Monte Carlo e aprendizado por diferença temporal em TD de n passos e TD(λ).

Desafio: Configurando um Ambiente

Solução

Awesome!

Desafio: Configurando um Ambiente

Solução