PyBrain - 快速指南

PyBrain - 概述

Pybrain 是一个使用 python 实现的机器学习开源库。该库为您提供了一些易于使用的网络训练算法、数据集、训练器来训练和测试网络。

Pybrain 官方文档的定义如下 -

PyBrain 是 Python 的模块化机器学习库。其目标是为机器学习任务提供灵活、易于使用且功能强大的算法，以及用于测试和比较算法的各种预定义环境。

PyBrain 是基于 Python 的强化学习、人工智能和神经网络库的缩写。事实上，我们首先想出了这个名字，然后对这个具有描述性的“Backronym”进行了逆向工程。

Pybrain的特点

以下是 Pybrain 的功能 -

网络

网络由模块组成，它们通过连接进行连接。Pybrain 支持前馈网络、循环网络等神经网络。

前馈网络是一种神经网络，节点之间的信息向前移动，永远不会向后传播。前馈网络是人工神经网络中第一个也是最简单的网络。

信息从输入节点传递到隐藏节点，然后传递到输出节点。

循环网络与前馈网络类似；唯一的区别是它必须记住每一步的数据。每个步骤的历史记录都必须保存。

数据集

数据集是用于在网络上进行测试、验证和训练的数据。要使用的数据集类型取决于我们要使用机器学习执行的任务。Pybrain 支持的最常用的数据集是SupervisedDataSet和ClassificationDataSet。

SupervisedDataSet - 它由input和target字段组成。它是最简单的数据集形式，主要用于监督学习任务。

ClassificationDataSet - 主要用于处理分类问题。它接受输入、目标字段以及一个称为“类”的额外字段，它是给定目标的自动备份。例如，输出将为 1 或 0，或者输出将与基于给定输入的值分组在一起，即，它将属于一个特定类别。

训练师

当我们创建一个网络（即神经网络）时，它将根据给定的训练数据进行训练。现在网络是否训练正确将取决于在该网络上测试的测试数据的预测。Pybrain Training 中最重要的概念是 BackpropTrainer 和 TrainUntilConvergence 的使用。

BackpropTrainer - 它是一个训练器，通过反向传播错误（随时间）根据监督或 ClassificationDataSet 数据集（可能是顺序的）来训练模块的参数。

TrainUntilConvergence - 用于在数据集上训练模块直到收敛。

工具

Pybrain 提供了工具模块，可以通过导入包来帮助构建网络：pybrain.tools.shortcuts.buildNetwork

可视化

测试数据无法使用 pybrain 可视化。但 Pybrain 可以与 Mathplotlib、pyplot 等其他框架一起使用来可视化数据。

Pybrain的优点

Pybrain 的优点是 -

  • Pybrain 是一个用于学习机器学习的开源免费库。对于任何对机器学习感兴趣的新手来说，这都是一个良好的开始。

  • Pybrain 使用 python 来实现它，与 Java/C++ 等语言相比，它的开发速度更快。

  • Pybrain 可以轻松地与其他 Python 库配合使用来可视化数据。

  • Pybrain 为前馈网络、循环网络、神经网络等流行网络提供支持。

  • 在 Pybrain 中使用 .csv 加载数据集非常简单。它还允许使用来自另一个库的数据集。

  • 使用 Pybrain 训练器可以轻松进行数据训练和测试。

Pybrain 的局限性

Pybrain 对于所面临的任何问题提供的帮助较少。stackoverflow和Google Group上有一些疑问没有得到解答。

Pybrain的工作流程

根据 Pybrain 文档，机器学习的流程如下图所示 -

Pybrain的工作流程

一开始，我们有原始数据，经过预处理后可以在 Pybrain 中使用。

Pybrain 的流程从数据集开始，数据集分为训练数据和测试数据。

  • 创建网络，并将数据集和网络提供给训练器。

  • 训练器在网络上训练数据，并将输出分类为可可视化的训练误差和验证误差。

  • 可以验证测试数据以查看输出是否与训练数据匹配。

术语

使用 Pybrain 进行机器学习时需要考虑一些重要术语。它们如下 -

总误差- 指网络训练后显示的误差。如果误差在每次迭代中不断变化，则意味着它仍然需要时间来稳定，直到它开始在迭代之间显示恒定的误差。一旦开始显示恒定的错误数，就意味着网络已经收敛，并且无论应用任何额外的训练，网络都将保持不变。

训练数据- 用于训练 Pybrain 网络的数据。

测试数据- 用于测试经过训练的 Pybrain 网络的数据。

训练器- 当我们创建一个网络（即神经网络）时，它将根据给定的训练数据进行训练。现在网络是否训练正确将取决于在该网络上测试的测试数据的预测。Pybrain Training 中最重要的概念是 BackpropTrainer 和 TrainUntilConvergence 的使用。

BackpropTrainer - 它是一个训练器，通过反向传播错误（随时间）根据监督或 ClassificationDataSet 数据集（可能是顺序的）来训练模块的参数。

