Em deep reinforcement learning/aprendizagem de reforço profundo (RL), resolver os jogos da Atari, Montezuma’s Revenge e Pitfall tem sido um grande desafio.

Esses jogos representam uma ampla classe de problemas desafiadores, do mundo real, chamados de “problemas de exploração difícil”, em que um agente precisa aprender tarefas complexas com um feedback muito pouco frequente ou enganoso.

O algoritmo de última geração em Montezuma’s Revenge obtém uma pontuação média de 11.347, uma pontuação máxima de 17.500, e resolveu o primeiro nível em um ponto em uma das dez tentativas. Surpreendentemente, apesar do considerável esforço de pesquisa, até agora nenhum algoritmo obteve uma pontuação maior que 0 em Pitfall.

Apresentamos o Go-Explore, uma nova família de algoritmos capaz de atingir mais de 2.000.000 de pontos em Montezuma’s Revenge e marcar mais de 400.000 em média! O Go-Explore soluciona de maneira confiável todo o jogo, ou seja, todos os três níveis exclusivos e, em seguida, é generalizado para os níveis subsequentes quase idênticos (que diferem apenas no tempo dos eventos e na pontuação da tela). Já vimos chegar ao nível 159!

No Pitfall, o Go-Explore alcança uma pontuação média de mais de 21.000, superando em muito o desempenho humano médio e pontuando acima de zero pela primeira vez em qualquer algoritmo de aprendizado.

Para fazê-lo, ele percorre 40 cenários, exigindo que ele balance em cordas sobre a água, salte sobre crocodilos, alçapões e mova barris, suba escadas e navegue em outros perigos.

Tudo dito, Go-Explore avança a última geração em Montezuma’s Revenge e Pitfall em duas ordens de magnitude e 21.000 pontos, respectivamente.

Ele não usa demonstrações humanas, mas também supera o desempenho de última geração nos algoritmos de aprendizagem de imitação de Montezuma’s Revenge, que recebem a solução na forma de demonstrações humanas.

O Go-Explore pode se beneficiar do conhecimento de domínio humano (sem a exigência onerosa de que um ser humano resolva toda a tarefa para fornecer uma demonstração), e os resultados acima o usam.

O conhecimento de domínio é mínimo e facilmente obtido a partir de pixels, destacando a capacidade profunda do Go-Explore de aproveitar o conhecimento mínimo a priori.

No entanto, mesmo sem qualquer conhecimento de domínio, o Go-Explore pontua mais de 35.000 pontos no Montezuma’s Revenge, que é mais de três vezes do que a última geração.

O Go-Explore difere radicalmente de outros algoritmos de RL profundos. Achamos que isso poderia permitir um rápido progresso em uma variedade de problemas importantes e desafiadores, especialmente a robótica.

Portanto, esperamos que isso ajude as equipes da Uber e de outros lugares a aproveitar cada vez mais os benefícios da inteligência artificial.

Atualização: Encorajamos você a ler a nova seção abaixo intitulada “Atualização sobre a questão da estocasticidade” para entender como nossos resultados se relacionam com outras variações do benchmark.

O desafio da exploração

Problemas com recompensas infrequentes são difíceis porque ações aleatórias são improváveis ​​de produzir recompensa, tornando impossível aprender. Montezuma’s Revenge é um desses “problemas com recompensas esparsas”.

Ainda mais difícil é quando as recompensas são enganosas, o que significa que a maximização das recompensas a curto prazo ensina a um agente a coisa errada a se fazer em relação a alcançar uma pontuação muito maior no geral.

Pitfall é enganoso desta maneira, porque muitas ações levam a pequenas recompensas negativas (como acertar um inimigo), então a maioria dos algoritmos aprende a não se mover e como resultado nunca aprendem a coletar tesouros difíceis de se obter. Muitos problemas desafiadores do mundo real são ao mesmo tempo escassos e enganosos.

Os algoritmos RL comuns geralmente não conseguem sair do primeiro cenário de Montezuma’s Revenge (pontuação de 400 ou menos) e pontuan 0 ou menos em Pitfall. Para tentar resolver esses desafios, os pesquisadores adicionam bônus para exploração, frequentemente chamados de motivação intrínseca (IM), aos agentes, que os recompensam por alcançar novos estados (situações ou locais).

