目錄

• ML-Agents（九）Wall Jump
  • 一、前言
  • 二、課程訓練（Curriculum Learning）
    • 一個教學示例
    • 具體實作
  • 三、環境與訓練引數
  • 四、場景基本構成
  • 五、代碼分析
    • Agent初始化
    • 環境觀測值收集
    • Agent動作反饋
    • Agent重置
    • 其他
  • 六、訓練
    • 訓練配置引數
    • 開始訓練
  • 七、總結

ML-Agents（九）Wall Jump

一、前言

這次我們來看一下Wall Jump示例，這個例子又和我們之前學習的示例不同，它參考了Curriculum Learning（課程學習）的學習方法，簡單來講就是使用授課學習的方式來訓練神經網路，學習的樣本從易到難，模擬人類學系的程序，先來看看本示例的最終效果：

由圖中可以看到本示例的效果，小藍需要越過藍色的墻體到達綠色的目標地點，此外還可以留意到，藍色的墻體高度是隨機變化的：當藍色的墻體較高時，小藍推動大白塊當梯子才能越過墻體；當藍色墻體高度較低時，小藍則可以直接跳躍過去，

因此，在本示例中，小藍擁有兩個訓練好的訓練模型——SmallWallJump和BigWallJump，分別對應矮墻（無墻）和高墻情況下的行動，

下面我們先來學習一下官方對于Curriculum Learning的相關檔案，

二、課程訓練（Curriculum Learning）

這一節內容主要是翻譯官方檔案 Training with Curriculum Learning，

首先檔案介紹了課程學習是ML-Agents的一項功能，它允許在訓練的程序中更改環境的屬性來幫助學習，

一個教學示例

先想象一個任務，agent需要越過一堵墻到達目標位置（其實就是Jump Wall），一開始訓練agent來完成該任務其實是一個隨機策略，因此直接訓練的話，開始的策略將使agent在回圈中運行，并且可能永遠，或者很少正確地越過墻體到達目標以獲得獎勵（意思就是一開始要是訓練難度過大，agent可能很難理解自己要達成的目標），如果我們從一個更簡單的任務開始，例如讓agent朝著一個無障礙的目標前進，那么agent則會很容易地學會完成任務，在此基礎上，我們再通過增加墻體的大小來慢慢增加任務的難度，直到agent可以完成最初幾乎不可能完成的任務（就是小藍通過大白塊間接越過高墻），下圖展示了任務由易到難的程序：

具體實作

在一個訓練環境中，具有相同Behavior Name的每一組Agent具有相同的課程，這些課程被稱為"metacurriculum"（元課程），元課程允許不同組的agent在同一環境中學習不同的課程，

指定課程

為了定義課程，第一步是確定環境的哪些引數會變化，在Wall Jump示例環境中，墻的高度則是這個變數，我們將墻的高度定義為Academy.Instance.EnvironmentParameters中可以訪問的Environment Parameters引數，并通過這樣做使得Python API來對其調整，我們將創建一個YAML組態檔來描述課程程序，而不是通過手動來調整課程，通過該組態檔，我們可以指定墻在訓練的某個階段開始改變高度，既可以通過訓練總步數的百分比來設定，也可以通過agent獲得的平均獎勵來設定（Wall Jump中用的是第一種），下面來看一會下Wall Jump環境課程的示例配置，

BigWallJump:
  measure: progress
  thresholds: [0.1, 0.3, 0.5]
  min_lesson_length: 100
  signal_smoothing: true
  parameters:
    big_wall_min_height: [0.0, 4.0, 6.0, 8.0]
    big_wall_max_height: [4.0, 7.0, 8.0, 8.0]

SmallWallJump:
  measure: progress
  thresholds: [0.1, 0.3, 0.5]
  min_lesson_length: 100
  signal_smoothing: true
  parameters:
    small_wall_height: [1.5, 2.0, 2.5, 4.0]

在配置的頂層是Behavior Name，即對應于agent的行為名稱（在Unity中的設定），每種行為的課程都有以下引數：

• measure：衡量學習進度和課程進度的方法，

  • reward：使用獎勵來衡量，
  • progress：使用steps/max_steps比例來衡量，