TrainUntilConvergence - 用于在数据集上训练模块直到收敛。

层- 层基本上是一组用于网络隐藏层的函数。

连接- 连接的工作原理类似于层；唯一的区别是它将数据从网络中的一个节点转移到另一个节点。

模块- 模块是由输入和输出缓冲区组成的网络。

监督学习- 在这种情况下，我们有输入和输出，我们可以利用算法将输入与输出映射。该算法根据给定的训练数据进行学习并对其进行迭代，当算法预测正确的数据时，迭代过程停止。

无监督- 在这种情况下，我们有输入但不知道输出。无监督学习的作用是利用给定的数据尽可能多地进行训练。

PyBrain - 环境设置

在本章中，我们将进行 PyBrain 的安装。要开始使用 PyBrain，我们需要先安装 Python。因此，我们将致力于以下工作 -

  • 安装Python
  • 安装 PyBrain

安装Python

要安装 Python，请访问 Python 官方网站：www.python.org/downloads（如下所示），然后单击适用于 Windows、Linux/Unix 和 macOS 的最新版本。根据您可用的 64 位或 32 位操作系统下载 Python。

安装Python

下载后，单击.exe文件并按照步骤在系统上安装 python。

设置进度

通过上述安装，Python 包管理器（即 pip）也会默认安装。要使其在您的系统上全局工作，请直接将 python 的位置添加到 PATH 变量中，安装开始时会显示相同的内容，请记住选中“ADD to PATH”复选框。如果您忘记检查它，请按照以下给出的步骤添加到 PATH。

添加到路径

要添加到 PATH，请按照以下步骤操作 -

  • 右键单击计算机图标，然后单击属性 -> 高级系统设置。

  • 它将显示如下所示的屏幕

系统属性

  • 单击环境变量，如上所示。它将显示如下所示的屏幕

环境变量

选择 Path 并单击 Edit 按钮，在末尾添加 python 的位置路径。现在让我们检查一下 python 版本。

检查 Python 版本

下面的代码帮助我们检查Python的版本 -

E:\pybrain>python --version
Python 3.7.3

安装 PyBrain

现在我们已经安装了Python，我们将安装Pybrain。克隆 pybrain 存储库，如下所示 -

git clone git://github.com/pybrain/pybrain.git


C:\pybrain>git clone git://github.com/pybrain/pybrain.git
Cloning into 'pybrain'...
remote: Enumerating objects: 2, done.
remote: Counting objects: 100% (2/2), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 12177 (delta 0), reused 0 (delta 0), pack-reused 12175
Receiving objects: 100% (12177/12177), 13.29 MiB | 510.00 KiB/s, done.
Resolving deltas: 100% (8506/8506), done.

现在执行cd pybrain并运行以下命令 -

python setup.py install

此命令将在您的系统上安装 pybrain。

完成后，要检查 pybrain 是否已安装，请打开命令行提示符并启动 python 解释器，如下所示 -

C:\pybrain\pybrain>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

我们可以使用以下代码添加 import pybrain -

>>> import pybrain
>>>

如果 import pybrain 运行没有任何错误，则表示 pybrain 安装成功。您现在可以编写代码来开始使用 pybrain。

PyBrain - PyBrain 网络简介

PyBrain 是一个为使用 Python 进行机器学习而开发的库。机器学习中有一些重要的概念，其中之一就是网络。网络由模块组成，它们通过连接进行连接。

简单神经网络的布局如下 -

简单的神经网络

Pybrain 支持前馈网络、循环网络等神经网络。

前馈网络是一种神经网络，节点之间的信息向前移动，永远不会向后传播。前馈网络是人工神经网络中第一个也是最简单的网络。信息从输入节点传递到隐藏节点，然后传递到输出节点。

这是一个简单的前馈网络布局。

前馈网络

圆圈被称为模块，带箭头的线是模块的连接。

节点A、B、C和D是输入节点

H1、H2、H3、H4是隐藏节点，O 是输出。

在上面的网络中，我们有 4 个输入节点、4 个隐藏层和 1 个输出。图中显示的行数表示模型中在训练过程中调整的权重参数。

循环网络与前馈网络类似，唯一的区别是它必须记住每一步的数据。每个步骤的历史记录都必须保存。

这是循环网络的简单布局 -

循环网络

PyBrain - 使用网络

网络由模块组成，模块之间通过连接进行连接。在本章中，我们将学习 -

  • 创建网络
  • 分析网络

创建网络

我们将使用 python 解释器来执行我们的代码。要在 pybrain 中创建网络，我们必须使用buildNetwork api，如下所示 -

C:\pybrain\pybrain>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>>
>>> from pybrain.tools.shortcuts import buildNetwork
>>> network = buildNetwork(2, 3, 1)
>>>

我们使用 buildNetwork() 创建了一个网络，参数为 2, 3, 1，这意味着该网络由 2 个输入、3 个隐藏层和 1 个输出组成。

以下是网络的详细信息，即模块和连接 -

C:\pybrain\pybrain>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from pybrain.tools.shortcuts import buildNetwork
>>> network = buildNetwork(2,3,1)
>>> print(network)
FeedForwardNetwork-8
   Modules:
   [<BiasUnit 'bias'>, <LinearLayer 'in'>, <SigmoidLayer 'hidden0'>,
<LinearLay er 'out'>]
   Connections:
   [<FullConnection 'FullConnection-4': 'hidden0' -> 'out'>, <FullConnection 'F
ullConnection-5': 'in' -> 'hidden0'>, <FullConnection 'FullConnection-6': 'bias'
-< 'out'>, <FullConnection 'FullConnection-7': 'bias' -> 'hidden0'>]
>>>

模块由层组成，连接由 FullConnection 对象组成。因此每个模块和连接的命名如上所示。

分析网络

您可以通过引用模块层和连接的名称来单独访问它们，如下所示 -

>>> network['bias']
<BiasUnit 'bias'>
>>> network['in']
<LinearLayer 'in'>

PyBrain - 使用数据集

数据集是用于测试、验证和训练网络的输入数据。要使用的数据集类型取决于我们要使用机器学习执行的任务。在本章中，我们将看看以下内容 -

  • 创建数据集
  • 将数据添加到数据集

我们将首先学习如何创建数据集并使用给定的输入测试数据集。

创建数据集

要创建数据集，我们需要使用 pybrain 数据集包：pybrain.datasets。

Pybrain 支持数据集类，如SupervisedDataset、 SequentialDataset 、 ClassificationDataSet 。我们将利用SupervisedDataset来创建我们的数据集。要使用的数据集取决于用户尝试实现的机器学习任务。SupervisedDataset 是最简单的一个，我们将在这里使用相同的数据集。

SupervisedDataset 数据集需要参数输入和目标。考虑一个异或真值表，如下所示 -

A 乙 异或B
0 0 0
0 1 1
1 0 1
1 1 0

给出的输入就像一个二维数组，我们得到 1 个输出。因此，这里输入变为大小，目标变为输出 1。因此，数据集的输入将为 2,1。

创建数据集.py

from pybrain.datasets import SupervisedDataSet
sds = SupervisedDataSet(2, 1)
print(sds)

这是当我们执行上面的代码时得到的结果 python createdataset.py -

C:\pybrain\pybrain\src>python createdataset.py
input: dim(0, 2)
[]
target: dim(0, 1)
[]

它显示大小 2 的输入和大小 1 的目标，如上所示。

将数据添加到数据集

现在让我们将示例数据添加到数据集中。

创建数据集.py

from pybrain.datasets import SupervisedDataSet
sds = SupervisedDataSet(2, 1)
xorModel = [
   [(0,0), (0,)],
   [(0,1), (1,)],
   [(1,0), (1,)],
   [(1,1), (0,)],
]
for input, target in xorModel:
sds.addSample(input, target)
print("Input is:")
print(sds['input'])
print("\nTarget is:")
print(sds['target'])

我们创建了一个 XORModel 数组，如下所示 -

xorModel = [
   [(0,0), (0,)],
   [(0,1), (1,)],
   [(1,0), (1,)],
   [(1,1), (0,)],
]

为了将数据添加到数据集中，我们使用 addSample() 方法来接收输入和目标。

要将数据添加到 addSample，我们将循环访问 xorModel 数组，如下所示 -

for input, target in xorModel:
   sds.addSample(input, target)

执行后，我们得到的输出如下：

python createdataset.py

C:\pybrain\pybrain\src>python createdataset.py
Input is:
[[0. 0.]
[0. 1.]
[1. 0.]
[1. 1.]]
Target is:
[[0.]
[1.]
[1.]
[0.]]

您可以通过简单地使用输入和目标索引从创建的数据集中获取输入和目标详细信息，如下所示 -

print(sds['input'])
print(sds[‘target’])

PyBrain - 数据集类型

数据集是用于在网络上进行测试、验证和训练的数据。要使用的数据集类型取决于我们要使用机器学习执行的任务。我们将在本章中讨论各种数据集类型。

我们可以通过添加以下包来处理数据集 -

pybrain.dataset

监督数据集

SupervisedDataSet 由input和target字段组成。它是最简单的数据集形式，主要用于监督学习任务。

以下是如何在代码中使用它 -

from pybrain.datasets import SupervisedDataSet

SupervisedDataSet 上可用的方法如下 -

addSample(inp, 目标)

此方法将添加新的输入和目标样本。

splitWithProportion(比例=0.10)

这会将数据集分为两部分。第一部分将数据集的百分比作为输入给出，即，如果输入为 0.10，则它是数据集的 10% 和数据的 90%。您可以根据自己的选择来决定比例。划分的数据集可用于测试和训练您的网络。