Apesar dos algoritmos de IM serem especificamente projetados para lidar com problemas de recompensa esparsa, eles ainda lutam contra Montezuma’s Revenge e Pitfall. O melhor raramente resolve o nível 1 de Montezuma’s Revenge e falha completamente em Pitfall, recebendo uma pontuação zero.

Nossa hipótese é que uma grande fraqueza dos algoritmos de IM atuais é o desprendimento/descolamento, em que os algoritmos esquecem as áreas promissoras que visitaram, o que significa que não retornam a eles para ver se levam a novos estados. Como exemplo, imagine um agente entre as entradas de dois labirintos.

Pode, por acaso, começar a explorar o labirinto do Oeste e o IM pode levá-lo a aprender a atravessar, digamos, 50% dele. Como os algoritmos atuais se espalham aleatoriamente (em ações ou parâmetros) para tentar novos comportamentos para encontrar recompensas explícitas ou intrínsecas, por acaso o agente pode em algum momento começar a explorar o labirinto do leste, onde também encontrará muita recompensa intrínseca.

Depois de explorar completamente o labirinto do Leste, não tem memória explícita da promissora fronteira de exploração que abandonou no labirinto do Oeste.

É provável que não haja memória implícita dessa fronteira, seja devido ao problema bem estudado de um catastrófico esquecimento na IA.

Pior ainda, o caminho que conduz à fronteira no labirinto do Oeste já foi explorado, de modo que não há (ou há pouca) motivação intrínseca para redescobri-lo.

Assim, dizemos que o algoritmo se desprendeu/deslocou da fronteira dos estados que fornecem motivação intrínseca. Como resultado, a exploração pode parar quando as áreas próximas de onde as visitas atuais do agente já foram exploradas.

Esse problema seria remediado se o agente retornasse a áreas promissoras previamente descobertas para exploração.

Go-Explore

O Go-Explore separa o aprendizado em duas etapas: exploração e robustificar.

Fase 1: Explore até resolvido. O Go-Explore constrói um arquivo de estados de jogo curiosamente diferentes (que chamamos de “células”) e trajetórias que levam a eles, da seguinte maneira:

Repita até resolvido:

• 1 – Escolha uma célula do arquivo probabilisticamente (opcionalmente prefira as promissoras, por exemplo, células mais novas)
• 2 – Volte para aquela cela
• 3 – Explore a partir dessa célula (por exemplo, aleatoriamente para n etapas)
• 4 – Para todas as celas visitadas (incluindo novas celas), se a nova trajetória for melhor (por exemplo, maior pontuação), troque-a como a trajetória para alcançar aquela célula

Ao armazenar explicitamente uma variedade de stepping stones/“pedras onde se pode pisar”/ trampolins em um arquivo, o Go-Explore lembra e retorna a áreas promissoras para exploração (diferentemente do que tende a acontecer quando se treinam políticas com motivação intrínseca).

Além disso, primeiro retornando às células antes de explorá-las (preferindo células distantes e de difícil acesso), o Go-Explore evita explorar excessivamente os estados facilmente alcançados (por exemplo, perto do ponto de partida) e, em vez disso, concentra-se em expandir sua esfera de conhecimento.

Finalmente, como o Go-Explore tenta visitar todos os estados acessíveis, ele é menos suscetível a funções de recompensa enganosas. Essas ideias serão reconhecíveis para aqueles familiarizados com algoritmos de diversidade de qualidade e discutiremos abaixo como o Go-Explore representa um novo tipo de algoritmo de diversidade de qualidade.

Fase 2: Robustificar (se necessário). Se as soluções encontradas não forem robustas ao ruído (como é o caso de nossas trajetórias Atari), as robustifique em uma rede neural profunda com um algoritmo de aprendizado de imitação.

Representações celulares

Para ser tratável em espaços de estado de alta dimensão como o Atari, o Go-Explore precisa de uma representação de célula de dimensão inferior para com ela formar seu arquivo.

