运用JavaScript完成机械进修和神经学收集

迎接人人前去云+社区，猎取更多腾讯海量手艺实践干货哦~

• 下载 heaton-Javascript-ml.zip &＃8211; 45.1 KB

基础引见

在本文中，你会对怎样运用Javascript完成机械进修这个话题有一些基础的相识。我会运用Encon（一个先进的神经收集和机械进修框架）这个框架，并向你们展现怎样用这个框架来完成光学字符辨识，模仿退火法，遗传算法和神经收集。Encog同时包括了几个GUI窗体小部件，这些小部件可以更方便地显示出平常机械进修使命的输出。

运转环境

Encog是一个面向Java，C#，Javascript和C/C++的高等机械进修平台。除此以外，Encog还可以为http://www.heatonresearch.com&＃8230;的现实案例天生对应代码，本文将重点引见怎样运用支撑Javascript的Encog框架，该框架许可你建立运用人工智能完成的交互式web运用顺序。接见以下网址猎取有关Encog的更多信息。

http://www.heatonresearch.com&＃8230;

代码挪用

本文引见的一切示例代码都可以在附带的下载中找到。

这段代码同时被托管鄙人面的GitHub库中。

https://github.com/encog/enco&＃8230;

你可以看到本文议论的一切示例都运转鄙人面的URL中：

http://www.heatonresearch.com&＃8230;

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之间的欧氏间隔。两比拟较，最短的就是最相似的。

从数学角度来讲，欧氏间隔由以下方程式举行盘算。

图 1: 欧氏间隔

运用这个公式，我们如今可以盘算上文中的欧氏间隔

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


欧氏间隔可以被用来建立一个简朴的光学字符辨识实例。你可以鄙人图中看到运用顺序运转实例：

图 2: Javascript光学字符辨识

你可以鄙人面这个URL中检察顺序的运转实例：

http://www.heatonresearch.com&＃8230;

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 {
delta = data[i] - downSampleData[i];
sum = sum + (delta*delta);
}
sum = Math.sqrt(sum);
// 最基础的，我们需要盘算的是欧氏间隔
// 我们画上去的字母，我们进修的每一个样本
// 顺序将会返回欧氏间隔最小的谁人字符
if( sum{
bestScore = sum;
bestChar = c;
}
}


簇拥算法

这个例子展现一个名为flocking（簇拥）的诱人的简朴算法。此处的粒子是成群存在的。早先的时刻，它们各自随机出如今某个位置，然则，这些粒子会很快地添补成各种形式的组，并以看似庞杂的形式线路遨游飞翔。或许你也可以手动点击（或许触摸）一个位置，这些粒子会排挤并阔别你的接触点。

图3：flocking（簇拥算法）

你可以在线运转以下URL的实例顺序：

http://www.heatonresearch.com&＃8230;

这个实例可以需要一分钟（约莫），才能让成熟的簇拥集群涌现。纵然这些集群涌现了，它们也经常会再次破裂和重组。重启时点击“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)&＃8230;&＃8230;.3×2×1

由这个公式不难看出当一个顺序必需运用“暴力”体式格局举行搜刮时，这些数值会变得异常大。鄙人一节的议论中，我们运用的示例顺序会在几分钟内找到一个能处理50个都市题目标处理方案，这个顺序用到是模仿退火法的思绪，而不是运用一般的暴力搜刮。

模仿退火法

模仿退火法是一种模仿退火的物理历程的编程要领，退火是指将某种材料（比方钢铁或许玻璃）加热后再冷却的要领，一般用来软化材料以及下落材料硬度。由此可知，模仿退火法就是将一个“处理方案”暴露在“热处置惩罚”的环境中，然后举行冷却处置惩罚进而发作一个更好的处理方案。你可以鄙人面的URL中运转模仿退火法的示例顺序。

http://www.heatonresearch.com&＃8230;

模仿退火法是经由历程从肇端温度到完毕温度的屡次迭代举行完成的。轮回计数许可你指定温度下落的粒度。温度越高，体系引入的随机性就越高。你可以设置这三个参数的值。

下面的Javascript代码完成了模仿退火法

anneal.randomize = function(path, temperature) {
var length = path.length - 1;
// 调解途径上都市的序次（即模仿退火）
for (var i = 0; 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 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&＃8230;

为了运用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 {
if (!((i cutpoint2)))
{
child1Array[i] = fatherArray[i];
child2Array[i] = motherArray[i];
taken1[fatherArray[i]] = true;
taken2[motherArray[i]] = true;
}
}
// 处置惩罚外部的染色体部份
for (var i = 0; i {
if ((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&＃8230;

我们如今来视察这个顺序是怎样构建的。起首，我们建立输入和抱负输出。

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{
network.compute(XOR_INPUT[i],output);
var str = "Input: " + String(XOR_INPUT[i][0])
+ " ; " + String(XOR_INPUT[i][11])
+ " Output: " + String(output[0])
+ " Ideal: " + String(XOR_IDEAL[i][0]);
con.writeLine(str);
}


这是对神经收集的一个异常简朴的引见，我还做了一个关于Java和C#神经收集内容，你假如只对神经收集感兴趣，下面的内容应当会有所协助。

Introduction to Neural Networks for Java
Introduction to Neural Networks for C#


另外，假如你想相识神经收集的基础引见，下面的文章可以会对你有效。

http://www.heatonresearch.com&＃8230;

神经收集分类

如今我们来看一个轻微庞杂些的神经收集分类，这个神经收集将会进修怎样举行分类。我们会学到神经收集是怎样经由历程练习数据集来进修对数据点举行分类，而且可以对练习数据集合不存在的数据点举行分类。

你可以鄙人面的URL中在线运转这个示例代码：

http://www.heatonresearch.com&＃8230;

本案例将运用前馈神经收集道理举行分类。为了充分运用这个顺序，我们在画图地区绘制了几个彩色点。必需保证你至少有两个彩色点，不然顺序就没法举行分类。一旦你最先画点而且点击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&＃8230;

原文作者：JeffHeaton

原文译题：经由历程JS库Encog完成Javascript机械进修和神经学收集

相干浏览

Python中Keras深度进修库的回归教程

从顺序员的角度设想一个Java的神经收集

怎样运用 scikit-learn 为机械进修准备文本数据

此文已由作者受权云加社区宣布，转载请说明文章出处