Vamos dar um mergulho profundo no aprendizado por reforço. Neste artigo, abordaremos um problema concreto com bibliotecas modernas, como TensorFlow, TensorBoard, Keras e OpenAI gym. Você verá como implementar um dos algoritmos fundamentais chamados deep $ Q $ -learning para aprender seu funcionamento interno. Com relação ao hardware, todo o código funcionará em um PC típico e usará todos os núcleos de CPU encontrados (isso é feito de fábrica pelo TensorFlow).

O problema é chamado Mountain Car: um carro está em uma pista unidimensional, posicionada entre duas montanhas. O objetivo é subir a montanha à direita (alcançando a bandeira). No entanto, o motor do carro não é forte o suficiente para escalar a montanha em uma única passagem. Portanto, a única maneira de ter sucesso é ir e voltar para ganhar impulso.

Este problema foi escolhido porque é simples o suficiente para encontrar uma solução com aprendizado por reforço em minutos em um único núcleo da CPU. No entanto, é complexo o suficiente para ser um bom representante.

Primeiro, darei um breve resumo do que a aprendizagem por reforço faz em geral. Em seguida, cobriremos os termos básicos e expressaremos nosso problema com eles. Depois disso, descreverei o algoritmo $ Q $ -learning profundo e o implementaremos para resolver o problema.

Princípios básicos do aprendizado por reforço

A aprendizagem por reforço nas palavras mais simples é a aprendizagem por tentativa e erro. O personagem principal é chamado de “agente”, o que seria um carro em nosso problema. O agente realiza uma ação em um ambiente e recebe de volta uma nova observação e uma recompensa por essa ação. Ações que levam a recompensas maiores são reforçadas, daí o nome. Tal como acontece com muitas outras coisas na ciência da computação, este também foi inspirado pela observação de criaturas vivas.

As interações do agente com um ambiente são resumidas no gráfico a seguir:

qual a função do cfo?

O agente obtém uma observação e recompensa pela ação realizada. Em seguida, ele executa outra ação e dá a etapa dois. O ambiente agora retorna uma (provavelmente) observação e recompensa ligeiramente diferente. Isso continua até que o estado do terminal seja alcançado, sinalizado pelo envio de “concluído” a um agente. Toda a sequência de observações> ações> next_observations> recompensas é chamado de episódio (ou trajetória).

Voltando ao nosso Mountain Car: nosso carro é um agente. O meio ambiente é um mundo de caixa preta de montanhas unidimensionais. A ação do carro se resume a apenas um número: se positivo, o motor empurra o carro para a direita. Se negativo, empurra o carro para a esquerda. O agente percebe um ambiente por meio de uma observação: a posição X do carro e a velocidade. Se quisermos que nosso carro dirija no topo da montanha, definimos a recompensa de uma maneira conveniente: O agente recebe -1 em sua recompensa para cada passo em que não atingiu a meta. Quando atinge o objetivo, o episódio termina. Então, na verdade, o agente é punido por não estar na posição que desejamos. Quanto mais rápido ele chegar, melhor para ele. O objetivo do agente é maximizar a recompensa total, que é a soma das recompensas de um episódio. Portanto, se ele atingir o ponto desejado após, por exemplo, 110 passos, recebe um retorno total de -110, o que seria um ótimo resultado para Mountain Car, pois se não atingir a meta é punido por 200 passos (portanto, um retorno de -200).

Esta é toda a formulação do problema. Agora, podemos entregá-lo aos algoritmos, que já são poderosos o suficiente para resolver esses problemas em questão de minutos (se bem ajustados). É importante notar que não dizemos ao agente como atingir o objetivo. Nós nem mesmo fornecemos quaisquer dicas (heurísticas). O agente encontrará uma maneira (uma política) de vencer por conta própria.

Configurando o ambiente

Primeiro, copie todo o código do tutorial em seu disco:

git clone https://github.com/AdamStelmaszczyk/rl-tutorial cd rl-tutorial

