ML-Agents案例之蠕虫_小星AI

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

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

我前面的相关文章有：

ML-Agents案例之Crawler

ML-Agents案例之推箱子游戏

ML-Agents案例之跳墙游戏

ML-Agents案例之食物收集者

ML-Agents案例之双人足球

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

ML-Agents案例之地牢逃脱

ML-Agents案例之金字塔

环境说明

本环境可以参考ML-Agents案例之Crawler，两者的环境极其相似，都是仿生机器人，不同的只是仿生的对象不同，一个是蠕虫，一个是爬虫。奖励目标也是一致的，我们需要训练的是一个蠕虫形状的仿生机器人，让它自己学会蠕动前行，面向目标行走，最后吃到绿色的方块，并且这个过程越迅速越好。
首先我们来讲讲智能体本身的构造：

如上图所示，蠕虫分为四个部分。分别是一个头部和三节身躯（可以自己拓展到任意节数），四个部分由三个关节连接而成，可以看到，第一节身躯是头部的子物体，第二节身躯是第一节身躯的子物体，第三节身躯是第二节的子物体。（这里我个人的想法是四个部分应该相互独立，而不是子物体关系，否则前面关节的移动将导致后面整体的移动，待验证，可以自己改一下看看能否训练起来）

下面是第一个关节的设置：

可以看到这个关节的位置移动是锁定的，对于角度移动锁定了z轴，对于x轴和y轴限制一定角度的移动，如上图所示，我们可以通过Edit Angular Limits可视化调节。第二第三个关节同理。

想要控制各个关节的运动，我们需要在智能体上挂载一个JointDriveController.cs的脚本，这个脚本不会自己运作，只有在别的脚本的调用下才会起作用。关于这个脚本的代码说明参考ML-Agents案例之Crawler。

状态输入：首先是整个身体的主干部分到地面的距离，一维。目标的前进向量，三维。目标向量与智能体本体的朝向的夹角除以180，一维。智能体本体的朝向到目标朝向的旋转，四元数，四维。目标方块相对于智能体的坐标，三维。每节躯体的移动速度和角速度和是否接触地面，4 * 7维，每个关节的力度，3 * 1维。除了头部的躯体相对于头部的位置以及旋转，3 * 7维。一共是64维。

动作输出：三个关节，每个关节有x，y两个轴可以旋转，还需要输出关节转动的力度，一共有3 * 3共9维的连续输出。

代码讲解

我们直接看WormAgents.cs脚本：

定义变量

const float m_MaxWalkingSpeed = 10; //最高行走速度

[Header("Target Prefabs")] public Transform TargetPrefab; // 目标方块
private Transform m_Target; 
// 智能体的四节躯体位置
[Header("Body Parts")] public Transform bodySegment0;
public Transform bodySegment1;
public Transform bodySegment2;
public Transform bodySegment3;

//这个方块的设置为一个稳定的空间参考点，可以提高学习效果
OrientationCubeController m_OrientationCube;

// 箭头指示器的脚本
DirectionIndicator m_DirectionIndicator;
JointDriveController m_JdController;

private Vector3 m_StartingPos; //starting position of the agent

初始化方法Initialize()：

public override void Initialize()
{
    SpawnTarget(TargetPrefab, transform.position); // 生成目标方块

    m_StartingPos = bodySegment0.position;	// 头部是整个身躯的父物体，代表整个身躯的初始位置
    m_OrientationCube = GetComponentInChildren<OrientationCubeController>();
    m_DirectionIndicator = GetComponentInChildren<DirectionIndicator>();
    m_JdController = GetComponent<JointDriveController>();
	// 更新自己身上的指向方块
    UpdateOrientationObjects();

    // 初始化各节身躯
    m_JdController.SetupBodyPart(bodySegment0);
    m_JdController.SetupBodyPart(bodySegment1);
    m_JdController.SetupBodyPart(bodySegment2);
    m_JdController.SetupBodyPart(bodySegment3);
}
// 生成目标方块
void SpawnTarget(Transform prefab, Vector3 pos)
{
    m_Target = Instantiate(prefab, pos, Quaternion.identity, transform.parent);
}
// 更新自己身上的指向方块以及地上的指向箭头
void UpdateOrientationObjects()
{
    // 更新指向箭头
    m_OrientationCube.UpdateOrientation(bodySegment0, m_Target);
    // 更新指向方块
    if (m_DirectionIndicator)
    {
        m_DirectionIndicator.MatchOrientation(m_OrientationCube.transform);
    }
}

