[游戏开发] ML-Agents案例之地牢逃脱

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 游戏开发 -> ML-Agents案例之地牢逃脱 -> 正文阅读

[游戏开发]ML-Agents案例之地牢逃脱

本案例源自ML-Agents官方的示例，Github地址：https://github.com/Unity-Technologies/ml-agents，本文是详细的配套讲解。

本文基于我前面发的两篇文章，需要对ML-Agents有一定的了解，详情请见：Unity强化学习之ML-Agents的使用、ML-Agents命令及配置大全。

我前面的相关文章有：

Unity人工智能之不断自我进化的五人足球赛

在这里插入图片描述

环境说明

设置：特工被困在一个有龙的地牢中，必须共同努力才能逃脱。为了取回钥匙，其中一名特工必须找到并杀死龙，为此牺牲自己。龙会掉落一把钥匙供其他人使用。然后其他特工可以拿起这把钥匙并打开地牢门。如果特工花费的时间过长，龙将通过传送门逃跑并且环境会重置。
目标：打开地牢门并离开。
任何智能体成功打开门并离开地牢，则 +1 团队奖励。
此项目的训练难点在于，智能体为了团队奖励，必须学会牺牲自己。
输入：智能体的输入包含一个射线传感器RayPerceptionSensor3D，识别的标签分别为墙，队友，龙，钥匙，门锁，龙的洞穴。共15根射线，参数见下方图片。关于该传感器的详细说明见ML-Agents案例之推箱子游戏。

除了传感器之外，程序中还加入了一项检测智能体身上是否有钥匙的输入。
输出：智能体只采取了一项的离散输出，其中这个离散输出包含七个只，代表什么都不做、前进、后退、向左走、向右转、向左转、向右转。较少的输出会大大降低神经网络复杂度，减少训练时间。缺点是同一时间只能执行一个动作，降低智能体的灵活性，例如不能同时前进和旋转，也不能前进和向右转等。

代码讲解

首先是标准的三件套Behavior Parameters、Decision Requester 、Model Overrider。其中只有Behavior Parameters需要调参数，设置见上图。以前已详细讲解了各自的作用，这里不再讲解。

现在看看主要的智能体代码PushAgentEscape.cs：

初始化方法Initialize()：

public override void Initialize()
{
    // 获取组件
    m_GameController = GetComponentInParent<DungeonEscapeEnvController>();
    m_AgentRb = GetComponent<Rigidbody>();
    m_PushBlockSettings = FindObjectOfType<PushBlockSettings>();
    // 默认没有钥匙
    MyKey.SetActive(false);
    IHaveAKey = false;
}

每一个episode开始时的处理OnEpisodeBegin()方法：

public override void OnEpisodeBegin()
{
    MyKey.SetActive(false);
    IHaveAKey = false;
}

状态输入CollectObservations方法：

public override void CollectObservations(VectorSensor sensor)
{
    sensor.AddObservation(IHaveAKey);
}

可以看到除了传感器的输入之外，这里只有是否拥有钥匙一个输入。

动作输出OnActionReceived方法：

public override void OnActionReceived(ActionBuffers actionBuffers)
{
    MoveAgent(actionBuffers.DiscreteActions);
}

public void MoveAgent(ActionSegment<int> act)
{
    var dirToGo = Vector3.zero;
    var rotateDir = Vector3.zero;

    var action = act[0];

    switch (action)
    {
        case 1:
            dirToGo = transform.forward * 1f;
            break;
        case 2:
            dirToGo = transform.forward * -1f;
            break;
        case 3:
            rotateDir = transform.up * 1f;
            break;
        case 4:
            rotateDir = transform.up * -1f;
            break;
        case 5:
            dirToGo = transform.right * -0.75f;
            break;
        case 6:
            dirToGo = transform.right * 0.75f;
            break;
    }
    // 执行旋转
    transform.Rotate(rotateDir, Time.fixedDeltaTime * 200f);
    // 给刚体施加力，执行移动
    m_AgentRb.AddForce(dirToGo * m_PushBlockSettings.agentRunSpeed,
                       ForceMode.VelocityChange);
}

可以看到这里只有一个离散输出，包含0-6七个值，其中0为什么都不做。

碰撞检测：

碰撞检测分为两个部分，其中洞穴，龙，门锁是碰撞体，调用的是OnCollisionEnter方法：