Assim, a representação da célula deve conflitar estados que são semelhantes o suficiente para não valer a pena explorar separadamente (e não conflitar estados que são significativamente diferentes).

Importante, mostramos que o conhecimento de domínio específico do jogo não é necessário para criar tal representação. Descobrimos que o que é talvez a representação celular mais ingênua possível funcionou muito bem: simplesmente reduzir a escala da resolução do quadro de jogo atual.

Voltando para as células

Retornar para uma célula (antes de explorar) pode ser obtido de três maneiras, dependendo das restrições do ambiente. Em ordem de eficiência:

• Em um ambiente reajustável, pode-se simplesmente redefinir o estado do ambiente para o da célula
• Em um ambiente determinista, pode-se repetir a trajetória para a célula
• Em um ambiente estocástico, pode-se treinar uma política condicionada por metas [1, 10] que aprenda a retornar de maneira confiável a uma célula

Embora os problemas mais interessantes sejam estocásticos, um insight fundamental por trás do Go-Explore é que podemos primeiro resolver o problema e então lidar com o fazer a solução mais robusta depois (se necessário).

Em particular, em contraste com a visão usual do determinismo como um obstáculo para a produção de agentes que são robustos e de alto desempenho, ele pode se tornar um aliado ao aproveitar o fato de que os simuladores podem ser feitos de forma determinística e reajustável (salvando/economizando e restaurando o estado do simulador), e posteriormente pode ser estocástico para criar uma política mais robusta (incluindo a adição de randomização de domínio).

Essas observações são especialmente relevantes para as tarefas de robótica, nas quais o treinamento é frequentemente feito em simulação antes que as políticas sejam transferidas para o mundo real.

O Atari é reajustável, portanto, por questões de eficiência, retornamos às células visitadas anteriormente, carregando o estado do jogo.

Em Montezuma’s Revenge, essa otimização nos permite resolver o primeiro nível 45 vezes mais rápido do que repetindo trajetórias. No entanto, esse acesso ao emulador não é necessário para o Go-Explore funcionar; apenas torna mais rápido.

Neste trabalho, depois que o agente retorna a uma célula, ele explora simplesmente tomando ações aleatórias (com uma alta probabilidade de repetir a ação anterior).

Note que tal exploração não requer uma rede neural ou outro controlador, e toda a exploração nos experimentos seguintes não usa uma (embora as redes neurais sejam usadas para a robustez).

Essa exploração totalmente aleatória funciona tão bem, que destaca o surpreendente poder de simplesmente retornar às células interessantes.

Resultados da fase de exploração

Com a representação da célula da imagem com escala reduzida, o Go-Explore de Montezuma’s Revenge de Montezuma atinge uma média de 37 cenários e resolve nível 1 (que contém 24 cenários, nem todos precisam ser visitados) 65 por cento do tempo. A última geração anterior [3] explorou 22 cenários em média.

Robustificar

Nossa versão atual do Go-Explore explora o determinismo para encontrar soluções (trajetórias de alto desempenho) mais rapidamente. Tais trajetórias são frágeis: elas não se generalizam nem mesmo para estados ligeiramente diferentes, incluindo aqueles criados pela maneira clássica de tornar o Atari um pouco estocástica, que é forçar o agente a não fazer nada um número aleatório de vezes até 30 antes de iniciar o jogo.

O Go-Explore resolve esse problema de fragilidade com o aprendizado de imitação, um tipo de algoritmo que pode aprender uma política robusta e livre de modelos a partir de demonstrações.

Tipicamente, esses algoritmos usam demonstrações humanas [2, 5, 6, 9], mas a Fase 1 do Go-Explore pode gerar automaticamente tais demonstrações (e muitas delas, se mais forem úteis).

Qualquer algoritmo confiável de aprendizado de imitação funcionaria. Para este trabalho inicial, escolhemos o algoritmo “backward/atrasado/regressivo” de Salimans & Chen, porque ele é de código aberto e foi mostrado para resolver Montezuma’s Revenge quando foi fornecida uma demonstração gerada por humanos.

