Unity中利用遺傳算法訓練MLP

【USparkle專欄】如果你深懷絕技，愛“搞點研究”，樂于分享也博采眾長，我們期待你的加入，讓智慧的火花碰撞交織，讓知識的傳遞生生不息！

這是侑虎科技第1843篇文章，感謝作者狐王駕虎供稿。歡迎轉發分享，未經作者授權請勿轉載。如果您有任何獨到的見解或者發現也歡迎聯系我們，一起探討。（QQ群：793972859）

作者主頁：

https://home.cnblogs.com/u/OwlCat

梯度下降法訓練神經網絡通常需要我們給定訓練的輸入-輸出數據，而用遺傳算法會便捷很多，它不需要我們給定好數據，只需要隨機化多個權重進行N次“繁衍進化”，就可以得出效果不錯的網絡。

這種訓練方式的好處就是不需要訓練用的預期輸出數據，適合那類可以簡單通過環境交互判斷訓練好壞的神經網絡AI。當然，壞處就是訓練的時間可能需要很長，尤其是神經網絡比較龐大時。

完整項目gitee鏈接：

https://gitee.com/OwlCat/some-projects-in-tutorials/tree/master/ANNGA

一、用Compute Shader實現神經網絡

神經網絡的計算一般都用矩陣優化，像Python語言者學習實現神經網絡時，通常會借助NumPy的Torch進行計算，加速運算過程。

個人曾經嘗試過以單個神經元為最小單位實現的神經網絡，但其實這種做法并不好。后來嘗試過使用C#的MathNet庫中的矩陣，但發現它并沒有在硬件層面對矩陣運算進行加速。雖說對于小規模網絡，即便不加速計算也不會太影響性能，但總覺得得考慮的更長遠些。

想到神經網絡的預測過程中，其實我們只關心輸入層與輸出層，而隱藏層的那些計算結果其實根本不在乎。這似乎很適合用Compute Shader來完成！

隱藏層計算的結果完全可以只留在ComputeBuffer，只有輸入層需要將數據寫入以及輸出層將結果讀取，CPU與GPU間數據的傳遞并不會很多；而且Compute Shader強大的并行計算能力也可以加速我們的運算過程。

但由于本文主要還是想講遺傳算法，就不喧賓奪主了。

二、遺傳算法

在中學生物課本有提到達爾文的自然選擇學說四個主要觀點：過度繁殖、生存競爭、遺傳和變異、適者生存。遺傳算法就是借鑒了其中的思想，它的整個流程極其相似：

1. 初始化種群

在本例中，我們想要獲取神經網絡中各層合適的權重與偏置的值，來使神經網絡的輸出符合預期，所以我們將整個神經網絡的所有權重與偏置視為一個個體。

