🍁 🌥️ 🏗️ Agentes de aprendizado de máquina na Unity 😚 😹 🌒

Este artigo sobre agentes de aprendizado de máquina do Unity foi escrito por Michael Lanham, um inovador técnico, desenvolvedor ativo do Unity, consultor, gerente e autor de muitos jogos, projetos gráficos e livros do Unity.

Os desenvolvedores do Unity implementaram o suporte ao aprendizado de máquina e, em particular, ao aprendizado por reforço para a criação de SDKs de DDR (Deep Enhancement Learning) para desenvolvedores de jogos e simulação. Felizmente, a equipe da Unity, liderada por Danny Lange, implementou com sucesso um mecanismo DRL confiável e moderno capaz de fornecer resultados impressionantes. O Unity usa o modelo de otimização de política proximal (PPO) como base do mecanismo DRL; esse modelo é muito mais complexo e pode diferir em alguns aspectos.

Neste artigo, apresentarei as ferramentas e SDKs para a criação de agentes de DRL em jogos e simulações. Apesar da novidade e do poder dessa ferramenta, é fácil de usar e possui ferramentas auxiliares que permitem aprender conceitos de aprendizado de máquina em movimento. Para trabalhar com o tutorial, você precisa instalar o mecanismo do Unity.

Instalar agentes ML

Nesta seção, falarei brevemente sobre as etapas que devem ser tomadas para instalar o SDK do ML-Agents. Este material ainda está na versão beta e pode variar de versão para versão. Siga estes passos:

Instale o Git no computador; Funciona a partir da linha de comando. O Git é um sistema de gerenciamento de código-fonte muito popular e há muitos recursos na Internet sobre a instalação e o uso do Git em várias plataformas. Após instalar o Git, verifique se ele funciona criando um clone de qualquer repositório.
Abra um prompt de comando ou shell regular. Os usuários do Windows podem abrir a janela do Anaconda.
Vá para a pasta de trabalho onde deseja colocar seu novo código e digite o seguinte comando (os usuários do Windows podem selecionar C: \ ML-Agents):
```
  git clone https://github.com/Unity-Technologies/ml-agents 
```
Então você clona o repositório ml-agents no seu computador e cria uma nova pasta com o mesmo nome. Você também pode adicionar um número de versão ao nome da pasta. A unidade, como quase todo o mundo da inteligência artificial, está mudando constantemente, pelo menos por enquanto. Isso significa que novas mudanças estão aparecendo constantemente. No momento da redação, estamos clonando o repositório na pasta ml-agents.6:
```
  git clone https://github.com/Unity-Technologies/ml-agents ml-agents.6 
```

Crie um novo ambiente virtual para ml-agents e especifique a versão 3.6, assim:

  #Windows 
 conda create -n ml-agents python = 3.6
 
 #Mac
 Use a documentação para o seu ambiente preferido

Ative seu ambiente novamente com o Anaconda:
```
  ativar agentes ml 
```
Instale o TensorFlow. No Anaconda, isso pode ser feito com o seguinte comando:
```
  pip install tensorflow == 1.7.1 
```

Instale pacotes Python. No Anaconda, digite o seguinte:

cd ML-Agents #from root folder cd ml-agents or cd ml-agents.6 #for example cd ml-agents pip install -e . or pip3 install -e .

Então você instala todos os pacotes necessários do SDK do Agents; isso pode levar alguns minutos. Não feche a janela, ela será útil em breve.

Por isso, instalamos e configuramos o Unity Python SDK para agentes ML. Na próxima seção, aprenderemos como configurar e treinar um dos muitos ambientes fornecidos pelo Unity.

Treinamento de agentes

Agora podemos começar a trabalhar imediatamente e explorar exemplos que usam o DRL (Deep Reforço Learning). Felizmente, existem vários exemplos no kit de ferramentas do novo agente para demonstrar a potência do mecanismo. Abra o Unity ou o Unity Hub e siga estas etapas:

Clique no botão Abrir projeto na parte superior da caixa de diálogo Projeto.
Localize e abra a pasta do projeto UnitySDK, conforme mostrado na captura de tela:

Abra o projeto do SDK do Unity
Aguarde o carregamento do projeto e abra a janela Projeto na parte inferior do editor. Se uma janela abrir solicitando a atualização do projeto, selecione sim ou continue. Atualmente, todo o código do agente é compatível com versões anteriores.
Localize e abra a cena do GridWorld, conforme mostrado na captura de tela:

Abrindo um exemplo de uma cena do GridWorld
Selecione o objeto GridAcademy na janela Hierarquia.
Vá para a janela Inspetor e, ao lado do campo Cérebros, clique no ícone para abrir a caixa de diálogo Seleção do cérebro:
Selecione o cérebro do GridWorldPlayer. Esse cérebro pertence ao jogador, ou seja, o jogador (você) pode controlar o jogo.
Clique no botão Reproduzir na parte superior do editor e observe o ambiente. Como o jogo está agora configurado para controlar o jogador, você pode usar as teclas WASD para mover o cubo. A tarefa é mover o cubo azul para o símbolo verde +, evitando o X vermelho.

Sinta-se confortável no jogo. Observe que o jogo só funciona por um determinado período de tempo e não é baseado em turnos. Na próxima seção, aprenderemos como executar este exemplo com o agente DRL.

O que há no cérebro?

Um dos aspectos surpreendentes da plataforma ML-Agents é a capacidade de mudar rápida e facilmente do gerenciamento de jogadores para o gerenciamento de IA / agente. Para isso, o Unity usa o conceito de "cérebro". O cérebro pode ser controlado pelo jogador ou pelo agente (cérebro de aprendizado). O mais surpreendente é que você pode montar o jogo e testá-lo como jogador, e depois entregá-lo sob o controle de um agente da RL. Graças a isso, qualquer jogo escrito com um pouco de esforço pode ser feito para ser controlado usando a IA.

O processo de configurar e iniciar o treinamento do agente RL no Unity é bastante simples. O Unity usa Python externo para construir um modelo do cérebro que aprende. O uso do Python faz muito sentido, porque já existem várias bibliotecas de aprendizado profundo (DL) criadas em torno dele. Para treinar o agente no GridWorld, execute as seguintes etapas:

Selecione GridAcademy novamente e selecione o cérebro do GridWorldLearning no campo Brains em vez de GridWorldPlayer:

Mudando para o uso do GridWorldLearning Brain
Marque a caixa de controle à direita. Este parâmetro simples relata que o cérebro pode ser controlado externamente. Esta opção deve estar ativada.
Selecione o objeto trueAgent na janela Hierarquia e, na janela Inspetor, altere a propriedade Brain no componente Grid Agent para o cérebro GridWorldLearning:

GridWorldLearning trabalho cerebral para agente
Neste exemplo, precisamos que a Academy e o Agent usem o mesmo cérebro do GridWorldLearning. Alterne para a janela Anaconda ou Python e selecione a pasta ML-Agents / ml-agents.
Execute o seguinte comando em uma janela Anaconda ou Python usando o ambiente virtual ml-agents:
```
  mlagents-learn config / trainer_config.yaml --run-id = firstRun --train 
```
Isso iniciará o modelo de treinamento do Unity PPO e um agente de exemplo com a configuração especificada. Em um determinado momento, a janela do prompt de comando solicitará que você inicie o editor do Unity com o ambiente carregado.
Clique em Reproduzir no editor do Unity para iniciar o ambiente GridWorld. Logo depois, você verá o treinamento do agente e a saída para a janela de script Python:

Executando o GridWorld no Modo de Aprendizagem
Observe que o script mlagents-learn é um código Python que cria um modelo RL para executar um agente. Como você pode ver na saída do script, existem vários parâmetros (hiperparâmetros) que precisam ser configurados.
Deixe o agente aprender alguns milhares de iterações e observe a rapidez com que aprende. O modelo interno usado aqui chamado PPO provou ser um modelo de aprendizado muito eficaz para muitas tarefas diferentes e é muito adequado para o desenvolvimento de jogos. Com equipamentos suficientemente potentes, um agente pode aprender idealmente em menos de uma hora.

Deixe o agente aprender mais e explorar outras maneiras de acompanhar o processo de aprendizado do agente, conforme apresentado na próxima seção.

