Rețeaua Actor-Critic
În metodele actor-critic, două componente lucrează împreună ca să îmbunătățească comportamentul agentului:
- Actorul (actor) este strategia de decizie . Primește starea curentă și decide ce acțiune execută agentul.
- Criticul (critic) aproximează funcția de valoare a stării, . 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.
Inițializarea ortogonală
Secțiune intitulată „Inițializarea ortogonală”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 layerParametrul std al funcției layer_init stabilește amplitudinea inițială a ponderilor:
- pentru straturile ascunse urmate de activarea neliniară
Tanh, - pentru stratul final al criticului,
- pentru stratul de ieșire al actorului. Cu o scară atât de mică, mediile inițiale sunt foarte apropiate de zero, așa că agentul nu ia decizii extreme la începutul învățării.
Clasa ActorCritic
Secțiune intitulată „Clasa ActorCritic”Arhitectura completă reunește cele două rețele într-un singur modul PyTorch.
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()Separarea mediei de deviația standard
Secțiune intitulată „Separarea mediei de deviația standard”În controlul continuu contează mult și felul în care modelăm deviația standard :
self.actor_logstd = nn.Parameter(torch.zeros(1, act_dim))Metodele clasei
Secțiune intitulată „Metodele clasei”get_value(x)evaluează starea cu ajutorul criticului și returnează scalarul .get_action_and_value(x, action=None)este metoda principală. O folosim atât la colectarea datelor (cândactionesteNoneș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 , iar robotul se mișcă astfel cel mai stabil.
Verificarea locală
Secțiune intitulată „Verificarea locală”Putem verifica rapid că rețeaua funcționează: creăm modelul și îi dăm un lot de observații fictive.
import torchfrom model import ActorCritic
# 17 observații de intrare, 6 acțiuni continue de ieșireagent = 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 mediufake_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.
Bibliografie
Secțiune intitulată „Bibliografie”- Andrychowicz, M. et al. (2021). What Matters In On-Policy Reinforcement Learning? A Large-Scale Empirical Study. ICLR 2021.
- Glorot, X. și Bengio, Y. (2010). Understanding the difficulty of training deep feedforward neural networks. AISTATS 2010.
- He, K. et al. (2015). Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification. ICCV 2015.
- Huang, S. et al. (2022). The 37 Implementation Details of Proximal Policy Optimization. ICLR Blog Track.
- Konda, V. R. și Tsitsiklis, J. N. (2000). Actor-Critic Algorithms. Advances in Neural Information Processing Systems, 12.
- Saxe, A. M., McClelland, J. L. și Ganguli, S. (2014). Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. ICLR 2014.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.