A Ray egyedi környezeti renderelési problémájának megoldása a Freeze-Tag szimulációban

Kihívások az egyéni környezetek Ray és PyGame segítségével történő megjelenítésében

Egyéni környezetek létrehozása Pythonban bonyolult szimulációkhoz, például a befagyasztáshoz, gyakran előre nem látható problémákhoz vezethet, különösen, ha olyan keretrendszerekkel kombinálják, mint a Ray a többügynökös képzéshez. Ebben a forgatókönyvben a felhasználó egy edzőtermi környezetet hozott létre a PyGame-mel, hogy lefagyási címkét imitáljon, de problémákba ütközik, miközben megpróbálja megjeleníteni a környezetet edzés közben.

Az alapvető probléma az, hogy a szimuláció nem a tervezett módon jelenít meg, és sok PyGame ablakot generál, ami megnehezíti a betanítási folyamatot. Annak ellenére, hogy az edzőtermi környezet más aspektusai megfelelően működnek különböző módszerekkel, úgy tűnik, hogy a Ray Multi-Agent Proximal Policy Optimization (MAPPO) algoritmusa bevezeti ezeket a problémákat.

A Ray egy csodálatos keretrendszer az elosztott képzéshez, de ahhoz, hogy jól működjön olyan renderelő könyvtárakkal, mint a PyGame, az ablakgenerálás és a renderelési változtatások gondos kezelését teszi szükségessé. Ezen aggodalmak megoldása nélkül a képzési folyamat leállhat, ami frusztráló eredményeket eredményezhet a fejlesztők számára.

A következő megbeszélés során megvizsgáljuk ezeknek a renderelési nehézségeknek a valószínű okait, és konkrét javításokat kínálunk a zökkenőmentes szimuláció biztosítása érdekében. Ezenkívül megvizsgáljuk, hogyan kerülhető el sok ablakpéldány létrehozása, miközben a PyGame kijelző működőképes marad a MAPPO képzéshez Rayben.

A Ray renderelési és képzési folyamatának megértése PyGame segítségével

A felkínált szkriptek célja a két elsődleges kihívás megoldása, amelyek a Ray Multi-Agent Proximal Policy Optimization (MAPPO) technikájával, testreszabott edzőtermi környezet renderelése során merültek fel. Az első probléma számos PyGame ablak létrehozását akadályozza meg. Ezt annak biztosításával oldják meg, hogy a PyGame megjelenítését csak egyszer inicializálják óvatos ablaképítési logikával. Használjuk a pygame.display.set_mode() funkció annak ellenőrzésén belül, hogy a kijelző inicializálása megtörtént-e, így biztosítva, hogy az edzés során csak egy ablak jöjjön létre.

A második kulcsfontosságú képesség a renderelni módszer, amely minden időlépésben megjeleníti a környezet aktuális állapotát. A környezetben lévő ágensek segítségével ábrázoltuk pygame.draw.circle(), helyzetük és színük állapotuktól függően folyamatosan módosul. Ez lehetővé teszi, hogy megtekinthesse, mely ügynökök vannak lefagyva, és melyek még aktívak a zárolási címke forgatókönyvében. A pygame.display.flip() módszer minden renderelési lépés után frissíti a megjelenítést, biztosítva, hogy a környezet az ügynökök aktuális állapotát tükrözze.

A szkript azt is bemutatja, hogyan építheti be az egyéni környezetet a Ray-be. A env_creator függvény regisztrálja a környezetet a Ray-vel a register_env() funkció. A Ray oktatóalgoritmusai most már képesek észlelni és használni a testreszabott lefagyásos környezetet. Továbbá a script használ ray.init() a Ray létrehozása és annak biztosítása, hogy a képzést több dolgozó között el lehessen osztani. Ebben az elrendezésben azonban csak egyetlen közzétételi dolgozót használnak fel, hogy minimálisra csökkentsék az ablak-megjelenítés bonyolultságát számos dolgozó esetében.

Végül a képzési hurok a algo.train() funkció, amely végrehajtja a betanítási eljárást a megadott számú epizódhoz és időlépéshez. Az egyes iterációk eredményei létfontosságú visszajelzést adnak az ügynökök teljesítményéről, beleértve az olyan mérőszámokat, mint az átlagos jutalom és a teljes veszteség. A beállítások módosítása, mint pl rollout_fragment_length és train_batch_size javíthatja a képzési folyamatot. Ez a szkript moduláris és adaptálható, így számos, többügynökkel megerősített tanulási problémára használható, beleértve a Rayt és a PyGame-et.