Agora, precisamos instalar os pacotes Python que usaremos. Para não instalá-los em seu espaço de usuário (e risco de colisões), faremos uma limpeza e os instalaremos no ambiente conda. Se você não tiver conda instalado, siga https://conda.io/docs/user-guide/install/index.html .

Para criar nosso ambiente conda:

conda create -n tutorial python=3.6.5 -y

Para ativá-lo:

source activate tutorial

Você deverá ver (tutorial) perto de seu prompt no shell. Isso significa que um ambiente conda com o nome “tutorial” está ativo. A partir de agora, todos os comandos devem ser executados dentro desse ambiente conda.

Agora, podemos instalar todas as dependências em nosso ambiente conda hermético:

pip install -r requirements.txt

Terminamos a instalação, então vamos rodar alguns códigos. Não precisamos implementar o ambiente do Mountain Car; a biblioteca OpenAI Gym fornece essa implementação. Vamos ver um agente aleatório (um agente que executa ações aleatórias) em nosso ambiente:

import gym env = gym.make('MountainCar-v0') done = True episode = 0 episode_return = 0.0 for episode in range(5): for step in range(200): if done: if episode > 0: print('Episode return: ', episode_return) obs = env.reset() episode += 1 episode_return = 0.0 env.render() else: obs = next_obs action = env.action_space.sample() next_obs, reward, done, _ = env.step(action) episode_return += reward env.render()

Este é see.py Arquivo; para executá-lo, execute:

python see.py

Você deve ver um carro indo e voltando aleatoriamente. Cada episódio consistirá em 200 etapas; o retorno total será de -200.

Agora precisamos substituir as ações aleatórias por algo melhor. Existem muitos algoritmos que podem ser usados. Para um tutorial introdutório, acho que uma abordagem chamada deep $ Q $ -learning é uma boa opção. A compreensão desse método fornece uma base sólida para aprender outras abordagens.

Deep $ Q $ -learning

O algoritmo que usaremos foi descrito pela primeira vez em 2013 por Mnih et al. dentro Jogando Atari com Deep Reinforcement Learning e polido dois anos depois em Controle no nível humano por meio do aprendizado por reforço profundo . Muitos outros trabalhos são construídos a partir desses resultados, incluindo o algoritmo atual de última geração arco Iris (2017):

Rainbow atinge um desempenho sobre-humano em muitos jogos Atari 2600. Vamos nos concentrar na versão básica do DQN, com o menor número de melhorias adicionais possíveis, para manter este tutorial em um tamanho razoável.

Uma política, normalmente denotada $ π (s) $, é uma função que retorna probabilidades de realizar ações individuais em um determinado estado $ s $. Assim, por exemplo, uma política aleatória de Mountain Car retorna para qualquer estado: 50% à esquerda, 50% à direita. Durante o jogo, usamos uma amostra dessa política (distribuição) para obter ações reais.

$ Q $ -aprendizagem (Q é para Qualidade) refere-se à função de valor de ação denotada $ Q_π (s, a) $. Ele retorna o retorno total de um determinado estado $ s $, escolhendo a ação $ a $, seguindo uma política concreta $ π $. O retorno total é a soma de todas as recompensas em um episódio (trajetória).

Se soubéssemos a função $ Q $ ótima, denotada $ Q ^ * $, poderíamos resolver o jogo facilmente. Seguiríamos apenas as ações com o maior valor de $ Q ^ * $, ou seja, o maior retorno esperado. Isso garante que atingiremos o maior retorno possível.

No entanto, geralmente não sabemos $ Q ^ * $. Em tais casos, podemos aproximar - ou “aprender” - a partir das interações com o meio ambiente. Esta é a parte “$ Q $ -learning” do nome. Também existe a palavra 'profundo' nele porque, para aproximar essa função, usaremos redes neurais profundas, que são aproximadores de função universal. Redes neurais profundas que se aproximam dos valores de $ Q $ foram chamadas de Deep Q-Networks (DQN). Em ambientes simples (com o número de estados cabendo na memória), pode-se apenas usar uma tabela em vez de uma rede neural para representar a função $ Q $, caso em que seria chamada de “$ Q $ -learning tabular”.