• thresholds(float array)：配合measure使用，應當改變課程的階段，

  簡單解釋一下以上兩個屬性，以Wall Jump為例，其measure屬性為progress，對應thresholds為[0.1,0.3,0.5]，其含義是：

  一開始訓練時，墻的高度變化范圍是0-4（參考下面parameters引數）；當steps/max_steps=0.1（當前訓練步數/總訓練步數=0.1）時，改變一次墻的高度范圍（對應下面引數為4.0-7.0）；當steps/max_steps=0.3時，在改變一次墻的高度范圍（6.0-8.0）；當steps/max_steps=0.5時，墻的高度固定為8.0，

• min_lesson_length(int)：在課程改變之前，應該完成的episodes最小數量，如果measure設定為reward，則將使用最后min_lesson_length episodes的平均獎勵來確定課程是否應該改變，必須是非負數，

  重要：與thresholds比較的平均獎勵不同于控制臺（Console）中記錄的平均獎勵，例如，如果min_lesson_length為100，那么在最近100的episodes的平均累積獎勵超過當前thresholds設定的值后，課程將改變，記錄到控制臺的平均獎勵是由組態檔中summary_freq引數決定的，

• signal_smoothing(true/false)：是否通過以前的值來衡量當前的進度，

  • 如果設定為true，則權重將由老的0.25變為新的0.75，

• parameters(dictionary: key(string),value(float array))：對應于要控制的環境引數，每個陣列的長度應該大于thresholds的數目，具體的意思在上面也有解釋，

一旦我們定義好課程配置，我們就必須使用定義的環境引數，并通過agent的OnEpisodeBegin()函式來修改環境，具體我們在后面的章節介紹Wall Jump的Agent腳本時再來看，

開始訓練

至此，我們指定好了我們的課程組態檔，然后通過ml-agents命令臺中使用-curriculum命令字來指定我們的組態檔，PPO將使用課程學習進行訓練，例如下面要通過課程學習訓練Wall Jump，在控制臺中可以輸入：

mlagents-learn config/trainer_config.yaml --curriculum=config/curricula/wall_jump.yaml --run-id=wall-jump-curriculum

主要是留意--curriculum命令字的使用，

Note：如果要恢復使用課程的訓練，在mlagents-learn時使用--lesson標志來輸入最后課程的編號，

至此，我們大概了解了在ML-Agents中課程訓練的組態檔，下面我們開始正式學習Wall Jump示例，

三、環境與訓練引數

• 設定：一個平臺環境中，agent可以跳過一堵墻，
• 目標：Agent必須使用方塊越過墻體到達目的地，
• Agents：環境中包含一個鏈接到兩個不同模型的agent，Agent的策略鏈接改變取決于墻的高度（即墻低的時候<4時，采用SmallWallJump訓練，墻高度>4時，采用BigWallJump訓練），策略的改變在WallJumpAgent腳本中實作，下面看代碼會有介紹，
• Agent獎勵設定：
  • 每一步-0.0005，
  • 如果agent到達目的地，則+1.0，
  • 如果agent從平臺上掉落，則-1.0，
• 行為引數：
  • 矢量觀測空間：74個變數，對應于14條射線（ray casts），每條射線檢測四個物體，再加agent的世界坐標以及agent是否已接地，
  • 矢量動作空間：離散（Discrete），4個分支，分別是
    • 前后移動：前移、后移、No Action
    • 旋轉：左旋轉、右旋轉、No Action
    • 左右移動：左平移、右平移、No Action
    • 跳躍：跳躍、NoAction
  • 視覺觀察值：無
• 可變引數：4個
• 基準平均獎勵（Big && Small Wall）：0.8

四、場景基本構成

場景中包含24個訓練單元，訓練單元之間都相隔較遠距離，如下圖：

• PlayerCam

  PlayerCam是我們一開始游戲的相機，對應于第一個訓練單元：

  