copy() - 返回数据集的深层副本。

clear() - 清除数据集。

saveToFile（文件名，格式=无，**kwargs）

将对象保存到文件名指定的文件中。

例子

这是一个使用 SupervisedDataset 的工作示例 -

测试网络.py

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

输出

上述程序的输出如下 -

python 测试网络.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 0.005227359234093431
, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

分类数据集

该数据集主要用于处理分类问题。它接受输入、目标字段以及一个称为“类”的额外字段，它是给定目标的自动备份。例如，输出将为 1 或 0，或者输出将与基于给定输入的值分组在一起，即，它将属于一个特定类别。

以下是如何在代码中使用它 -

from pybrain.datasets import ClassificationDataSet
Syntax
// ClassificationDataSet(inp, target=1, nb_classes=0, class_labels=None)

ClassificationDataSet 上可用的方法如下 -

addSample(inp, target) - 此方法将添加输入和目标的新样本。

splitByClass() - 此方法将提供两个新数据集，第一个数据集将选择类别（0..nClasses-1），第二个数据集将包含剩余样本。

_convertToOneOfMany() - 此方法将目标类转换为 1-of-k 表示形式，保留旧目标作为字段类

这是ClassificationDataSet的一个工作示例。

例子

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel
digits = datasets.load_digits()
X, y = digits.data, digits.target
ds = ClassificationDataSet(64, 1, nb_classes=10)

for i in range(len(X)):
ds.addSample(ravel(X[i]), y[i])
test_data_temp, training_data_temp = ds.splitWithProportion(0.25)
test_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, test_data_temp.getLength()):
test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):
training_data.addSample( training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] )
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()
net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01
)
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()
trainer.trainEpochs(10)
print('Percent Error on testData:',percentError(trainer.testOnClassData(dataset=test_data), test_data['class']))

上面例子中使用的数据集是一个数字数据集，类别是从0到9，所以有10个类别。输入为 64，目标为 1，类别为 10。

该代码使用数据集训练网络并输出训练误差和验证误差的图表。它还给出了测试数据的百分比误差，如下所示 -

输出

分类数据集。 
Total error: 0.0432857814358
Total error: 0.0222276374185
Total error: 0.0149012052174
Total error: 0.011876985318
Total error: 0.00939854792853
Total error: 0.00782202445183
Total error: 0.00714707652044
Total error: 0.00606068893793
Total error: 0.00544257958975
Total error: 0.00463929281336
Total error: 0.00441275665294
('train-errors:', '[0.043286 , 0.022228 , 0.014901 , 0.011877 , 0.009399 , 0.007
   822 , 0.007147 , 0.006061 , 0.005443 , 0.004639 , 0.004413 ]')
('valid-errors:', '[0.074296 , 0.027332 , 0.016461 , 0.014298 , 0.012129 , 0.009
   248 , 0.008922 , 0.007917 , 0.006547 , 0.005883 , 0.006572 , 0.005811 ]')
Percent Error on testData: 3.34075723830735

PyBrain - 导入数据集的数据

在本章中，我们将学习如何使用 Pybrain 数据集获取数据。

最常用的数据集是 -

  • 使用sklearn
  • 来自 CSV 文件

使用sklearn

使用sklearn

以下链接包含 sklearn 数据集的详细信息：https ://scikit-learn.org/stable/datasets/index.html

以下是如何使用 sklearn 数据集的一些示例 -

示例 1：load_digits()

from sklearn import datasets
from pybrain.datasets import ClassificationDataSet
digits = datasets.load_digits()
X, y = digits.data, digits.target
ds = ClassificationDataSet(64, 1, nb_classes=10)
for i in range(len(X)):
ds.addSample(ravel(X[i]), y[i])

示例 2：load_iris()

from sklearn import datasets
from pybrain.datasets import ClassificationDataSet
digits = datasets.load_iris()
X, y = digits.data, digits.target
ds = ClassificationDataSet(4, 1, nb_classes=3)
for i in range(len(X)):
ds.addSample(X[i], y[i])

来自 CSV 文件

我们还可以使用 csv 文件中的数据，如下所示 -

以下是异或真值表的示例数据：datasettest.csv

CSV 文件

以下是从 .csv 文件中读取数据集数据的工作示例。

例子

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
import pandas as pd

print('Read data...')
df = pd.read_csv('data/datasettest.csv',header=0).head(1000)
data = df.values

train_output = data[:,0]
train_data = data[:,1:]

print(train_output)
print(train_data)

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
_gate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
for i in range(0, len(train_output)) :
   _gate.addSample(train_data[i], train_output[i])

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, _gate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=_gate, verbose = True)

Panda 用于从 csv 文件读取数据，如示例所示。

输出