Monitorando o aprendizado com o TensorBoard

Treinar um agente usando o modelo RL ou qualquer modelo de DL geralmente é uma tarefa assustadora e requer atenção aos detalhes. Felizmente, o TensorFlow possui um conjunto de ferramentas de gráficos chamado TensorBoard que você pode usar para monitorar seu processo de aprendizado. Siga estas etapas para iniciar o TensorBoard:

Abra uma janela Anaconda ou Python. Ative o ambiente virtual ml-agents. Não feche a janela na qual o modelo de treinamento está sendo executado; precisamos que continue.
Vá para a pasta ML-Agents / ml-agents e execute o seguinte comando:
```
  tensorboard --logdir = resumos 
```
Então, lançamos o TensorBoard em nosso próprio servidor da web incorporado. Você pode carregar a página usando o URL mostrado após o comando anterior.
Digite o URL para o TensorBoard conforme mostrado na janela ou digite localhost: 6006 ou nome da máquina: 6006 no navegador. Após cerca de uma hora, você verá algo parecido com isto:

Janela Gráfico do TensorBoard
A captura de tela anterior mostra gráficos, cada um dos quais exibe um aspecto separado do treinamento. Para entender como nosso agente é treinado, você precisa lidar com cada um desses gráficos; portanto, analisaremos a saída de cada seção:

Ambiente: esta seção mostra como o agente se manifesta no ambiente como um todo. Abaixo está uma visão mais detalhada dos gráficos com a tendência preferida:

Uma imagem detalhada dos gráficos da seção Ambiente

Recompensa cumulativa: Essa é a recompensa total que maximiza o agente. Geralmente é necessário que aumente, mas por algum motivo pode diminuir. É sempre melhor maximizar as recompensas entre 1 e -1. Se as recompensas do cronograma ultrapassarem esse intervalo, isso também precisará ser corrigido.
Duração do episódio: se esse valor diminui, geralmente é um bom sinal. Por fim, quanto mais curtos os episódios, mais treinamento. No entanto, lembre-se de que, se necessário, a duração dos episódios pode aumentar, portanto a imagem pode ser diferente.
Lição: esse gráfico deixa claro em qual lição o agente está; Destina-se à aprendizagem curricular.
Perdas: Esta seção mostra gráficos que representam as perdas ou custos calculados para a política e o valor. Abaixo está uma captura de tela desta seção com setas apontando para as configurações ideais:

Perdas e treinamento preferencial

Perda de política: Este gráfico determina a quantidade de alteração de política ao longo do tempo. A política é um elemento que define ações e, no caso geral, esse cronograma deve tender para baixo, mostrando que a política está tomando melhores decisões.
Perda de valor: é a perda média da função de valor. Em essência, ele modela o quão bem o agente prevê o valor do seu próximo estado. Inicialmente, esse valor deve aumentar e, após a estabilização da remuneração, deve diminuir.
Política: para avaliar a qualidade das ações no OPP, é utilizado o conceito de política, não o modelo. A captura de tela abaixo mostra os gráficos de políticas e a tendência preferida:

Gráficos de políticas e tendências preferidas
Entropia: Este gráfico mostra a magnitude do agente de pesquisa. Esse valor precisa ser reduzido, porque o agente aprende mais sobre o meio ambiente e precisa de menos pesquisas.
Taxa de aprendizado: nesse caso, esse valor deve diminuir gradualmente linearmente.
Estimativa do valor: este é o valor médio visitado por todos os estados do agente. Para refletir o aumento do conhecimento de um agente, esse valor deve crescer e depois se estabilizar.

6. Deixe o agente em execução até concluir e não feche o TensorBoard.
7. Volte à janela Anaconda / Python que treinou o cérebro e execute este comando:

  mlagents-learn config / trainer_config.yaml --run-id = secondRun --train

8. Você será solicitado novamente a clicar em Reproduzir no editor; então faça isso. Deixe o agente começar o treinamento e realizar várias sessões. No processo, observe a janela TensorBoard e observe como o secondRun é exibido nos gráficos. Você pode deixar esse agente funcionar até a conclusão, mas pode interrompê-lo, se desejar.

Nas versões anteriores do ML-Agents, você precisava primeiro criar o executável do Unity como um ambiente de aprendizado para o jogo e depois executá-lo. O cérebro externo de Python deveria ter funcionado da mesma maneira. Esse método dificultava a depuração de problemas no código ou no jogo. Na nova técnica, todas essas dificuldades foram eliminadas.

Agora que vimos como é fácil configurar e treinar um agente, vamos para a próxima seção, na qual aprendemos como executar um agente sem o cérebro externo do Python e executá-lo diretamente no Unity.

Lançamento do agente

O treinamento em Python é ótimo, mas você não pode usá-lo em um jogo real. Idealmente, gostaríamos de criar um gráfico TensorFlow e usá-lo no Unity. Felizmente, foi criada a biblioteca TensorFlowSharp que permite ao .NET usar gráficos TensorFlow. Isso nos permite criar modelos TFModels offline e injetá-los posteriormente no jogo. Infelizmente, só podemos usar modelos treinados, mas não treiná-los dessa maneira, pelo menos ainda não.

Vamos ver como isso funciona, usando o exemplo do gráfico que acabamos de treinar para o ambiente GridWorld; use-o como um cérebro interno no Unity. Siga as etapas na seção a seguir para configurar e usar seu cérebro interno:

Faça o download do plugin TFSharp aqui
No menu do editor, selecione Ativos | Pacote de importação | Pacote personalizado ...
Encontre o pacote de ativos que você acabou de baixar e use as caixas de diálogo de importação para carregar o plug-in no projeto.
No menu, selecione Editar | Configurações do projeto. A janela Configurações é aberta (apareceu na versão 2018.3)
Encontre os caracteres de Definir símbolos de script nas opções do Player e altere o texto para ENABLE_TENSORFLOW, além de ativar o código não seguro de permissão, conforme mostrado na captura de tela:

Definindo o sinalizador ENABLE_TENSORFLOW
Encontre o objeto GridWorldAcademy na janela Hierarquia e verifique se ele usa Brains | GridWorldLearning. Desative a opção Controle na seção Brains do script Grid Academy.
Encontre o cérebro do GridWorldLearning na pasta Assets / Examples / GridWorld / Brains e verifique se o parâmetro Model na janela Inspector está definido, conforme mostrado na captura de tela:

Tarefa modelo para o cérebro
O GridWorldLearning já deve estar definido como modelo. Neste exemplo, usamos o TFModel que acompanha o exemplo GridWorld.
Clique em Reproduzir para iniciar o editor e ver como o agente gerencia o cubo.

Agora estamos lançando o ambiente pré-treinado da Unity. Na próxima seção, aprenderemos como usar o cérebro que treinamos na seção anterior.

Carga cerebral treinada

Todos os exemplos do Unity possuem cérebros pré-treinados que podem ser usados para estudar exemplos. Obviamente, queremos poder carregar nossos próprios gráficos TF no Unity e executá-los. Para carregar um gráfico treinado, siga estas etapas:

Vá para a pasta ML-Agents / ml-agents / models / firstRun-0. Dentro desta pasta está o arquivo GridWorldLearning.bytes. Arraste esse arquivo para a pasta Project / Assets / ML-Agents / Examples / GridWorld / TFModels dentro do editor do Unity:

Arrastando um gráfico de bytes para o Unity
Portanto, importamos o gráfico para o projeto do Unity como um recurso e o renomeamos para GridWorldLearning 1. O mecanismo faz isso porque o modelo padrão já tem o mesmo nome.
Localize o GridWorldLearning na pasta brain, selecione-o na janela Inspector e arraste o novo modelo GridWorldLearning 1 para o campo Model dos parâmetros Brain Parameters:

Carregando o cérebro no campo Modelo de Gráfico
Nesse estágio, não precisamos alterar nenhum outro parâmetro, mas preste atenção especial em como o cérebro está configurado. Por enquanto, as configurações padrão serão suficientes.
Clique em Reproduzir no editor do Unity e veja como o agente se move com sucesso pelo jogo.
O sucesso do agente no jogo depende do tempo de seu treinamento. Se você permitir que ele complete o treinamento, o agente será semelhante a um agente do Unity totalmente treinado.