Achamos que não é confiável aprender com uma única demonstração. No entanto, como o Go-Explore pode produzir muitas demonstrações, modificamos o algoritmo atrasado para aprender simultaneamente a partir de várias demonstrações (neste caso, 4 e, nas experiências posteriores, com conhecimento de domínio 10).

Também adicionamos um número aleatório de no-ops (comandos que não fazem nada) à condição inicial para tornar a política robusta a esse tipo de estocasticidade.

Resultados com políticas robustas de redes neurais profundas

Todas as tentativas de produzir políticas robustas a partir das trajetórias que resolvem o nível 1 de Montezuma’s Revenge funcionaram. A pontuação média é de 35.410, que é mais do que o triplo da última geração anterior de 11.347 e bate levemente a média de especialistas humanos [5] de 34.900!

Adicionando conhecimento de domínio

A capacidade de um algoritmo de integrar conhecimento de domínio fácil de fornecer pode ser um ativo importante. O Go-Explore oferece a oportunidade de alavancar o conhecimento do domínio na representação da célula (embora a rede neural final ainda seja reproduzida diretamente a partir dos pixels apenas).

Em particular, testamos uma versão de conhecimento de domínio do Go-Explore no Montezuma’s Revenge, em que as células eram definidas como combinações exclusivas da posição x-y do agente, o cenário atual, o nível atual e o número atual de chaves retidas. Nós escrevemos um código simples para extrair esta informação diretamente dos pixels.

Com essa representação de estado aprimorada, a Fase 1 do Go-Explore localiza 238 cenários impressionantes, resolve em média 9 níveis, e faz isso na metade do número de etapas do emulador em comparação com a representação da célula de imagem com escala reduzida.

Resultados robustecidos

Robustificar as trajetórias encontradas com a versão de conhecimento de domínio do Go-Explore produz políticas de redes neurais profundas que resolvem com segurança os primeiros 3 níveis de Montezuma’s Revenge (e são robustos a números aleatórios de no-ops iniciais).

Porque neste jogo todos os níveis além do nível 3 são quase idênticos (como descrito acima), o Go-Explore resolveu o jogo inteiro!

De fato, nossos agentes generalizam além de suas trajetórias iniciais, em média, resolvendo 29 níveis e alcançando uma pontuação de 469.209!

Isso quebra a última geração de Montezuma’s Revenge, tanto para algoritmos RL tradicionais quanto para algoritmos de aprendizado de imitação que receberam a solução na forma de uma demonstração humana.

Inacreditavelmente, algumas redes neurais da Go-Explore alcançam pontuações superiores a 2 milhões e alcançam o nível 159!

Para ver o que esses agentes podem fazer, tivemos que aumentar o tempo que o OpenAI’s Gym permite que os agentes joguem o jogo. A pontuação máxima do Go-Explore é substancialmente maior do que o recorde mundial humano de 1.219.200, alcançando até mesmo a definição mais estrita de “desempenho sobre-humano”.

O vídeo completo desta corrida que quebrou o recorde é de 53 minutos, mesmo quando acelerado 4x. O agente não morre, mas entra no limite de tempo (já bastante aumentado).

Pitfall

Pitfall também requer uma exploração significativa e é mais difícil do que o Montezuma’s Revenge porque suas recompensas são mais esparsas (apenas 32 recompensas positivas espalhadas por 255 cenários) e muitas ações geram pequenas recompensas negativas que dissuadem os algoritmos RL de explorar o ambiente.

Até hoje, nenhum algoritmo RL que conhecemos coletou até mesmo uma única recompensa positiva neste jogo (sem receber demonstrações humanas).

Em contraste, o Go-Explore com conhecimento de domínio mínimo (posição na tela e número do cenário, ambos obtidos de pixels) é capaz de visitar todos os 255 cenários e coletar mais de 60.000 pontos na fase de exploração do algoritmo.

Sem conhecimento de domínio (ou seja, a representação de pixels com redução de escala), o Go-Explore encontra impressionantes 22 cenários, mas não encontra nenhuma recompensa.

Acreditamos que a representação de pixels com redução de escala tenha um baixo desempenho em Pitfall porque o jogo contém muitos estados diferentes que possuem representações de pixel idênticas (ou seja, cenários de aparência idêntica em locais diferentes no jogo).

