Python Academy · Aula

Implementação da tabela Q em Python

Um exemplo simples de aprendizado Q.

Implementação da tabela Q em Python é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 de 5. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 5 aulas no total.

Implementando o aprendizado Q em Python

Nesta lição, implementaremos um algoritmo simples de aprendizado Q em Python. O agente aprenderá a se movimentar por um mundo em grade para maximizar suas recompensas.

Implementação da tabela Q em Python — ilustração 1

Definindo o ambiente

Definimos um mundo em grade simples de 4×4, no qual o agente começa no canto superior esquerdo e precisa chegar ao canto inferior direito para receber uma recompensa.

import numpy as np

# Define the environment
num_states = 16  # 4x4 grid
num_actions = 4  # Up, Down, Left, Right

# Define rewards (-1 for each step, +10 for the goal)
rewards = np.zeros(num_states)
rewards[-1] = 10

Inicializando a tabela Q

A tabela Q é inicializada com zeros para todos os pares de estado e ação.

# Initialize the Q-Table
q_table = np.zeros((num_states, num_actions))

print("Initial Q-Table:")
print(q_table)

Implementando o algoritmo de aprendizado Q

Usamos os seguintes parâmetros:

α (Taxa de aprendizado): Controla quanto as novas informações substituem as antigas.
γ (Fator de desconto): Pondera as recompensas futuras em relação às recompensas imediatas.
ε (Taxa de exploração): Equilibra a exploração e o aproveitamento do que já foi aprendido.

# Parameters
alpha = 0.1  # Learning rate
gamma = 0.9  # Discount factor
epsilon = 0.1  # Exploration rate

# Q-Learning loop
num_episodes = 1000
for episode in range(num_episodes):
    state = 0  # Start at the first state
    done = False
    while not done:
        # Exploration or exploitation
        if np.random.rand() < epsilon:
            action = np.random.randint(num_actions)  # Explore
        else:
            action = np.argmax(q_table[state])  # Exploit

        # Transition to the next state
        next_state = (state + action) % num_states  # Simplified transition logic
        reward = rewards[next_state]

        # Update Q-value
        q_table[state, action] = q_table[state, action] + alpha * (
            reward + gamma * np.max(q_table[next_state]) - q_table[state, action]
        )

        # Move to the next state
        state = next_state
        done = state == num_states - 1

Avaliando a política aprendida

Após o treinamento, avaliamos a política seguindo as ações ideais armazenadas na tabela Q:

# Evaluate the policy
state = 0
optimal_path = [state]
while state != num_states - 1:
    action = np.argmax(q_table[state])
    state = (state + action) % num_states  # Simplified transition logic
    optimal_path.append(state)

print("Optimal Path:", optimal_path)

Visualizando a tabela Q

Podemos visualizar a tabela Q para entender os valores aprendidos para cada par de estado e ação:

import matplotlib.pyplot as plt
import seaborn as sns

# Visualize Q-Table
plt.figure(figsize=(10, 8))
sns.heatmap(q_table, annot=True, fmt=".2f", cmap="coolwarm")
plt.title("Q-Table Heatmap")
plt.xlabel("Actions")
plt.ylabel("States")
plt.show()

Vantagens do aprendizado Q

O aprendizado Q oferece vários benefícios:

É simples e fácil de implementar.
Pode lidar com ambientes estocásticos.
Converge para a política ideal com exploração suficiente.

Limitações do aprendizado Q

O aprendizado Q tem algumas limitações:

Não é bem escalável para ambientes com grandes espaços de estados e ações.
O aprendizado pode ser lento em ambientes complexos.
Exige uma representação bem definida de estados e ações.

Resumo e próximos passos

Nesta lição, nós:

Implementamos um algoritmo simples de aprendizado Q em Python.
Treinamos um agente para se movimentar por um mundo em grade usando uma tabela Q.
Avaliamos a política aprendida e visualizamos a tabela Q.

Em seguida, exploraremos o aprendizado Q profundo, que usa redes neurais para lidar com ambientes com grandes espaços de estados e ações.

Implementação da tabela Q em Python — ilustração 10

Perguntas Frequentes

A aula “Implementação da tabela Q em Python” é grátis?

Sim — o texto completo de “Implementação da tabela Q em Python” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 5 aulas no total.

O que vou aprender em “Implementação da tabela Q em Python”?

Um exemplo simples de aprendizado Q. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 5.

Quanto tempo leva a aula “Implementação da tabela Q em Python”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Conceitos básicos de aprendizado por reforço
Conceito de tabela Q
Implementação da tabela Q em Python
Aprendizado Q profundo
Explorando o OpenAI Gym

← Voltar para Python Academy