C:\pybrain\pybrain\src>python testcsv.py
Read data...
[0 1 1 0]
[
   [0 0]
   [0 1]
   [1 0]
   [1 1]
]
Testing on data:
('out: ', '[0.004 ]')
('correct:', '[0 ]')
error: 0.00000795
('out: ', '[0.997 ]')
('correct:', '[1 ]')
error: 0.00000380
('out: ', '[0.996 ]')
('correct:', '[1 ]')
error: 0.00000826
('out: ', '[0.004 ]')
('correct:', '[0 ]')
error: 0.00000829
('All errors:', [7.94733477723902e-06, 3.798267582566822e-06, 8.260969076585322e
-06, 8.286246525558165e-06])
('Average error:', 7.073204490487332e-06)
('Max error:', 8.286246525558165e-06, 'Median error:', 8.260969076585322e-06)

PyBrain - 网络训练数据集

到目前为止，我们已经了解了如何创建网络和数据集。为了一起使用数据集和网络，我们必须在培训师的帮助下完成。

下面是一个工作示例，了解如何将数据集添加到创建的网络中，然后使用训练器进行训练和测试。

测试网络.py

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

为了测试网络和数据集，我们需要 BackpropTrainer。BackpropTrainer 是一个训练器，它根据监督数据集（可能是顺序的）通过反向传播误差（随时间）来训练模块的参数。

我们创建了 2 个类数据集 - SupervisedDataSet。我们正在使用 NOR 数据模型，如下 -

A 乙 A 或 B
0 0 1
0 1 0
1 0 0
1 1 0

上述数据模型用于训练网络。

norgate = SupervisedDataSet(2, 1)
# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

以下是用于测试的数据集 -

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

训练器的使用方式如下 -

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()

要测试数据集，我们可以使用以下代码 -

trainer.testOnData(dataset=nortrain, verbose = True)

输出

python 测试网络.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 0.005227359234093431
, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

如果检查输出，测试数据几乎与我们提供的数据集匹配，因此误差为 0.008。

现在让我们更改测试数据并查看平均误差。我们更改了输出，如下所示 -

以下是用于测试的数据集 -

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (0,))
norgate.addSample((0, 1), (1,))
norgate.addSample((1, 0), (1,))
norgate.addSample((1, 1), (0,))

现在让我们测试一下。

输出

python 测试网络.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.988 ]')
('correct:', '[0 ]')
error: 0.48842978
('out: ', '[0.027 ]')
('correct:', '[1 ]')
error: 0.47382097
('out: ', '[0.021 ]')
('correct:', '[1 ]')
error: 0.47876379
('out: ', '[-0.04 ]')
('correct:', '[0 ]')
error: 0.00079160
('All errors:', [0.4884297811030845, 0.47382096780393873, 0.47876378995939756, 0
.0007915982149002194])
('Average error:', 0.3604515342703303)
('Max error:', 0.4884297811030845, 'Median error:', 0.47876378995939756)

我们得到的误差为 0.36，这表明我们的测试数据与训练的网络并不完全匹配。

PyBrain - 测试网络

在本章中，我们将看到一些示例，其中我们将训练数据并测试训练数据上的错误。

我们将利用培训师 -

反向传播训练器

BackpropTrainer 是一个训练器，它根据监督或 ClassificationDataSet 数据集（可能是顺序的）通过反向传播误差（随时间）来训练模块的参数。

训练直至收敛

它用于在数据集上训练模块直到收敛。

当我们创建一个神经网络时，它将根据给定的训练数据进行训练。现在网络是否训练正确将取决于在该网络上测试的测试数据的预测。

让我们一步步看一个工作示例，它将构建一个神经网络并预测训练误差、测试误差和验证误差。

测试我们的网络

以下是我们测试网络时将遵循的步骤 -

  • 导入所需的 PyBrain 和其他包
  • 创建分类数据集
  • 将数据集 25% 作为测试数据，75% 作为训练数据
  • 将测试数据和训练数据转换回 ClassificationDataSet
  • 创建神经网络
  • 训练网络
  • 可视化错误和验证数据
  • 测试数据误差百分比

步骤1

导入所需的 PyBrain 和其他包。

我们需要的包被导入，如下所示 -

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel

第2步

下一步是创建 ClassificationDataSet。

对于数据集，我们将使用 sklearn 数据集中的数据集，如下所示 -

请参阅以下链接中 sklearn 的 load_digits 数据集 -

https://scikit-learn.org/stable/modules/ generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits

digits = datasets.load_digits()
X, y = digits.data, digits.target

ds = ClassificationDataSet(64, 1, nb_classes=10) 
# we are having inputs are 64 dim array and since the digits are from 0-9 the 
classes considered is 10.

for i in range(len(X)):
   ds.addSample(ravel(X[i]), y[i]) # adding sample to datasets

步骤3

将数据集 25% 作为测试数据，75% 作为训练数据 -

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

因此，在这里，我们在数据集上使用了一种名为 splitWithProportion() 的方法，其值为 0.25，它将把数据集拆分为 25% 作为测试数据，75% 作为训练数据。