Diferenciar esses estados sem conhecimento de domínio provavelmente exigirá uma representação do estado que leve em conta estados anteriores ou outras técnicas que planejamos investigar.

A partir das trajetórias coletadas na fase de exploração, podemos robustecer de maneira confiável as trajetórias que coletam mais de 21.000 pontos, superando substancialmente a última geração e o desempenho humano médio.

Trajetórias mais longas e de maior pontuação se mostraram difíceis de serem robustificadas, possivelmente porque diferentes comportamentos podem ser necessários para estados visualmente indistinguíveis. Acreditamos que este problema é solucionável com pesquisas adicionais em técnicas que ajudem o agente a desambiguar tais estados.

Uma política de rede neural robusta e profunda que define o registro de AI em Pitfall, marcando mais de 21.000 pontos (sem contar os 2.000 pontos dados no início).

Três insights principais

Acreditamos que o Go-Explore funciona tão bem em problemas de exploração difícil devido a três princípios fundamentais:

• 1 – Lembra de bons trampolins de exploração (estados interessantes visitados até agora)
• 2 – Primeiro retorna a um estado, e então explora
• 3 – Primeiro resolve um problema, depois robustifica (se necessário)

Esses princípios não existem na maioria dos algoritmos RL, mas seria interessante construí-los/tecê-los. Como discutido acima, os algoritmos RL contemporâneos não fazem o número 1.

O número 2 é importante porque os algoritmos RL atuais exploram perturbando aleatoriamente os parâmetros ou ações de a política atual na esperança de explorar novas áreas do meio ambiente, que é ineficaz quando a maioria das mudanças quebra ou altera substancialmente uma política de tal forma que não pode primeiro retornar a estados difíceis de alcançar antes de explorar mais a partir deles.

Este problema torna-se pior quanto mais longa, mais complexa e mais precisa é a sequência de ações necessárias para atingir um estado.

O Go-Explore resolve esse problema primeiro retornando a um estado e explorando a partir daí. Isso permite uma exploração profunda que pode encontrar uma solução para o problema, que pode então ser robustecida para produzir uma política confiável (princípio número 3).

A ideia de preservar e explorar a partir de trampolins em um arquivo vem da família de algoritmos de diversidade de qualidade (QD) (como MAP-elites [4, 8] e busca de novidades com competição local), e Go-Explore é um algoritmo QD aprimorado baseado em MAP-Elites.

No entanto, os algoritmos QD anteriores se concentram em explorar o espaço dos comportamentos perturbando aleatoriamente o arquivo atual de políticas (na verdade partindo de um trampolim no espaço da política, em vez de no espaço de estados), em vez de explicitamente explorar o espaço de estado partindo para explorar precisamente de onde no espaço de estado parou uma exploração anterior.

Com efeito, o Go-Explore oferece uma exploração significativamente mais controlada do espaço de estados do que outros métodos de QD, garantindo que o escopo de exploração seja cumulativo através do espaço de estados à medida que cada nova trajetória exploratória se afasta do ponto final de um anterior.

É notável que a versão atual do Go-Explore funcione tomando ações inteiramente aleatórias durante a exploração (sem qualquer rede neural!) e que seja eficaz mesmo quando aplicada a uma discretização muito simples do espaço de estados.

Seu sucesso, apesar dessa exploração surpreendentemente simplista, sugere fortemente que recordar e explorar a partir de bons trampolins é uma chave para a exploração efetiva, e que fazer isso, mesmo com uma exploração ingênua, ajuda a buscar mais do que métodos RL modernos profundos para encontrar novos estados e representar esses estados.

O Go-Explore poderia ser ainda mais poderoso combinando-o com representações aprendidas e efetivas e substituindo a atual exploração aleatória por políticas de exploração mais inteligentes. Estamos perseguindo esses dois caminhos.

O Go-Explore também demonstra como a exploração e o tratamento da estocasticidade ambiental são problemas que podem ser resolvidos separadamente, realizando-se primeiro a exploração em um ambiente determinista e, em seguida, robustecendo as soluções relevantes.