• OverviewCam

  OverviewCam是一個鳥瞰相機，注意它是在Display 2中，具體效果如下：

  

  這個相機目前沒發現什么特殊的用途，感覺應該是想把所有的訓練單元都納入，于是我自己調整了一下，就變成如下效果：

  

  這個視圖還是有一點好處，就是之后我們在訓練的時候，因為這個示例也和上一次講的PushBlock示例一樣，當小藍完成任務地面就變綠閃一下；當小藍任務失敗或者掉落平臺，地面就變紅閃一下，用這種鳥瞰視圖就很容易看出來你訓練的效果怎么樣，例如一開始應該是紅色閃的多，越到后面就是綠色閃的多，由此來看訓練效果，

• WallJumpSettings

  WallJumpSettings物體依舊是設定了一些全域變數，主要有小藍的速度、小藍跳躍的高度等，

• WallJumpArea

  WallJumpArea是一個基本的訓練單元，主要有以下物體：

  

  這里面的構成和PushBlock里的很相似，沒什么太難的點，主要說一下SpawnVolume，這個物件在運行的時候就令它SetActive(false)了，那為什么還需要這個物件呢？其實是在Agent的腳本里，利用了該物件的Bounds，即控制大白塊的位置是隨機產生在該區域里的，

  其他的物體沒什么好說的，下面我們直接進入代碼環節，

五、代碼分析

其余代碼都比較簡單，我們主要來研究一下WallJumpAgent.cs腳本，

Agent初始化

using System.Collections;
using UnityEngine;
using MLAgents;
using Barracuda;
using MLAgents.Sensors;

public class WallJumpAgent : Agent
{
    //該值范圍為[0,5]，控制墻體高度以及設定不同的Brain
    int m_Configuration;
    //當墻體高度為0時，采用此Brain
    public NNModel noWallBrain;
    //當墻體高度為1時，采用此Brain（實際上與NoWallBrain是一樣的）
    public NNModel smallWallBrain;
    //當墻體高度大于1時，采用此Brain
    public NNModel bigWallBrain;

    public GameObject ground;//地面，變換地面材質用
    public GameObject spawnArea;//大白塊隨機生成區域
    Bounds m_SpawnAreaBounds;//區域的Bounds

    public GameObject goal;//目標區域
    public GameObject shortBlock;//大白塊
    public GameObject wall;//墻體
    Rigidbody m_ShortBlockRb;//大白塊的剛體
    Rigidbody m_AgentRb;//小藍的剛體
    Material m_GroundMaterial;
    Renderer m_GroundRenderer;
    WallJumpSettings m_WallJumpSettings;//小藍的速度、跳躍高度等設定

    public float jumpingTime;//跳起空中時間
    public float fallingForce;//小藍在空中時下降時所受向下的力
    //判斷小藍是否在落在地上、墻上或大白塊上
    public Collider[] hitGroundColliders = new Collider[3];
    Vector3 m_JumpTargetPos;//跳躍目標位置
    Vector3 m_JumpStartingPos;//起跳位置

    /// <summary>
    /// 初始化Agent
    /// </summary>
    public override void InitializeAgent()
    {
        m_WallJumpSettings = FindObjectOfType<WallJumpSettings>();//獲取全域設定
        m_Configuration = Random.Range(0, 5);//隨機產生墻面高度

        m_AgentRb = GetComponent<Rigidbody>();//獲得小藍的剛體
        m_ShortBlockRb = shortBlock.GetComponent<Rigidbody>();//獲得大白的剛體
        m_SpawnAreaBounds = spawnArea.GetComponent<Collider>().bounds;//獲得大白隨機產生的區域范圍
        m_GroundRenderer = ground.GetComponent<Renderer>();
        m_GroundMaterial = m_GroundRenderer.material;//獲得地面的材質，以備后面改變地面材質

        spawnArea.SetActive(false);
    }
}

初始化內容都比較簡單，注意第一個變數m_Configuration，該變數只標識了墻的高度應該為多少，但并不是指定墻的高度是幾，例如m_Configuration=1時，實際墻的高度會是4而不是1，該值的使用一會兒在ConfigureAgent(int config)方法中講解，下面我們來看Agent收集的環境觀測值，

環境觀測值收集