void OnCollisionEnter(Collision col)
{
     // 当身上有钥匙，碰到锁，那么门打开，同时消耗钥匙，调用UnlockDoor方法
    if (col.transform.CompareTag("lock"))
    {       
        if (IHaveAKey)
        {
            MyKey.SetActive(false);
            IHaveAKey = false;
            m_GameController.UnlockDoor();
        }
    }
    // 当碰到龙时，销毁身上的钥匙（实际上身上此时不可能有钥匙，为了逻辑完整这样写），并且调用KilledByBaddie方法
    if (col.transform.CompareTag("dragon"))
    {
        m_GameController.KilledByBaddie(this, col);
        MyKey.SetActive(false);
        IHaveAKey = false;
    }
    // 当碰到洞穴时，调用TouchedHazard方法
    if (col.transform.CompareTag("portal"))
    {
        m_GameController.TouchedHazard(this);
    }
}

另一部分是钥匙，它被设定为触发器而非碰撞体，调用的是OnTriggerEnter方法：

void OnTriggerEnter(Collider col)
{
    // 如果钥匙是和智能体在同一个父物体下并且智能体为激活状态
    // 那么取消激活钥匙并激活身上的子物体钥匙，所以看起来像捡起来钥匙一样
    if (col.transform.CompareTag("key") && col.transform.parent == transform.parent && 	                           		  gameObject.activeInHierarchy)
    {
        print("Picked up key");
        MyKey.SetActive(true);
        IHaveAKey = true;
        col.gameObject.SetActive(false);
    }
}

如果玩家想手动操控其中一个智能体，则需要在智能体没有模型的情况下重写Heuristic方法：

public override void Heuristic(in ActionBuffers actionsOut)
{
    var discreteActionsOut = actionsOut.DiscreteActions;
    if (Input.GetKey(KeyCode.D))
    {
        discreteActionsOut[0] = 3;
    }
    else if (Input.GetKey(KeyCode.W))
    {
        discreteActionsOut[0] = 1;
    }
    else if (Input.GetKey(KeyCode.A))
    {
        discreteActionsOut[0] = 4;
    }
    else if (Input.GetKey(KeyCode.S))
    {
        discreteActionsOut[0] = 2;
    }
}

下面讲解控制整个环境的脚本DungeonEscapeEnvController.cs：

脚本先定义了智能体和恶龙所拥有的信息类，把关键信息封装起来便于调用，使得代码更加简洁美观：

// 定义智能体信息类
public class PlayerInfo
{
    // 智能体脚本
    public PushAgentEscape Agent;
    // 智能体起始位置
    public Vector3 StartingPos;
    // 智能体起始旋转向量
    public Quaternion StartingRot;
    // 智能体刚体
    public Rigidbody Rb;
    // 智能体碰撞体
    public Collider Col;
}

// 定义龙信息类
public class DragonInfo
{
    // 龙的脚本
    public SimpleNPC Agent;
    // 龙的起始位置
    public Vector3 StartingPos;
    // 龙的其实旋转向量
    public Quaternion StartingRot;
    // 龙的刚体
    public Rigidbody Rb;
    // 龙的碰撞体
    public Collider Col;
    // 起始的Transform
    public Transform T;
    // 是否死亡
    public bool IsDead;
}

然后定义了一系列的变量：

// 每一个episode的最大步数和最大时间，超过两者环境会重置
[Header("Max Environment Steps")] public int MaxEnvironmentSteps = 25000;
private int m_ResetTimer;
// 区域大小
public Bounds areaBounds;
// 地面
public GameObject ground;
// 地面材质
Material m_GroundMaterial; 
// 地面渲染
Renderer m_GroundRenderer;
// 智能体信息列表
public List<PlayerInfo> AgentsList = new List<PlayerInfo>();
// 龙的信息列表
public List<DragonInfo> DragonsList = new List<DragonInfo>();
// 建立一个字典，键为智能体脚本，值为智能体信息
private Dictionary<PushAgentEscape, PlayerInfo> m_PlayerDict = new Dictionary<PushAgentEscape, PlayerInfo>();
// 是否随机智能体的位置和旋转
public bool UseRandomAgentRotation = true;
public bool UseRandomAgentPosition = true;
// 把推方块的脚本拿过来复用了，名字都没改
PushBlockSettings m_PushBlockSettings;
// 存货的智能体数量
private int m_NumberOfRemainingPlayers;
// 钥匙
public GameObject Key;
// 墓碑
public GameObject Tombstone;
// 智能体组（重中之重）
private SimpleMultiAgentGroup m_AgentGroup;

然后就是对场景初始化，调用的Start方法：