A dependência de ter acesso a um ambiente determinístico pode inicialmente parecer uma desvantagem do Go-Explore. No entanto, enfatizamos que os ambientes determinísticos estão disponíveis em muitos domínios RL populares, incluindo jogos de vídeos, simuladores robóticos ou até mesmo modelos mundiais instruídos.

Uma vez que uma solução frágil é encontrada, ou especialmente um conjunto diversificado de soluções frágeis, uma solução robusta pode então ser produzida na simulação.

Se o objetivo final é uma política para o mundo real (por exemplo, na robótica), pode-se usar qualquer uma das muitas técnicas disponíveis para transferir a política robusta da simulação para o mundo real [4, 7, 11].

Além disso, pretendemos demonstrar que é possível substituir os estados determinísticos de carregamento por uma política condicionada por metas que aprende a lidar com os ambientes estocásticos desde o início. Tal algoritmo ainda se beneficiaria dos três princípios-chave do Go-Explore.

Alguns podem objetar que, enquanto este método já funciona no domínio de alta dimensão do Atari-from-pixels, ele não pode escalar para domínios verdadeiramente de alta dimensão como simulações do mundo real.

Acreditamos que o método poderia funcionar lá, mas ele terá que se juntar/casar com uma representação de célula mais inteligente de estados curiosamente diferentes (por exemplo, representações aprendidas e comprimidas do mundo) com uma exploração inteligente (ao invés de aleatória).

Curiosamente, quanto mais conflação (mapeando mais estados para a mesma célula), mais se precisa de exploração inteligente para alcançar células qualitativamente diferentes. Além disso, aprender a explorar de forma inteligente a partir de qualquer célula dada permitiria a reutilização eficiente das habilidades necessárias para a exploração (por exemplo, caminhar).

Trabalho relatado