import pygame
from ray import init, shutdown
from ray.rllib.algorithms.ppo import PPOConfig
from ray.tune.registry import register_env
def render(self):
    if not hasattr(self, 'initialized') or not self.initialized:
        pygame.display.set_mode([1000, 1000])  # Prevent multiple windows
        self.initialized = True
    self.screen.fill((255, 255, 255))
    for agent in self.all_agents:
        color = agent.color if agent.status == 1 else (0, 255, 255)
        pygame.draw.circle(self.screen, color, (agent.x, agent.y), agent.size)
    pygame.display.flip()
def env_creator(config):
    return MyCustomEnv(screen=pygame.display.get_surface())  # Use existing display
register_env("Env_FTP", env_creator)
def train_and_evaluate(time_steps):
    init(ignore_reinit_error=True)
    config = PPOConfig().environment("Env_FTP").rollouts(num_rollout_workers=1)
    algo = config.build()
    for _ in range(episodes):
        results = algo.train()
    shutdown()

import ray
from ray.rllib.algorithms.ppo import PPOConfig
import pygame
class EnvWithRendering:
    def __init__(self, screen, agents, adversaries, time_steps):
        self.screen = screen
        self.agents = agents
        self.adversaries = adversaries
        self.time_steps = time_steps
    def render(self):
        pygame.init()
        self.screen.fill((255, 255, 255))
        for agent in self.agents:
            color = agent.color if agent.status == 1 else (0, 255, 255)
            pygame.draw.circle(self.screen, color, (agent.x, agent.y), agent.size)
        pygame.display.update()
def env_creator(config):
    return EnvWithRendering(pygame.display.set_mode([1000, 1000]), 5, 2, 500)
ray.init()
register_env("Env_FTP", env_creator)
config = PPOConfig().rollouts(num_rollout_workers=1)
algo = config.build()
algo.train()

A Ray többszereplős képzésének javítása megfelelő környezeti megjelenítéssel

A Ray's MAPPO testreszabott környezetben való hatékony integrálásának kritikus eleme annak biztosítása, hogy a renderelés és az ügynökkezelés hibátlanul működjön együtt. Egy többügynököt tartalmazó forgatókönyvben, mint például a befagyasztás, a vizuális bevitel kritikus a hibakereséshez és az ügynöktevékenység megfigyeléséhez. A rendereléssel kapcsolatos elsődleges nehézség gyakran a PyGame ablakok edzés közbeni kezeléséhez kapcsolódik. Számos ablak megnyitásának megakadályozása érdekében az egyik működőképes módszer a PyGame ablak indítása feltételes ellenőrzésekkel. Ez garantálja, hogy a környezet megfelelően és túlzott többletköltség nélkül rendes legyen.

Egy másik kulcsfontosságú szempont az, hogy az ágensek viselkedését hogyan építik be a szimulációba. A Ray bevezetései határozzák meg, hogy a különböző időkben szerzett tapasztalatokat hogyan gyűjtik össze és használják fel az ügynökök oktatására. Amikor minden ügynök egy cselekvést hajt végre, a reprezentációnak tükröznie kell az új pozíciókat és állapotokat. PyGame pygame.display.flip() A parancs itt létfontosságú, mivel valós időben megváltoztatja a képernyőt, lehetővé téve számunkra, hogy nyomon kövessük az összes ügynök mozgását és állapotát a szimuláció során.

A folyamat másik fontos lépése a Ray és a PyGame közötti interfész optimalizálása. A Ray képessége az elosztott számítások kezelésére lenyűgöző, de megfelelően kell kezelni, ha vizuális megjelenítést igénylő környezetben használják. Ray segítségével create_env_on_local_worker érvelés szerint a környezet helyileg a renderelést végző dolgozóra épül, megakadályozva, hogy több dolgozó versengjen a nyitott ablakokért. Az elosztott tanulásnak és a pontos renderelésnek ez a keveréke sikeres szimulációt eredményez, amely könnyen kibővíthető több ügynök tanítására egyszerre.