Plug-in ml-Agent für die Einheit

In jüngerer Zeit wurden ml-agents auf v0.4 aktualisiert. Für diejenigen, die es nicht wissen, ist dies ein Open-Source-Plugin, eine Umgebung, in der Agenten in Einheit geschult werden können. Sie können mit Hilfe der Python-API mit Hilfe von Reinforcement Learning, Imitation Learning, Neuroevolution oder anderen Methoden des maschinellen Lernens trainiert werden. Es bietet auch eine Reihe moderner Algorithmen (basierend auf TensorSlow), mit denen Sie intelligentere NPCs für Ihre Spiele erstellen können.

Was benötigen Sie, um maschinelles Lernen in Unity zu implementieren?


Sie können dieses Plugin hier herunterladen . Sie benötigen den Unity-Envonment-Ordner. Erstellen Sie zuvor ein leeres Projekt. Fügen Sie im Ordner "Assets" den Inhalt des Ordners "Assets" mit Unity-Envonment hinzu. Tun Sie dies mit ProjectSettings. Beachten Sie, dass Sie, wenn Sie dieses Plugin zu einem vorhandenen Projekt hinzufügen, zuerst ein leeres Projekt erstellen, die obigen Schritte ausführen und ein Paket (Assets-ExportPackage) erstellen und es dann einfach in Ihr vorhandenes Projekt importieren. Dies ist erforderlich, damit Sie die vorhandenen ProjectSettings-Einstellungen in Ihrem Projekt nicht verlieren.

Ich werde die Implementierung des maschinellen Lernens am Beispiel eines Fußballspiels demonstrieren (diese Szene ist bereits im Plugin enthalten). Es hat zwei Teams, blau und rot. Jede Mannschaft hat einen Stürmer und einen Torwart.


Kommen wir zurück zum Plugin. Damit er auf der Bühne arbeiten kann, benötigen wir mindestens ein Academy-, Brain- und Agent-Objekt. Das folgende Interaktionsschema ist zu sehen:



Das Academy-Objekt und seine Tochterunternehmen GoalieBrain und StrikerBrain befinden sich auf der Bühne. Wie aus dem Diagramm ersichtlich, kann jede Akademie mehrere Gehirne haben, aber jedes Gehirn muss eine Akademie haben.

Agent - das sind unsere Spielobjekte, die wir trainieren möchten.



Gehen Sie dann zum Code. Die SoccerAcademy-Klasse, die zu GameObject Academy hinzugefügt wurde, erbt von der Academy-Klasse. Zuvor sollten Sie mit MLAgents einen Namespace hinzufügen. Danach sollten wir die Methoden überschreiben

public override void AcademyReset()
    {
    }
    public override void AcademyStep()
    {
    }

Und fügen Sie Links zu hinzu, die von Brain erstellt wurden

public Brain brainStriker;
    public Brain brainGoalie;

Fügen Sie GoalieBrain und StrikerBrain eine Brain-Komponente hinzu und weisen Sie sie der Academy zu. Die



AgentSoccer-Klasse erbt von Soccer. Fügen Sie es jedem Spieler hinzu und geben Sie an, welches Gehirn verwendet wird.



Im AgentSoccer-Skript beschreiben wir die Logik der Spieler. In der überschriebenen CollectObservations () -Methode fügen wir eine Liste von Strahlen hinzu, mit deren Hilfe Spieler das Gameplay überwachen und darauf reagieren können.


public override void CollectObservations()
    {
        float rayDistance = 20f;
        float[] rayAngles = { 0f, 45f, 90f, 135f, 180f, 110f, 70f };
        string[] detectableObjects;
        if (team == Team.red)
        {
            detectableObjects = new string[] { "ball", "redGoal", "blueGoal",
                "wall", "redAgent", "blueAgent" };
        }
        else
        {
            detectableObjects = new string[] { "ball", "blueGoal", "redGoal",
                "wall", "blueAgent", "redAgent" };
        }
        AddVectorObs(rayPer.Perceive(rayDistance, rayAngles, detectableObjects, 0f, 0f));
        AddVectorObs(rayPer.Perceive(rayDistance, rayAngles, detectableObjects, 1f, 0f));
    }

Die überschriebene AgentAction-Methode ist eine Entsprechung zu Update. Darin rufen wir die move-Methode auf und verteilen die Belohnungen.


    public override void AgentAction(float[] vectorAction, string textAction)
    {
        // Existential penalty for strikers.
        if (agentRole == AgentRole.striker)
        {
            AddReward(-1f / 3000f);
        }
        // Existential bonus for goalies.
        if (agentRole == AgentRole.goalie)
        {
            AddReward(1f / 3000f);
        }
        MoveAgent(vectorAction);
    }

Wenn wir den Ball berühren, drücken Sie ihn


    void OnCollisionEnter(Collision c)
    {
        float force = 2000f * kickPower;
        if (c.gameObject.tag == "ball")
        {
            Vector3 dir = c.contacts[0].point - transform.position;
            dir = dir.normalized;
            c.gameObject.GetComponent().AddForce(dir * force);
        }
    }

Befehle zurücksetzen, wenn das Ziel erreicht ist


public override void AgentReset()
    {
        if (academy.randomizePlayersTeamForTraining)
        {
            ChooseRandomTeam();
        }
        if (team == Team.red)
        {
            JoinRedTeam(agentRole);
            transform.rotation = Quaternion.Euler(0f, -90f, 0f);
        }
        else
        {
            JoinBlueTeam(agentRole);
            transform.rotation = Quaternion.Euler(0f, 90f, 0f);
        }
        transform.position = area.GetRandomSpawnPos(team.ToString(),
                                                    agentRole.ToString());
        agentRB.velocity = Vector3.zero;
        agentRB.angularVelocity = Vector3.zero;
        area.ResetBall();
    }

Trainingsmöglichkeiten


Sie können Agenten im Unity-Editor sowie mit TensorFlow schulen . Für die Einheit müssen Sie die Bestrafung und die Belohnung für jedes Gehirn in der Akademie festlegen.



Es lohnt sich auch, Brain seinen TypeBrain mitzuteilen, indem Sie den Wert auf External setzen. Sie kommen auch in den folgenden Typen:

  • Extern - Hier werden Entscheidungen mithilfe der Python-API getroffen. Hier werden die von Brain generierten Beobachtungen und Belohnungen über einen externen Kommunikator an die Python-API weitergeleitet. Die Python-API gibt dann die entsprechende Aktion zurück, die der Agent ausführen soll.
  • Intern - Hier werden Entscheidungen mithilfe des integrierten TensorFlow-Modells getroffen. Das verschachtelte TensorFlow-Modell stellt eine wissenschaftliche Richtlinie dar, und Brain verwendet dieses Modell direkt, um die Aktion für jeden Agenten zu bestimmen.
  • Player - Hier werden Entscheidungen über echte Tastatur- oder Controller-Eingaben getroffen. Hier kontrolliert der menschliche Spieler den Agenten, und die vom Gehirn gesammelten Beobachtungen und Belohnungen werden nicht zur Kontrolle des Agenten verwendet.
  • Heuristik - wo Entscheidungen unter Verwendung von hartcodiertem Verhalten getroffen werden. Dies ähnelt der Definition der meisten Charaktere und kann zum Debuggen oder Vergleichen des Verhaltens eines Agenten mit fest codierten Regeln mit einem Agenten hilfreich sein, dessen Verhalten trainiert wurde.

Jetzt auch beliebt: