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

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

作者主頁：

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

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

這種訓(xùn)練方式的好處就是不需要訓(xùn)練用的預(yù)期輸出數(shù)據(jù)，適合那類可以簡單通過環(huán)境交互判斷訓(xùn)練好壞的神經(jīng)網(wǎng)絡(luò)AI。當(dāng)然，壞處就是訓(xùn)練的時間可能需要很長，尤其是神經(jīng)網(wǎng)絡(luò)比較龐大時。

完整項目gitee鏈接：

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

一、用Compute Shader實現(xiàn)神經(jīng)網(wǎng)絡(luò)

神經(jīng)網(wǎng)絡(luò)的計算一般都用矩陣優(yōu)化，像Python語言者學(xué)習(xí)實現(xiàn)神經(jīng)網(wǎng)絡(luò)時，通常會借助NumPy的Torch進行計算，加速運算過程。

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

想到神經(jīng)網(wǎng)絡(luò)的預(yù)測過程中，其實我們只關(guān)心輸入層與輸出層，而隱藏層的那些計算結(jié)果其實根本不在乎。這似乎很適合用Compute Shader來完成！

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

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

二、遺傳算法

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

1. 初始化種群

在本例中，我們想要獲取神經(jīng)網(wǎng)絡(luò)中各層合適的權(quán)重與偏置的值，來使神經(jīng)網(wǎng)絡(luò)的輸出符合預(yù)期，所以我們將整個神經(jīng)網(wǎng)絡(luò)的所有權(quán)重與偏置視為一個個體。

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("各全連層的權(quán)重和偏置")]         public LayerWeightAndBias[] WeiBiasArray;         [Tooltip("全連接層的Compute Shader")]         public ComputeShader affine;         [Tooltip("激活函數(shù)的Compute Shader")]         public ComputeShader activateFunc;         [Tooltip("損失函數(shù)的Compute Shader)]         public ComputeShader lossFunc;         [Tooltip("當(dāng)前損失函數(shù)在反向傳播時是否要載入上次輸出，用于sigmoid等函數(shù)")]         public bool isLoadLastOutput;         [Header("隨機初始化權(quán)重")]         [Tooltip("是否要隨機初始化")]         public bool isRandomWeightAndBias = false;         [Tooltip("當(dāng)前權(quán)重是否是訓(xùn)練成功后的")]         public bool isFinishedWeightAndBias = false;         [Tooltip("隨機初始化的最大值和最小值")]         public float minRandValue = -1, maxRandValue = 1;         [Tooltip("是否隨機化權(quán)重")]         public bool isRandomBias = false;         private void OnValidate()         {             if(isRandomWeightAndBias && !isFinishedWeightAndBias)             {                 RandomWeightAndBias(ref WeiBiasArray, minRandValue, maxRandValue, isRandomBias);                 isRandomWeightAndBias = false;             }         }         ///         /// 隨機初始化權(quán)重和偏置         ///         /// WeiBiasArray">被隨機化的數(shù)層權(quán)重和偏置         /// 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;                 // 初始化權(quán)重                 for (int i = 0; i < wb.weights.Length; ++i)                 {                     wb.weights[i] = (float)(rand.NextDouble() * range + minRandValue); // 使用指定范圍生成隨機數(shù)                 }                 // 初始化偏置                 for (int i = 0; i < wb.bias.Length; ++i)                 {                     wb.bias[i] = isRandomBias ?  (float)(rand.NextDouble() * range + minRandValue) : 0;                 }             }         }         ///         /// 深拷貝所有層的權(quán)重與偏置         ///         /// source">拷貝源         /// target">目標(biāo)處         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];                 }             }         }         ///         /// 交換所有層的權(quán)重與偏置         ///         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;         }     } }

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

2. 競爭

我們讓游戲中的使用神經(jīng)網(wǎng)絡(luò)決策的AI個體，分別應(yīng)用種群中各個體作為神經(jīng)網(wǎng)絡(luò)的權(quán)重與偏置，并直接應(yīng)用神經(jīng)網(wǎng)絡(luò)進行決策。由于這些權(quán)重與偏置都是隨機的，執(zhí)行的效果幾乎都不堪入目。

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

但我們需要“矮子里拔高個”，設(shè)計一個評估函數(shù)計算每個個體的適應(yīng)度。比如評估一個小車，我們就可以通過它行駛的距離、速度等進行加權(quán)和得到一個適應(yīng)度。總之，要確保評估函數(shù)的計算結(jié)果能合理表達出決策結(jié)果的好壞。

3. 繁殖與變異

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

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

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

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

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

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

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

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

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

變異的發(fā)生可以與繁殖放在一起：

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為變異的幅度，即變異帶來的數(shù)值增減幅度                     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為變異的幅度，即變異帶來的數(shù)值增減幅度                     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. 優(yōu)勝劣汰

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

//在父代和子代組成的整體中選出適應(yīng)度高的新父代 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)); }

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

三、實例：賽道小球

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

1. 創(chuàng)建神經(jīng)網(wǎng)絡(luò)

在我的實現(xiàn)中，已將網(wǎng)絡(luò)結(jié)構(gòu)以ScriptObject形式存儲，我們先新建一個，在Project下右鍵Create/ANN/WeightAngBias：

然后設(shè)置具體結(jié)構(gòu)，這次要完成的工作比較簡單，就是訓(xùn)練一個可以繞圈跑的小球，所以網(wǎng)絡(luò)結(jié)構(gòu)比較簡單。兩個隱藏層足矣（對應(yīng)Wei Bias Array的兩個元素），這個神經(jīng)網(wǎng)絡(luò)接受三個輸入，輸出兩個數(shù)據(jù)。

至于中間其它參數(shù)的設(shè)計要符合神經(jīng)網(wǎng)絡(luò)的結(jié)構(gòu)，具體來說就是：每一層的Weights數(shù)量要等于InputCount * OutputCount；除了第一層外，其它層的InputCount要等于上一層的OutputCount。（如果你對神經(jīng)網(wǎng)絡(luò)有所了解，那就能理解這些。）

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

2. 創(chuàng)建遺傳個體

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

神經(jīng)網(wǎng)絡(luò)的3個輸入數(shù)據(jù)就來自小球的三條射線檢測：

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];     } }

神經(jīng)網(wǎng)絡(luò)的兩個輸出分別用來控制，移動速度以及角位移：

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); }

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

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

這樣，個體的設(shè)置就搞定了，它將作為訓(xùn)練時的運行個體。

3. 遺傳算法訓(xùn)練器

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

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

至于綠色框內(nèi)的，Is End Train用來結(jié)束遺傳算法的訓(xùn)練，并將最好的結(jié)果保存到先前的ScriptObject中。其余只是用來觀察小球當(dāng)前訓(xùn)練情況而已。

一切就緒后，點擊運行即可訓(xùn)練。訓(xùn)練時我們可以調(diào)整Project Settings/Time/Time Scale加速訓(xùn)練。

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

四、尾聲

完整的訓(xùn)練視頻在項目中有，如果了解神經(jīng)網(wǎng)絡(luò)，或許這篇就好看懂些。大伙感興趣就嘗試下項目吧，也可以嘗試更復(fù)雜的賽道，更龐大的網(wǎng)絡(luò)。

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

近期精彩回顧

【學(xué)堂上新】

【厚積薄發(fā)】

【學(xué)堂上新】

【厚積薄發(fā)】