void Start()
{
    // 获取地面界限
    areaBounds = ground.GetComponent<Collider>().bounds;
    // 获取地面渲染，方便改变材质
    m_GroundRenderer = ground.GetComponent<Renderer>();
    // 初始材质
    m_GroundMaterial = m_GroundRenderer.material;
    // 获取全局设定脚本
    m_PushBlockSettings = FindObjectOfType<PushBlockSettings>();
    // 重新计算场上存在的智能体
    m_NumberOfRemainingPlayers = AgentsList.Count;
    // 隐藏钥匙
    Key.SetActive(false);
    // 给列表中的智能体添加上对应的信息，并把智能体添加到组中，同一组的智能体会相互合作
    m_AgentGroup = new SimpleMultiAgentGroup();
    foreach (var item in AgentsList)
    {
        item.StartingPos = item.Agent.transform.position;
        item.StartingRot = item.Agent.transform.rotation;
        item.Rb = item.Agent.GetComponent<Rigidbody>();
        item.Col = item.Agent.GetComponent<Collider>();
        // 添加到组
        m_AgentGroup.RegisterAgent(item.Agent);
    }
    // 给龙列表中的龙添加信息
    foreach (var item in DragonsList)
    {
        item.StartingPos = item.Agent.transform.position;
        item.StartingRot = item.Agent.transform.rotation;
        item.T = item.Agent.transform;
        item.Col = item.Agent.GetComponent<Collider>();
    }
	// 重置场景
    ResetScene();
}

在ResetScene中：

 void ResetScene()
 {
     // 重置计时
     m_ResetTimer = 0;
     // 重置生存的智能体数量
     m_NumberOfRemainingPlayers = AgentsList.Count;
	// 四个方向任意旋转场景，可以防止过拟合在一个位置上
     var rotation = Random.Range(0, 4);
     var rotationAngle = rotation * 90f;
     transform.Rotate(new Vector3(0f, rotationAngle, 0f));

     // 重置列表中的每个智能体
     foreach (var item in AgentsList)
     {
         // 如果设定了随机，在场景中随机一个位置，没有就固定位置
         var pos = UseRandomAgentPosition ? GetRandomSpawnPos() : item.StartingPos;
         var rot = UseRandomAgentRotation ? GetRandomRot() : item.StartingRot;		
         item.Agent.transform.SetPositionAndRotation(pos, rot);
         // 状态都清零
         item.Rb.velocity = Vector3.zero;
         item.Rb.angularVelocity = Vector3.zero;
         item.Agent.MyKey.SetActive(false);
         item.Agent.IHaveAKey = false;
         item.Agent.gameObject.SetActive(true);
         // 这一行我认为可以去掉，无需再次添加
         m_AgentGroup.RegisterAgent(item.Agent);
     }
     // 重置钥匙
     Key.SetActive(false);

     // 重置墓碑
     Tombstone.SetActive(false);

     // 重置列表中的每一只龙
     foreach (var item in DragonsList)
     {
         if (!item.Agent)
         {
             return;
         }
         // 设定固定的起始位置
         item.Agent.transform.SetPositionAndRotation(item.StartingPos, item.StartingRot);
         // 设定随机的行走速度
         item.Agent.SetRandomWalkSpeed();
         // 激活智能体
         item.Agent.gameObject.SetActive(true);
     }
 }

在获取任意场景中位置的时候，调用的是GetRandomSpawnPos，这段代码可复用很强。

public Vector3 GetRandomSpawnPos()
{
    var foundNewSpawnLocation = false;
    var randomSpawnPos = Vector3.zero;
    while (foundNewSpawnLocation == false)
    {
        var randomPosX = Random.Range(-areaBounds.extents.x * m_PushBlockSettings.spawnAreaMarginMultiplier,
                                      areaBounds.extents.x * m_PushBlockSettings.spawnAreaMarginMultiplier);

        var randomPosZ = Random.Range(-areaBounds.extents.z * m_PushBlockSettings.spawnAreaMarginMultiplier,
                                      areaBounds.extents.z * m_PushBlockSettings.spawnAreaMarginMultiplier);
        randomSpawnPos = ground.transform.position + new Vector3(randomPosX, 1f, randomPosZ);
        // 检查生成的位置有没有碰撞体，有的话就重新生成，没有就退出循环
        if (Physics.CheckBox(randomSpawnPos, new Vector3(2.5f, 0.01f, 2.5f)) == false)
        {
            foundNewSpawnLocation = true;
        }
    }
    return randomSpawnPos;
}

接下来是每0.02秒都执行一次的FixedUpdate方法：

这里主要检测一个episode是否已经到达了设定的时间和最大步数，满足两者则环境重置。

void FixedUpdate()
{
    m_ResetTimer += 1;
    if (m_ResetTimer >= MaxEnvironmentSteps && MaxEnvironmentSteps > 0)
    {
        m_AgentGroup.GroupEpisodeInterrupted();
        ResetScene();
    }
}

接下来定义了三个对应接触龙，接触洞穴，接触门锁的方法：

当智能体接触洞穴时：

