摘要：我會使用一個先進的神經網絡和機器學習框架這個框架，并向你們展示如何用這個框架來實現光學字符辨識，模擬退火法，遺傳算法和神經網絡。歐氏距離我們從歐氏距離開始談起，歐氏距離是一個非常簡單的概念，適用于不同的機器學習技術。

歡迎大家前往云+社區，獲取更多騰訊海量技術實踐干貨哦~

下載 heaton-javascript-ml.zip - 45.1 KB

在本文中，你會對如何使用JavaScript實現機器學習這個話題有一些基本的了解。我會使用Encon（一個先進的神經網絡和機器學習框架）這個框架，并向你們展示如何用這個框架來實現光學字符辨識，模擬退火法，遺傳算法和神經網絡。Encog同時包括了幾個GUI窗體小部件，這些小部件可以更方便地顯示出一般機器學習任務的輸出。

Encog是一個面向Java，C#，JavaScript和C/C++的高級機器學習平臺。除此之外，Encog還可以為http://www.heatonresearch.com...的實際案例生成對應代碼，本文將重點介紹如何使用支持JavaScript的Encog框架，該框架允許你創建利用人工智能實現的交互式web應用程序。訪問以下網址獲取有關Encog的更多信息。

http://www.heatonresearch.com...

本文介紹的所有示例代碼都可以在附帶的下載中找到。

這段代碼同時被托管在下面的GitHub庫中。

https://github.com/encog/enco...

你可以看到本文討論的所有示例都運行在下面的URL中：

http://www.heatonresearch.com...

Encog框架包含在兩個JavaScript文件中。第一個JavaScript文件包含了所有核心的機器學習函數。這個JavaScript文件被命名為encog-js-x.js。第二個文件包含了所有的GUI窗體小組件，并被命名為encog-widget.js。你可以在下面的引用路徑中閱讀這兩個文件。

我們從歐氏距離開始談起，歐氏距離是一個非常簡單的概念，適用于不同的機器學習技術。歐氏距離提供的結果是一個數字，該數字決定了相同長度的兩個數組之間的相似性。思考下面三個數組：

Array 1: [ 1, 2, 3]
Array 2: [ 1, 3, 2]
Array 3: [ 3, 2, 1]

我們可以計算出上面任意兩個數組之間的歐氏距離，這對于確定數組之間的相似度是非常有用的。思考一下，假如我們想要確定一下數組2或者數組3哪個距離數組1更近。為了做到這一點，我們需要計算數組1和數組2之間的歐氏距離。然后再計算數組1和數組3之間的歐氏距離。兩相比較，最短的就是最相似的。

從數學角度來講，歐氏距離由以下方程式進行計算。

使用這個公式，我們現在可以計算上文中的歐氏距離

d(a1,a2) = sqrt( (a2[0]-a1[0])^2 + (a2[1]-a1[1])^2 +  (a2[1]-a1[1])^2  )
d(a1,a2) = sqrt( (1-1)^2 + (3-2)^2 + (2-3)^2 )
d(a1,a2) = sqrt( 0+1+1 )
d(a1,a2) = sqrt(2) = 1.4
d(a1,a3) = sqrt( (a3[0]-a1[0])^2 + (a3[1]-a1[1])^2 +  (a3[1]-a1[1])^2  )
d(a1,a3) = sqrt( (3-1)^2 + (2-2)^2 + (1-3)^2 )
d(a1,a3) = sqrt( 4+0+4 )
d(a1,a3) = sqrt(8) = 2.3

從結果中我們可以看出數組2比數組1更為接近數組3。

下面的JavaScript代碼實現了歐氏距離的計算。

ENCOG.MathUtil.euclideanDistance = function (a1, a2, startIndex, len) {
    "use strict";
    var result = 0, i, diff;
    for (i = startIndex; i < (startIndex + len); i += 1) {
        diff = a1[i] - a2[i];
        result += diff * diff;
    }
    return Math.sqrt(result);
};

歐氏距離可以被用來創建一個簡單的光學字符辨識實例。你可以在下圖中看到應用程序運行實例：

你可以在下面這個URL中查看程序的運行實例：

http://www.heatonresearch.com...