步骤4

将测试数据和训练数据转换回 ClassificationDataSet。

test_data = ClassificationDataSet(64, 1, nb_classes=10)
for n in range(0, test_data_temp.getLength()):
   test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):

training_data.addSample( 
   training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
)
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()

在数据集上使用 splitWithProportion() 方法会将数据集转换为监督数据集，因此我们将数据集转换回分类数据集，如上一步所示。

步骤5

下一步是创建神经网络。

net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)

我们正在创建一个网络，其中的输入和输出均来自训练数据。

步骤6

训练网络

现在重要的部分是在数据集上训练网络，如下所示 -

trainer = BackpropTrainer(net, dataset=training_data, 
momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01)

我们正在使用 BackpropTrainer() 方法并使用创建的网络上的数据集。

步骤7

下一步是可视化数据的错误和验证。

trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()

我们将在训练数据上使用一种名为 trainUntilConvergence 的方法，该方法将在 10 个时期内收敛。它将返回我们绘制的训练误差和验证误差，如下所示。蓝线显示训练误差，红线显示验证误差。

训练数据

执行上述代码期间收到的总错误如下所示 -

Total error: 0.0432857814358
Total error: 0.0222276374185
Total error: 0.0149012052174
Total error: 0.011876985318
Total error: 0.00939854792853
Total error: 0.00782202445183
Total error: 0.00714707652044
Total error: 0.00606068893793
Total error: 0.00544257958975
Total error: 0.00463929281336
Total error: 0.00441275665294
('train-errors:', '[0.043286 , 0.022228 , 0.014901 , 0.011877 , 0.009399 , 0.007
822 , 0.007147 , 0.006061 , 0.005443 , 0.004639 , 0.004413 ]')
('valid-errors:', '[0.074296 , 0.027332 , 0.016461 , 0.014298 , 0.012129 , 0.009
248 , 0.008922 , 0.007917 , 0.006547 , 0.005883 , 0.006572 , 0.005811 ]')

误差从 0.04 开始，然后每个时期都会下降，这意味着网络正在接受训练并且每个时期都会变得更好。

步骤8

测试数据错误百分比

我们可以使用%Error 方法检查百分比误差，如下所示 -

print('Percent Error on 
   testData:',percentError(trainer.testOnClassData(dataset=test_data), 
   test_data['class']))

测试数据的百分比错误- 3.34075723830735

我们得到的错误百分比为 3.34%，这意味着神经网络的准确度为 97%。

下面是完整的代码 -

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel
digits = datasets.load_digits()
X, y = digits.data, digits.target

ds = ClassificationDataSet(64, 1, nb_classes=10)

for i in range(len(X)):
   ds.addSample(ravel(X[i]), y[i])

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)
test_data = ClassificationDataSet(64, 1, nb_classes=10)
for n in range(0, test_data_temp.getLength()):
   test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):
   training_data.addSample( 
      training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
   )
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()

net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,
   learningrate=0.01,verbose=True,weightdecay=0.01
)
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()

trainer.trainEpochs(10)
print('Percent Error on testData:',percentError(
   trainer.testOnClassData(dataset=test_data), test_data['class']
))

PyBrain - 使用前馈网络

前馈网络是一种神经网络，节点之间的信息向前移动，永远不会向后传播。前馈网络是人工神经网络中第一个也是最简单的网络。信息从输入节点传递到隐藏节点，然后传递到输出节点。

在本章中，我们将讨论如何 -

  • 创建前馈网络
  • 将连接和模块添加到 FFN

创建前馈网络

您可以使用您选择的 python IDE，即 PyCharm。在此，我们使用 Visual Studio Code 编写代码并将在终端中执行相同的代码。

要创建前馈网络，我们需要从pybrain.struct导入它，如下所示 -

ffn.py

from pybrain.structure import FeedForwardNetwork
network = FeedForwardNetwork()
print(network)

执行 ffn.py 如下所示 -

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-0
Modules:
[]
Connections:
[]

我们尚未向前馈网络添加任何模块和连接。因此，网络显示模块和连接的空数组。

添加模块和连接

首先，我们将创建输入层、隐藏层、输出层并将其添加到模块中，如下所示 -

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

print(network)

输出

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-3
Modules:
[]
Connections:
[]

我们仍然将模块和连接视为空。我们需要提供与创建的模块的连接，如下所示 -

在下面的代码中，我们创建了输入层、隐藏层和输出层之间的连接，并将该连接添加到网络中。

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection
network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)

print(network)

输出

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-3
Modules:
[]
Connections:
[]

我们仍然无法获得模块和连接。现在让我们添加最后一步，即我们需要添加 sortModules() 方法，如下所示 -

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection
network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)
network.sortModules()

print(network)