O Go-Explore é uma reminiscência de trabalhos anteriores que separam exploração/descobrimento e exploração. No entanto, o Go-Explore decompõe mais ainda três elementos de exploração/descobrimento: Acumule trampolins (estados curiosamente diferentes), retorne a trampolins promissores e explore-os em busca de trampolins adicionais (ou seja, os princípios #1 e #2 acima).

Os impressionantes resultados que o Go-Explore alcança ao inserir algoritmos muito simples para cada elemento mostram o valor dessa decomposição. Outra diferença em relação a todos os algoritmos RL atuais, como mencionado acima quando comparados a algoritmos QD, é que o Go-Explore não tenta alcançar estados novos ou de alto desempenho perturbando políticas que recentemente chegaram a novos estados, mas primeiro retorna a um estado sem qualquer perturbação, então explora a partir dele.

O aspecto do Go-Explore de primeiro encontrar uma solução e depois robustificar em torno dela tem precedente na Pesquisa de Política Orientada.

No entanto, esse método requer uma função de perda não enganosa, não esparsa e diferenciável para encontrar soluções, o que significa que não pode ser aplicada diretamente a problemas onde as recompensas são discretas, esparsas e/ou enganosas, como são no Atari e em muitos problemas do mundo real.

Além disso, a Pesquisa de Política Orientada requer um modelo diferenciado do mundo ou o aprendizado de um conjunto de modelos locais, o que, para ser tratável, requer que o estado completo do sistema seja observável durante o tempo de treinamento.

Conclusão

No geral, o Go-Explore é uma excitante nova família de algoritmos para resolver problemas de aprendizagem de reforço de exploração difícil, ou seja, aqueles com recompensas esparsas e/ou enganosas.

Ele abre um grande número de novas direções de pesquisa, incluindo a experimentação de diferentes arquivos, diferentes métodos para escolher a que células retornar, diferentes representações celulares, diferentes métodos de exploração e diferentes métodos de robustificação, como diferentes algoritmos de aprendizagem de imitação.

Também estamos animados para ver quais tipos de domínios o Go-Explore é excelente e quando ele falha. Parece-nos um novo espaço de possibilidades para explorar e esperamos que se junte a nós na investigação deste terreno.

Para permitir que a comunidade se beneficie do Go-Explore e ajude a investigar seu potencial, o código-fonte e um documento completo descrevendo o Go-Explore estarão disponíveis aqui em breve.

Atualização sobre a questão da estocasticidade

Recebemos muitas mensagens em resposta ao nosso artigo do blog e agradecemos o feedback da comunidade. Abordaremos o máximo de questões que pudermos em nosso próximo artigo, mas quisemos atualizar mais rapidamente nossa postagem com nossos pensamentos sobre uma questão fundamental: a estocasticidade, incluindo as chamadas “ações aderentes”.

Um problema estocástico é aquele em que há alguma quantidade de aleatoriedade (por exemplo, devido ao vento). Queremos robôs e software que possam lidar com domínios de problemas estocásticos.

Entretanto, nosso trabalho levanta uma questão que poucos (incluindo nós) haviam considerado profundamente antes: nós nos importamos apenas que o produto final de um algoritmo de aprendizado de máquina (por exemplo, a “política” da rede neural resultante) manipule a estocasticidade (ou seja, se a estocasticidade é exigida apenas no ambiente de teste), ou devemos também exigir algoritmos de aprendizado para lidar com a estocasticidade durante o treinamento? Vamos pegar cada um por sua vez.

Estocasticidade durante o teste

Concordamos que os agentes devem, em última análise, operar em face da estocasticidade e, portanto, que os ambientes de teste devem ser estocásticos.

Desde pelo menos 2015, a maneira padrão de adicionar estocasticidade ao benchmark do Atari foi forçar o robô a não fazer nada (executar uma ação “sem operação”) um número aleatório de vezes até 30. Seguimos esta convenção.

Em 2017, uma nova proposta foi feita para adicionar um nível mais alto de estocasticidade por meio de “ações aderentes”, o que significa que cada ação tem a chance de ser repetida aleatoriamente.

Não estávamos cientes de uma mudança da forma convencional do benchmark antes de nossa postagem no blog, mas concordamos que essa variante do benchmark torna o ambiente de teste muito mais estocástico.

A maneira natural de o Go-Explore lidar com essa forma de estocasticidade é adicionar ações aderentes durante nossa fase de robustificação. Tais experimentos estão em andamento e nós reportaremos os resultados o mais rápido possível.

No entanto, testamos se nossas redes atuais já são robustas para ações aderentes e descobrimos que elas ainda produzem resultados substancialmente acima da última geração.

Quando testadas com ações aderentes, apesar de não serem treinadas para lidar com elas ainda, as redes treinaram com e sem conhecimento de domínio na pontuação média 19.540 e 72.543, respectivamente, em Montezuma’s Revenge, e 4.655 em Pitfall (com conhecimento de domínio), todos os quais superam a última geração anterior.

Como mencionado, esperamos que essas pontuações aumentem ainda mais quando tivermos tempo para fazer as coisas da maneira certa.

Estocasticidade durante o treinamento

Esse problema é complexo. Argumentamos que há alguns casos de uso em que não devemos exigir estocasticidade durante o treinamento e outros onde devemos. Nós começamos com o primeiro.

Para muitos problemas do mundo real, um simulador está frequentemente disponível (por exemplo, simuladores robóticos, simuladores de tráfego, etc.) e pode ser feito determinístico.

Em tais problemas, queremos uma solução final confiável (por exemplo, um robô que encontre sobreviventes de forma confiável após um desastre natural) e não devemos nos importar se conseguimos essa solução por meio de treinamento inicialmente determinístico.

Além disso, como os algoritmos RL atuais podem tomar ações inseguras e exigem uma quantidade tremenda de experiência para aprender, esperamos que a maioria das aplicações de RL no futuro previsível exija treinamento em um simulador.

O Go-Explore mostra que podemos resolver problemas anteriormente insolúveis, incluindo aqueles que são estocásticos no tempo de avaliação, através da criação de simuladores determinísticos. Por que não faríamos isso?

Dito isso, reconhecemos que há casos em que um simulador não está disponível, como aprender diretamente no mundo real, no qual os algoritmos de aprendizado devem enfrentar a estocabilidade durante o treinamento.

Como escrevemos em nossa postagem original, acreditamos que o Go-Explore pode lidar com essas situações treinando políticas condicionadas por objetivos durante a fase de exploração, uma hipótese que estamos testando atualmente.

Com esse framework em vigor, podemos revisitar nossa afirmação de que resolvemos Montezuma’s Revenge e produzimos resultados de última geração nesse benchmark.

Para fazer isso, temos que perguntar: que tipo de problema Montezuma’s Revenge deveria representar? O primeiro tipo (onde todos nós nos preocupamos é uma solução que é robusta a estocasticidade no tempo de teste) ou o segundo (situações em que o algoritmo deve lidar com a estocasticidade durante o treinamento)?

Acreditamos que poucos haviam considerado essa questão antes de nosso trabalho e que o Go-Explore criou um debate saudável sobre esse assunto.

Concluímos que devemos ter benchmarks para cada um. Uma versão de uma tarefa pode exigir estocasticidade somente durante o teste, e outra pode exigir estocasticidade durante o treinamento e o teste.

O Go-Explore produz resultados de última geração para o que pensávamos ser a versão clássica de Montezuma’s Revenge e Pitfall (estocasticidade requerida em testes apenas).

Com os novos resultados que acabamos de mencionar nesta atualização, isso acontece independentemente de essa estocasticidade ocorrer por meio de no-ops iniciais ou ações aderentes.

Mas nós não testamos o Go-Explore na versão de estocasticidade exigida em treinamento do Montezuma’s Revenge, onde a última geração atualmente pertence ao artigo da Random Network Distillation.

Em relação a Pitfall, as pessoas que leram nosso artigo nos informaram sobre dois artigos que alcançaram pontuações acima de zero em Pitfall.

Até onde sabemos, ambos são testados em uma versão puramente determinista do jogo (onde o Go-Explored marcou mais de 60.000 pontos antes de pararmos de executá-lo).

Embora ambos os artigos sejam interessantes, não mudamos nossa afirmação sobre algoritmos anteriores que não pontuam acima de zero, porque acreditamos que o benchmark clássico requer estocasticidade em tempo de teste via no-ops.

Esperamos que isso esclareça nosso pensamento atualizado sobre esse assunto e estabeleça um registro correto em relação às alegações de desempenho de última geração.

Atualização sobre a robustificação com ações aderentes

Como observamos em nossa atualização anterior, a maneira apropriada de “Go-Explore” lidar com ações aderentes é adicioná-las durante a Fase 2, a Fase de Robustificação.

Fazendo isso, nossas experiências foram concluídas e, embora esses números possam ser um pouco mais altos com treinamento adicional, achamos que vale a pena compartilhá-los na forma atual.

Note que eles são mais altos do que os relatados na palestra convidada de Jeff Clune no workshop NeurIPS Deep RL porque nós deixamos as corridas serem mais longas.

As redes neurais produzidas pelo Go-Explore quando robustecidas e depois testadas com estocasticidade na forma de ações aderentes em Montezuma’s Revenge alcançam uma média de 281.264 (e atingem o nível 18) com conhecimento de domínio e 33.836 sem conhecimento de domínio.

Em Pitfall, a pontuação média com conhecimento de domínio é 20.527 com um máximo de 64.616. Todos estes números ultrapassam substancialmente a última geração anterior (quando não requerem estocasticidade durante o treinamento, mas somente durante o teste, como discutido em nossa atualização anterior).

Curiosamente, o escore máximo de Pitfall de 64.616 foi alcançado ao robustificar uma trajetória que marcou apenas 22.505.

Assim, aprendeu com a demonstração habilidades que costumava generalizar para novas situações para mais do que triplicar sua pontuação, revelando um novo e interessante benefício da abordagem Go-Explore de adicionar uma fase de robustificação após a descoberta de uma solução.

***

Este artigo é do Uber Engineering. Ele foi escrito por Adrien Ecoffet, Joost Huizinga, Joel Lehman, Kenneth O. Stanley e Jeff Clune. A tradução foi feita pela Redação iMasters com autorização. Você pode conferir o original em: https://eng.uber.com/go-explore/