Salt la conținut

Rețeaua Actor-Critic

AvansatLectură: 3 min

În metodele actor-critic, două componente lucrează împreună ca să îmbunătățească comportamentul agentului:

  1. Actorul (actor) este strategia de decizie πθ(a∣s)\pi_\theta(a \mid s). Primește starea curentă și decide ce acțiune execută agentul.
  2. Criticul (critic) aproximează funcția de valoare a stării, Vϕ(s)V_\phi(s). Estimează recompensa cumulată pe care o putem aștepta pornind din acea stare și servește drept linie de bază la calculul avantajului acțiunii alese.

Tot codul arhitecturii se află în fișierul model.py.

model.py
def layer_init(layer: nn.Linear, std: float = np.sqrt(2), bias_const: float = 0.0) -> nn.Linear:
"""Inițializează ortogonal ponderile unui strat liniar și setează bias-ul constant."""
nn.init.orthogonal_(layer.weight, std)
nn.init.constant_(layer.bias, bias_const)
return layer

Parametrul std al funcției layer_init stabilește amplitudinea inițială a ponderilor:

  • 2≈1,414\sqrt{2} \approx 1{,}414 pentru straturile ascunse urmate de activarea neliniară Tanh,
  • 1,01{,}0 pentru stratul final al criticului,
  • 0,010{,}01 pentru stratul de ieșire al actorului. Cu o scară atât de mică, mediile inițiale μ(s)\mu(s) sunt foarte apropiate de zero, așa că agentul nu ia decizii extreme la începutul învățării.

Arhitectura completă reunește cele două rețele într-un singur modul PyTorch.

model.py
class ActorCritic(nn.Module):
"""Arhitectură Actor-Critic pentru spații de acțiuni continue."""
def __init__(self, obs_dim: int, act_dim: int, hidden_dim: int = 64):
super().__init__()
self.obs_dim = obs_dim
self.act_dim = act_dim
# Rețeaua critic estimează valoarea stării V(s)
self.critic = nn.Sequential(
layer_init(nn.Linear(obs_dim, hidden_dim)),
nn.Tanh(),
layer_init(nn.Linear(hidden_dim, hidden_dim)),
nn.Tanh(),
layer_init(nn.Linear(hidden_dim, 1), std=1.0),
)
# Rețeaua actor prezice media acțiunilor mu(s)
self.actor_mean = nn.Sequential(
layer_init(nn.Linear(obs_dim, hidden_dim)),
nn.Tanh(),
layer_init(nn.Linear(hidden_dim, hidden_dim)),
nn.Tanh(),
layer_init(nn.Linear(hidden_dim, act_dim), std=0.01),
)
# Logaritmul deviației standard (log_std), parametru învățabil independent de stare
self.actor_logstd = nn.Parameter(torch.zeros(1, act_dim))
def get_value(self, x: torch.Tensor) -> torch.Tensor:
"""Calculează valoarea estimată a stării V(s)."""
return self.critic(x)
def get_action_and_value(
self, x: torch.Tensor, action: torch.Tensor | None = None
) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
"""
Produce acțiunea eșantionată, log-probabilitatea, entropia și valoarea stării.
Dacă este furnizată o acțiune existentă, calculează log-probabilitatea și entropia acesteia.
"""
action_mean = self.actor_mean(x)
action_logstd = self.actor_logstd.expand_as(action_mean)
action_std = torch.exp(action_logstd)
probs = Normal(action_mean, action_std)
if action is None:
action = probs.sample()
# Pentru distribuții multivariate diagonale, log-probabilitatea este suma pe dimensiuni
log_prob = probs.log_prob(action).sum(axis=-1)
entropy = probs.entropy().sum(axis=-1)
value = self.critic(x)
return action, log_prob, entropy, value
def predict(self, x: torch.Tensor, deterministic: bool = True) -> torch.Tensor:
"""Produce o acțiune pentru evaluare (implicit deterministă, prin media distribuției)."""
action_mean = self.actor_mean(x)
if deterministic:
return action_mean
action_std = torch.exp(self.actor_logstd.expand_as(action_mean))
return Normal(action_mean, action_std).sample()

În controlul continuu contează mult și felul în care modelăm deviația standard σ\sigma:

self.actor_logstd = nn.Parameter(torch.zeros(1, act_dim))
  • get_value(x) evaluează starea xx cu ajutorul criticului și returnează scalarul V(x)V(x).
  • get_action_and_value(x, action=None) este metoda principală. O folosim atât la colectarea datelor (când action este None și se eșantionează o acțiune nouă), cât și la optimizarea PPO (când primește acțiunile salvate în buffer și recalculează pentru aceste acțiuni log-probabilitățile și entropia cu ponderile curente).
  • predict(x, deterministic=True) servește la evaluare și la testarea finală. În modul determinist, ignoră zgomotul gaussian și returnează direct media μ(x)\mu(x), iar robotul se mișcă astfel cel mai stabil.

Putem verifica rapid că rețeaua funcționează: creăm modelul și îi dăm un lot de observații fictive.

import torch
from model import ActorCritic
# 17 observații de intrare, 6 acțiuni continue de ieșire
agent = ActorCritic(obs_dim=17, act_dim=6)
num_params = sum(p.numel() for p in agent.parameters() if p.requires_grad)
print(f"Număr total de parametri: {num_params:,}")
# Simulăm un lot de 4 observații din mediu
fake_obs = torch.randn(4, 17)
action, log_prob, entropy, value = agent.get_action_and_value(fake_obs)
print("Forma acțiunilor: ", tuple(action.shape)) # (4, 6)
print("Forma log-prob: ", tuple(log_prob.shape)) # (4,)
print("Forma valorilor V(s):", tuple(value.shape)) # (4, 1)

Rezultatul este de aproximativ 11.000 de parametri, mult mai puțini decât la un model de limbaj. De aceea, rețeaua rulează foarte repede, atât la inferență, cât și la antrenare.

Avem acum o rețea pentru strategie și una pentru funcția de valoare. Pasul următor este algoritmul care le actualizează ponderile, descris pe pagina Algoritmul PPO și GAE.