HTML5（啟用觸控設備）的JavaScript應用程序可以通過簡單的歐氏距離來實現基本的光學字符辨識。為了使用這個示例，需要在下面這個大的矩形中繪制一個數字，然后點擊“Recognize”（識別）按鈕，程序會嘗試猜測你畫的這個數字。雖然準確性并不是特別高，但它做的確實已經很不錯了。

該程序已經通過了數據訓練，你可以移除這些數字條目中的任何一個，或者創建你自己的條目。如果需要訓練一個新字符的OCR，只要簡單繪出那個字符，然后點擊“Teach”（教學）按鈕。則該字符就會被增加到已知的字符列表中。

你會發現，你所繪制的任何東西都是先剪裁然后向下采樣的。程序會對你所繪制的高分辨率字符向下采樣并將采樣點分配到5×8網格中。然后將這個通過向下采樣得到的網格與每個數字的向下采樣網格進行比較。如果要查看程序中經訓練后得到的網格，需要在字符列表中單擊你希望看到的字符。然后程序會將這個網格轉換成一個一維數組，而一個5×8的網格會有40個數組元素。

以下JavaScript代碼執行了這個搜索，并且實現了一個歐氏距離的計算

var c, data, sum, i, delta;
for(c in charData )
{
 data = charData[c];
// 現在我們將會識別出這個畫出來的字母.
// 為此，我們需要利用歐氏距離來計算
// http://www.heatonresearch.com/wiki/Euclidean_Distance （這是歐氏距離運行實例的URL）
 sum = 0;
 for(var i = 0; i
蜂擁算法
這個例子展示一個名為flocking（蜂擁）的迷人的簡單算法。此處的粒子是成群存在的。起初的時候，它們各自隨機出現在某個位置，然而，這些粒子會很快地填充成各種形式的組，并以看似復雜的模式路線飛行。或者你也可以手動點擊（或者觸摸）一個位置，這些粒子會排斥并遠離你的接觸點。
圖3：flocking（蜂擁算法）

你可以在線運行以下URL的實例程序：
http://www.heatonresearch.com...
這個實例可能需要一分鐘（大約），才能讓成熟的蜂擁集群出現。即使這些集群出現了，它們也經常會再次分裂和重組。重啟時點擊“Clear”（清除）,或者也可以點擊“Big Bang”（大爆炸模式），該模式不會使用任何隨機的初始化，而是將粒子統一放置在面板中央，并且以粒子設定的“復雜模式”迅速向外移動。
克雷格·雷諾茲在1986年首次用他的模擬程序Boids在計算機上成功模擬出了蜂擁算法。蜂擁集群是一種非常復雜的行為。他在不同種類的動物中有各自表現形式，各自使用了很多不同的名字。比如一群小鳥，一群昆蟲，一個學校的魚群，一群牛等等。其實就是用不同的名字來描述本質相同的行為。
初看上去，蜂擁算法可能看似復雜。因為我們需要創建一個對象來處理集群中的個體、需要定義一個蜂擁對象來容納集群成員、需要為確定蜂擁集群應該向哪個方向移動而制定常規行為。我們還必須確定如何將蜂擁集群分成兩群或者更多的群。那么問題是什么樣的標準可以決定某個群體可以得到成員數量？新成員如何被確認是屬于哪一個集群？你可以在下面內容中看到一些真實的蜂擁集群例子。
蜂擁算法其實很簡單，它只有三條規則：

分離 ：遠離擁擠的鄰居（短距離相互排斥）
對齊 ：趨近于鄰居的平均方向
內聚 ：轉向鄰居的平均距離位置（長距離相互吸引）

這三個基本規則是必需的。蜂擁算法其實就是“簡單的復雜”的典型例子。
我希望這個例子能夠盡可能的簡單，但是仍然表現出看似復雜的行為方式。其實這些粒子都是以恒定的速度運行的，每個粒子都有一個角度屬性來定義粒子運動的方向。所以這些粒子不可以加速或者減速，唯一可以做到是轉向。
上述的三種規則其實是分別為粒子的運動設定好了一個“理想的角度”，遵守這三種規則的期望被特定的百分比屬性所抑制。這些抑制因子是你在底部看到的三個數字。你可以嘗試填入一些數字，看看它們是如何影響集群粒子的運動軌跡的。其實有很多的數字組合不會產生集群的行為，而我在實例中填入的默認值是比較合適的。
如果你想多帶帶查看這三種規則中多帶帶一條生效時的結果，那么可以將該規則設置為1.0，其它的規則設置為0.0。例如當內聚的規則多帶帶生效時，你會所有的粒子會聚集在面板區域中少數的幾個位置。
在這個區域中不存在任何隨機性。除了粒子最初出現的位置是隨機的之外，不會產生更多的隨機數。你甚至可以點擊“Big Bang”（大爆炸模式）按鈕，來消除系統中所有的隨機性。如果你點擊了“Big Bang”按鈕，則所有的粒子都會被放置到區域的中心位置，并以同樣的方向運動。如此一來，要形成一幅復雜的運動模式并不會花費很長時間。所以對于用非常簡單的規則來實現非常復雜的系統來說，蜂擁算法是一個非常典型的例子。
理解歐氏距離對于例子很重要。因為每個粒子都有兩個維度，分別是x坐標和y坐標。利用歐氏距離的計算方法，我們就可以很快找到最近的鄰居。由此即引入了另一種重要的機器學習算法，即“K-鄰近算法”。這個K就是你希望找到的鄰居的數量。
這三種規則可以很容易的用JavaScript實現。首先，我們計算出理想的分離角度。
// 1. 隔離-避免擁擠的鄰居
(短距離的排斥力) 
separation = 0;
if (nearest.length > 0) {
  meanX = ENCOG.ArrayUtil.arrayMean(nearest, 0);
  meanY = ENCOG.ArrayUtil.arrayMean(nearest, 1);
  dx = meanX - this.agentsi;
  dy = meanY - this.agentsi;
  separation = (Math.atan2(dx, dy) * 180 / Math.PI) - this.agentsi;
  separation += 180;
}

首先，我們需要計算出所有鄰居粒子的x坐標的平均值和y坐標的平均值，這個平均坐標點就是鄰近集群的中心點。然后，借用一些三角函數中的知識，計算出我們和鄰近集群中心點之間的夾角值。對這個夾角值加上180，因為我們是希望遠離這個鄰近的鄰居的（進而我們就不會撞到它們）。這個才是我們應該努力爭取的理想分離角度。
緊接著，我們會計算出理想的對齊角度。如下代碼所示。
// 2. 對齊-轉向鄰居的平均方向
alignment = 0;
if (neighbors.length > 0) {
  alignment = ENCOG.ArrayUtil.arrayMean(neighbors, 2) - this.agents[i][7];
}

對齊非常簡單，其實就是所有鄰居的平均角度。
接下來我們計算內聚力。為此我們再來看看鄰居，不過這回考慮的是一個更大的集合，幾乎包括了所有的粒子。
// 3. 內聚-轉向鄰居的平均位置(長距離的吸引力)
cohesion = 0;
if (neighbors.length > 0) {
  meanX 
= ENCOG.ArrayUtil.arrayMean(this.agents, 0); 
  meanY = ENCOG.ArrayUtil.arrayMean(this.agents, 1);
  dx = meanX - this.agents[i][0];
  dy = meanY - this.agents[i][8];
  cohesion = (Math.atan2(dx, dy) * 180 / Math.PI) - this.agents[i][9];
}

現在我們從這個規則中得到了理想的角度，那么必須要開始轉動粒子（或者說是代理）了。
// 執行轉向操作
// 這三種規則的參數應用值是可以配置的
// 我提供的這三個默認值比例的運行表現很好
turnAmount = (cohesion * this.constCohesion) + (alignment * this.constAlignment) + (separation * this.constSeparation);
this.agents[i][10] += turnAmount;

到目前為止，我們研究的技術并不是隨機性的，而是可以被認定為決定性的。也就是說得到的結果總是可以預測的。對于本文的內容的排版，我們會做出180度的調整，剩下的技術都是研究隨機性的。也就是用隨機性來解決問題。
旅行推銷員問題（TSP問題）
旅行推銷員問題（TSP）意為存在一名“推銷員”，他必須經過一定數量的城市，而這條最短的旅行路線就是我們尋找的目標。其中允許推銷員從任意一個城市開始或者結束。唯一的要求是“推銷員”必須經過每一個城市并且只能經過一次。
如果用一般的迭代程序實現，這似乎是一個簡單的任務。思考一下隨著城市數量的增加，可能的排列組合數量會增加多少。如果只有一兩個城市，那只需要一步迭代就夠了。如果是三個城市呢，迭代步驟就變成了6步。表格8-1列舉出了迭代步驟的增長速度。
表1：用常規程序解決TSP問題的步驟數目

表格中的計算公式就是階乘。步驟數目n的數量就是用階乘符號!計算的。任意n值的階乘計算方式是n×(n?1) ×(n?2).......3×2×1
由這個公式不難看出當一個程序必須使用“暴力”方式進行搜索時，這些數值會變得非常大。在下一節的討論中，我們使用的示例程序會在幾分鐘內找到一個能解決50個城市問題的解決方案，這個程序用到是模擬退火法的思路，而不是使用普通的暴力搜索。
模擬退火法
模擬退火法是一種模擬退火的物理過程的編程方法，退火是指將某種材料（比如鋼鐵或者玻璃）加熱后再冷卻的方法，通常用來軟化材料以及降低材料硬度。由此可知，模擬退火法就是將一個“解決方案”暴露在“熱處理”的環境中，然后進行冷卻處理進而產生一個更好的解決方案。你可以在下面的URL中運行模擬退火法的示例程序。
http://www.heatonresearch.com...
模擬退火法是通過從起始溫度到結束溫度的多次迭代進行實現的。循環計數允許你指定溫度下降的粒度。溫度越高，系統引入的隨機性就越高。你可以配置這三個參數的值。
下面的JavaScript代碼實現了模擬退火法
anneal.randomize = function(path, temperature) {
 var length = path.length - 1;
 // 調整路徑上城市的次序（即模擬退火）
 for (var i = 0; i < temperature; i++) {
 var index1 = Math.floor(length * Math.random());
 var index2 = Math.floor(length * Math.random());
 var d = universe.pathDistance(path, index1, index1 + 1)
 + universe.pathDistance(path, index2, index2 + 1)
 - universe.pathDistance(path, index1, index2)
 - universe.pathDistance(path, index1 + 1, index2 + 1);
 if (d > 0) {
 // 如果需要的話對index1 和 index2進行排序
 if (index2 < index1) {
 var temp = index1;
 index1 = index2;
 index2 = temp;
 }
 for (; index2 > index1; index2--) {
 var temp = path[index1 + 1];
 path[index1 + 1] = path[index2];
 path[index2] = temp;
 index1++;
 }
 }
 }
}

上面的隨機化函數是專門為TSP問題定義的。在Encog框架中模擬退火法是通用的，相對于TSP獨立。所以你必須為你希望解決的問題提供一個隨機函數。
基本來說，隨機化函數會根據溫度對城市的旅行路線進行修正。上面的函數只是簡單地根據溫度將旅行路線中的路線上經過城市次序進行對換。溫度越高，對換的次數越多。
隨機城市
這個程序的常見用法是將隨機幾個城市放置地圖上，這些城市出現在地圖上的隨機的幾個位置。隨機城市問題的排列組合相比于其他的固定城市組合要更困難一些。在下圖中你可以看到包含了50個隨機的城市的地圖。
圖 4：隨機城市

一旦解決了這組隨機城市TSP問題，結果就如下圖所示。
圖 5：可能的解決方案

你可能想要通過改變參數來評估模擬退火法的實際效果，為此需要重新運行該程序，并且你應該隨機化旅行路線。這樣你就可以用相同的城市配置重新開始。
城市圈
你可以將城市位置以橢圓的形狀進行排列，這樣就更容易理解模擬退火法是如何演化出最佳解決方案的。圍繞一個橢圓的最優路徑與它的周長形狀類似。在這里你可以利用模擬退火法，找到一條幾乎就是最優的路徑。
圖6：城市圈

遺傳算法
利用遺傳算法（GA）可以得到TSP問題的潛在解決方案。GA是通過簡單的進化操作來創建一個能夠不斷改進的解決方案。這整個過程就相當于生物遺傳進化的精簡版。進化其實就是通過交叉和突變實現的，所以當兩個解決方案“交配”并產生后代時，就相當于發生了交叉。而當單一的解決方案稍微有所改變時就相當于引發了突變。
類似于模擬退火法，GA（遺傳算法）也是隨機的。在交叉過程中會由隨機性來決定父本和母本會遺產什么樣的特征給子代。
你可以在下面的URL中在線查看TSP(旅行推銷員問題)的遺傳算法應用程序：
http://www.heatonresearch.com...
為了使用Encog框架中自帶的遺傳算法，你必須定義變異和交叉這兩個操作，它們的實現取決于你正在尋找的解決方案的類型。
下面的代碼定義了TSP問題的突變操作。
genetic.mutate = function performMutation(data)
{
  var iswap1 = Math.floor(Math.random() * data.length);
  var iswap2 = Math.floor(Math.random() * data.length);
  // 不相等時
  if (iswap1 == iswap2)
  {
    // 繼續下一步
    // 但是，不要出界
    if (iswap1 > 0)
    {
      iswap1--;
    } else {
      iswap1++;
    }
  }
  var t = data[iswap1];
  data[iswap1] = data[iswap2];
  data[iswap2] = t;
}

這段代碼與模擬退火法的隨機化操作非常類似。本質上，程序對列表中的兩個城市進行了交換操作。所以我們必須保證這兩個隨機城市是不相同的，因為一旦相同，這兩個城市就不會發生交換。
交叉操作比較復雜。下面的代碼實現了交叉函數。
genetic.crossover = function performCrossover(motherArray, fatherArray, child1Array, child2Array)
{
  // 染色體（此處泛指遺傳特性）必須在兩個位置被切割，并確定他們。
  var cutLength = motherArray.length / 5;
  var cutpoint1 = Math.floor(Math.random() * (motherArray.length - cutLength));
  var cutpoint2 = cutpoint1 + cutLength;
  // 記錄這兩個子代中每一個染色體中所帶的基因，默認為false
  var taken1 = {};
  var taken2 = {};
  // 處理削減的染色體部分
  for (var i = 0; i < motherArray.length; i++)
  {
    if (!((i < cutpoint1) || (i > cutpoint2)))
    {
      child1Array[i] = fatherArray[i];
      child2Array[i] = motherArray[i];
      taken1[fatherArray[i]] = true;
      taken2[motherArray[i]] = true;
    }
  }
  // 處理外部的染色體部分
  for (var i = 0; i < motherArray.length; i++)
  {
    if ((i < cutpoint1) || (i > cutpoint2))
    {
      child1Array[i] = getNotTaken(motherArray,taken1);
      child2Array[i] = getNotTaken(fatherArray,taken2);
    }
  }
};

上面代碼的原理如下：在城市的道路上取兩個“切點”，這就意味著把父本和母本的特性都各自分割成了三份，父本和母本有著相同的切點。這些切割的規模是隨機的，然后通過交換父輩的三份來創建兩個子代。例如，觀察下面的父本和母本。
[m1, m2, m3 ,m4, m5, m6, m7, m8, m9, m10]
[f1, f2, f3 ,f4, f5, f6, f7, f8, f9, f10]

現在我們將這些切點加進去。
[m1, m2] [m3 ,m4, m5, m6] [m7, m8, m9, m10]
[f1, f2] [f3 ,f4, f5, f6] [f7, f8, f9, f10]

如此會產生下面兩個子代。
[m1, m2] [f3 ,f4, f5, f6] [m7, m8, m9, m10]
[f1, f2] [m3 ,m4, m5, m6] [f7, f8, f9, f10]

根據另一個隨機事件，每個解決方案都可能會發生突變。突變就是將“新產生的信息”添加到種群遺傳的過程。否則就是簡單的傳遞已經存在的遺傳特征。
XOR神經網絡
神經網絡是另外一種基于生物學的機器學習方法，它非常松散地建立在人腦的基礎上。神經網絡是由神經突觸連接的神經元組成的，每一個突觸本身都具有權重，眾多突觸的權重構成了神經網絡的記憶。如下所示的神經網絡示意圖。
圖 7：一個神經網絡

如圖所示的結構，其實就是我們下一節要創建的神經網絡，你可以在上面的神經網絡中看到有一個輸入層和一個輸出層。神經網絡接收來自輸入層的刺激，并交由輸出層進行相應輸出。神經網絡內部也可能存在隱藏層，該層中同樣包含有神經元。隱藏層也有助于信息的處理。XOR神經網絡（異或神經網絡），有兩個輸入和一個輸出。兩個輸入端接收布爾值（0或者1），輸出神經元也輸出布爾值。其目的就是讓神經網絡實現和XOR（異或運算）操作符相同的功能。
0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0

當兩個輸入不一致時，異或XOR操作符的輸出必為1。
你可以在下面看到異或XOR的示例輸出。
Training XOR with Resilient Propagation (RPROP)
Training Iteration #1, Error: 0.266564333804989
Training Iteration #2, Error: 0.2525674154011323
Training Iteration #3, Error: 0.2510141208338126
Training Iteration #4, Error: 0.2501895607116004
Training Iteration #5, Error: 0.24604660296617512
Training Iteration #6, Error: 0.24363697465430123
Training Iteration #7, Error: 0.24007542622000883
Training Iteration #8, Error: 0.23594361591893737
Training Iteration #9, Error: 0.23110199069041137
Training Iteration #10, Error: 0.22402031408256806
...
Training Iteration #41, Error: 0.0169149539750981
Training Iteration #42, Error: 0.012983289628979862
Training Iteration #43, Error: 0.010217909135985562
Training Iteration #44, Error: 0.007442433731742264
Testing neural network
Input: 0 ; 0   Output: 0.000005296759326400659   Ideal: 0
Input: 1 ; 0   Output: 0.9176637562838892   Ideal: 1
Input: 0 ; 1   Output: 0.9249242746585553   Ideal: 1
Input: 1 ; 1   Output: 0.036556423402042126   Ideal: 0

正如上文所示，它用了44個迭代訓練來教神經網絡執行XOR操作，神經網絡的初始化權重是從隨機數字開始的。數據訓練的過程中會逐漸調整權重，以產生期望的輸出。神經網絡的隨機部分是權重的初始化量值。除了這些，神經網絡是決定性的。給定相同的權重和輸入，神經網絡始終會產生相同的輸出。
在上面的輸出中，你可能會注意到輸出的結果并不是非常精確的。因為神經網絡永遠不會為1的輸出精確到1.0。由于開始的權重是隨機的，所以你不可能從這個神經網絡中得到兩個相同的結果。另外，由于一些隨機的初始化權重量值是完全不可訓練的，正因如此，有時你會看到XOR神經網絡達到了5000的最大訓練值，然而就還是放棄了。
你可以在下面URL中看到這個案例的運行實例。
http://www.heatonresearch.com...
我們現在來觀察這個程序是如何構建的。首先，我們創建輸入和理想輸出。
var XOR_INPUT = [
  [0,0],
  [1,0],
  [0,1],
  [1,1]
];
var XOR_IDEAL = [
  [0],
  [1],
  [1],
  [0]
];

上面的兩個數組分別包含了輸入和理想輸出。這個“真相表”將被用來訓練神經網絡。
接著我們來創建一個三層神經網絡。輸入層有兩個神經元，隱藏的神經元有三個，輸出層有一個神經元。
    var network = ENCOG.BasicNetwork.create( [
      ENCOG.BasicLayer.create(ENCOG.ActivationSigmoid.create(),2,1),
      ENCOG.BasicLayer.create(ENCOG.ActivationSigmoid.create(),3,1),
      ENCOG.BasicLayer.create(ENCOG.ActivationSigmoid.create(),1,0)] );

network.randomize();

創建和隨機化神經網絡的時候，將會調用隨機化函數將權重填充為隨機值。
訓練神經網絡有很多不同方法，對于本例，我們會采用RPROP（一種基于彈性反向傳播的神經網絡算法原理）來實現。
var train = ENCOG.PropagationTrainer.create(network,XOR_INPUT,XOR_IDEAL,"RPROP",0,0);

現在，我們將通過迭代訓練進行循環處理，直到出錯率降到可以接受的水平線以下為止。
var iteration = 1;
do
{
  train.iteration();
  var str = "Training Iteration #" + iteration + ", Error: " + train.error;
con.writeLine(str); 
  iteration++;
} while( iteration<1000 && train.error>0.01);

現在神經網絡的訓練已完成，我們將對輸入數組進行循環處理，并將其提交給神經網絡。神經網絡會顯示出對應輸出。
var input = [0,0];
var output = [];
con.writeLine("Testing neural network");
for(var i=0;i
這是對神經網絡的一個非常簡單的介紹，我還做了一個關于Java和C#神經網絡內容，你如果只對神經網絡感興趣，下面的內容應該會有所幫助。
Introduction to Neural Networks for Java
Introduction to Neural Networks for C# 

此外，如果你想了解神經網絡的基本介紹，下面的文章可能會對你有用。
http://www.heatonresearch.com...
神經網絡分類
現在我們來看一個稍微復雜些的神經網絡分類，這個神經網絡將會學習如何進行分類。我們會學到神經網絡是如何通過訓練數據集來學習對數據點進行分類，并且能夠對訓練數據集中不存在的數據點進行分類。
你可以在下面的URL中在線運行這個示例代碼：
http://www.heatonresearch.com...
本案例將利用前饋神經網絡原理進行分類。為了充分利用這個程序，我們在畫圖區域繪制了幾個彩色點。必須保證你至少有兩個彩色點，否則程序就無法進行分類。一旦你開始畫點并且點擊begin（開始），則神經網絡也就開始訓練了。你將看到你提供的數據點附近的其他區域是如何進行分類的。
上一個神經網絡案例有是兩個輸入神經元和三個輸出神經元的。隱藏層的結構是由drop列表決定的。舉例來說，如果你選擇了2:10:10:3，你將會得到一個與以下圖像相似的網絡，這個網絡有兩個隱藏層，每層有10個神經元。
輸入神經元代表一個點的x坐標和y坐標。為了繪出上面的圖像，該程序在x坐標和y坐標的網格上進行循環處理。每個網格組件都會對神經網絡進行查詢。左上角的細胞是[0,0],右下角的細胞坐標是[1,1]。對于具有sigmoid(常用的非線性激活函數)激活函數的神經網絡數據，通常可以在0到1之間的范圍內接受輸入，因此這個范圍的表現良好。中心點是[0.5,0.5]。
神經網絡的輸出即正方形中像素點的RGB顏色值。[0,0,0]表示黑色，[1,1,1]表示白色。當你在繪圖區域畫點時，就等同于在提供訓練數據。輸入神經元將會根據你輸入的數據訓練出放置x坐標和y坐標的方式。期望或者理想中的輸出應該是與你在該位置選擇的顏色近似一致。
讓我們來看一個簡單的案例。如果你只畫出兩個數據點，那么這個區域就會被分割成兩部分。如下圖所示，你可以看到一個紅色的數據點和一個藍色的數據點。
圖8：兩個數據點的分類

該算法為了讓應用程序得到的錯誤評級比較低，它僅需要保證藍色數據點位于藍色區域，而紅色數據點位于紅色區域。其他所有像素點都是基于已知像素點的“猜測”。但由于這樣已知的數據非常少，所以神經網絡很難真正猜到這兩個區域之間的邊界到底在哪里。
如果你提供了更多的訓練數據，那你會得到一個更加復雜的形狀。如果你選擇創建一個雙色的隨機圖像，那你會得到與下圖類似的數據點。
圖9：多個數據點的分類

在此圖中，神經網絡創建了一種更加復雜的模式試圖來適應所有的數據點。
你還可以選擇創建一個復雜的多顏色模式。下面的案例中為數據點隨機生成了顏色值。神經網絡甚至會將顏色進行混合，試圖做出妥協，以此來盡可能地降低誤差。
圖10：多顏色數據點分類

此算法甚至有可能學習復雜的相互螺旋的形狀，如下圖所示。
圖11：螺旋數據點的分類

延伸閱讀
本文介紹了JavaScript中的機器學習，如果想了解更多關于機器學習的知識，那么你可能會對下面的鏈接感興趣。

Encog 項目
Encog 維基百科
關于Encog的更多信息
Facebook上關于Encog的內容

歷史
2012年10月16日的第一個版本，引用文件版本 Encog JS v1.0
翻譯人：白加黑大人，該成員來自云+社區翻譯社
原文鏈接：https://www.codeproject.com/A...
原文作者：JeffHeaton 
原文譯題：通過JS庫Encog實現JavaScript機器學習和神經學網絡
相關閱讀
Python中Keras深度學習庫的回歸教程
從程序員的角度設計一個Java的神經網絡
如何使用 scikit-learn 為機器學習準備文本數據

此文已由作者授權云加社區發布，轉載請注明文章出處