using System; using System.Collections; using System.Collections.Generic; using UnityEngine; namespace JufGame {     [CreateAssetMenu(menuName = ("JufGame/AI/ANN/WeightBias"), fileName = ("WeightAndBias_"))]     publicclassWeightBiasMemory : ScriptableObject     {         [Serializable]         public struct LayerWeightAndBias         {             publicint inputCount;             publicint outputCount;             publicfloat[] weights;             publicfloat[] bias;         }         [Tooltip("各全連層的權重和偏置")]         public LayerWeightAndBias[] WeiBiasArray;         [Tooltip("全連接層的Compute Shader")]         public ComputeShader affine;         [Tooltip("激活函數的Compute Shader")]         public ComputeShader activateFunc;         [Tooltip("損失函數的Compute Shader)]         public ComputeShader lossFunc;         [Tooltip("當前損失函數在反向傳播時是否要載入上次輸出，用于sigmoid等函數")]         public bool isLoadLastOutput;         [Header("隨機初始化權重")]         [Tooltip("是否要隨機初始化")]         public bool isRandomWeightAndBias = false;         [Tooltip("當前權重是否是訓練成功后的")]         public bool isFinishedWeightAndBias = false;         [Tooltip("隨機初始化的最大值和最小值")]         public float minRandValue = -1, maxRandValue = 1;         [Tooltip("是否隨機化權重")]         public bool isRandomBias = false;         private void OnValidate()         {             if(isRandomWeightAndBias && !isFinishedWeightAndBias)             {                 RandomWeightAndBias(ref WeiBiasArray, minRandValue, maxRandValue, isRandomBias);                 isRandomWeightAndBias = false;             }         }         ///         /// 隨機初始化權重和偏置         ///         /// WeiBiasArray">被隨機化的數層權重和偏置         /// minRandValue">最小隨機值         /// maxRandValue">最大隨機值         /// isRandomBias">偏置是否也要隨機化，如果false則置0         public static void RandomWeightAndBias(ref LayerWeightAndBias[] WeiBiasArray, float minRandValue,              float maxRandValue, bool isRandomBias = false)         {             var rand = new System.Random();             foreach (var wb in WeiBiasArray)             {                 float range = maxRandValue - minRandValue;                 // 初始化權重                 for (int i = 0; i < wb.weights.Length; ++i)                 {                     wb.weights[i] = (float)(rand.NextDouble() * range + minRandValue); // 使用指定范圍生成隨機數                 }                 // 初始化偏置                 for (int i = 0; i < wb.bias.Length; ++i)                 {                     wb.bias[i] = isRandomBias ?  (float)(rand.NextDouble() * range + minRandValue) : 0;                 }             }         }         ///         /// 深拷貝所有層的權重與偏置         ///         /// source">拷貝源         /// target">目標處         public static void DeepCopyAllLayerWB(ref LayerWeightAndBias[] source, ref LayerWeightAndBias[] target)         {             for(int i = 0, j; i < source.Length; ++i)             {                 var wb = target[i];                 for (j = 0; j < wb.weights.Length; ++j)                 {                     wb.weights[j] = source[i].weights[j];                 }                 for (j = 0; j < wb.bias.Length; ++j)                 {                     wb.bias[j] = source[i].bias[j];                 }             }         }         ///         /// 交換所有層的權重與偏置         ///         public static void DeepSwap(ref LayerWeightAndBias[] a, ref LayerWeightAndBias[] b)         {             float tp;             for(int i = 0, j; i < a.Length; ++i)             {                 var wb = b[i];                 for (j = 0; j < wb.weights.Length; ++j)                 {                     tp = wb.weights[j];                     wb.weights[j] = a[i].weights[j];                     a[i].weights[j] = tp;                 }                 for (j = 0; j < wb.bias.Length; ++j)                 {                     tp = wb.bias[j];                     wb.bias[j] = a[i].bias[j];                     a[i].bias[j] = tp;                 }             }         }     } }

using System.Collections; using System.Collections.Generic; using UnityEngine; namespace JufGame {     //遺傳算法中的個體，具體邏輯需繼承該類擴展     publicclassGAUnit : MonoBehaviour     {         public WeightBiasMemory memory;         publicfloat FitNess;         public bool isOver;         public virtual voidReStart()         {             isOver = false;             FitNess = 0;         }     } }

然后初始化指定數量的該類個體作為初始種群，擔任原始父本，并讓個體權重與偏置隨機化。這樣一來，每個個體就都是不同的了，至于它們中誰具有更好的潛質，就需要通過競爭得知了。

2. 競爭

我們讓游戲中的使用神經網絡決策的AI個體，分別應用種群中各個體作為神經網絡的權重與偏置，并直接應用神經網絡進行決策。由于這些權重與偏置都是隨機的，執行的效果幾乎都不堪入目。

private voidFixedUpdate() {     if(isEndTrain) //如果選擇結束訓練，則保留當前最好的個體     {         SaveBest();     }     elseif(TrainUnit.isOver) //如果當前訓練單位的訓練結束     {         parents[curIndex].fitness = TrainUnit.FitNess;         TrainUnit.ReStart();         //輪流將當前父本中個體權重與偏置賦給訓練單位進行決策         if(++curIndex < AllPopulation)         {             WeightBiasMemory.DeepCopyAllLayerWB(ref parents[curIndex].WB, ref TrainUnit.memory.WeiBiasArray);         }         //……     } }

但我們需要“矮子里拔高個”，設計一個評估函數計算每個個體的適應度。比如評估一個小車，我們就可以通過它行駛的距離、速度等進行加權和得到一個適應度?？傊?，要確保評估函數的計算結果能合理表達出決策結果的好壞。

3. 繁殖與變異

現在，我們要隨機從原始父本中選出兩個不同的個體，進行繁殖得到兩個新的個體。

這個繁殖的過程很簡單，與染色體互換的過程極其相似。對于新權重和偏置，隨機從兩個作為父本的個體選擇一個，選取其對應部分的值。每個位置都這么做一遍，就得到了兩個新個體（子代）。

但值得注意的是，如果是自然界，其實更優秀的個體會擁有更大的繁殖機會。所以，我們可以使用一種叫輪盤賭的隨機選擇方式，代替之前的純隨機選擇。這樣，就可以讓適應度更高的個體有更大機會變成父本，但也保留弱小個體被選中的可能。

以上圖藍色段被選中的機會為例，原本它應當為0.4，也就是生成一個0~1的隨機數，如果隨機數的值小于0.4，那么藍色就被選中。

而轉化為輪盤賭后，藍色段的部分為0.227~0.59，也就是只有隨機值落在這個范圍內時，它才會被選中。如果是其它值，就留給其它段了。

可以明顯看出，這樣的選擇更照顧整體，原本大的值會有更大概率被選中，但小的也有機會。代碼實現也非常簡單：

//計算輪盤賭概率分布 privatevoidCalcRouletteWheel() {     floattotalFitness=0f;     for (inti=0; i < parents.Length; i++)     {         totalFitness += parents[i].fitness;     }     floatcumulativeSum=0f;     for (inti=0; i < cumulativeProbabilities.Length; i++)     {         cumulativeSum += (parents[i].fitness / totalFitness);         cumulativeProbabilities[i] = cumulativeSum;     } } //輪盤賭隨機下標 privateintGetRouletteRandom() {     floatrand= Random.value;     // 選擇個體     for (inti=0; i < cumulativeProbabilities.Length; i++)     {         if (rand < cumulativeProbabilities[i])         {             return i;         }     }     // 如果沒有找到，返回最后一個個體（通常不會發生）     return cumulativeProbabilities.Length - 1; }

現在還有一個問題，僅僅只是交叉互換，那么最終得到的最優個體也只會囿于初始種群。如果初始種群中無論怎么交叉互換都無法得到優良個體又該怎么辦？這時就得靠變異了。

變異的手段并不固定，只要能做到突破就可以。我的做法就是在原本數值的基礎上隨機增減一個小數值。但變異通常不能太頻繁發生，我們要為它規定一個較小的概率，否則大規模的變異反而會破壞優良父本的傳承。

變異的發生可以與繁殖放在一起：

private voidGetChild() {     int p1, p2;     for(inti=0; i < parents.Length; i += 2)     {         p2 = p1 = GetRouletteRandom();         varcurWB= parents[i].WB;         while(p1 == p2 && parents.Length > 1)         {             p2 = GetRouletteRandom();         }         for(intj=0; j < curWB.Length; ++j)         {             varcurW= curWB[j].weights;             for (intk=0; k < curW.Length; ++k)             {                 if(Random.value < 0.5)                 {                     children[i].WB[j].weights[k] = parents[p2].WB[j].weights[k];                     if (i + 1 < children.Length)                     {                         children[i + 1].WB[j].weights[k] = parents[p1].WB[j].weights[k];                     }                 }                 else                 {                     children[i].WB[j].weights[k] = parents[p1].WB[j].weights[k];                     if (i + 1 < children.Length)                     {                         children[i + 1].WB[j].weights[k] = parents[p2].WB[j].weights[k];                     }                 }                 if (Random.value < mutationRate) //隨機變異，mutationRate為變異率                 {                     //mutationScale為變異的幅度，即變異帶來的數值增減幅度                     children[i].WB[j].weights[k] += Random.Range(-mutationScale, mutationScale);                 }                 if (i + 1 < children.Length && Random.value < mutationRate)                 {                     children[i + 1].WB[j].weights[k] += Random.Range(-mutationScale, mutationScale);                 }             }             varcurB= curWB[j].bias;             for (intk=0; k < curB.Length; ++k)             {                 if(Random.value < 0.5)                 {                     children[i].WB[j].bias[k] = parents[p2].WB[j].bias[k];                     if (i + 1 < children.Length)                     {                         children[i + 1].WB[j].bias[k] = parents[p1].WB[j].bias[k];                     }                 }                 else                 {                     children[i].WB[j].bias[k] = parents[p1].WB[j].bias[k];                     if (i + 1 < children.Length)                     {                         children[i + 1].WB[j].bias[k] = parents[p2].WB[j].bias[k];                     }                 }                 if (Random.value < mutationRate) //隨機變異，mutationRate為變異率                 {                     //mutationScale為變異的幅度，即變異帶來的數值增減幅度                     children[i].WB[j].bias[k] += Random.Range(-mutationScale, mutationScale);                 }                 if (i + 1 < children.Length && Random.value < mutationRate)                 {                     children[i + 1].WB[j].bias[k] += Random.Range(-mutationScale, mutationScale);                 }             }         }     } }

4. 優勝劣汰

在繁殖得到新的一批子代后，我們將這些子代也進行一次競爭，這樣所有的父代、子代就都有各自的適應度了。我們將它們一起根據適應度進行排序，顯然，如果父代的數量是N，那么總共就有2N個個體。在排序后我們選擇前N個個體作為本輪的優勝者，也是下輪的新父本。

//在父代和子代組成的整體中選出適應度高的新父代 privatevoidGetBest() {     for(inti=0; i < totalPopulation.Length; ++i)     {         if (i < AllPopulation)             totalPopulation[i] = parents[i];         else             totalPopulation[i] = children[i - AllPopulation];     }     Array.Sort(totalPopulation, (a, b) => b.fitness.CompareTo(a.fitness)); }

也就是說，有更高適應度的個體能存活下來，其它的就被淘汰。而這些存活下來的個體會不斷重復這個過程。在數次迭代后，我們就一定可以得到理想中的個體（比如適應度超高的那種）。這時，我們就可以結束算法了。

三、實例：賽道小球

用一個比較簡單的實例，串一遍整個過程。我們將訓練一個用來跑賽道的小球。

1. 創建神經網絡

在我的實現中，已將網絡結構以ScriptObject形式存儲，我們先新建一個，在Project下右鍵Create/ANN/WeightAngBias：

然后設置具體結構，這次要完成的工作比較簡單，就是訓練一個可以繞圈跑的小球，所以網絡結構比較簡單。兩個隱藏層足矣（對應Wei Bias Array的兩個元素），這個神經網絡接受三個輸入，輸出兩個數據。

至于中間其它參數的設計要符合神經網絡的結構，具體來說就是：每一層的Weights數量要等于InputCount * OutputCount；除了第一層外，其它層的InputCount要等于上一層的OutputCount。（如果你對神經網絡有所了解，那就能理解這些。）

Affine固定使用同名的Compute Shader，至于Activate Func和Loss Func其實可以不管，因為遺傳算法訓練用不著。

2. 創建遺傳個體

場景中已有一個球形物體，掛載了繼承GAUnit的Car腳本。

神經網絡的3個輸入數據就來自小球的三條射線檢測：

private voidCheckEnv() {     totalSensor = 0;     for(inti=0; i < direactions.Length; ++i)     {         vardir= transform.TransformDirection(direactions[i]);         if(Physics.Raycast(transform.position, dir, out RaycastHit hit,              rayLength[i], hitMask, QueryTriggerInteraction.Ignore))         {             inputVal[i] = hit.distance / rayLength[i];         }         else         {             inputVal[i] = 1;         }         totalSensor += inputVal[i];     } }

神經網絡的兩個輸出分別用來控制，移動速度以及角位移：

private void RunMLP() {     myMLP.Predict(inputVal);     moveVel = transform.TransformDirection(new Vector3( 0, 0, myMLP.outputData[0] * 10));     moveVel = Vector3.MoveTowards(rb.velocity, moveVel, 0.02f);     rb.velocity = moveVel;     transform.eulerAngles += new Vector3(0, myMLP.outputData[1] * 90 * Time.fixedDeltaTime, 0); }

我們還需要設計一個衡量適應度的函數。而因為我們打算訓練一個能在賽道正中央前進的小球，所以這里主要考慮「位移距離、速度、檢測距離」以及「是否有碰到墻」。一旦isOver為true后，GA會讓小球回到起始點，進行新的訓練。

private voidCalculateFitness() {     totalMoveDis += Vector3.Distance(transform.position, lastPos);     avgSpeed = totalMoveDis / runningTime;     //適應度與位移距離、速度、檢測距離有關     FitNess = (totalMoveDis*distanceMultipler) + (avgSpeed*avgSpeedMultiplier) + ( totalSensor / inputVal.Length *sensorMultiplier);     if (runningTime > 20 && FitNess < 40) //存活足夠時間且適應度不低時，結束本輪     {         isOver = true;     }     if(FitNess >= 1000) //適應度很高時，直接算成功，結束     {         isOver = true;     } } privatevoidOnCollisionEnter(Collision other) {     if(!isOver && hitMask.ContainLayer(other.gameObject.layer))     {         isOver = true; //碰到墻上，直接結束         rb.velocity = Vector3.zero;     } }

這樣，個體的設置就搞定了，它將作為訓練時的運行個體。

3. 遺傳算法訓練器

在場景中任意激活的物體上，掛載GA腳本，并將Car拖拽在指定位置：

這個腳本中All Population是初始化種群的數量，這里填50。但注意，這并不會讓場景中出現50個小球，而是每輪小球得重復50次來逐一嘗試種群中的個體。Mutation Rate是變異率，這里填0.3；Mutation Scale是變異幅度默認為1即可。

至于綠色框內的，Is End Train用來結束遺傳算法的訓練，并將最好的結果保存到先前的ScriptObject中。其余只是用來觀察小球當前訓練情況而已。

一切就緒后，點擊運行即可訓練。訓練時我們可以調整Project Settings/Time/Time Scale加速訓練。

需要注意的是，當你想測試小球時，一定要關閉GA腳本，或者將Train Unit置空，否則一運行就會又重新訓練Train Unit中的個體。比如這里，花了4分鐘訓練出了一個能走圈的小球，保存訓練結果，就要先勾上Is End Train，再終止運行，而后取消啟用GA；這時再運行，會發現小球可以自動繞圈走了：

四、尾聲

完整的訓練視頻在項目中有，如果了解神經網絡，或許這篇就好看懂些。大伙感興趣就嘗試下項目吧，也可以嘗試更復雜的賽道，更龐大的網絡。

文末，再次感謝狐王駕虎 的分享， 作者主頁：https://home.cnblogs.com/u/OwlCat， 如果您有任何獨到的見解或者發現也歡迎聯系我們，一起探討。（QQ群： 793972859 ）。

近期精彩回顧

【學堂上新】

【厚積薄發】

【學堂上新】

【厚積薄發】