En aquest tema, aprendrem a implementar un agent d'aprenentatge automàtic en un videojoc. Ens centrarem en l'aprenentatge per reforç, una tècnica popular per entrenar agents a prendre decisions òptimes a través de l'experiència.
Objectius
- Comprendre els conceptes bàsics de l'aprenentatge per reforç.
- Implementar un agent senzill utilitzant Q-learning.
- Integrar l'agent en un entorn de videojoc.
- Avaluar i optimitzar el rendiment de l'agent.
Conceptes Bàsics de l'Aprenentatge per Reforç
L'aprenentatge per reforç (RL) és una àrea de l'aprenentatge automàtic on un agent aprèn a comportar-se en un entorn, realitzant accions i observant els resultats d'aquestes accions. Els components clau són:
- Agent: El sistema que pren decisions.
- Entorn: El món amb el qual l'agent interactua.
- Estat (s): Una representació de la situació actual de l'agent en l'entorn.
- Acció (a): Una decisió presa per l'agent.
- 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.
Implementació de Q-learning
Q-learning és un algorisme d'aprenentatge per reforç que busca trobar la millor política per a l'agent. La idea és aprendre una funció Q(s, a) que estima el valor de prendre una acció a en un estat s.
Pseudocodi de Q-learning
Inicialitza Q(s, a) arbitràriament per a tots els estats s i accions a
Per cada episodi:
Inicialitza l'estat s
Mentre s no sigui un estat terminal:
Tria una acció a des de s utilitzant una política (per exemple, ε-greedy)
Executa l'acció a i observa la recompensa r i el nou estat s'
Actualitza Q(s, a) segons la fórmula:
Q(s, a) = Q(s, a) + α [r + γ max Q(s', a') - Q(s, a)]
s = s'Implementació en Python
A continuació, implementarem un agent de Q-learning en Python. Utilitzarem un entorn senzill com el "FrozenLake" de la biblioteca OpenAI Gym.
Instal·lació de les Llibreries Necessàries
Codi de l'Agent de Q-learning
import gym
import numpy as np
# Paràmetres de Q-learning
alpha = 0.1 # Taxa d'aprenentatge
gamma = 0.99 # Factor de descompte
epsilon = 0.1 # Probabilitat d'exploració
# Inicialitza l'entorn
env = gym.make('FrozenLake-v0')
n_states = env.observation_space.n
n_actions = env.action_space.n
# Inicialitza la taula Q
Q = np.zeros((n_states, n_actions))
# Funció per triar una acció utilitzant una política ε-greedy
def choose_action(state):
if np.random.uniform(0, 1) < epsilon:
return env.action_space.sample() # Exploració
else:
return np.argmax(Q[state, :]) # Explotació
# Entrenament de l'agent
n_episodes = 1000
for episode in range(n_episodes):
state = env.reset()
done = False
while not done:
action = choose_action(state)
next_state, reward, done, _ = env.step(action)
Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[next_state, :]) - Q[state, action])
state = next_state
print("Taula Q entrenada:")
print(Q)Integració en un Entorn de Videojoc
Per integrar aquest agent en un videojoc, necessitarem:
- Definir l'entorn: Crear un entorn de joc que pugui ser representat en termes d'estats i accions.
- Implementar la interfície: Assegurar que l'agent pugui interactuar amb l'entorn del joc, enviant accions i rebent recompenses i nous estats.
- Entrenar l'agent: Utilitzar l'algorisme de Q-learning per entrenar l'agent en aquest entorn.
Exemple d'Integració
Suposem que tenim un joc on un agent ha de trobar un tresor en un laberint. Podem definir els estats com les posicions del laberint i les accions com els moviments possibles (amunt, avall, esquerra, dreta).
class Laberint:
def __init__(self, mida):
self.mida = mida
self.reset()
def reset(self):
self.agent_pos = [0, 0]
self.tresor_pos = [self.mida - 1, self.mida - 1]
return self._get_state()
def _get_state(self):
return self.agent_pos[0] * self.mida + self.agent_pos[1]
def step(self, action):
if action == 0: # Amunt
self.agent_pos[0] = max(0, self.agent_pos[0] - 1)
elif action == 1: # Avall
self.agent_pos[0] = min(self.mida - 1, self.agent_pos[0] + 1)
elif action == 2: # Esquerra
self.agent_pos[1] = max(0, self.agent_pos[1] - 1)
elif action == 3: # Dreta
self.agent_pos[1] = min(self.mida - 1, self.agent_pos[1] + 1)
if self.agent_pos == self.tresor_pos:
return self._get_state(), 1, True # Recompensa de 1 i estat terminal
else:
return self._get_state(), 0, False # Recompensa de 0 i no terminal
# Inicialitza l'entorn del laberint
env = Laberint(5)
n_states = env.mida * env.mida
n_actions = 4
# Inicialitza la taula Q
Q = np.zeros((n_states, n_actions))
# Entrenament de l'agent en el laberint
n_episodes = 1000
for episode in range(n_episodes):
state = env.reset()
done = False
while not done:
action = choose_action(state)
next_state, reward, done, _ = env.step(action)
Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[next_state, :]) - Q[state, action])
state = next_state
print("Taula Q entrenada:")
print(Q)Avaluació i Optimització
Després d'entrenar l'agent, és important avaluar el seu rendiment i fer ajustos si cal. Alguns consells per a l'avaluació i optimització inclouen:
- Mesurar la taxa d'èxit: Quantes vegades l'agent aconsegueix l'objectiu en un nombre determinat d'episodis.
- Ajustar els hiperparàmetres: Provar diferents valors per a α, γ i ε per veure com afecten el rendiment.
- Exploració vs. Explotació: Ajustar la política ε-greedy per equilibrar l'exploració de noves accions i l'explotació de les accions conegudes.
Resum
En aquest tema, hem après a implementar un agent d'aprenentatge automàtic utilitzant Q-learning. Hem vist com definir l'entorn, entrenar l'agent i integrar-lo en un videojoc. També hem discutit com avaluar i optimitzar el rendiment de l'agent. Amb aquests coneixements, estàs preparat per crear agents més complexos i eficients per als teus videojocs.
IA per a Videojocs
Mòdul 1: Introducció a la IA en Videojocs
Mòdul 2: Navegació en Videojocs
Mòdul 3: Presa de Decisions
Mòdul 4: Aprenentatge Automàtic
- Introducció a l'Aprenentatge Automàtic
- Xarxes Neuronals en Videojocs
- Aprenentatge per Reforç
- Implementació d'un Agent d'Aprenentatge
Mòdul 5: Integració i Optimització
Mòdul 6: Projectes Pràctics
- Projecte 1: Implementació de Navegació Bàsica
- Projecte 2: Creació d'un NPC amb Presa de Decisions
- Projecte 3: Desenvolupament d'un Agent amb Aprenentatge Automàtic