Mudança média python numpy

Este é um wrapper Python para TA-LIB com base em Cython em vez de SWIG. Na página inicial: a TA-Lib é amplamente utilizada pelos desenvolvedores de software que exigem a análise técnica dos dados do mercado financeiro. Inclui 150 indicadores como ADX, MACD, RSI, estocástico, Bandas Bollinger, etc. Reconhecimento de padrão de castiçal API de fonte aberta para CC, Java, Perl, Python e 100 Managed. NET. As ligações originais de Python usam SWIG que, infelizmente, são difíceis de instalar. E não são tão eficientes quanto poderiam ser. Portanto, este projeto usa Cython e Numpy para se conectar de forma eficiente e limpa a TA-Lib - produzindo resultados 2-4 vezes mais rápido do que a interface SWIG. Instale o TA-Lib ou Leia os Documentos Semelhantes ao TA-Lib, a interface da função fornece um invólucro leve dos indicadores expostos do TA-Lib. Cada função retorna uma matriz de saída e tem valores padrão para seus parâmetros, a menos que especificado como argumentos de palavras-chave. Normalmente, essas funções terão um período de lookback inicial (um número necessário de observações antes que uma saída seja gerada) configurado para NaN. Todos os exemplos a seguir usam a função API: Calcule uma média móvel simples dos preços de fechamento: Cálculo de bandas de bollinger, com média móvel exponencial tripla: Cálculo do momento dos preços de fechamento, com um período de tempo de 5: Inicialização da API Resumo Se você estiver Já familiarizado com o uso da função API, você deve se sentir em casa usando a API abstrata. Cada função leva a mesma entrada, passada como um dicionário de matrizes Numpy: as funções podem ser importadas diretamente ou instanciadas pelo nome: a partir daí, as funções de chamada são basicamente as mesmas que a função API: Saiba mais sobre o uso mais avançado do TA-Lib aqui . Indicadores suportados Podemos mostrar todas as funções de TA suportadas pelo TA-Lib, seja como uma lista ou como um orden ordenado por grupo (por exemplo, Estudos de sobreposição, Indicadores de Momento, etc.): Função Grupos Aprendizagem de reforço de aprendizado: Pong de pixels Isso é muito atrasado Postagem no blog sobre Reforço de aprendizagem (RL). RL é quente Você pode ter notado que os computadores agora podem aprender a jogar jogos ATARI automaticamente (a partir de pixels do jogo bruto), eles estão batendo campeões do mundo em Go. Quadrúpedes simulados estão aprendendo a correr e a pular. E os robôs estão aprendendo a realizar tarefas de manipulação complexas que desafiam a programação explícita. Acontece que todos esses avanços estão sob o guarda-chuva da pesquisa RL. Também me interessei pelo RL no último ano: trabalhei no livro de Richard Suttons. Leia o curso David Silvers. Assistiu as palestras de John Schulmanns. Escreveu uma biblioteca RL em Javascript. Durante o verão internado na DeepMind trabalhando no grupo DeepRL e, mais recentemente, lançou um pouco sobre o design do desenvolvimento do OpenAI Gym. Um novo kit de ferramentas de benchmarking RL. Então, eu certamente estive neste movimento há pelo menos um ano, mas até agora não consegui escrever uma breve publicação sobre o motivo da RL é um grande negócio, sobre o que aconteceu, como tudo se desenvolveu e para onde poderia estar acontecendo. Exemplos de RL na natureza. Da esquerda para a direita . Deep Q Learning Network jogando ATARI, AlphaGo, Berkeley, empilhando robôs Legos, fisicamente simulado em quadrúpedes saltando sobre o terreno. É interessante refletir sobre a natureza do progresso recente na RL. Eu geralmente gostaria de pensar em quatro fatores separados que impedem AI: Compute (o óbvio: Lei Moores, GPUs, ASICs), Dados (em uma forma legal, não apenas em algum lugar na internet - por exemplo, ImageNet), Algoritmos ( Pesquisa e idéias, por exemplo, backprop, CNN, LSTM) e infra-estrutura (software sob você - Linux, TCPIP, Git, ROS, PR2, AWS, AMT, TensorFlow, etc.). Semelhante ao que aconteceu no Computer Vision, o progresso na RL não é conduzido tanto quanto você pode razoavelmente assumir por novas ideias incríveis. Em Computer Vision, o AlexNet de 2017 foi principalmente uma versão ampliada (maior e mais ampla) dos ConvNets dos anos 90. Da mesma forma, o trabalho ATARI Deep Q Learning a partir de 2017 é uma implementação de um algoritmo padrão (Q Aprendendo com aproximação de função, que você pode encontrar no livro RL padrão de Sutton, 1998), onde o calculador de função passou a ser um ConvNet. AlphaGo usa gradientes de políticas com Monte Carlo Tree Search (MCTS) - estes também são componentes padrão. Claro, é preciso muita habilidade e paciência para que ele funcione, e vários ajustes inteligentes sobre os algoritmos antigos foram desenvolvidos, mas para uma aproximação de primeira ordem, o principal driver do progresso recente não é os algoritmos, mas (semelhante Para Computer Vision) computedatainfrastructure. Agora volte para RL. Sempre que há uma desconexão entre o que parece mágico e o quão simples é sob o capô eu tenho todo o antsy e realmente quero escrever uma postagem de blog. Neste caso, eu vi muitas pessoas que não acreditam que podemos aprender automaticamente a jogar a maioria dos jogos da ATARI no nível humano, com um algoritmo, a partir de pixels e a partir do zero - e é incrível, e eu já estive lá. A abordagem que usamos também é muito profundamente idiota (embora eu ache que é fácil fazer essas afirmações em retrospectiva). De qualquer forma, eu gosto de orientá-lo através de Gradientes de políticas (PG), nossa opção padrão preferida por atacar problemas de RL no momento. Se você estiver fora de RL, você pode estar curioso porque não estou apresentando o DQN em vez disso, o que é um algoritmo de RL alternativo e mais conhecido, amplamente divulgado pelo jogo ATARI. Acontece que o Q-Learning não é um ótimo algoritmo (você poderia dizer que o DQN é tão 2017 (ok, Im 50 brincando)). Na verdade, a maioria das pessoas prefere usar os Gradientes de Políticas, incluindo os autores do documento DQN original que mostraram que os Gradientes de Políticas funcionam melhor que o Q Learning quando ajustados. PG é preferido porque é de ponta a ponta: há uma política explícita e uma abordagem baseada em princípios que otimiza diretamente a recompensa esperada. De qualquer forma, como um exemplo de corrida, aprenda a jogar um jogo ATARI (Pong) com PG, desde o ponto de vista, a partir de pixels, com uma rede neural profunda e o conjunto é 130 linhas de Python usando apenas numpy como uma dependência (link Gist) . Vamos lá. Pong de pixels à esquerda: o jogo de Pong. Direito: Pong é um caso especial de um Processo de Decisão Markov (MDP). Um gráfico onde cada nó é um determinado estado do jogo e cada vantagem é uma transição possível (em geral probabilística). Cada vantagem também dá uma recompensa, e o objetivo é calcular a maneira ideal de atuar em qualquer estado para maximizar as recompensas. O jogo de Pong é um excelente exemplo de uma simples tarefa RL. Na versão ATARI 2600, use-o como uma das pás (o outro é controlado por uma IA decente) e você tem que saltar a bola além do outro jogador (eu na verdade não preciso explicar Pong, certo). No nível baixo, o jogo funciona da seguinte forma: recebemos uma moldura de imagem (uma matriz de 210x160x3 bytes (inteiros de 0 a 255 que dão valores de pixel)) e nós decidimos se queremos mover a paddle UP ou DOWN (ou seja, um binário escolha). Depois de cada única escolha, o simulador de jogo executa a ação e nos dá uma recompensa: ou uma recompensa 1 se a bola passou pelo adversário, uma recompensa -1 se perdi a bola ou 0 de outra forma. E é claro, nosso objetivo é mover a padela para que recebamos muita recompensa. Ao passar pela solução, lembre-se de que, bem, tente fazer muito poucos pressupostos sobre Pong, porque secretamente não nos importamos muito com Pong. Nós nos preocupamos com problemas complexos e de alta dimensão, como manipulação de robôs, montagem e navegação. Pong é apenas um caso de teste de brinquedo divertido, algo com o qual jogamos enquanto descobrimos como escrever sistemas de AI muito gerais que podem um dia fazer tarefas úteis arbitrárias. Rede de políticas. Primeiro, deveríamos definir uma rede de políticas que implemente o nosso jogador (ou agente). Esta rede tomará o estado do jogo e decidirá o que devemos fazer (mover para cima ou para baixo). Como nosso bloco simples de cálculo simples, use uma rede neural de 2 camadas que leva os pixels da imagem bruta (100.800 números totais (2101603)) e produz um único número indicando a probabilidade de subir. Note-se que é padrão usar uma política estocástica, o que significa que nós apenas produzimos uma probabilidade de avançar. Toda iteração que amostrasmos dessa distribuição (ou seja, jogue uma moeda tendenciosa) para obter o movimento real. A razão para isso se tornará mais clara uma vez que falamos sobre treinamento. Nossa rede de políticas é uma rede completamente conectada de 2 camadas. E para tornar as coisas concretas aqui é como você pode implementar esta rede de políticas em Pythonnumpy. Suponhamos ter um vetor x que contém as informações de pixels (pré-processadas). Nós calcularíamos: onde neste snippet W1 e W2 há duas matrizes que inicializamos aleatoriamente. Não estava usando vícios porque eu. Observe que usamos a não linearidade sigmoide no final, que esmaga a probabilidade de saída para o intervalo 0,1. Intuitivamente, os neurônios na camada oculta (que tem os pesos dispostos ao longo das linhas de W1) podem detectar vários cenários de jogo (por exemplo, a bola está no topo e a nossa paddle está no meio), e os pesos em W2 podem então Decida se, em cada caso, devemos estar indo PARA CIMA ou ABAIXO. Agora, o aleatório inicial W1 e W2, naturalmente, faz com que o jogador espagueie no local. Então, o único problema agora é encontrar W1 e W2 que levem ao jogo especializado da impressão Pong Fine: pré-processamento. Idealmente, você deseja alimentar pelo menos 2 quadros na rede de políticas para que ele possa detectar o movimento. Para tornar as coisas um pouco mais simples (fiz essas experiências no meu Macbook), faço um pequeno trecho de pré-processamento, p. Ex. Bem, na verdade, alimente quadros de diferença para a rede (ou seja, subtração do atual e último quadro). Parece meio impossível. Neste ponto, gostaria que você apreciasse o quão difícil era o problema de RL. Recebemos 100.800 números (2101603) e encaminhemos nossa rede de políticas (que facilmente envolve na ordem de um milhão de parâmetros em W1 e W2). Suponha que decidimos ir para cima. O jogo pode responder que obtemos 0 recompensas neste momento e nos dá outros 100.800 números para a próxima moldura. Poderíamos repetir esse processo por cem timestaps antes de obtermos uma recompensa não-zero, E. g. Suponha que finalmente conseguimos um 1. Isso é ótimo, mas como podemos dizer o que fez isso acontecer. Era algo que fazíamos agora ou talvez 76 quadros atrás. Ou talvez tivesse algo a ver com o quadro 10 e depois com o quadro 90 E como nós achamos Qual dos milhões de botões a mudar e como, para fazer melhor no futuro, chamamos isso de problema de atribuição de crédito. No caso específico de Pong, sabemos que conseguimos um 1 se a bola passar pelo oponente. A verdadeira causa é que nós passamos a saltar a bola em uma boa trajetória, mas na verdade fizemos tantos quadros há - por exemplo, Talvez cerca de 20 no caso de Pong, e cada ação que fizemos depois teve efeito zero sobre se acabamos recebendo a recompensa ou não. Em outras palavras, enfrentaram um problema muito difícil e as coisas parecem bastante sombrias. Aprendizagem supervisionada. Antes de mergulhar na solução Policy Gradients Id, gostaria de lembrá-lo brevemente sobre a aprendizagem supervisionada, pois, também, veja, RL é muito semelhante. Consulte o diagrama abaixo. Na aprendizagem supervisionada ordinária, alimentaríamos uma imagem para a rede e obteríamos algumas probabilidades, p. ex. Para duas classes para cima e para baixo. Estou mostrando probabilidades de log (-1.2, -0.36) para UP e DOWN em vez das probabilidades brutas (30 e 70 neste caso) porque sempre otimizamos a probabilidade logarítmica do rótulo correto (isso torna as matemáticas mais bonitas e é equivalente a otimizar A probabilidade bruta porque o log é monotônico). Agora, na aprendizagem supervisionada, teríamos acesso a um rótulo. Por exemplo, pode-se dizer que a coisa correta a fazer agora é ir para cima (etiqueta 0). Em uma implementação, entraríamos gradiente de 1.0 na probabilidade de log de UP e executar backprop para calcular o vetor de gradiente (nabla log p (yUP mid x)). Este gradiente nos diria como devemos mudar cada um dos nossos milhões de parâmetros para tornar a rede um pouco mais propensa a prever UP. Por exemplo, um dos milhões de parâmetros na rede pode ter um gradiente de -2,1, o que significa que, se ampliássemos esse parâmetro por uma pequena quantidade positiva (por exemplo, 0,001), a probabilidade logarítmica de UP diminuirá em 2,1,001 ( Diminuição devido ao sinal negativo). Se, então, fizesse uma atualização de parâmetro, então, nossa rede agora seria um pouco mais propensa a prever UP quando ver uma imagem muito semelhante no futuro. Gradientes de políticas. Ok, mas o que fazemos se não possuímos o rótulo correto na configuração de Reforço de Aprendizado. Aqui está a solução de Gradientes de Política (consulte novamente o diagrama abaixo). Nossa rede de políticas calculou a probabilidade de subir UP como 30 (logprob -1.2) e DOWN como 70 (logprob -0.36). Agora amostraremos uma ação dessa distribuição. Suponha que amostraso DOWN, e vamos executá-lo no jogo. Neste ponto, note um fato interessante: podemos preencher imediatamente um gradiente de 1.0 para ABAIXO como fizemos em aprendizado supervisionado e encontrar o vetor de gradiente que incentivaria a rede a ser um pouco mais propensos a fazer a ação DOWN no ​​futuro. Então, podemos avaliar imediatamente esse gradiente e isso é ótimo, mas o problema é que, pelo menos por enquanto, ainda não sabemos se ir para baixo é bom. Mas o ponto crítico é que está tudo bem, porque podemos simplesmente esperar um pouco e ver Por exemplo, em Pong, poderíamos aguardar até o final do jogo, então pegue a recompensa que obtemos (ou seja, se ganhássemos ou -1 se perdêssemos ), E entre nesse escalar como o gradiente para a ação que tomamos (ABAIXO neste caso). No exemplo abaixo, ir para baixo acabou com a gente perdendo o jogo (-1 recompensa). Então, se preenchermos -1 para a probabilidade de log de DOWN e fazer backprop, encontraremos um gradiente que desencoraja a rede de tomar a ação DOWN para essa entrada no futuro (e com razão, uma vez que levar essa ação nos levou a perder o jogo ). E é isso: temos uma política estocástica que amostras de ações e, em seguida, as ações que acabam levando a bons resultados são encorajadas no futuro, e as ações tomadas que levam a resultados ruins são desencorajadas. Além disso, a recompensa nem precisa ser 1 ou -1 se ganharmos o jogo eventualmente. Pode ser uma medida arbitrária de algum tipo de eventual qualidade. Por exemplo, se as coisas acontecerem muito bem, poderia ser 10,0, o que, então, entraríamos como gradiente em vez de -1 para iniciar o backprop. Essa é a beleza das redes neurais. Usá-las pode sentir como trapaça: você pode ter 1 milhão de parâmetros incorporados em 1 teraflop de computação e você pode fazer coisas arbitrárias com o SGD. Não deve funcionar, mas divertidamente nós vivemos em um universo onde ele faz. Protocolo de treinamento. Então, aqui é como o treinamento funcionará em detalhes. Inicializaremos a rede de políticas com alguns W1. W2 e jogue 100 jogos de Pong (chamamos esses lançamentos de políticas). Vamos assumir que cada jogo é composto de 200 quadros, de modo que, no total, fizemos 20.000 decisões para ir para cima ou para baixo e, para cada um desses, conhecemos o gradiente do parâmetro, o que nos diz como devemos mudar os parâmetros se quisermos encorajar isso Decisão nesse estado no futuro. Tudo o que resta agora é rotular todas as decisões tomadas como boas ou ruins. Por exemplo, suponhamos que ganhamos 12 jogos e perdemos 88. Pegue todas as 20012 2400 decisões que fizemos nos jogos vencedores e faça uma atualização positiva (preenchendo um 1.0 no gradiente para a ação amostrada, fazendo backprop e atualização de parâmetros encorajando as ações Nós escolhemos em todos esses estados). E bem, tome as outras decisões do 20088 17600 que fizemos nos jogos perdidos e fizemos uma atualização negativa (desencorajando o que fizemos). E é isso. A rede agora se tornará um pouco mais propensa a repetir as ações que funcionaram, e um pouco menos propensos a repetir as ações que não funcionaram. Agora jogamos outros 100 jogos com nossa nova política ligeiramente melhorada e enxágue e repita. Gradientes de políticas: Execute uma política por um tempo. Veja quais ações levaram a altas recompensas. Aumente sua probabilidade. Diagrama dos desenhos animados de 4 jogos. Cada círculo preto é algum estado do jogo (três estados de exemplo são visualizados na parte inferior) e cada seta é uma transição, anotada com a ação que foi amostrada. Nesse caso, ganhamos 2 jogos e perdemos 2 jogos. Com os Gradientes de Políticas, nós levamos os dois jogos que ganhamos e incentivamos um pouco cada ação que fizemos nesse episódio. Por outro lado, também levamos os dois jogos que perdemos e desencorajamos ligeiramente todas as ações que fizemos nesse episódio. Se você pensar nesse processo, você começará a encontrar algumas propriedades engraçadas. Por exemplo, se fizéssemos uma boa ação no quadro 50 (saltando a bola de volta corretamente), mas então perdi a bola no quadro 150. Se cada ação única agora é rotulada como ruim (porque perdemos), isso não desencorajaria o salto correto Quadro 50 Você está certo - sim. No entanto, quando você considera o processo ao longo de milhares de milhões de jogos, então, fazer o primeiro salto com correção faz com que você possua mais chances de ganhar a estrada, então, em média, você verá atualizações mais positivas do que negativas para o salto correto e sua política acabará fazendo a coisa certa. Atualização: 9 de dezembro de 2017 - visão alternativa. Na minha explicação acima, uso os termos, como preencher o gradiente e backprop, o que eu percebo é um tipo especial de pensamento se você estiver escrevendo seu próprio código de backprop ou usando Torch onde os gradientes são explícitos e abertos para retoques. No entanto, se você estiver acostumado com Theano ou TensorFlow, você pode estar um pouco perplexo porque o código é oranizado em torno de especificar uma função de perda e o backprop é totalmente automático e difícil de mexer. Nesse caso, a seguinte visão alternativa pode ser mais intuitiva. Na aprendizagem supervisionada de baunilha, o objetivo é maximizar (sumi log p (yi mid xi)) onde (xi, yi) são exemplos de treinamento (como imagens e seus rótulos). Os gradientes de política são exatamente o mesmo que o aprendizado supervisionado com duas diferenças menores: 1) Não temos os rótulos corretos (yi), de modo que, como uma etiqueta falsa, substituímos a ação que passamos a provar da política quando viu (xi) e 2 ) Nós modulamos a perda para cada exemplo de forma multiplicativa com base no resultado final, uma vez que queremos aumentar a probabilidade de log para ações que funcionaram e diminuí-las para aqueles que não fizeram. Então, em resumo, nossa perda agora parece (sumi Ai log p (yi mid xi)), onde (yi) é a ação que passamos a amostra e (Ai) é um número que chamamos de vantagem. No caso de Pong, por exemplo, (Ai) poderia ser 1,0 se, eventualmente, ganhássemos no episódio que continha (xi) e -1,0 se perdêssemos. Isso garantirá que maximizamos a probabilidade logarítmica de ações que levaram a um bom resultado e minimizem a probabilidade logarítmica dos que não o fizeram. Assim, o aprendizado de reforço é exatamente como o aprendizado supervisionado, mas em um conjunto de dados em constante mudança (os episódios), escalados pela vantagem, e nós só queremos fazer uma (ou muito poucas) atualizações com base em cada conjunto de dados amostrado. Funções de vantagem mais gerais. Eu também prometi um pouco mais de discussão sobre os retornos. Até agora, julgamos a bondade de cada ação individual com base em se ganhamos ou não o jogo. Em uma configuração RL mais geral, receberíamos alguma recompensa (rt) em cada etapa. Uma escolha comum é usar uma recompensa com desconto, então a eventual recompensa no diagrama acima se tornaria (Rt sum gammak r), onde (gama) é um número entre 0 e 1 chamado fator de desconto (por exemplo, 0,99). A expressão afirma que a força com a qual incentivamos uma ação amostrada é a soma ponderada de todas as recompensas depois, mas as recompensas posteriores são exponencialmente menos importantes. Na prática, também pode ser importante normalizá-los. Por exemplo, suponha que nós computem (Rt) para todas as 20.000 ações no lote de lançamentos de jogos de 100 Pong acima. Uma boa idéia é padronizar esses retornos (por exemplo, subtrair média, dividir por desvio padrão) antes de conectá-los em backprop. Desta forma, sempre foram encorajadores e desencorajando cerca de metade das ações realizadas. Matematicamente, você também pode interpretar esses truques como uma maneira de controlar a variância do estimador de gradiente de política. Uma exploração mais aprofundada pode ser encontrada aqui. Derivados de política de derivação. Eu também gostaria de dar um esboço de onde os Gradientes de Políticas provêm matematicamente. Gradientes de política são um caso especial de um estimador de gradiente de função de pontuação mais geral. O caso geral é que quando temos uma expressão da forma (E f (x)) - ou seja, a expectativa de alguma função de pontuação escalar (f (x)) em alguma distribuição de probabilidade (p (xtheta)) parametrizada por alguns ( Theta). A dica de dica, (f (x)) se tornará a nossa função de recompensa (ou a função de vantagem em geral) e (p (x)) será a nossa rede de políticas, que é realmente um modelo para (p (meia I)), dando Uma distribuição sobre ações para qualquer imagem (I). Então, estamos interessados ​​em descobrir como devemos mudar a distribuição (através de seus parâmetros (theta)) para aumentar as pontuações de suas amostras, conforme julgado por (f) (ou seja, como mudamos os parâmetros das redes para que as amostras de ação obtenham recompensas mais elevadas ). Nós temos isso: para colocar isso em inglês, temos alguma distribuição (p (xtheta)) (usei taquigrafia (p (x)) para reduzir a desordem) de que podemos experimentar (por exemplo, isso pode ser um gaussiano). Para cada amostra, também podemos avaliar a função de pontuação (f) que leva a amostra e nos dá um escore escalonado. Esta equação está nos dizendo como devemos mudar a distribuição (por meio de seus parâmetros (theta)) se quisermos que suas amostras alcancem pontuações mais altas, conforme julgado por (f). Em particular, diz que olhe: desenhe algumas amostras (x), avalie suas pontuações (f (x)), e para cada (x) também avalie o segundo termo (nabla log p (xtheta)). O que é este segundo termo É um vetor - o gradiente que está nos dando a direção no espaço de parâmetros que levaria ao aumento da probabilidade atribuída a (x). Em outras palavras, se estivéssemos empurrar (theta) na direção de (nabla log p (xtheta)) veríamos a nova probabilidade atribuída a alguns (x) aumentar ligeiramente. Se você olha para trás na fórmula, está nos dizendo que devemos seguir esta direção e multiplicar nele a pontuação escalonada (f (x)). Isso fará com que as amostras que tenham uma pontuação maior arrasarão a densidade de probabilidade mais forte do que as amostras com menor pontuação, então, se fôssemos fazer uma atualização com base em várias amostras de (p), a densidade de probabilidade mudaria em torno de A direção de pontuações mais altas, tornando as amostras altamente pontuais mais prováveis. Uma visualização do estimador de gradiente de função de pontuação. Esquerda . Uma distribuição gaussiana e algumas amostras dele (pontos azuis). Em cada ponto azul também traçamos o gradiente da probabilidade de log em relação ao parâmetro médio dos gaussianos. A seta indica a direção na qual a média da distribuição deve ser empurrada para aumentar a probabilidade dessa amostra. Médio. Sobreposição de alguma função de pontuação dando -1 em todos os lugares, exceto 1 em algumas regiões pequenas (note que esta pode ser uma função arbitrária e não necessariamente diferencial de valor escalar). As setas agora são codificadas por cores porque devido à multiplicação na atualização, vamos em média todas as setas verdes e o negativo das setas vermelhas. Certo . Após a atualização do parâmetro, as setas verdes e as setas vermelhas invertidas nos cutucam para a esquerda e para a parte inferior. As amostras dessa distribuição agora terão uma pontuação esperada mais alta, conforme desejado. Espero que a conexão com a RL seja clara. Nossa rede de políticas nos fornece exemplos de ações, e algumas funcionam melhor do que outras (conforme julgado pela função de vantagem). Esta pequena peça de matemática está nos dizendo que a maneira de mudar os parâmetros da polícia é fazer alguns lançamentos, assumir o gradiente das ações amostradas, multiplicá-la pela pontuação e adicionar tudo, o que foi feito acima. Para uma derivação e discussão mais completa, recomendo a leitura de John Schulmans. Aprendendo . Tudo bem, desenvolvemos a intuição para os gradientes de políticas e vimos um esboço de sua derivação. Eu implementei toda a abordagem em um script Python de 130 linhas. Que usa OpenAI Gym s ATARI 2600 Pong. Eu treinei uma rede de políticas de 2 camadas com 200 unidades de camada oculta usando RMSProp em lotes de 10 episódios (cada episódio é uma dúzia de jogos, porque os jogos chegam a uma pontuação de 21 para qualquer jogador). Eu não ajustei os hiperparâmetros demais e executei o experimento no Macbook (lento), mas depois de treinar por 3 noites acabei com uma política ligeiramente melhor do que o jogador AI. O número total de episódios foi de aproximadamente 8.000, de modo que o algoritmo jogou aproximadamente 200.000 jogos Pong (bastante não é) e realizou um total de 800 atualizações. Eu disse aos amigos que, se você treinar na GPU com ConvNets por alguns dias, você pode vencer o jogador da AI com mais freqüência e, se você também otimizar cuidadosamente os hiperparâmetros, você também pode dominar consistentemente o jogador da IA ​​(ou seja, vencer todos os jogos). No entanto, eu não passava muito tempo informando ou ajustando, então, ao invés disso, acabamos com um Pong AI que ilustra as idéias principais e funciona muito bem: o agente aprendido (no verde, à direita) de frente para fora com o oponente de AI codificado esquerda). Aprendeu pesos. Podemos também dar uma olhada nos pesos aprendidos. Devido ao pré-processamento, cada uma de nossas entradas é uma imagem de diferença de 80x80 (quadro atual menos último quadro). Agora podemos levar cada linha de W1. Esticá-los para 80x80 e visualizar. Abaixo está uma coleção de 40 neurônios (em 200) em uma grade. Os pixels brancos são pesos positivos e os pixels pretos são pesos negativos. Observe que vários neurônios são sintonizados em traços particulares de bola saltando, codificados com alternando preto e branco ao longo da linha. A bola só pode estar em um único ponto, então esses neurônios são multitarefa e dispararão para vários locais da bola ao longo dessa linha. A alternância de preto e branco é interessante porque, à medida que a bola viaja ao longo do traço, a atividade dos neurônios flutuará como uma onda senoidal e, devido ao ReLU, ele dispararia em posições discretas e separadas ao longo do traçado. Há um pouco de ruído nas imagens, o que eu suponho que teria sido mitigado se eu usasse a regularização de L2. O que não está acontecendo Então lá você tem isso - nós aprendemos a jogar Pong a partir de pixels em bruto com gradientes de políticas e isso funciona bastante bem. A abordagem é uma forma elegante de adivinhar e verificar, onde o adivinho refere-se a lançamentos de amostragem de nossa política atual, e o cheque refere-se a ações encorajadoras que levam a bons resultados. Modulo alguns detalhes, isso representa o estado da arte em como atualmente abordamos problemas de aprendizagem de reforço. É impressionante que possamos aprender esses comportamentos, mas se você entendeu intuitivamente o algoritmo e você sabe como funciona, você deve estar um pouco decepcionado. Em particular, como isso não funciona Compare isso com a forma como um ser humano pode aprender a jogar Pong. Você mostra o jogo e diz algo ao longo das linhas de Youre no controle de uma pá e você pode movê-lo para cima e para baixo, e sua tarefa é saltar a bola além do outro jogador controlado pela AI, e você está pronto e pronto para ir . Observe algumas das diferenças: em configurações práticas geralmente comunicamos a tarefa de alguma maneira (por exemplo, inglês acima), mas em um problema de RL padrão você assume uma função de recompensa arbitrária que você precisa descobrir através de interações ambientais. Pode-se argumentar que se um humano entrou no jogo de Pong, mas sem saber nada sobre a função de recompensa (de fato, especialmente se a função de recompensa fosse alguma função estática, mas aleatória), o humano teria muita dificuldade em aprender o que fazer, mas Gradientes de política seria indiferente, e provavelmente funcionará muito melhor. Da mesma forma, se tomarmos os quadros e permutássemos os pixels de forma aleatória, então os humanos provavelmente falhariam, mas nossa solução de Gradiente de Política não poderia nem mesmo dizer a diferença (se estiver usando uma rede totalmente conectada como feita aqui). Um humano traz uma grande quantidade de conhecimento prévio, como a física intuitiva (a bola salta, é improvável que se teleporte, é improvável que pareça de repente, mantém uma velocidade constante, etc.) e psicologia intuitiva (o oponente de IA quer Ganhar, é provável que siga uma óbvia estratégia de se mover para a bola, etc.). Você também entende o conceito de estar no controle de uma pá, e que ele responde aos comandos da tecla UPDOWN. Em contraste, nossos algoritmos começam a partir do zero, que é simultaneamente impressionante (porque funciona) e deprimente (porque faltamos idéias concretas sobre como não fazer isso). Gradientes de política são uma solução de força bruta, onde as ações corretas são eventualmente descobertas e internalizadas em uma política. Os seres humanos constroem um modelo e plano rico e abstrato dentro dele. Em Pong, posso argumentar que o oponente é bastante lento, por isso pode ser uma boa estratégia para saltar a bola com alta velocidade vertical, o que faria com que o oponente não atira a tempo. No entanto, também parece que também podemos internalizar as boas soluções no que se sente mais como uma política de memória muscular reativa. Por exemplo, se você estiver aprendendo uma nova tarefa de motor (por exemplo, dirigindo um carro com mudança de palito), muitas vezes sente-se pensando muito no começo, mas eventualmente a tarefa se torna automática e sem sentido. Os Gradientes de Políticas têm que realmente experimentar uma recompensa positiva, e experimentá-lo com muita frequência, a fim de mudar eventualmente e lentamente os parâmetros da política para movimentos repetitivos que dão altas recompensas. Com o nosso modelo abstrato, os seres humanos podem descobrir o que é susceptível de dar recompensas sem nunca experimentar a transição gratificante ou sem recompensas. Eu não tenho que realmente experimentar bater meu carro em uma parede algumas centenas de vezes antes de começar lentamente a evitar fazê-lo. À esquerda: Montezumas Revenge: um jogo difícil para nossos algoritmos RL. O jogador deve pular, subir, pegar a chave e abrir a porta. Um humano entende que a aquisição de uma chave é útil. O computador analisa bilhões de movimentos aleatórios e 99 do tempo caem em sua morte ou são mortos pelo monstro. Em outras palavras, é difícil tropeçar na situação gratificante. Certo: outro jogo difícil chamado Frostbite, onde um humano entende que as coisas se movem, algumas coisas são boas para tocar, algumas coisas são ruins ao tocar, e o objetivo é construir o tijolo de iglu por tijolo. Uma boa análise deste jogo e uma discussão das diferenças entre a abordagem humana e informática podem ser encontradas nas máquinas de construção que aprendem e pensam como pessoas. Eu também gostaria de enfatizar o fato de que, inversamente, há muitos jogos em que os Gradientes de Políticas derrotaram facilmente um humano. Em particular, qualquer coisa com freqüentes sinais de recompensa que requer uma jogada precisa, reflexos rápidos e não muito planejamento a longo prazo seria ideal, uma vez que estas correlações de curto prazo entre recompensas e ações podem ser facilmente percebidas pela abordagem e a execução meticulosamente Aperfeiçoado pela política. Você pode ver dicas que já estão acontecendo no nosso agente de Pong: ele desenvolve uma estratégia em que aguarda a bola e, em seguida, rapidamente se precipita para pegá-la apenas na borda, que aciona rapidamente e com alta velocidade vertical. O agente registra vários pontos consecutivos repetindo essa estratégia. Existem muitos jogos ATARI onde Deep Q Learning destrói o desempenho da linha de base humana dessa maneira - por ex. Pinball, Breakout, etc. Em conclusão, uma vez que você entenda o truque pelo qual esses algoritmos funcionam, você pode argumentar com seus pontos fortes e fracos. Em particular, não estamos perto dos humanos na construção de representações abstratas e ricas de jogos que podemos planejar dentro e usar para aprendizado rápido. Um dia, um computador examinará uma série de pixels e notará uma chave, uma porta e pensará que é provavelmente uma boa idéia pegar a chave e chegar à porta. Por enquanto, não há nada em nada próximo disso, e tentar chegar lá é uma área de pesquisa ativa. Computação não diferenciável em Neural Networks Id gostaria de mencionar uma aplicação mais interessante de Policy Gradients não relacionada aos jogos: nos permite projetar e treinar redes neurais com componentes que executam (ou interagem com) computação não diferenciável. A idéia foi introduzida pela primeira vez em Williams 1992 e mais recentemente popularizada por Modelos Recorrentes de Atenção Visual sob o nome de atenção difícil, no contexto de um modelo que processou uma imagem com uma seqüência de olhares foveais de baixa resolução (inspirados em nossos próprios olhos humanos ). Em particular, em cada iteração, um RNN receberia um pequeno pedaço da imagem e avaliaria um local a seguir. Por exemplo, a RNN pode olhar para a posição (5,30), receber um pequeno pedaço da imagem, então decidir olhar para (24, 50), etc. O problema com essa idéia é que existe uma rede que produz uma Distribuição de onde procurar em seguida e depois amostras dele. Infelizmente, esta operação não é diferenciável porque, intuitivamente, não sabemos o que teria acontecido se amostrasse um local diferente. More generally, consider a neural network from some inputs to outputs: Notice that most arrows (in blue) are differentiable as normal, but some of the representation transformations could optionally also include a non-differentiable sampling operation (in red). We can backprop through the blue arrows just fine, but the red arrow represents a dependency that we cannot backprop through. Policy gradients to the rescue Well think about the part of the network that does the sampling as a small stochastic policy embedded in the wider network. Therefore, during training we will produce several samples (indicated by the branches below), and then well encourage samples that eventually led to good outcomes (in this case for example measured by the loss at the end). In other words we will train the parameters involved in the blue arrows with backprop as usual, but the parameters involved with the red arrow will now be updated independently of the backward pass using policy gradients, encouraging samples that led to low loss. This idea was also recently formalized nicely in Gradient Estimation Using Stochastic Computation Graphs . Trainable Memory IO . Youll also find this idea in many other papers. For example, a Neural Turing Machine has a memory tape that they it read and write from. To do a write operation one would like to execute something like mi x. where i and x are predicted by an RNN controller network. However, this operation is non-differentiable because there is no signal telling us what would have happened to the loss if we were to write to a different location j i. Therefore, the NTM has to do soft read and write operations. It predicts an attention distribution a (with elements between 0 and 1 and summing to 1, and peaky around the index wed like to write to), and then doing for all i: mi aix. This is now differentiable, but we have to pay a heavy computational price because we have to touch every single memory cell just to write to one position. Imagine if every assignment in our computers had to touch the entire RAM However, we can use policy gradients to circumvent this problem (in theory), as done in RL-NTM. We still predict an attention distribution a. but instead of doing the soft write we sample locations to write to: i sample(a) mi x. During training we would do this for a small batch of i. and in the end make whatever branch worked best more likely. The large computational advantage is that we now only have to readwrite at a single location at test time. However, as pointed out in the paper this strategy is very difficult to get working because one must accidentally stumble by working algorithms through sampling. The current consensus is that PG works well only in settings where there are a few discrete choices so that one is not hopelessly sampling through huge search spaces. However, with Policy Gradients and in cases where a lot of datacompute is available we can in principle dream big - for instance we can design neural networks that learn to interact with large, non-differentiable modules such as Latex compilers (e. g. if youd like char-rnn to generate latex that compiles), or a SLAM system, or LQR solvers, or something. Or, for example, a superintelligence might want to learn to interact with the internet over TCPIP (which is sadly non-differentiable) to access vital information needed to take over the world. Thats a great example. Conclusions We saw that Policy Gradients are a powerful, general algorithm and as an example we trained an ATARI Pong agent from raw pixels, from scratch, in 130 lines of Python. More generally the same algorithm can be used to train agents for arbitrary games and one day hopefully on many valuable real-world control problems. I wanted to add a few more notes in closing: On advancing AI . We saw that the algorithm works through a brute-force search where you jitter around randomly at first and must accidentally stumble into rewarding situations at least once, and ideally often and repeatedly before the policy distribution shifts its parameters to repeat the responsible actions. We also saw that humans approach these problems very differently, in what feels more like rapid abstract model building - something we have barely even scratched the surface of in research (although many people are trying). Since these abstract models are very difficult (if not impossible) to explicitly annotate, this is also why there is so much interest recently in (unsupervised) generative models and program induction. On use in complex robotics settings . The algorithm does not scale naively to settings where huge amounts of exploration are difficult to obtain. For instance, in robotic settings one might have a single (or few) robots, interacting with the world in real time. This prohibits naive applications of the algorithm as I presented it in this post. One related line of work intended to mitigate this problem is deterministic policy gradients - instead of requiring samples from a stochastic policy and encouraging the ones that get higher scores, the approach uses a deterministic policy and gets the gradient information directly from a second network (called a critic ) that models the score function. This approach can in principle be much more efficient in settings with very high-dimensional actions where sampling actions provides poor coverage, but so far seems empirically slightly finicky to get working. Another related approach is to scale up robotics, as were starting to see with Googles robot arm farm. or perhaps even Teslas Model S Autopilot . There is also a line of work that tries to make the search process less hopeless by adding additional supervision. In many practical cases, for instance, one can obtain expert trajectories from a human. For example AlphaGo first uses supervised learning to predict human moves from expert Go games and the resulting human mimicking policy is later finetuned with policy gradients on the real objective of winning the game. In some cases one might have fewer expert trajectories (e. g. from robot teleoperation ) and there are techniques for taking advantage of this data under the umbrella of apprenticeship learning. Finally, if no supervised data is provided by humans it can also be in some cases computed with expensive optimization techniques, e. g. by trajectory optimization in a known dynamics model (such as (Fma) in a physical simulator), or in cases where one learns an approximate local dynamics model (as seen in very promising framework of Guided Policy Search ). On using PG in practice . As a last note, Id like to do something I wish I had done in my RNN blog post. I think I may have given the impression that RNNs are magic and automatically do arbitrary sequential problems. The truth is that getting these models to work can be tricky, requires care and expertise, and in many cases could also be an overkill, where simpler methods could get you 90 of the way there. The same goes for Policy Gradients. They are not automatic: You need a lot of samples, it trains forever, it is difficult to debug when it doesnt work. One should always try a BB gun before reaching for the Bazooka. In the case of Reinforcement Learning for example, one strong baseline that should always be tried first is the cross-entropy method (CEM). a simple stochastic hill-climbing guess and check approach inspired loosely by evolution. And if you insist on trying out Policy Gradients for your problem make sure you pay close attention to the tricks section in papers, start simple first, and use a variation of PG called TRPO. which almost always works better and more consistently than vanilla PG in practice. The core idea is to avoid parameter updates that change your policy too much, as enforced by a constraint on the KL divergence between the distributions predicted by the old and the new policy on a batch of data (instead of conjugate gradients the simplest instantiation of this idea could be implemented by doing a line search and checking the KL along the way). And thats it I hope I gave you a sense of where we are with Reinforcement Learning, what the challenges are, and if youre eager to help advance RL I invite you to do so within our OpenAI Gym :) Until next time