输出

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-6
Modules:
[<LinearLayer 'LinearLayer-3'gt;, <SigmoidLayer 'SigmoidLayer-7'>, 
   <LinearLayer 'LinearLayer-8'>]
Connections:
[<FullConnection 'FullConnection-4': 'SigmoidLayer-7' -> 'LinearLayer-8'>, 
   <FullConnection 'FullConnection-5': 'LinearLayer-3' -> 'SigmoidLayer-7'>]

我们现在可以看到前馈网络的模块和连接详细信息。

PyBrain - 使用循环网络

循环网络与前馈网络相同，唯一的区别是您需要记住每一步的数据。每一步的历史记录都必须保存。

我们将学习如何 -

  • 创建循环网络
  • 添加模块和连接

创建循环网络

为了创建循环网络，我们将使用 RecurrentNetwork 类，如下所示 -

py

from pybrain.structure import RecurrentNetwork
recurrentn = RecurrentNetwork()
print(recurrentn)

蟒蛇 rn.py

C:\pybrain\pybrain\src>python rn.py
RecurrentNetwork-0
Modules:
[]
Connections:
[]
Recurrent Connections:
[]

我们可以看到循环网络有一个名为“循环连接”的新连接。目前没有可用数据。

现在让我们创建层并添加到模块并创建连接。

添加模块和连接

我们将创建层，即输入层、隐藏层和输出层。这些层将被添加到输入和输出模块。接下来，我们将创建输入到隐藏、隐藏到输出的连接以及隐藏到隐藏之间的循环连接。

这是带有模块和连接的循环网络的代码。

py

from pybrain.structure import RecurrentNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection
recurrentn = RecurrentNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2, 'rn_in')
hiddenLayer = SigmoidLayer(3, 'rn_hidden')
outputLayer = LinearLayer(1, 'rn_output')

#adding the layer to feedforward network
recurrentn.addInputModule(inputLayer)
recurrentn.addModule(hiddenLayer)
recurrentn.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)
hidden_to_hidden = FullConnection(hiddenLayer, hiddenLayer)

#add connection to the network
recurrentn.addConnection(input_to_hidden)
recurrentn.addConnection(hidden_to_output)
recurrentn.addRecurrentConnection(hidden_to_hidden)
recurrentn.sortModules()

print(recurrentn)

蟒蛇 rn.py

C:\pybrain\pybrain\src>python rn.py
RecurrentNetwork-6
Modules:
[<LinearLayer 'rn_in'>, <SigmoidLayer 'rn_hidden'>, 
   <LinearLayer 'rn_output'>]
Connections:
[<FullConnection 'FullConnection-4': 'rn_hidden' -> 'rn_output'>, 
   <FullConnection 'FullConnection-5': 'rn_in' -> 'rn_hidden'>]
Recurrent Connections:
[<FullConnection 'FullConnection-3': 'rn_hidden' -> 'rn_hidden'>]

在上面的输出中，我们可以看到模块、连接和循环连接。

现在让我们使用 activate 方法激活网络，如下所示 -

py

将以下代码添加到之前创建的代码中 -

#activate network using activate() method
act1 = recurrentn.activate((2, 2))
print(act1)

act2 = recurrentn.activate((2, 2))
print(act2)

蟒蛇 rn.py

C:\pybrain\pybrain\src>python rn.py
[-1.24317586]
[-0.54117783]

使用优化算法训练网络

我们已经了解了如何使用 pybrain 中的训练器来训练网络。在本章中，将使用 Pybrain 提供的优化算法来训练网络。

在示例中，我们将使用需要导入的 GA 优化算法，如下所示 -

from pybrain.optimization.populationbased.ga import GA

例子

下面是使用 GA 优化算法的训练网络的工作示例 -

from pybrain.datasets.classification import ClassificationDataSet
from pybrain.optimization.populationbased.ga import GA
from pybrain.tools.shortcuts import buildNetwork

# create XOR dataset
ds = ClassificationDataSet(2)
ds.addSample([0., 0.], [0.])
ds.addSample([0., 1.], [1.])
ds.addSample([1., 0.], [1.])
ds.addSample([1., 1.], [0.])
ds.setField('class', [ [0.],[1.],[1.],[0.]])

net = buildNetwork(2, 3, 1)
ga = GA(ds.evaluateModuleMSE, net, minimize=True)

for i in range(100):
net = ga.learn(0)[0]

print(net.activate([0,0]))
print(net.activate([1,0]))
print(net.activate([0,1]))
print(net.activate([1,1]))

输出

网络上输入的激活方法几乎与输出匹配，如下所示 -

C:\pybrain\pybrain\src>python example15.py
[0.03055398]
[0.92094839]
[1.12246157]
[0.02071285]

PyBrain - 层

层基本上是一组用于网络隐藏层的函数。

我们将在本章中详细介绍有关层的以下详细信息 -

  • 理解层
  • 使用 Pybrain 创建图层

了解图层

我们之前已经看到过使用图层的示例，如下所示 -

  • Tanh层
  • Softmax层

