Herstel van fouten bij het leren van versterking door meerdere agenten in aangepaste beleidsnetwerken

Inzicht in het opnieuw vormgeven van fouten in aangepaste netwerken

Bij het implementeren van een aangepast beleidsnetwerk voor versterkend leren zijn fouten een veelvoorkomend obstakel, vooral in omgevingen met meerdere agenten. Deze fouten ontstaan ​​vaak bij het definiëren van observatie- en actieruimtes die tijdens de modeltraining niet correct uitgelijnd zijn.

In dit scenario onderzoeken we een veranderingsprobleem dat zich voordoet in een aangepaste massa-omgeving, waarbij de observatie- en actieruimten van de agent zorgvuldig moeten worden behandeld om mismatches in dimensies te voorkomen. Dit probleem kan de training stopzetten en de voortgang van modellen belemmeren.

Het probleem doet zich doorgaans voor wanneer gegevens door neurale netwerklagen worden doorgegeven, vooral wanneer de dimensies van de actieruimte verkeerd worden vormgegeven. Dit is terug te voeren op de interactie tussen de dimensies van de observatieruimte en de lagen van het aangepaste beleidsnetwerk.

Door de foutmeldingen zorgvuldig te analyseren en de netwerkstructuur te beoordelen, zal deze handleiding u helpen de hoofdoorzaak van dergelijke fouten te begrijpen en oplossingen bieden om het ontwerp van het beleidsnetwerk aan te passen. Het correct hervormen van arrays zorgt voor een soepele training en voorkomt kritieke fouten tijdens leertaken voor versterking.

Onderzoek naar aangepaste beleidsnetwerken voor omgevingen met meerdere agenten

De meegeleverde Python-scripts zijn ontworpen om hervormingsfouten binnen aangepaste beleidsnetwerken aan te pakken, met name in omgevingen met meerdere agenten die gebruik maken van versterkend leren. Het eerste script definieert de structuur van a aangepast multi-agentbeleid, die acteur-criticusmethoden gebruikt. De acteur is verantwoordelijk voor het bepalen van de actie van de agent op basis van zijn observatie, terwijl de criticus de waarde van de actie evalueert. Het belangrijke aspect van dit netwerk is de manier waarop het omgaat met de observatie- en actieruimtes, en ervoor zorgt dat deze aansluiten bij de lagen van het netwerk. Het gebruik van PyTorch's Opeenvolgende lagen stroomlijnen de modelarchitectuur en helpen gegevens efficiënt door meerdere verborgen lagen te sturen.

Het tweede deel van het script richt zich op de definities van actie- en observatieruimtes met behulp van Gym's spaties.Box(). Dit is van cruciaal belang bij het versterken van leeromgevingen, waar agenten binnen vooraf gedefinieerde grenzen moeten communiceren. De actieruimte is hier continu, waarbij elke agent twee waarden ontvangt, zoals beweging in de x- en y-as. De observatieruimte is op dezelfde manier gedefinieerd, maar bevat aanvullende parameters zoals snelheid. Ervoor zorgen dat deze ruimtes overeenkomen met de behoeften van de agent is van cruciaal belang om fouten bij het opnieuw vormgeven te voorkomen, vooral als het gaat om multidimensionale arrays en grote agentteams.

Het script integreert ook foutafhandeling om hervormingsproblemen aan te pakken, die vaak voorkomen bij opstellingen voor versterkend leren. De lijn gebruikt actie.reshape() zorgt ervoor dat de actie-arrays overeenkomen met de afmetingen die door het netwerk worden verwacht. Dit is een belangrijke functie om fouten in de dimensies tijdens runtime te voorkomen. Als de gegevens niet voldoen aan de verwachte vorm, vangt het script de fout op en registreert deze voor foutopsporing. Dit foutafhandelingsmechanisme is belangrijk voor continue trainingsprocessen, waarbij niet-afgehandelde fouten de training van het hele netwerk zouden kunnen stopzetten.

Het derde deel van de oplossing introduceert het gebruik van PyTorch-tensoren en distributiebemonstering voor actieselectie. Door observaties om te zetten in tensoren, wordt het model geoptimaliseerd voor uitvoering op zowel CPU als GPU. Door het gebruik van de categorische distributie kan het netwerk acties bemonsteren op basis van de logits die door het actornetwerk worden geproduceerd. Dit zorgt ervoor dat de acties van de agent probabilistisch worden gekozen, wat cruciaal is bij versterkende leeralgoritmen zoals Proximal Policy Optimization (PPO). Deze combinatie van lagen, ruimtes en tensormanipulatie maakt effectief leren mogelijk in een dynamische omgeving met meerdere agenten.