在第三章環境訓練引數中，我們知道了本示例小藍除了采用了14條射線來收集射線監測資料外，還需要采集自己的世界坐標以及是否接觸地面的資訊，這兩種資訊在CollectObservations(Vector sensor)方法中進行收集，

	/// <summary>
    /// 收集環境中其他資料
    /// </summary>
    /// <param name="sensor"></param>
    public override void CollectObservations(VectorSensor sensor)
    {
        var agentPos = m_AgentRb.position - ground.transform.position;
        //小藍相對于地面中心的位置，除以20是為了讓其位置x、y、z值歸一化
        sensor.AddObservation(agentPos / 20f);
        //判斷小藍是否落地
        sensor.AddObservation(DoGroundCheck(true) ? 1 : 0);
    }
    /// <summary>
    /// 檢測是否落地
    /// </summary>
    /// <param name="smallCheck">墻的高度是否是低（<=4）</param>
    /// <returns>true為落地，否則為false</returns>
    public bool DoGroundCheck(bool smallCheck)
    {
        if (!smallCheck)
        {//4<墻高度<=8
            hitGroundColliders = new Collider[3];
            var o = gameObject;
            //無GC的相交盒檢測，可采集與相交盒碰撞的碰撞體Collider[]
            //此處賦值給hitGroundColliders
            Physics.OverlapBoxNonAlloc(
                o.transform.position + new Vector3(0, -0.05f, 0),
                new Vector3(0.95f / 2f, 0.5f, 0.95f / 2f),
                hitGroundColliders,
                o.transform.rotation);
            var grounded = false;
            foreach (var col in hitGroundColliders)
            {//遍歷與碰撞盒產生碰撞的物體
                if (col != null && col.transform != transform &&
                    (col.CompareTag("walkableSurface") ||
                     col.CompareTag("block") ||
                     col.CompareTag("wall")))
                {
                    //若碰撞的物體為地面、大白塊或墻體，則判斷小藍已落地
                    grounded = true; //then we're grounded
                    break;
                }
            }
            return grounded;
        }
        else
        {//0<=墻高度<=4
            RaycastHit hit;
            //若墻的高度較低，則只需要向下發出長度為1的射線來檢測小藍是否落地
            Physics.Raycast(transform.position + new Vector3(0, -0.05f, 0), -Vector3.up, out hit,
                1f);
            if (hit.collider != null &&
                (hit.collider.CompareTag("walkableSurface") ||
                 hit.collider.CompareTag("block") ||
                 hit.collider.CompareTag("wall"))
                && hit.normal.y > 0.95f)
            {
                return true;
            }
            return false;
        }
    }
    

此處代碼中，需要注意DoGroundCheck(bool smallCheck)這個方法，該方法除了在收集觀測值時使用，還在其他3處地方分別使用，

首先該方法是為了檢測小藍是否落地，是則回傳true，否則回傳false，然后其分別處理了墻面高和低的兩種情況：若墻面較高，則采用無GC的相交盒來檢測小藍的碰撞狀態；若墻面較低，則直接向下發射射線來檢測小藍是否落地，

Physics.OverlapBoxNonAlloc()則是相交盒檢測方法，在上一篇“ML-Agents（八）PushBlock”中介紹了Physics.CheckBox()，該方法與CheckBox()不同的是，CheckBox只會回傳bool來判斷是否產生碰撞，而OverlapBox()不僅可以回傳bool來判斷是否產生碰撞，而且可以將產生碰撞的Colliders獲取到，

如下圖，我將小藍材質改透明，其中白色的方塊則是代碼中Physics.OverlapBoxNonAlloc()方法產生的相交盒，Physics.OverlapXXXNonAlloc()對應無GC的方式，這里XXX也可以是Sphere和Capsule，