使用 TanhLayer 的示例

下面是我们使用 TanhLayer 构建网络的一个示例 -

测试网络.py

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

输出

上述代码的输出如下 -

python 测试网络.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 
   0.005227359234093431, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

使用 SoftMaxLayer 的示例

下面是我们使用 SoftmaxLayer 构建网络的一个示例 -

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure.modules import SoftmaxLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=SoftmaxLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

输出

输出如下 -

C:\pybrain\pybrain\src>python example16.py
Testing on data:
('out: ', '[0.918 ]')
('correct:', '[1 ]')
error: 0.00333524
('out: ', '[0.082 ]')
('correct:', '[0 ]')
error: 0.00333484
('out: ', '[0.078 ]')
('correct:', '[0 ]')
error: 0.00303433
('out: ', '[-0.082]')
('correct:', '[0 ]')
error: 0.00340005
('All errors:', [0.0033352368788838365, 0.003334842961037291, 
   0.003034328685718761, 0.0034000458892589056])
('Average error:', 0.0032761136037246985)
('Max error:', 0.0034000458892589056, 'Median error:', 0.0033352368788838365)

在 Pybrain 中创建层

在 Pybrain 中，您可以创建自己的层，如下所示 -

要创建图层，您需要使用NeuronLayer 类作为基类来创建所有类型的图层。

例子

from pybrain.structure.modules.neuronlayer import NeuronLayer
class LinearLayer(NeuronLayer):
   def _forwardImplementation(self, inbuf, outbuf):
      outbuf[:] = inbuf
   def _backwardImplementation(self, outerr, inerr, outbuf, inbuf):
      inerr[:] = outer

要创建一个 Layer，我们需要实现两个方法：_forwardImplementation()和_backwardImplementation()。

_forwardImplementation() 接受 2 个参数 inbuf和 outbuf，它们是 Scipy 数组。它的大小取决于层的输入和输出尺寸。

_backwardImplementation ()用于计算输出相对于给定输入的导数。

因此，要在 Pybrain 中实现图层，这是图层类的骨架 -

from pybrain.structure.modules.neuronlayer import NeuronLayer
class NewLayer(NeuronLayer):
   def _forwardImplementation(self, inbuf, outbuf):
      pass
   def _backwardImplementation(self, outerr, inerr, outbuf, inbuf):
      pass

如果您想将二次多项式函数实现为一个层，我们可以这样做 -

考虑我们有一个多项式函数 -

f(x) = 3x2

上述多项式函数的导数如下 -

f(x) = 6 x

上述多项式函数的最终层类如下 -

测试层.py

from pybrain.structure.modules.neuronlayer import NeuronLayer
class PolynomialLayer(NeuronLayer):
   def _forwardImplementation(self, inbuf, outbuf):
      outbuf[:] = 3*inbuf**2
   def _backwardImplementation(self, outerr, inerr, outbuf, inbuf):
      inerr[:] = 6*inbuf*outerr

现在让我们利用创建的图层，如下所示 -

测试层1.py

from testlayer import PolynomialLayer
from pybrain.tools.shortcuts import buildNetwork
from pybrain.tests.helpers import gradientCheck

n = buildNetwork(2, 3, 1, hiddenclass=PolynomialLayer)
n.randomize()

gradientCheck(n)

GradientCheck()将测试该层是否工作正常。我们需要将使用该层的网络传递给gradientCheck(n)。如果该层工作正常，它将给出“完美梯度”的输出。

输出

C:\pybrain\pybrain\src>python testlayer1.py
Perfect gradient

PyBrain - 连接

连接的工作方式类似于层；唯一的区别是它将数据从网络中的一个节点转移到另一个节点。

在本章中，我们将学习 -

  • 了解连接
  • 创建连接

了解连接

以下是创建网络时使用的连接的工作示例。

例子

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection

network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)
network.sortModules()

print(network)

输出

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-6
Modules:
[<LinearLayer 'LinearLayer-3'>, <SigmoidLayer 'SigmoidLayer-7'>, 
   <LinearLayer 'LinearLayer-8'>]
Connections:
[<FullConnection 'FullConnection-4': 'SigmoidLayer-7' -> 'LinearLayer-8'>, 
   <FullConnection 'FullConnection-5': 'LinearLayer-3' -> 'SigmoidLayer-7'>]

创建连接

在 Pybrain 中，我们可以使用连接模块创建连接，如下所示 -

例子

连接.py

from pybrain.structure.connections.connection import Connection
class YourConnection(Connection):
   def __init__(self, *args, **kwargs):
      Connection.__init__(self, *args, **kwargs)
   def _forwardImplementation(self, inbuf, outbuf):
      outbuf += inbuf
   def _backwardImplementation(self, outerr, inerr, inbuf):
      inerr += outer

要创建连接，有 2 种方法 — _forwardImplementation()和_back