Q Learning in Python: O que é, Definições [Exemplos de codificação]

Aprendizado por reforço é quando um agente de aprendizado aprende a se comportar de maneira otimizada de acordo com seu ambiente por meio de interações constantes. O agente passa por diversas situações, que também são conhecidas como estados. Como você deve ter adivinhado, o aprendizado por reforço tem muitas aplicações em nosso mundo. Saiba mais se estiver interessado em saber mais sobre algoritmos de ciência de dados.

Além disso, possui muitos algoritmos, entre os mais populares está o Q learning . Neste artigo, discutiremos o que é esse algoritmo e como ele funciona.

Então, sem mais delongas, vamos começar.

O que é Aprendizado Q?

O aprendizado Q é um algoritmo de aprendizado por reforço e se concentra em encontrar o melhor curso de ação para uma situação específica. Está fora da política porque as ações com as quais a função de aprendizado Q aprende estão fora da política existente, portanto, não requer uma. Ele se concentra em aprender uma política que aumenta sua recompensa total. É uma forma simples de aprendizado por reforço que usa valores de ação (ou valores Q) para aprimorar o comportamento do agente de aprendizado.

O aprendizado Q é um dos algoritmos mais populares no aprendizado por reforço, pois é fácil de entender e implementar. O 'Q' na aprendizagem Q representa qualidade. Como mencionamos anteriormente, o aprendizado Q se concentra em encontrar a melhor ação para uma situação específica. E a qualidade mostra o quão útil é uma ação específica e qual recompensa ela pode ajudá-lo a alcançar.

Definições importantes

Antes de começarmos a discutir como funciona, devemos primeiro dar uma olhada em alguns conceitos essenciais de q aprendizagem. Vamos começar.

Valores Q

Os valores Q também são conhecidos como valores de ação. Eles são representados por Q(S, A) e fornecem uma estimativa de quão boa a ação A deve ser tomada no estado S. O modelo calculará essa estimativa de forma iterativa usando a regra de Atualização de Diferença Temporal que discutimos posteriormente nesta secção.

Episódios e recompensas

Um agente começa de um estado inicial, passa por várias transições e então se move do estado atual para o próximo de acordo com suas ações e seu ambiente. Sempre que o agente age, ele recebe alguma recompensa. E quando não há transições possíveis, é a conclusão do episódio.

Atualização TD (Diferença Temporal)

Aqui está a regra TD-Update ou Diferença Temporal:

Q(S,A) Q(S,A) + (R + Q(S',A')-Q(S,A))

Aqui, S representa o estado atual do agente, enquanto S' representa o próximo estado. A representa a ação atual, A' representa a melhor ação a seguir de acordo com a estimativa do valor Q, R mostra a recompensa atual de acordo com a ação presente, representa o fator de desconto e mostra o comprimento do passo.

Leia também: Pré-requisito para Ciência de Dados. Como isso muda ao longo do tempo?

Exemplo de Q Learning Python

A melhor maneira de entender o Q Learning Python é ver um exemplo. Neste exemplo, estamos usando o ambiente de academia do OpenAI e treinamos nosso modelo com ele. Primeiro, você terá que instalar o ambiente. Você pode fazer isso com o seguinte comando:

pip instalar academia

Agora, importaremos as bibliotecas necessárias para este exemplo:

importar ginásio

importar itertools

importar matplotlib

importar matplotlib.style

importar numpy como np

importar pandas como pd

sistema de importação

de coleções import defaultdict

de windy_gridworld importar WindyGridworldEnv

plotagem de importação

matplotlib.style.use('ggplot')

Sem as bibliotecas necessárias, você não poderá realizar essas operações com êxito. Após importarmos as bibliotecas, criaremos o ambiente:

env = WindyGridworldEnv()

Agora vamos criar a política -greedy:

def createEpsilonGreedyPolicy(Q, epsilon, num_actions):

“””

Cria uma política epsilon-gananciosa baseada

em uma dada função Q e épsilon.

Retorna uma função que recebe o estado

como entrada e retorna as probabilidades

para cada ação na forma de uma matriz numpy

do comprimento do espaço de ação (conjunto de respostas possíveis).

“””

def políticaFunção(estado):

Action_probabilities = np.ones(num_actions,

dtype = float) * epsilon / num_actions

best_action = np.argmax(Q[estado])

Action_probabilities[best_action] += (1.0 – épsilon)

return Action_probabilities

política de devoluçãoFunção

Aqui está o código para construir um modelo de q-learning:

def qLearning(env, num_episódios, fator_desconto = 1.0,

alfa = 0,6, épsilon = 0,1):

“””

Algoritmo Q-Learning: Controle TD fora da política.

Encontra a política gananciosa ideal enquanto melhora

seguindo uma política epsilon-gananciosa”””

# Função de valor da ação

# Um dicionário aninhado que mapeia

# estado -> (ação -> valor da ação).

Q = defaultdict(lambda: np.zeros(env.action_space.n))

# Mantém o controle de estatísticas úteis

stats = plotting.EpisodeStats(

comprimento_do_episódio = np.zeros(num_episódios),

episódio_recompensas = np.zeros(num_episódios))

# Cria uma função de política gananciosa epsilon

# apropriadamente para o espaço de ação ambiental

policy = createEpsilonGreedyPolicy(Q, epsilon, env.action_space.n)

# Para cada episódio

para ith_episode no intervalo (num_episodes):

# Redefina o ambiente e escolha a primeira ação

estado = env.reset()

para t em itertools.count():

# obtém probabilidades de todas as ações do estado atual

action_probabilities = política(estado)

# escolha a ação de acordo com

# a distribuição de probabilidade

ação = np.random.choice(np.arange(

len(action_probabilities)),

p = ação_probabilidades)

# agir e obter recompensa, transitar para o próximo estado

next_state, recompensa, feito, _ = env.step(action)

# Atualizar estatísticas

stats.episode_rewards[i_episode] += recompensa

stats.episode_lengths[i_episode] = t

# Atualização TD

best_next_action = np.argmax(Q[next_state])

td_target = recompensa + fator_desconto * Q[next_state][best_next_action]

td_delta = td_target – Q[estado][ação]

Q[estado][ação] += alfa * td_delta

# feito é verdadeiro se o episódio foi encerrado

se feito:

pausa

estado = próximo_estado

retornar Q, estatísticas

Vamos treinar o modelo agora:

Q, estatísticas = qLearning(env, 1000)

Depois de criar e treinar o modelo, podemos traçar as estatísticas essenciais do mesmo:

plotting.plot_episode_stats(stats)

Use este código para executar o modelo e traçar o gráfico. Que tipo de resultados você vê? Compartilhe seus resultados conosco e, se tiver alguma confusão ou dúvida, informe-nos.

Leia também: Algoritmos de aprendizado de máquina para ciência de dados

Aprenda cursos de ciência de dados das melhores universidades do mundo. Ganhe Programas PG Executivos, Programas de Certificado Avançado ou Programas de Mestrado para acelerar sua carreira.

Pensamentos finais

Ao traçar o gráfico, você verá que a recompensa por episódio aumenta progressivamente ao longo do tempo. E depois de certos episódios, o enredo também reflete que nivela o alto limite de recompensa por episódio. O que isso indica?

Isso significa que seu modelo aprendeu a aumentar a recompensa total que pode ganhar em um episódio, garantindo que ele se comporte de maneira ideal. Você também deve ter visto porque q aprender Python vê aplicações em tantas indústrias e áreas.