Agent動作反饋

	/// <summary>
    /// Agent動作
    /// </summary>
    /// <param name="vectorAction"></param>
    public override void AgentAction(float[] vectorAction)
    {
        MoveAgent(vectorAction);//小藍移動
        if ((!Physics.Raycast(m_AgentRb.position, Vector3.down, 20))
            || (!Physics.Raycast(m_ShortBlockRb.position, Vector3.down, 20)))
        {//若小藍落下平臺或大白塊落下平臺
            SetReward(-1f);//懲罰1
            Done();//本次訓練結束，并重置agent
            ResetBlock(m_ShortBlockRb);//重置大白塊位置、速度等
            //設定地面顏色為紅色
            StartCoroutine(
                GoalScoredSwapGroundMaterial(m_WallJumpSettings.failMaterial, .5f));
        }
    }
	/// <summary>
    /// Agent移動
    /// </summary>
    /// <param name="act"></param>
    public void MoveAgent(float[] act)
    {
        AddReward(-0.0005f);//每一步-0.0005
        //判斷小藍是否在地面上，若在地面上則移動速度相應要快一些，在空中的話移動速度要減半
        var smallGrounded = DoGroundCheck(true);//墻低情況
        var largeGrounded = DoGroundCheck(false);//墻高情況

        var dirToGo = Vector3.zero;
        var rotateDir = Vector3.zero;
        var dirToGoForwardAction = (int)act[0];//前后移動
        var rotateDirAction = (int)act[1];//左右旋轉
        var dirToGoSideAction = (int)act[2];//左右移動
        var jumpAction = (int)act[3];//跳躍

        //前后移動
        if (dirToGoForwardAction == 1)
            dirToGo = (largeGrounded ? 1f : 0.5f) * 1f * transform.forward;
        else if (dirToGoForwardAction == 2)
            dirToGo = (largeGrounded ? 1f : 0.5f) * -1f * transform.forward;
        //左右旋轉
        if (rotateDirAction == 1)
            rotateDir = transform.up * -1f;
        else if (rotateDirAction == 2)
            rotateDir = transform.up * 1f;
        //左右平移
        if (dirToGoSideAction == 1)
            dirToGo = (largeGrounded ? 1f : 0.5f) * -0.6f * transform.right;
        else if (dirToGoSideAction == 2)
            dirToGo = (largeGrounded ? 1f : 0.5f) * 0.6f * transform.right;
        //跳躍
        if (jumpAction == 1)
            if ((jumpingTime <= 0f) && smallGrounded)
            {//判斷小藍是否在地上且jumpingTime<=0，初始化起跳變數
                Jump();
            }
        transform.Rotate(rotateDir, Time.fixedDeltaTime * 300f);//旋轉
        m_AgentRb.AddForce(dirToGo * m_WallJumpSettings.agentRunSpeed,
            ForceMode.VelocityChange);//前后左右移動
        
        if (jumpingTime > 0f)
        {//起跳條件滿足
            m_JumpTargetPos =
                new Vector3(m_AgentRb.position.x,
                    m_JumpStartingPos.y + m_WallJumpSettings.agentJumpHeight,
                    m_AgentRb.position.z) + dirToGo;//計算跳躍后控制位置
            //使得小藍跳到計算后的位置m_JumpTargetPos，并限制其速度
            MoveTowards(m_JumpTargetPos, m_AgentRb, m_WallJumpSettings.agentJumpVelocity,
                m_WallJumpSettings.agentJumpVelocityMaxChange);
        }

        if (!(jumpingTime > 0f) && !largeGrounded)
        {//判斷小藍處于空中，給小藍施加向下的力使其下落
            m_AgentRb.AddForce(
                Vector3.down * fallingForce, ForceMode.Acceleration);
        }
        jumpingTime -= Time.fixedDeltaTime;
    }
	/// <summary>
    /// 重置大白塊
    /// </summary>
    /// <param name="blockRb"></param>
    void ResetBlock(Rigidbody blockRb)
    {
        //重置大白塊的位置
        blockRb.transform.position = GetRandomSpawnPos();
        blockRb.velocity = Vector3.zero;//速度置零
        blockRb.angularVelocity = Vector3.zero;//角速度置零
    }
 	/// <summary>
    /// 改變地面材質顏色
    /// </summary>
    /// <returns></returns>
    /// <param name="mat">要換的材質</param>
    /// <param name="time">變換材質后變回原先材質的延時時間</param>
    IEnumerator GoalScoredSwapGroundMaterial(Material mat, float time)
    {
        m_GroundRenderer.material = mat;
        yield return new WaitForSeconds(time); //等待2秒
        m_GroundRenderer.material = m_GroundMaterial;
    }

這里的代碼雖長，但是都比較簡單，屬于一看就懂系列，但是有一個點可以注意一下，即此處小藍起跳以及下落的代碼處理程序，感覺和我見過處理跳躍的方式有一些不同，

