Tutorial sobre o pacote kaggle-environments¶

O objetivo deste tutorial é mostrar o funcionamento básico do ambiente para que você possa implementar um agente para o mesmo.

Por exemplo, abaixo é apresentado como fazer a carga do ambiente para o jogo da velha (tictactoe):

In [4]:

from kaggle_environments import make
env = make('tictactoe', debug=True)

from kaggle_environments import make env = make('tictactoe', debug=True)

Abaixo é impresso os agentes disponíveis neste ambiente:

In [5]:

print('Agentes disponíveis: ')
print(*env.agents)

print('Agentes disponíveis: ') print(*env.agents)

Agentes disponíveis: 
random reaction

O agente random tem comportamento aleatório, enquanto que o agente reaction é um pouco mais inteligente que isto.

Abaixo é apresentado como o agente tem acesso ao estado:

In [6]:

env.state

env.state

Out[6]:

[{'action': 0,
  'reward': 0,
  'info': {},
  'observation': {'remainingOverageTime': 2,
   'step': 0,
   'board': [0, 0, 0, 0, 0, 0, 0, 0, 0],
   'mark': 1},
  'status': 'ACTIVE'},
 {'action': 0,
  'reward': 0,
  'info': {},
  'observation': {'remainingOverageTime': 2, 'mark': 2},
  'status': 'INACTIVE'}]

Vamos fazer a execução de um agente aleatório contra outro aleatório?

In [7]:

steps = env.run(["random", "random"])

steps = env.run(["random", "random"])

In [8]:

# mostra a execucao da partida
env.render(mode='ipython', width=200, height=200)

# mostra a execucao da partida env.render(mode='ipython', width=200, height=200)

E se eu quiser desenvolver um agente próprio? Como eu devo proceder?

In [9]:

# definicao de um agente bem basico que marca a primeira celula disponivel
def my_agent(obs,reward):
  print(obs['board'])
  print(reward)
  return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]

# definicao de um agente bem basico que marca a primeira celula disponivel def my_agent(obs,reward): print(obs['board']) print(reward) return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]

Vamos colocar este agente my_agent contra um random?

In [11]:

steps = env.run([my_agent, "random"])
env.render(mode='ipython', width=200, height=200)

steps = env.run([my_agent, "random"]) env.render(mode='ipython', width=200, height=200)

[0, 0, 0, 0, 0, 0, 0, 0, 0]
{'episodeSteps': 10, 'actTimeout': 1, 'runTimeout': 1200, 'agentTimeout': 2}
[1, 2, 0, 0, 0, 0, 0, 0, 0]
{'episodeSteps': 10, 'actTimeout': 1, 'runTimeout': 1200, 'agentTimeout': 2}
[1, 2, 1, 0, 0, 0, 0, 0, 2]
{'episodeSteps': 10, 'actTimeout': 1, 'runTimeout': 1200, 'agentTimeout': 2}
[1, 2, 1, 1, 0, 0, 2, 0, 2]
{'episodeSteps': 10, 'actTimeout': 1, 'runTimeout': 1200, 'agentTimeout': 2}

Da forma como está implementado acima nós conseguimos visualizar a partida, mas não temos muitos dados sobre o resultado da partida. Dados que podemos utilizar depois para sumarizar o desempenho do nosso agente. No código abaixo é apresentado uma forma de avaliar o desempenho do nosso agente.

In [12]:

from kaggle_environments import evaluate

environment = 'tictactoe'
configuration = {}
steps = []
agents = [my_agent, "random"]
num_episodes = 10

rewards = evaluate(environment, agents, configuration, steps, num_episodes)

from kaggle_environments import evaluate environment = 'tictactoe' configuration = {} steps = [] agents = [my_agent, "random"] num_episodes = 10 rewards = evaluate(environment, agents, configuration, steps, num_episodes)

In [13]:

rewards

rewards

Out[13]:

[[0, 0],
 [-1, 1],
 [1, -1],
 [1, -1],
 [1, -1],
 [1, -1],
 [1, -1],
 [1, -1],
 [1, -1],
 [1, -1]]

No exemplo apresentado acima temos:

• 8 vezes que o my_agent ganha do aleatório [1, -1];
• 1 vez que o my_agent perde do aleatório [-1, 1], e;
• 1 empate [0,0].

O my_agent é um agente extremamente simples. Podemos perceber isto quando colocamos o my_agent para jogar contra o reaction:

In [14]:

from kaggle_environments import evaluate

environment = 'tictactoe'
configuration = {}
steps = []
agents = [my_agent, "reaction"]
num_episodes = 10

rewards = evaluate(environment, agents, configuration, steps, num_episodes)

from kaggle_environments import evaluate environment = 'tictactoe' configuration = {} steps = [] agents = [my_agent, "reaction"] num_episodes = 10 rewards = evaluate(environment, agents, configuration, steps, num_episodes)

In [15]:

rewards

rewards

Out[15]:

[[0, 0],
 [-1, 1],
 [0, 0],
 [-1, 1],
 [-1, 1],
 [-1, 1],
 [-1, 1],
 [-1, 1],
 [-1, 1],
 [-1, 1]]

Neste caso o agente my_agent não ganha nenhuma vez e só empata 2 vezes.

O que devemos fazer para implementar um agente mais inteligente?