import torch as th
import numpy as np
from gym import spaces
from stable_baselines3.common.policies import ActorCriticPolicy

# Custom Policy Network for Reinforcement Learning
class CustomMultiAgentPolicy(ActorCriticPolicy):
    def __init__(self, observation_space, action_space, lr_schedule, kwargs):
        super(CustomMultiAgentPolicy, self).__init__(observation_space, action_space, lr_schedule, kwargs)
        self.obs_size = observation_space.shape[0]
        self.hidden_size = 128
        self.actor = th.nn.Sequential(
            th.nn.Linear(self.obs_size, self.hidden_size),
            th.nn.ReLU(),
            th.nn.Linear(self.hidden_size, action_space.shape[0])
        )
        self.critic = th.nn.Sequential(
            th.nn.Linear(self.obs_size, self.hidden_size),
            th.nn.ReLU(),
            th.nn.Linear(self.hidden_size, 1)
        )

    def forward(self, obs, kwargs):
        action_logits = self.actor(obs)
        action_distribution = th.distributions.Categorical(logits=action_logits)
        actions = action_distribution.sample()
        log_probs = action_distribution.log_prob(actions)
        values = self.critic(obs)
        return actions, values, log_probs

import numpy as np
import torch as th

# Observation and Action space setup
min_action = np.array([-5, -5] * len(self.agents), dtype=np.float32)
max_action = np.array([5, 5] * len(self.agents), dtype=np.float32)
self.action_space = spaces.Box(low=min_action, high=max_action, dtype=np.float32)

min_obs = np.array([-np.inf, -np.inf, -2.5, -2.5] * len(self.agents), dtype=np.float32)
max_obs = np.array([np.inf, np.inf, 2.5, 2.5] * len(self.agents), dtype=np.float32)
self.observation_space = spaces.Box(low=min_obs, high=max_obs, dtype=np.float32)

# Reshaping check to avoid errors
try:
    action = action.reshape((self.n_envs, self.action_dim))
except ValueError as e:
    print(f"Reshape error: {e}. Check input dimensions.")

Versterkingsleren optimaliseren met aangepaste beleidsnetwerken

Een belangrijk aspect van versterkend leren in aangepaste omgevingen is het juiste ontwerp van de observatie- en actieruimtes. Deze ruimtes bepalen hoe agenten omgaan met hun omgeving. Een typisch probleem doet zich voor wanneer agenten met continue actieruimten, zoals stroomagenten, een zorgvuldige uitlijning tussen de observatieruimte en netwerklagen vereisen. Hier, de actie ruimte moet correct worden gedefinieerd met behulp van Gym's spaties.Box(), waardoor de acties van agenten binnen het gespecificeerde bereik vallen, wat een directe invloed heeft op de leerprestaties van het beleidsnetwerk.

Bij het opschalen van deze netwerken naar een multi-agentomgeving wordt het verwerken van multidimensionale gegevens een grote uitdaging. In dergelijke gevallen moeten netwerklagen in staat zijn om multidimensionale invoer efficiënt te verwerken. Tools zoals die van PyTorch nn.ModuleLijst() kunt u meerdere lagen op een modulaire manier stapelen, waardoor het gemakkelijker wordt om de netwerkarchitectuur te schalen naarmate de complexiteit van de omgeving toeneemt. Modulaire architecturen verbeteren de herbruikbaarheid van code en vereenvoudigen ook het debuggen wanneer fouten zoals het opnieuw vormgeven van problemen optreden tijdens de training.

Bovendien kan het belang van foutafhandeling niet genoeg worden benadrukt. Het gebruik van gestructureerde methoden zoals proberen-behalve blokken om hervormfouten op te vangen zorgen ervoor dat de training kan doorgaan zonder abrupte mislukkingen. Dit is met name handig bij het testen in dynamische omgevingen waar agenten regelmatig met elkaar communiceren. Door deze fouten vroegtijdig op te sporen, kunt u de oorzaak van het probleem achterhalen en oplossingen implementeren om de algehele prestaties van het model te verbeteren. Het regelmatig registreren van de apparaatstatus en laaguitvoer is een andere manier om een ​​soepele en foutloze uitvoering van het aangepaste beleidsnetwerk te garanderen.