Agent重置

	/// <summary>
    /// Agent重置
    /// </summary>
    public override void AgentReset()
    {
        ResetBlock(m_ShortBlockRb);//重置大白塊
        //重置小藍位置
        transform.localPosition = new Vector3(
            18 * (Random.value - 0.5f), 1, -12);
        m_Configuration = Random.Range(0, 5);//重置墻體高度以及選用的Brain
        m_AgentRb.velocity = default(Vector3);//小藍速度置零
    }
	/// <summary>
    /// 檢測小藍是否到達目標區域
    /// </summary>
    /// <param name="col"></param>
    void OnTriggerStay(Collider col)
    {
        if (col.gameObject.CompareTag("goal") && DoGroundCheck(true))
        {//若小藍到目標區域，且在地面上
            SetReward(1f);//獎勵1
            Done();//結束此次訓練
            //使地面置為綠色
            StartCoroutine(
                GoalScoredSwapGroundMaterial(m_WallJumpSettings.goalScoredMaterial, 2));
        }
    }

重置Agent的代碼，一部分實際上是在Unity的方法OnTriggerStay(Collider col)中實作的，因為目標區域其實也是有碰撞體的，因此若小藍Stay在目標區域，則會觸發此函式，

到此為止，我們還沒有看到此示例是如何使用兩個Brain來回切換使用的，下面我們就來看一下這一部分代碼是如何實作的，

其他

void FixedUpdate()
    {
        if (m_Configuration != -1)
        {
            //設定agent的Brain
            ConfigureAgent(m_Configuration);
            //標志位置位
            m_Configuration = -1;
        }
    }

    /// <summary>
    /// 設定Agent的Brain，墻的高低來決定不同的Brain
    /// </summary>
    /// <param name="config">
    /// 如果為0：No wall + noWallBrain
    /// 如果為1：Samll Wall + samllWallBrain
    /// 其他：Tall wall + bigWallBrain
    /// </param>
    void ConfigureAgent(int config)
    {
        var localScale = wall.transform.localScale;//墻的比例大小
        if (config == 0)
        {//如果m_Configuration==0，墻高度為0
            localScale = new Vector3(
                localScale.x,
                Academy.Instance.FloatProperties.GetPropertyWithDefault("no_wall_height", 0),
                localScale.z);
            wall.transform.localScale = localScale;
            //設定agent的Model
            GiveModel("SmallWallJump", noWallBrain);
        }
        else if (config == 1)
        {//如果m_Configuration==1
            localScale = new Vector3(
                localScale.x,
                Academy.Instance.FloatProperties.GetPropertyWithDefault("small_wall_height", 4),
                localScale.z);
            wall.transform.localScale = localScale;
            GiveModel("SmallWallJump", smallWallBrain);
        }
        else
        {//如果m_Configuration>1
            //若開始訓練時，此處的min和max值取決于課程配置值
            var min = Academy.Instance.FloatProperties.GetPropertyWithDefault("big_wall_min_height", 8);
            var max = Academy.Instance.FloatProperties.GetPropertyWithDefault("big_wall_max_height", 8);
            var height = min + Random.value * (max - min);
            localScale = new Vector3(
                localScale.x,
                height,
                localScale.z);
            wall.transform.localScale = localScale;
            GiveModel("BigWallJump", bigWallBrain);
        }
    }

由以上代碼可以看出，其實作是在FixedUpdate()中，實時判斷m_Configuration的值來改變agent不同的Brain，m_Configuration會在訓練一開始以及AgentReset的時候隨機重置，

此外，之前已經講過，Academy.Instance.FloatProperties.GetPropertyWithDefault(string key, float defaultValue)這個方法的第二個引數defaultValue是默認值，若key沒讀取到，則采用輸入的默認值，因此在該示例運行的時候，你會發現墻的高度只有0、4、8這是三個值，但是如果開始訓練后，該方法中的key就會與之前課程配置檔案中的值開始對應，

即在SmallWallJump的時候，墻的高度從1.5->2.0->2.5->4.0；在BigWallJump時，墻的高度則一開始會在0-4隨機，然后在4-7隨機，然后在6-8隨機，最后高度固定在8，從此也可以看出課程訓練從易到難的特點，

六、訓練