在OrentationCubeController.cs中有：

public void UpdateOrientation(Transform rootBP, Transform target)
{
    var dirVector = target.position - transform.position;
    dirVector.y = 0; //flatten dir on the y. this will only work on level, uneven surfaces
    var lookRot =
        dirVector == Vector3.zero
        ? Quaternion.identity
        : Quaternion.LookRotation(dirVector); //get our look rot to the target

    //UPDATE ORIENTATION CUBE POS & ROT
    transform.SetPositionAndRotation(rootBP.position, lookRot);
}

状态输入CollectObservations方法：

// 对于每节身躯的输入
public void CollectObservationBodyPart(BodyPart bp, VectorSensor sensor)
{
    // 是否接触地面
    sensor.AddObservation(bp.groundContact.touchingGround ? 1 : 0); 
	// 相对于指向方块空间中的刚体速度和角速度，如果是输入是世界空间中的向量，效果会不好
    sensor.AddObservation(m_OrientationCube.transform.InverseTransformDirection(bp.rb.velocity));
    sensor.AddObservation(m_OrientationCube.transform.InverseTransformDirection(bp.rb.angularVelocity));
	// 后面三节身躯相对于头部的位置和本地的空间旋转
    if (bp.rb.transform != bodySegment0)
    {
        sensor.AddObservation(
            m_OrientationCube.transform.InverseTransformDirection(bp.rb.position - bodySegment0.position));
        sensor.AddObservation(bp.rb.transform.localRotation);
    }
	// 输入每个关节的控制力度
    if (bp.joint)
        sensor.AddObservation(bp.currentStrength / m_JdController.maxJointForceLimit);
}

public override void CollectObservations(VectorSensor sensor)
{
    // 输入身躯与地面的距离
    RaycastHit hit;
    float maxDist = 10;
    if (Physics.Raycast(bodySegment0.position, Vector3.down, out hit, maxDist))
    {
        sensor.AddObservation(hit.distance / maxDist);
    }
    else
        sensor.AddObservation(1);
	
    var cubeForward = m_OrientationCube.transform.forward;
    var velGoal = cubeForward * m_MaxWalkingSpeed;
    // 输入目标的移动速度（三维向量）
    sensor.AddObservation(m_OrientationCube.transform.InverseTransformDirection(velGoal));
    // 输入现在的rotation和目标rotation的夹角
    sensor.AddObservation(Quaternion.Angle(m_OrientationCube.transform.rotation,
                                           m_JdController.bodyPartsDict[bodySegment0].rb.rotation) / 180);
    // 输入现在的前进方向到目标前进方向的四元数
    sensor.AddObservation(Quaternion.FromToRotation(bodySegment0.forward, cubeForward));

    // 输入目标方块相对于自身的坐标
    sensor.AddObservation(m_OrientationCube.transform.InverseTransformPoint(m_Target.transform.position));
	// 每一节身躯的输入，详情看上面的CollectObservationBodyPart方法
    foreach (var bodyPart in m_JdController.bodyPartsList)
    {
        CollectObservationBodyPart(bodyPart, sensor);
    }
}

动作输出方法OnActionReceived：

public override void OnActionReceived(ActionBuffers actionBuffers)
{
    // 获取身躯的字典
    var bpDict = m_JdController.bodyPartsDict;

    var i = -1;
    // 获取连续输入的列表
    var continuousActions = actionBuffers.ContinuousActions;
    // 输入三个关节的旋转
    bpDict[bodySegment0].SetJointTargetRotation(continuousActions[++i], continuousActions[++i], 0);
    bpDict[bodySegment1].SetJointTargetRotation(continuousActions[++i], continuousActions[++i], 0);
    bpDict[bodySegment2].SetJointTargetRotation(continuousActions[++i], continuousActions[++i], 0);

    // 输入关节的力度
    bpDict[bodySegment0].SetJointStrength(continuousActions[++i]);
    bpDict[bodySegment1].SetJointStrength(continuousActions[++i]);
    bpDict[bodySegment2].SetJointStrength(continuousActions[++i]);

    // 如果掉到地面的下方，结束游戏
    if (bodySegment0.position.y < m_StartingPos.y - 2)
    {
        EndEpisode();
    }
}

每一个episode（回合）开始时执行的方法OnEpisodeBegin：

public override void OnEpisodeBegin()
{
    // 重新初始化各个身躯的参数
    foreach (var bodyPart in m_JdController.bodyPartsList)
    {
        bodyPart.Reset(bodyPart);
    }

    // 随机旋转，使得智能体初始时面朝的方向随机
    bodySegment0.rotation = Quaternion.Euler(0, Random.Range(0.0f, 360.0f), 0);
	// 更新指向方块和指向箭头
    UpdateOrientationObjects();
}

