Introducció
L'aprenentatge per reforç (RL) és una branca de l'aprenentatge automàtic on un agent aprèn a prendre decisions mitjançant la interacció amb un entorn. L'objectiu és maximitzar una recompensa acumulada al llarg del temps. En aquest mòdul, explorarem els conceptes bàsics de l'aprenentatge per reforç i com implementar-lo utilitzant PyTorch.
Conceptes Clau
- Agent: L'entitat que pren decisions.
- Entorn: El món amb el qual l'agent interactua.
- Acció (A): Les decisions que l'agent pot prendre.
- Estat (S): La representació de la situació actual de l'entorn.
- Recompensa (R): El feedback que l'agent rep després de prendre una acció.
- Política (π): La funció que l'agent utilitza per decidir quina acció prendre en cada estat.
- Funció de valor (V): Una funció que estima la recompensa esperada a llarg termini des d'un estat donat.
Implementació d'un Agent de Q-Learning amb PyTorch
Pas 1: Configuració de l'Entorn
Utilitzarem gym, una biblioteca popular per a l'aprenentatge per reforç, per crear el nostre entorn.
import gym
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
# Creem l'entorn
env = gym.make('CartPole-v1')Pas 2: Definició de la Xarxa Neuronal
Definirem una xarxa neuronal simple per estimar la funció Q.
class QNetwork(nn.Module):
def __init__(self, state_size, action_size):
super(QNetwork, self).__init__()
self.fc1 = nn.Linear(state_size, 64)
self.fc2 = nn.Linear(64, 64)
self.fc3 = nn.Linear(64, action_size)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
return x
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
q_network = QNetwork(state_size, action_size)Pas 3: Definició de la Política d'Exploració
Utilitzarem una política epsilon-greedy per equilibrar l'exploració i l'explotació.
def epsilon_greedy_policy(state, epsilon):
if np.random.rand() < epsilon:
return env.action_space.sample() # Exploració
else:
state = torch.FloatTensor(state).unsqueeze(0)
q_values = q_network(state)
return torch.argmax(q_values).item() # ExplotacióPas 4: Entrenament de l'Agent
Definirem el bucle d'entrenament per actualitzar la xarxa neuronal.
optimizer = optim.Adam(q_network.parameters(), lr=0.001)
criterion = nn.MSELoss()
num_episodes = 1000
gamma = 0.99
epsilon = 1.0
epsilon_decay = 0.995
min_epsilon = 0.01
for episode in range(num_episodes):
state = env.reset()
total_reward = 0
for t in range(200):
action = epsilon_greedy_policy(state, epsilon)
next_state, reward, done, _ = env.step(action)
total_reward += reward
# Calcula el valor objectiu
next_state = torch.FloatTensor(next_state).unsqueeze(0)
target = reward + gamma * torch.max(q_network(next_state)).item() * (1 - done)
# Actualitza la xarxa neuronal
state = torch.FloatTensor(state).unsqueeze(0)
q_values = q_network(state)
target_f = q_values.clone()
target_f[0][action] = target
optimizer.zero_grad()
loss = criterion(q_values, target_f)
loss.backward()
optimizer.step()
state = next_state.squeeze(0).numpy()
if done:
break
epsilon = max(min_epsilon, epsilon * epsilon_decay)
print(f'Episodi {episode+1}/{num_episodes}, Recompensa: {total_reward}, Epsilon: {epsilon:.2f}')Pas 5: Validació de l'Agent
Després de l'entrenament, validarem l'agent per veure com de bé ha après a jugar.
state = env.reset()
total_reward = 0
for t in range(200):
env.render()
action = epsilon_greedy_policy(state, 0.01) # Utilitzem un epsilon molt baix per maximitzar l'explotació
next_state, reward, done, _ = env.step(action)
total_reward += reward
state = next_state
if done:
break
print(f'Recompensa total durant la validació: {total_reward}')
env.close()Exercicis Pràctics
- Modifica la Xarxa Neuronal: Prova d'afegir més capes o canviar la mida de les capes existents per veure com afecta el rendiment de l'agent.
- Canvia l'Entorn: Utilitza un entorn diferent de
gymi adapta el codi per entrenar l'agent en aquest nou entorn. - Implementa DQN: Implementa Deep Q-Learning Network (DQN) amb una xarxa de target per millorar l'estabilitat de l'entrenament.
Conclusió
En aquest mòdul, hem après els conceptes bàsics de l'aprenentatge per reforç i hem implementat un agent de Q-Learning utilitzant PyTorch. Hem explorat com definir una xarxa neuronal, una política d'exploració i com entrenar l'agent. Els exercicis pràctics proporcionats us ajudaran a aprofundir en aquests conceptes i a experimentar amb diferents configuracions.
PyTorch: De Principiant a Avançat
Mòdul 1: Introducció a PyTorch
- Què és PyTorch?
- Configuració de l'Entorn
- Operacions Bàsiques amb Tensor
- Autograd: Diferenciació Automàtica
Mòdul 2: Construcció de Xarxes Neuronals
- Introducció a les Xarxes Neuronals
- Creació d'una Xarxa Neuronal Simple
- Funcions d'Activació
- Funcions de Pèrdua i Optimització
Mòdul 3: Entrenament de Xarxes Neuronals
- Càrrega i Preprocessament de Dades
- Bucle d'Entrenament
- Validació i Prova
- Desament i Càrrega de Models
Mòdul 4: Xarxes Neuronals Convolucionals (CNNs)
- Introducció a les CNNs
- Construcció d'una CNN des de Zero
- Aprenentatge per Transferència amb Models Preentrenats
- Ajust Fi de les CNNs
Mòdul 5: Xarxes Neuronals Recurrents (RNNs)
- Introducció a les RNNs
- Construcció d'una RNN des de Zero
- Xarxes de Memòria a Llarg i Curt Termini (LSTM)
- Unitats Recurrents Gated (GRUs)
Mòdul 6: Temes Avançats
- Xarxes Generatives Adversàries (GANs)
- Aprenentatge per Reforç amb PyTorch
- Desplegament de Models PyTorch
- Optimització del Rendiment