e são alguns domínios que estão entre os principais chavões do setor e por um bom motivo. A IA vai criar 2,3 milhões de empregos até 2020, considerando que seu principal objetivo é permitir que as máquinas imitem o comportamento humano. Estranho, não é? Portanto, hoje vamos discutir o Q Learning, o bloco de construção do Reinforcement Learning na seguinte ordem:
- O que é Aprendizagem por Reforço?
- Processo de Q-Learning
- Equação de Bellman
- Processo de decisão de Markov
- Demonstração do Q-Learning: NumPy
O que é Aprendizagem por Reforço?
Vamos dar uma olhada em nosso dia a dia. Realizamos inúmeras tarefas no ambiente e algumas dessas tarefas nos trazem recompensas, enquanto outras não. Continuamos em busca de caminhos diferentes e tentamos descobrir qual caminho nos levará a recompensas e com base em nossa ação aprimoramos nossas estratégias para atingir metas. Isso, meus amigos, é uma das analogias mais simples do Aprendizado por Reforço.
Principais áreas de interesse:
- Meio Ambiente
- Açao
- Recompensa
- Estado
O Aprendizado por Reforço é o ramo do aprendizado de máquina que permite aos sistemas aprender com os resultados de suas próprias decisões. Ele resolve um tipo específico de problema em que a tomada de decisões é sequencial e a meta é de longo prazo.
Processo de Q-Learning
Vamos entender o que é Q aprender com nossa declaração de problema aqui. Isso nos ajudará a definir os principais componentes de uma solução de aprendizagem por reforço, ou seja, agentes, ambiente, ações, recompensas e estados.
Analogia da fábrica de automóveis:
Estamos em uma fábrica de automóveis repleta de robôs. Esses robôs ajudam os operários, transportando as peças necessárias para montar um carro. Essas diferentes peças estão localizadas em locais diferentes dentro da fábrica em 9 estações. As peças incluem chassi, rodas, painel, motor e assim por diante. O Factory Master priorizou o local onde o chassi está sendo instalado como a prioridade mais alta. Vamos dar uma olhada na configuração aqui:
como usar system.exit em java
Estados:
O local em que um robô está presente em uma instância específica é chamado de estado. Uma vez que é fácil codificá-lo em vez de lembrar por nomes. Vamos mapear o local para números.
Ações:
As ações nada mais são do que movimentos feitos pelos robôs para qualquer local. Considere, um robô está no local L2 e os locais diretos para os quais ele pode se mover são L5, L1 e L3. Vamos entender isso melhor se visualizarmos:
Recompensas:
Uma recompensa será dada ao robô por ir diretamente de um estado para outro. Por exemplo, você pode alcançar L5 diretamente de L2 e vice-versa. Portanto, uma recompensa de 1 será fornecida em ambos os casos. Vamos dar uma olhada na tabela de recompensas:
Lembre-se de quando o Mestre da Fábrica priorizou a localização do chassi. Foi o L7, então vamos incorporar esse fato à nossa tabela de recompensas. Então, vamos atribuir um número muito grande (999 em nosso caso) na localização (L7, L7).
Equação de Bellman
Agora, suponha que um robô precise ir do ponto A ao B. Ele escolherá o caminho que renderá uma recompensa positiva. Para isso, suponha que fornecemos uma recompensa em termos de pegada para que ele siga.
Mas e se o robô começar de algum lugar entre onde ele pode ver dois ou mais caminhos? O robô pode, portanto, não tomar uma decisão e isso ocorre principalmente porque ele não possui um memória . É aqui que a equação de Bellman entra em cena.
V (s) = máx (R (s, a) + & # 120632V (s ’))
Onde:
- s = um estado particular
- a = ação
- s '= estado para o qual o robô vai de s
- & # 120632 = fator de desconto
- R (s, a) = uma função de recompensa que assume um estado (s) e ação (a) e produz um valor de recompensa
- V (s) = valor de estar em um estado particular
Já o bloco abaixo do destino terá recompensa 1, que é a maior recompensa. Mas e o outro bloco? Bem, é aqui que entra o fator de desconto. Vamos supor um fator de desconto de 0,9 e preencher todos os blocos um por um.
Processo de decisão de Markov
Imagine que um robô está no bloco laranja e precisa chegar ao destino. Mas mesmo que haja uma ligeira disfunção, o robô ficará confuso sobre qual caminho seguir em vez de subir.
Portanto, precisamos modificar o processo de tomada de decisão. Tem que ser Parcialmente Aleatório e Parcialmente sob o controle do robô . Parcialmente Aleatório porque não sabemos quando o robô irá funcionar mal e Parcialmente sob controle porque ainda é uma decisão do robô. E isso forma a base para o Processo de Decisão de Markov.
Um processo de decisão de Markov (MDP) é um processo de controle estocástico de tempo discreto. Ele fornece uma estrutura matemática para modelar a tomada de decisão em situações onde os resultados são parcialmente aleatórios e parcialmente sob o controle de um tomador de decisão.
Então, vamos usar nossa equação de Bellman original e fazer alterações nela. O que não sabemos é o próximo estado, ou seja. s ’. O que sabemos são todas as possibilidades de uma curva e vamos mudar a equação.
V (s) = max (R (s, a) + & # 120632 V (s ’))
V (s) = max (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) V (s '))
P (s, a, s ’): Probabilidade de mudança de estado s para s ’ com ação para
& Sigmas ’P (s, a, s ’) V (s ’): Expectativas de aleatoriedade do robô
V (s) = max (R (s, a) + & # 120632 ((0,8V (salaacima)) + (0,1 V (salabaixa) +….))
sair de um programa em java
Agora, vamos fazer a transição para o Q Learning. O Q-Learning apresenta uma ideia de avaliar a qualidade de uma ação que é realizada para mover para um estado em vez de determinar o valor possível do estado para o qual está sendo movido.
É o que obteremos se incorporarmos a ideia de avaliar a qualidade das ações para a passagem para um determinado estado. Da equação de Bellman atualizada, se removê-los max componente, estamos assumindo apenas uma pegada para a ação possível que nada mais é do que o Qualidade da ação.
Q (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) V (s '))
Nesta equação que Quantifica a Qualidade de ação, podemos assumir que V (s) é o máximo de todos os valores possíveis de Q (s, a). Então, vamos substituir v (s ') por uma função de Q ().
Q (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) max Q (s ’, a’))
Estamos apenas a um passo de nossa Equação de Q Learning final. Vamos apresentar um Diferença Temporal para calcular os valores Q em relação às mudanças no ambiente ao longo do tempo. Mas como observamos a mudança em Q?
TD (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) max Q (s ’, a’)) - Q (s, a)
é pós-graduação e mestrado o mesmo
Nós recalculamos o novo Q (s, a) com a mesma fórmula e subtraímos o Q (s, a) previamente conhecido dele. Então, a equação acima se torna:
Qt(s, a) = Qt-1(s, a) + α TDt(s, a)
Qt(s, a) = Valor Q atual
Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)-Qt-1(s, a))
Demonstração do Q Learning: NumPy
Vou usar NumPy para demonstrar como funciona o Q Learning.
Etapa 1: importações, parâmetros, estados, ações e recompensas
import numpy as np gamma = 0.75 # Fator de desconto alpha = 0.9 # Learning rate location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} ações = [0,1,2,3,4,5,6,7,8] recompensas = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,1,0]])Etapa 2: mapear índices para locais
state_to_location = dict ((estado, localização) para localização, estado em location_to_state.items ())
Etapa 3: Obtenha a rota ideal usando o processo Q Learning
def get_optimal_route (local_início, local_final): rewards_new = np.copy (recompensas) estado_de_localização = local_para_estado [local_final] rewards_new [estado_de_finição, estado_de_finição] = 999 Q = np.array (np.zeros ([9,9])) # Q- Processo de aprendizagem para i no intervalo (1000): # Pegando um estado aleatório current_state = np.random.randint (0,9) # Python exclui o limite superior playable_actions = [] # Iterando através da nova matriz de recompensas para j no intervalo ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Escolha uma ação aleatória que nos levará ao próximo estado next_state = np.random.choice (playable_actions) # Calculando a diferença temporal TD = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Atualizando o Q-Value usando a equação de Bellman Q [current_state, next_state] + = alpha * TD # Inicialize a rota ideal com a localização inicial route = [start_location] #Initialize next_location com a localização inicial next_location = star # Busca o valor Q mais alto pertencente ao estado inicial next_state = np.argmax (Q [initial_state,]) # Obtemos o índice do próximo estado. Mas precisamos da carta correspondente. next_location = state_to_location [next_state] route.append (next_location) # Atualize a localização inicial para a próxima iteração start_location = next_location rota de retorno
Etapa 4: imprima a rota
imprimir (get_optimal_route ('L1', 'L9'))Resultado:
Com isso, chegamos ao fim do Q-Learning. Espero que você tenha conhecido o funcionamento do Q Learning junto com as várias dependências que existem, como a diferença temporal, a equação de Bellman e muito mais.
Edureka's torna você proficiente em técnicas como aprendizado supervisionado, aprendizado não supervisionado e processamento de linguagem natural. Inclui treinamento sobre os avanços mais recentes e abordagens técnicas em Inteligência Artificial e Aprendizado de Máquina, como Aprendizado Profundo, Modelos Gráficos e Aprendizado por Reforço.