ajuste de desempenho no sql server 2008 passo a passo

Portanto, nosso objetivo agora é aproximar a função $ Q ^ * $. Usaremos a equação de Bellman:

[Q (s, a) = r + γ espaço textrm {max} _ {a '} Q (s', a ') ]

$ s ’$ é o estado após $ s $. $ γ $ (gama), normalmente 0,99, é um fator de desconto (é um hiperparâmetro). Coloca um peso menor nas recompensas futuras (porque elas são menos certas do que recompensas imediatas com nosso $ Q $ imperfeito). A equação de Bellman é fundamental para o aprendizado profundo de $ Q $. Ele diz que o valor $ Q $ para um determinado estado e ação é uma recompensa $ r $ recebida após realizar a ação $ a $ Mais o maior valor $ Q $ para o estado em que pousamos em $ s ’$. O maior é no sentido de que estamos escolhendo uma ação $ a ’$, que leva ao maior retorno total de $ s’ $.

Com a equação de Bellman, podemos usar o aprendizado supervisionado para aproximar $ Q ^ * $. A função $ Q $ será representada (parametrizada) pelos pesos da rede neural denotados como $ θ $ (theta). Uma implementação direta tomaria um estado e uma ação como a entrada e saída da rede do valor Q. A ineficiência é que, se quisermos saber os valores de $ Q $ para todas as ações em um determinado estado, precisamos chamar $ Q $ tantas vezes quantas forem as ações. Existe uma maneira muito melhor: tomar apenas o estado como uma entrada e saída de valores $ Q $ para todas as ações possíveis. Graças a isso, podemos obter valores de $ Q $ para todas as ações em apenas uma passagem para frente.

Começamos a treinar a rede $ Q $ com pesos aleatórios. Do ambiente, obtemos muitas transições (ou “experiências”). Estas são tuplas de (estado, ação, próximo estado, recompensa) ou, em resumo, ($ s $, $ a $, $ s ’$, $ r $). Armazenamos milhares deles em um buffer de anel denominado 'repetição de experiência'. Em seguida, coletamos amostras de experiências desse buffer com o desejo de que a equação de Bellman seja válida para elas. Poderíamos ter pulado o buffer e aplicado as experiências uma a uma (isso é chamado de “online” ou “na política”); o problema é que as experiências subsequentes são altamente correlacionadas entre si e o DQN treina mal quando isso ocorre. É por isso que a repetição da experiência foi introduzida (uma abordagem 'offline', 'fora da política') para quebrar essa correlação de dados. O código de nossa implementação de buffer de anel mais simples pode ser encontrado em replay_buffer.py arquivo, eu encorajo você a lê-lo.

No início, como os pesos da nossa rede neural eram aleatórios, o valor do lado esquerdo da equação de Bellman estará longe do lado direito. A diferença quadrática será nossa função de perda. Minimizaremos a função de perda alterando os pesos da rede neural $ θ $. Vamos escrever nossa função de perda:

[L (θ) = [Q (s, a) - r - γ space textrm {max} _ {a '} Q (s', a ')] ^ 2 ]

É uma equação de Bellman reescrita. Digamos que amostramos uma experiência ($ s $, esquerda, $ s ’$, -1) da repetição da experiência do Mountain Car. Fazemos uma passagem direta por nossa rede $ Q $ com o estado $ s $ e para a ação deixada nos dá -120, por exemplo. Portanto, $ Q (s, textrm {left}) = -120 $. Em seguida, alimentamos $ s ’$ para a rede, o que nos dá, por exemplo, -130 para a esquerda e -122 para a direita. Então, claramente a melhor ação para $ s ’$ é a certa, portanto $ textrm {max} _ {a’} Q (s ’, a’) = -122 $. Sabemos $ r $, esta é a recompensa real, que foi -1. Portanto, nossa previsão de rede $ Q $ estava um pouco errada, porque $ L (θ) = [-120 - 1 + 0,99 ⋅ 122] ^ 2 = (-0,22 ^ 2) = 0,0484 $. Assim, propagamos o erro para trás e corrigimos ligeiramente os pesos $ θ $. Se tivéssemos que calcular a perda novamente para a mesma experiência, agora seria menor.

Uma observação importante antes de passarmos ao código. Vamos notar que, para atualizar nosso DQN, faremos dois passes para frente no DQN ... em si. Isso geralmente leva a um aprendizado instável. Para aliviar isso, para a próxima previsão de estado $ Q $, não usamos o mesmo DQN. Usamos uma versão mais antiga dele, que no código é chamada de target_model (em vez de model, sendo o DQN principal). Graças a isso, temos um alvo estável. Nós atualizamos target_model definindo-o como model pesa a cada 1000 passos. Mas model atualiza cada etapa.

Vejamos o código que cria o modelo DQN:

def create_model(env): n_actions = env.action_space.n obs_shape = env.observation_space.shape observations_input = keras.layers.Input(obs_shape, name='observations_input') action_mask = keras.layers.Input((n_actions,), name='action_mask') hidden = keras.layers.Dense(32, activation='relu')(observations_input) hidden_2 = keras.layers.Dense(32, activation='relu')(hidden) output = keras.layers.Dense(n_actions)(hidden_2) filtered_output = keras.layers.multiply([output, action_mask]) model = keras.models.Model([observations_input, action_mask], filtered_output) optimizer = keras.optimizers.Adam(lr=LEARNING_RATE, clipnorm=1.0) model.compile(optimizer, loss='mean_squared_error') return model

Em primeiro lugar, a função assume as dimensões de ação e espaço de observação do ambiente OpenAI Gym fornecido. É necessário saber, por exemplo, quantas saídas nossa rede terá. Deve ser igual ao número de ações. As ações são um codificado a quente:

def one_hot_encode(n, action): one_hot = np.zeros(n) one_hot[int(action)] = 1 return one_hot

Então (por exemplo) a esquerda será [1, 0] e a direita será [0, 1].

Podemos ver que as observações são passadas como entrada. Também aprovamos action_mask como uma segunda entrada. Por quê? Ao calcular $ Q (s, a) $, precisamos saber o valor de $ Q $ apenas para uma determinada ação, não todas. action_mask contém 1 para as ações que queremos passar para a saída DQN. Se action_mask tem 0 para alguma ação, então o valor $ Q $ correspondente será zerado na saída. O filtered_output camada está fazendo isso. Se quisermos todos os valores $ Q $ (para cálculo máximo), podemos apenas passar todos os uns.

O código usa keras.layers.Dense para definir uma camada totalmente conectada. Keras é uma biblioteca Python para abstração de nível superior no TensorFlow. Sob o capô, Keras cria um gráfico TensorFlow, com vieses, inicialização de peso adequada e outras coisas de baixo nível. Poderíamos ter apenas usado o TensorFlow bruto para definir o gráfico, mas não será uma linha única.

Assim, as observações são passadas para a primeira camada oculta, com ativações ReLU (unidade linear retificada). ReLU(x) é apenas uma função $ textrm {max} (0, x) $. Essa camada está totalmente conectada com uma segunda camada idêntica, hidden_2. A camada de saída reduz o número de neurônios para o número de ações. No final, temos filtered_output, que apenas multiplica a saída por action_mask.

Para encontrar pesos $ θ $, usaremos um otimizador chamado “Adam” com uma perda de erro quadrática média.

Tendo um modelo, podemos usá-lo para prever valores de $ Q $ para determinadas observações de estado:

def predict(env, model, observations): action_mask = np.ones((len(observations), env.action_space.n)) return model.predict(x=[observations, action_mask])

Queremos $ Q $ -values ​​para todas as ações, portanto, action_mask é um vetor de uns.

Para fazer o treinamento real, usaremos fit_batch():

gerador de site estático node js

def fit_batch(env, model, target_model, batch): observations, actions, rewards, next_observations, dones = batch # Predict the Q values of the next states. Passing ones as the action mask. next_q_values = predict(env, target_model, next_observations) # The Q values of terminal states is 0 by definition. next_q_values[dones] = 0.0 # The Q values of each start state is the reward + gamma * the max next state Q value q_values = rewards + DISCOUNT_FACTOR_GAMMA * np.max(next_q_values, axis=1) one_hot_actions = np.array([one_hot_encode(env.action_space.n, action) for action in actions]) history = model.fit( x=[observations, one_hot_actions], y=one_hot_actions * q_values[:, None], batch_size=BATCH_SIZE, verbose=0, ) return history.history['loss'][0]

O lote contém BATCH_SIZE experiências. next_q_values é $ Q (s, a) $. q_values é $ r + γ space textrm {max} _ {a ’} Q (s’, a ’) $ da equação de Bellman. As ações que tomamos são codificadas a quente e passadas como action_mask à entrada ao chamar model.fit(). $ y $ é uma letra comum para um “alvo” no aprendizado supervisionado. Aqui estamos passando o q_values. Eu aceito q_values[:. None] para aumentar a dimensão da matriz porque ela deve corresponder à dimensão de one_hot_actions array. Isso é chamado de notação de fatia se você quiser ler mais sobre isso.

Retornamos a perda para salvá-la no arquivo de log do TensorBoard e depois visualizá-la. Há muitas outras coisas que iremos monitorar: quantos passos por segundo fazemos, uso total de RAM, qual é o retorno médio do episódio, etc. Vamos ver esses gráficos.

Corrida

Para visualizar o arquivo de log do TensorBoard, primeiro precisamos ter um. Então, vamos apenas executar o treinamento:

python run.py

Isso imprimirá primeiro o resumo do nosso modelo. Em seguida, ele criará um diretório de log com a data atual e iniciará o treinamento. A cada 2.000 etapas, uma linha de registro será impressa semelhante a esta:

episode 10 steps 200/2001 loss 0.3346639 return -200.0 in 1.02s 195.7 steps/s 9.0/15.6 GB RAM

A cada 20.000, avaliaremos nosso modelo em 10.000 etapas:

Evaluation 100%|█████████████████████████████████████████████████████████████████████████████████| 10000/10000 [00:07<00:00, 1254.40it/s] episode 677 step 120000 episode_return_avg -136.750 avg_max_q_value -56.004

Após 677 episódios e 120.000 passos, o retorno médio do episódio melhorou de -200 para -136,75! Definitivamente está aprendendo. O que avg_max_q_value estou deixando como um bom exercício para o leitor. Mas é uma estatística muito útil para olhar durante o treinamento.

Após 200.000 passos, nosso treinamento está concluído. Na minha CPU de quatro núcleos, leva cerca de 20 minutos. Podemos olhar dentro do date-log diretório, por exemplo, 06-07-18-39-log. Haverá quatro arquivos de modelo com .h5 extensão. Este é um instantâneo dos pesos do gráfico do TensorFlow, nós os salvamos a cada 50.000 etapas para depois dar uma olhada na política que aprendemos. Para ver:

python run.py --model 06-08-18-42-log/06-08-18-42-200000.h5 --view

Para ver os outros sinalizadores possíveis: python run.py --help.

Agora, o carro está fazendo um trabalho muito melhor para atingir a meta desejada. No date-log diretório, há também o events.out.* Arquivo. Este é o arquivo onde o TensorBoard armazena seus dados. Escrevemos nele usando o método mais simples TensorBoardLogger definido em loggers.py. Para visualizar o arquivo de eventos, precisamos executar o servidor TensorBoard local:

tensorboard --logdir=.

--logdir apenas aponta para o diretório no qual existem diretórios de log de datas, no nosso caso, este será o diretório atual, então .. O TensorBoard imprime o URL em que está escutando. Se você abrir http://127.0.0.1:6006 , você deverá ver oito gráficos semelhantes a estes:

Empacotando

train() faz todo o treinamento. Primeiro criamos o modelo e reproduzimos o buffer. Então, em um loop muito semelhante ao de see.py, interagimos com o ambiente e armazenamos as experiências no buffer. O importante é que sigamos uma política gananciosa com o epsilon. Podemos sempre escolher a melhor ação de acordo com a função $ Q $; no entanto, isso desencoraja a exploração, o que prejudica o desempenho geral. Portanto, para reforçar a exploração com probabilidade épsilon, realizamos ações aleatórias:

def greedy_action(env, model, observation): next_q_values = predict(env, model, observations=[observation]) return np.argmax(next_q_values) def epsilon_greedy_action(env, model, observation, epsilon): if random.random()

Epsilon foi definido para 1%. Após 2000 experiências, o replay enche o suficiente para iniciar o treinamento. Fazemos isso chamando fit_batch() com um lote aleatório de experiências amostradas do buffer de reprodução:

batch = replay.sample(BATCH_SIZE) loss = fit_batch(env, model, target_model, batch)

A cada 20.000 etapas, avaliamos e registramos os resultados (a avaliação é feita com epsilon = 0, política totalmente gananciosa):

if step >= TRAIN_START and step % EVAL_EVERY == 0: episode_return_avg = evaluate(env, model) q_values = predict(env, model, q_validation_observations) max_q_values = np.max(q_values, axis=1) avg_max_q_value = np.mean(max_q_values) print( 'episode {} ' 'step {} ' 'episode_return_avg {:.3f} ' 'avg_max_q_value {:.3f}'.format( episode, step, episode_return_avg, avg_max_q_value, )) logger.log_scalar('episode_return_avg', episode_return_avg, step) logger.log_scalar('avg_max_q_value', avg_max_q_value, step)

O código inteiro tem cerca de 300 linhas e run.py contém cerca de 250 dos mais importantes.

Pode-se notar que existem muitos hiperparâmetros:

DISCOUNT_FACTOR_GAMMA = 0.99 LEARNING_RATE = 0.001 BATCH_SIZE = 64 TARGET_UPDATE_EVERY = 1000 TRAIN_START = 2000 REPLAY_BUFFER_SIZE = 50000 MAX_STEPS = 200000 LOG_EVERY = 2000 SNAPSHOT_EVERY = 50000 EVAL_EVERY = 20000 EVAL_STEPS = 10000 EVAL_EPSILON = 0 TRAIN_EPSILON = 0.01 Q_VALIDATION_SIZE = 10000

E isso nem todos eles. Também existe uma arquitetura de rede - usamos duas camadas ocultas com 32 neurônios, ativações ReLU e otimizador Adam, mas existem muitas outras opções. Mesmo pequenas mudanças podem ter um grande impacto no treinamento. Pode-se gastar muito tempo ajustando hiperparâmetros. Em uma competição OpenAI recente, um concorrente em segundo lugar descobriu é possível quase em dobro Pontuação de Rainbow após o ajuste do hiperparâmetro. Naturalmente, é preciso lembrar que é fácil overfit. Atualmente, os algoritmos de reforço estão lutando com a transferência de conhecimento para ambientes semelhantes. Nosso Mountain Car não generaliza para todos os tipos de montanhas agora. Você pode realmente modificar o ambiente do OpenAI Gym e ver até que ponto o agente pode generalizar.

Outro exercício será encontrar um conjunto de hiperparâmetros melhor do que o meu. É definitivamente possível. No entanto, uma corrida de treinamento não será suficiente para julgar se sua mudança é uma melhoria. Geralmente, há uma grande diferença entre as corridas de treinamento; a variação é grande. Você precisaria de muitas execuções para determinar se algo está melhor. Se você gostaria de ler mais sobre um tópico tão importante como reprodutibilidade, eu o encorajo a ler Aprendizado de reforço profundo que importa . Em vez de ajustar manualmente, podemos automatizar esse processo até certo ponto - se estivermos dispostos a gastar mais capacidade de computação no problema. Uma abordagem simples é preparar um intervalo promissor de valores para alguns hiperparâmetros e, em seguida, executar uma pesquisa em grade (verificando suas combinações), com treinamentos em paralelo. A paralelização em si é um grande tópico por si só, pois é crucial para o alto desempenho.

Deep $ Q $ -learning representa uma grande família de algoritmos de aprendizagem por reforço que usam iteração de valor. Tentamos aproximar a função $ Q $ e apenas a usamos de maneira gananciosa na maioria das vezes. Há outra família que usa iteração de política. Eles não se concentram em aproximar a função $ Q $, mas em encontrar a política ótima $ π ^ * $ diretamente. Para ver onde a iteração de valor se encaixa no cenário de algoritmos de aprendizagem por reforço:

Seus pensamentos podem ser que o aprendizado por reforço profundo parece frágil. Você estará certo; existem muitos problemas. Você pode se referir a Aprendizado de reforço profundo ainda não funciona e O Aprendizado por Reforço nunca funcionou e 'profundo' só ajudou um pouco .

Isso conclui o tutorial. Implementamos nosso próprio DQN básico para fins de aprendizagem. Código muito semelhante pode ser usado para obter um bom desempenho em alguns dos jogos do Atari. Em aplicações práticas, muitas vezes são feitas implementações testadas de alto desempenho, por exemplo, uma de Linhas de base OpenAI . Se você gostaria de ver quais desafios podemos enfrentar ao tentar aplicar a aprendizagem por reforço profundo em um ambiente mais complexo, você pode ler Nosso NIPS 2017: Abordagem para aprender a correr . Se você gostaria de aprender mais em um ambiente de competição divertido, dê uma olhada em Competições NIPS 2018 ou crowdai.org .

Se você está prestes a se tornar um aprendizado de máquina especialista e gostaria de aprofundar seus conhecimentos em aprendizagem supervisionada, confira Análise de vídeo de aprendizado de máquina: identificando peixes para uma experiência divertida na identificação de peixes.

Relacionado: Schooling Flappy Bird: um tutorial de aprendizado por reforço

Compreender o básico

O que é aprendizagem por reforço?

O aprendizado por reforço é um método de tentativa e erro de treinamento de agente inspirado na biologia. Recompensamos o agente por boas ações para reforçar o comportamento desejado. Também penalizamos as más ações, para que ocorram com menos frequência.

O que é Q em Q-learning?

Q significa 'qualidade'. Refere-se à função de valor de ação denotada Qπ (s, a). Ele retorna o retorno total de um determinado estado s, escolhendo a ação a, seguindo uma política concreta π. O retorno total é a soma de todas as recompensas em um episódio.

Qual é a equação de Bellman?

Q (s, a) = r + γ maxa'Q (s ', a'). Verbalmente: o valor Q para um determinado estado e ação é uma recompensa r recebida após realizar a ação a + o valor Q mais alto para o estado que pousamos em s '. O mais alto no sentido de que estamos escolhendo uma ação a 'que leva ao maior retorno total de s'.

Qual é o princípio de otimização de Bellman?

Princípio da otimização: Uma política ótima tem a propriedade de que quaisquer que sejam o estado e as ações iniciais, as ações restantes devem constituir uma política ótima em relação ao estado resultante da ação inicial. É usado no Q-learning, mas em geral em todas as técnicas de programação dinâmica.

como encontrar um vazamento de memória

O que são parâmetros e hiperparâmetros?

Os parâmetros referem-se aos parâmetros do modelo, portanto, se estiver usando redes neurais, refere-se aos seus pesos. Normalmente, temos milhares ou milhões de parâmetros. Os hiperparâmetros são usados ​​para ajustar o processo de aprendizagem - por exemplo, taxa de aprendizagem, número de camadas, neurônios, etc. Normalmente, temos menos de cem hiperparâmetros.