訓練配置引數

Wall Jump的課程訓練配置已經在上面第二章講解過了，下面我們來看一下Wall Jump的訓練配置：

trainer_config.yaml

SmallWallJump:
    max_steps: 5e6
    batch_size: 128
    buffer_size: 2048
    beta: 5.0e-3
    hidden_units: 256
    summary_freq: 20000
    time_horizon: 128
    num_layers: 2
    normalize: false

BigWallJump:
    max_steps: 2e7
    batch_size: 128
    buffer_size: 2048
    beta: 5.0e-3
    hidden_units: 256
    summary_freq: 20000
    time_horizon: 128
    num_layers: 2
    normalize: false

首先因為要訓練兩個Model，分別對應SmallWallJump和BigWallJump，因此在組態檔中對應的是兩個部分，可以看出Small的max_steps比Big的更小，也好理解，簡單的任務訓練快，難的任務需要訓練步數應該較多，

其他的屬性在前幾篇都已經分析過，所以不再贅述，這里有一個normalize屬性，其作用是是否對輸入的矢量觀測值（vector observation）進行規范化處理，在之前的內容我們知道，規范化對于復雜的連續控制(continuous control)問題很有用，但對于較簡單的離散控制(discrete control)可能反而有害，而且我們在代碼中已經對小藍位置做過規范化處理，因此這里使其變為false，

開始訓練

cd到ml-agents目錄，并輸入一下命令：

mlagents-learn config/trainer_config.yaml --curriculum=config/curricula/wall_jump.yaml --run-id=walljump

開始訓練，一開始會發現失敗的情況更多，如下圖：

上面紅色閃爍則為失敗的單元，同時我們觀察Console會發現，SmallWallJump和BigWallJump會隨機穿插進行訓練，如下圖：

訓練了一晚上，發現沒訓練成功，，，，，摔！

由圖可以看到已經訓練9個小時了，但平均收益還是-1.1左右，在Unity中也是失敗的多，沒有什么改觀，

其實這期間我又做了許多次嘗試，包括修改原始碼之類的，但是都沒有訓練成功，于是我最終從git上又拉取了最新版的ml-agents（release_1），并重新新建了一個Anaconda訓練環境（具體可參考Unity ML-Agents v0.15.0（一）環境部署與試運行），然后開始訓練，終于得到了比較好的訓練效果：

這才是訓練了40萬步左右的結果，相比之前的訓練效果好了不止N倍，其實我現在還沒搞清楚為什么一開始的版本（0.15.0）訓練失敗，，，

除此之外，最新版release_1里的檔案少了很多，包括課程訓練的簡介都沒有了，大家要是想看英文原版，還是要選0.15.1之前版本的doc才能看到，

OK，這次訓練結果就沒有問題了，相應的Tensorboard如下：

圖中橘黃色線的是SmallWallJump的訓練資料，藍色線是BigWallJump的訓練資料，在Lesson圖表有明顯的階梯狀，代表各個課程的開始，

我們再以藍色線BigWallJump訓練資料為例，在Cumulative Reward圖示里，可以看出每次課程難度的增加，會使得改變時的累計獎勵驟減，但是慢慢會上升，最終的基準平均獎勵也和官方的資料一致，大概在0.8左右，

我們把訓練好的模型放到Unity中試驗一下：

方便起見直接用一個來測驗即可，

OK，發現訓練的模型也沒有問題，

七、總結

這個示例我們主要學習了如何使用Curriculum Learning進行訓練，其中關于射線傳感器的資料采集內容在ML-Agents（八）PushBlock已有講述，不熟悉的親可以回看，本篇文章就此結束，歡迎大家留言交流~

寫文不易~因此做以下申明：

1.博客中標注原創的文章，著作權歸原作者 煦陽（本博博主） 所有；

2.未經原作者允許不得轉載本文內容，否則將視為侵權；

3.轉載或者參考本文內容請注明來源及原作者；

4.對于不遵守此宣告或者其他違法使用本文內容者，本人依法保留追究權等，

標籤：其他

上一篇：深度學習環境搭建：window10+CUDA10.0+CUDNN+pytorch1.2.0

下一篇：經典卷積神經網路演算法(1)：LeNet-5