public void TouchedHazard(PushAgentEscape agent)
{
    // 智能体死亡，数量-1，数量为0时重置环境
    m_NumberOfRemainingPlayers--;
    if (m_NumberOfRemainingPlayers == 0 || agent.IHaveAKey)
    {
        m_AgentGroup.EndGroupEpisode();
        ResetScene();
    }
    else
    {
        agent.gameObject.SetActive(false);
    }
}

当智能体接触门锁时：

public void UnlockDoor()
{
    // 获得集体奖励
    m_AgentGroup.AddGroupReward(1f);
   // 改变地面材质0.5秒
    StartCoroutine(GoalScoredSwapGroundMaterial(m_PushBlockSettings.goalScoredMaterial, 0.5f));
    print("Unlocked Door");
    // 结束游戏
    m_AgentGroup.EndGroupEpisode();
	// 重置场景
    ResetScene();
}

当智能体接触龙时：

public void KilledByBaddie(PushAgentEscape agent, Collision baddieCol)
{
    // 龙被杀死，隐藏
    baddieCol.gameObject.SetActive(false);
    // 一个智能体死亡，隐藏
    m_NumberOfRemainingPlayers--;
    agent.gameObject.SetActive(false);
    print($"{baddieCol.gameObject.name} ate {agent.transform.name}");

    // 激活墓碑
    Tombstone.transform.SetPositionAndRotation(agent.transform.position, agent.transform.rotation);
    Tombstone.SetActive(true);

    // 激活钥匙
    Key.transform.SetPositionAndRotation(baddieCol.collider.transform.position, baddieCol.collider.transform.rotation);
    Key.SetActive(true);
}

此处可以试试扣除接触龙智能体本身的分数，看看智能体是否舍己为人，牺牲自己的分数换取团队的收益。

改变地面材质的携程：

IEnumerator GoalScoredSwapGroundMaterial(Material mat, float time)
{
    m_GroundRenderer.material = mat;
    yield return new WaitForSeconds(time); // Wait for 2 sec
    m_GroundRenderer.material = m_GroundMaterial;
}

以下是NPC龙的代码，很简单，只有移动的逻辑：

using UnityEngine;

public class SimpleNPC : MonoBehaviour
{

    public Transform target;
    private Rigidbody rb;
    public float walkSpeed = 1;
    private Vector3 dirToGo;
	// 比Start更早执行
    void Awake()
    {
        rb = GetComponent<Rigidbody>();
    }
    void Update()
    {
    }
	// 每0.02秒执行一次
    void FixedUpdate()
    {
        dirToGo = target.position - transform.position;
        dirToGo.y = 0;
        rb.rotation = Quaternion.LookRotation(dirToGo);
        // 执行移动
        rb.MovePosition(transform.position + transform.forward * walkSpeed * Time.deltaTime);
    }
    // 设置一个随机速度
    public void SetRandomWalkSpeed()
    {
        walkSpeed = Random.Range(1f, 7f);
    }
}

在龙下还挂着一个脚本，用来检测龙是否接触到洞穴：

using UnityEngine;
using UnityEngine.Events;

namespace Unity.MLAgentsExamples
{

    public class CollisionCallbacks : MonoBehaviour
    {
 		// 以下定义了多个事件，需要在Unity编辑器中订阅它们
        [System.Serializable]
        public class TriggerEvent : UnityEvent<Collider>
        {
        }

        [Header("Trigger Callbacks")]
        public TriggerEvent onTriggerEnterEvent = new TriggerEvent();

 	    // 这个案例只用到了这个方法，其他方法都没有订阅
        private void OnCollisionEnter(Collision col)
        {
            if (col.transform.CompareTag(tagToDetect))
            {
                onCollisionEnterEvent.Invoke(col, transform);
        }      
    }
}

订阅事件：

在这里插入图片描述

其中执行的方法如下：

public void BaddieTouchedBlock()
{
    m_AgentGroup.EndGroupEpisode();
    StartCoroutine(GoalScoredSwapGroundMaterial(m_PushBlockSettings.failMaterial, 0.5f));
    ResetScene();
}

配置文件

最简单的配置：

behaviors:
  DungeonEscape:
    trainer_type: poca
    hyperparameters:
      batch_size: 1024
      buffer_size: 10240
      learning_rate: 0.0003
      beta: 0.01
      epsilon: 0.2
      lambd: 0.95
      num_epoch: 3
      learning_rate_schedule: constant
    network_settings:
      normalize: false
      hidden_units: 256
      num_layers: 2
      vis_encode_type: simple
    reward_signals:
      extrinsic:
        gamma: 0.99
        strength: 1.0
    keep_checkpoints: 5
    max_steps: 20000000
    time_horizon: 64
    summary_freq: 60000