每0.02秒执行一次的FixedUpdate：

void FixedUpdate()
{
	// 更新指向方块和指向箭头
    UpdateOrientationObjects();
    // 当实际移动速度和目标速度越接近，获得的奖励越高
    var velReward =
        GetMatchingVelocityReward(m_OrientationCube.transform.forward * m_MaxWalkingSpeed,
                                  m_JdController.bodyPartsDict[bodySegment0].rb.velocity);

    // 指向方块的朝向和躯体朝向的夹角
    var rotAngle = Quaternion.Angle(m_OrientationCube.transform.rotation,
                                    m_JdController.bodyPartsDict[bodySegment0].rb.rotation);

    var facingRew = 0f;
    // 当智能体面朝的方向和目标方向的夹角小于30度，给予一定的奖励
    if (rotAngle < 30)
    {
        facingRew = 1 - (rotAngle / 180);
    }
    // 面朝奖励和移动奖励相乘得到实际奖励
    AddReward(velReward * facingRew);
}
public float GetMatchingVelocityReward(Vector3 velocityGoal, Vector3 actualVelocity)
{
    var velDeltaMagnitude = Mathf.Clamp(Vector3.Distance(actualVelocity, velocityGoal), 0, m_MaxWalkingSpeed);
    return Mathf.Pow(1 - Mathf.Pow(velDeltaMagnitude / m_MaxWalkingSpeed, 2), 2);
}

本案例还给环境加上了一个AdjustTrainingTimescale的脚本：

using UnityEngine;

namespace MLAgentsExamples
{
    public class AdjustTrainingTimescale : MonoBehaviour
    {
        // Update is called once per frame
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.Alpha1))
            {
                Time.timeScale = 1f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha2))
            {
                Time.timeScale = 2f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha3))
            {
                Time.timeScale = 3f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha4))
            {
                Time.timeScale = 4f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha5))
            {
                Time.timeScale = 5f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha6))
            {
                Time.timeScale = 6f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha7))
            {
                Time.timeScale = 7f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha8))
            {
                Time.timeScale = 8f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha9))
            {
                Time.timeScale = 9f;
            }
            if (Input.GetKeyDown(KeyCode.Alpha0))
            {
                Time.timeScale *= 2f;
            }
        }
    }
}

这个脚本可以通过按键盘上方的数字键自由调整游戏运行速率。

配置文件

PPO算法：

behaviors:
  Worm:
    trainer_type: ppo
    hyperparameters:
      batch_size: 2024
      buffer_size: 20240
      learning_rate: 0.0003
      beta: 0.005
      epsilon: 0.2
      lambd: 0.95
      num_epoch: 3
      learning_rate_schedule: linear
    network_settings:
      normalize: true
      hidden_units: 512
      num_layers: 3
      vis_encode_type: simple
    reward_signals:
      extrinsic:
        gamma: 0.995
        strength: 1.0
    keep_checkpoints: 5
    max_steps: 7000000
    time_horizon: 1000
    summary_freq: 30000

SAC算法：

behaviors:
  Worm:
    trainer_type: sac
    hyperparameters:
      learning_rate: 0.0003
      learning_rate_schedule: constant
      batch_size: 256
      buffer_size: 500000
      buffer_init_steps: 0
      tau: 0.005
      steps_per_update: 20.0
      save_replay_buffer: false
      init_entcoef: 1.0
      reward_signal_steps_per_update: 20.0
    network_settings:
      normalize: true
      hidden_units: 512
      num_layers: 3
      vis_encode_type: simple
    reward_signals:
      extrinsic:
        gamma: 0.995
        strength: 1.0
    keep_checkpoints: 5
    max_steps: 5000000
    time_horizon: 1000
    summary_freq: 30000

效果演示

后记

本案例是继爬虫机器人Crawler之后的另一个ML-Agents中的仿生机器人的案例，这种案例相比于其他没有关节的智能体来说，难点就是关节和身体各个部位的观测和控制，需要采用更为严格的措施来使训练稳定。例如加入一个指向方块使得输入更加稳定。

和Crawler相比，这里有个新增的ML-Agents实验性的传感器Rigid Body Sensor Component没有用上，这个组件能够给关节提供更好的状态输入接口，对于有关节的智能体来说，可以尝试加上该组件，看看能够改善训练。