Pybrain 简明教程

PyBrain - Quick Guide

PyBrain - Overview

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

Pybrain 官方文档对其的定义如下 −

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

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

Features of Pybrain

以下是 Pybrain 的功能 −

Networks

一个网络由模块组成，并且它们使用连接进行连接。Pybrain 支持神经网络，如前馈网络、循环网络等。

feed-forward network 是神经网络，其中节点之间的信息向前移动，并且永远不会向后传播。前馈网络是人工神经网络中可用网络中第一个也是最简单的网络。

信息从输入节点传递到下一个隐藏节点，之后传递到输出节点。

Recurrent Networks 类似于前馈神经网络；唯一的区别是它必须在每个步骤中记住数据。必须保存每个步骤的历史记录。

Datasets

数据集是提供给测试、验证和训练网络的数据。要使用的数据集类型取决于我们要使用机器学习完成的任务。Pybrain 支持的最常使用的数据集是 SupervisedDataSet 和 ClassificationDataSet 。

SupervisedDataSet − 它由 input 和 target 组成。它是最简单的 dataset 形式，主要用于监督学习任务。

ClassificationDataSet − 它主要用于解决分类问题。它接受 input 、 target 域，还接受一个名为“class”的额外域，它是所给目标的自动备份。例如，输出要么是 1 或 0，要么是基于给定输入的值将输出分组，也就是说，它会属于一个特定类。

Trainer

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

BackpropTrainer − 它是一个训练器，它通过反向传播误差（通过时间）根据监督或 ClassificationDataSet dataset（潜在序列）训练模块的参数。

TrainUntilConvergence − 用于训练数据模块，直至其收敛。

Tools

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

Visualization

测试数据无法使用 Pybrain 可视化。但是，Pybrain 可以与其他框架（如 Mathplotlib、pyplot）配合使用来可视化数据。

Advantages of Pybrain

Pybrain 的优点包括：

Pybrain 是一个开源的免费库，用于学习机器学习。对于任何对机器学习感兴趣的新手来说，这都是一个很好的起点。
Pybrain 使用 Python 来实现它，与 Java/C++ 等语言相比，这使得它的开发速度很快。
Pybrain 可以轻松地与 python 的其他库一起使用来可视化数据。
Pybrain 为前馈网络、循环网络、神经网络等流行网络提供支持。
在 Pybrain 中，使用 .csv 加载数据集非常容易。它还允许使用来自其他库的数据集。
使用 Pybrain 训练器，可以轻松地训练和测试数据。

Limitations of Pybrain

Pybrain 对遇到的任何问题提供的帮助更少。在 stackoverflow 和 Google Group 上有一些问题没有得到解答。

Workflow of Pybrain

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

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

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

创建网络，并向训练器提供 dataset 和网络。
训练者训练网络中的数据，将输出归类为训练误差和验证误差，这些误差可以直接显示。
可以验证测试数据以查看输出是否与训练数据匹配。

Terminology

在使用 Pybrain 进行机器学习时，有一些重要的术语需要注意。它们如下所示 −

Total Error − 它指的是网络训练后显示的误差。如果误差在每次迭代时都在不断变化，则表示它仍需要时间来平稳，直到它开始在迭代之间显示恒定的误差。一旦它开始显示恒定的误差数字，则表示网络已收敛，无论是否应用任何其他训练，它都将保持不变。

Trained data − 它是用于训练 Pybrain 网络的数据。

Testing data − 它是用于测试经过训练的 Pybrain 网络的数据。

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

BackpropTrainer − 它是一个训练器，它通过反向传播误差（通过时间）根据监督或 ClassificationDataSet dataset（潜在序列）训练模块的参数。

TrainUntilConvergence − 它用于训练模块上的数据集，直到它收敛。

Layers − 层基本上是用于网络隐含层的函数集。

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

Modules − 模块是包含输入和输出缓冲区的网络。

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

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

PyBrain - Environment Setup

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

Install Python
Install PyBrain

Installing Python

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

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

python 软件包管理器，即 pip，也将默认情况下通过上述安装进行安装。要使其在您的系统上全局运行，请将 python 的位置直接添加到 PATH 变量中，在安装开始时显示了相同的变量，以便记住选中复选框，该复选框表示添加到 PATH。如果您忘记选中该复选框，请按照下面给定的步骤将其添加到 PATH。

Add to PATH

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

右键单击您的计算机图标，然后单击属性 → 高级系统设置。
它会显示如下屏幕：

如上图所示，单击“环境变量”。它会显示如下屏幕：

选择“路径”并单击“编辑”按钮，在末尾添加 Python 的位置路径。现在，让我们检查 Python 版本。

Checking for Python version

以下代码帮助我们检查 Python 版本：

E:\pybrain>python --version
Python 3.7.3

Installing 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 - Introduction to PyBrain Networks

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

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

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

feed-forward network 是一个神经网络，其中节点之间的信息在正向移动，决不会往后退。在人工神经网络中，前馈网络是第一个也是最简单的一个。信息从输入节点传递到隐藏节点，然后传递到输出节点。

以下是简单前馈网络布局。

圆圈表示为模块而带箭头的线表示与模块的连接。

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

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

在上述网络中，我们有 4 个输入节点、4 个隐含层和 1 个输出。该图表中显示的线数指示模型中在训练期间将调整的权重参数。

Recurrent Networks 与前馈网络类似，唯一的不同之处在于它必须记住每一步的数据。必须保存每一步的历史记录。

以下是循环网络的简单布局 −

PyBrain - Working With Networks

一个网络由模块组成，它们使用连接进行连接。在本章中，我们将学习 −

Create Network
Analyze Network

Creating Network

我们将使用 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 个隐藏层和一个单一输出组成。

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

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 对象组成。因此，每个模块和连接都按上面所示命名。

Analyzing Network

您可以通过引用他们的名称来分别访问模块层和连接，如下所示 −

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

PyBrain - Working with Datasets

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

Creating Dataset
Adding Data to Dataset

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

Creating Dataset

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

PyBrain 支持 SupervisedDataset 、SequentialDataset、ClassificationDataSet 等数据集类。我们将使用 SupervisedDataset 来创建数据集。要使用的数据集取决于用户尝试实现的机器学习任务。SupervisedDataset 是最简单的，我们将在本文中使用它。

SupervisedDataset dataset 需要参数 input 和 target。考虑一个 XOR 真值表，如下所示 −

A	B	A XOR B
0	0	0
0	1	1
1	0	1
1	1	0

给定的输入像一个二维数组，我们得到一个输出。所以这里的输入变成大小，目标是输出 1。因此，输入数据集的大小将是 2、1。

createdataset.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 的目标。

Adding Data to Dataset

现在，我们向数据集添加示例数据。

createdataset.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() 方法，它输入 input 和 target。

以下所示，我们将遍历 xorModel 数组以将数据添加到 addSample 中 −

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 - Datasets Types

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

我们可以通过添加以下包来使用数据集 −

pybrain.dataset

SupervisedDataSet

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

以下是您如何在代码中使用它的方法 −

from pybrain.datasets import SupervisedDataSet

SupervisedDataSet 中可用的方法如下 −

addSample(inp, target)

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

splitWithProportion(proportion=0.10)

这将把数据集分为两部分。第一部分将占数据集输入部分的 %，即如果输入为 .10，那么它就是数据集的 10%，90% 的数据。您可以根据自己的选择决定比例。可以将已划分的数据集用于测试并训练您的网络。

copy() − 返回数据集的深度副本。

clear() − 清除数据集。

saveToFile(filename, format=None, **kwargs)

将对象保存到由 filename 给出的文件中。

Example

这里有一个使用 SupervisedDataset 的工作示例 −

testnetwork.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)

Output

以上程序的输出如下所示 −

python testnetwork.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)

ClassificationDataSet

此数据集主要用于解决分类问题。它使用输入、目标字段以及一个名为“class”的附加字段，它是所给目标的自动化备份。例如，输出将是 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 中 k 个表示形式，将旧目标作为字段类保留

下面是 ClassificationDataSet 的一个工作示例。

Example

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。

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

Output

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 - Importing Data For Datasets

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

最常用的数据集是：

Using sklearn
From CSV file

Using sklearn

使用 sklearn

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

以下是使用 sklearn 数据集的一些示例：

Example 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])

Example 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])

From CSV file

我们还可以通过以下方式使用 csv 文件中的数据：

下面是异或真值表的样本数据：datasettest.csv

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

Example

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 文件中的数据。

Output

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 - Training Datasets on Networks

目前为止，我们已经了解如何创建网络和数据集。为了配合使用数据集和网络，我们必须借助培训器来实现。

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

testnetwork.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	B	A NOR 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)

Output

python testnetwork.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,))

我们现在来测试一下。

Output

python testnework.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 - Testing Network

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

我们将使用训练器：

BackpropTrainer

BackpropTrainer 是按照有监督或 ClassificationDataSet 数据集（可能按顺序），通过反向传播错误（随时）来训练模块参数的训练器。

TrainUntilConvergence

它用于训练模块，直到它收敛。

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

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

Testing our Network

以下是我们将遵循的用于测试我们网络的步骤：

导入所必需的 PyBrain 和其他模块
Create ClassificationDataSet
将数据集拆分为 25% 为测试数据和 75% 为训练数据
将测试数据和训练数据转换回 ClassificationDataSet
Creating a Neural Network
Training the Network
可视化错误和验证数据
测试数据百分比错误

Step 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

Step 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

Step 3

将数据集拆分为 25% 作为测试数据和 75% 作为训练数据：

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

所以在这里，我们在数据集中使用了一个叫做 splitWithProportion() 的方法，其值为 0.25，它将把数据集拆分为 25% 作为测试数据和 75% 作为训练数据。

Step 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() 方法会将数据集转换为 superviseddataset，因此我们将数据集转换回 classificationdataset，如上一步所示。

Step 5

下一步是创建神经网络。

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

我们在其中创建了一个网络，该网络中的输入和输出是使用训练数据。

Step 6

Training the Network

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

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

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

Step 7

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

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

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

在执行上述代码期间收到的总误差如下所示 −

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 开始，然后随着每个 epoch 的进行而减小，这意味着网络正在接受训练，并且每个 epoch 都会变得更好。

Step 8

Percentage for test data error

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

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

Percent Error on testData − 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 - Working with Feed-Forward Networks

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

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

Create Feed-Forward Networks
向 FFN 添加连接和模块

Creating a Feed Forward Network

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

要创建一个前馈网络，我们需要从 pybrain.structure 导入它，如下所示 −

ffn.py

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

按如下所示执行 ffn.py −

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

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

Adding Modules and 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)

Output

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)

Output

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)

Output

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'>]

我们现在可以看到feedforwardnetwork的模块和连接详细信息。

PyBrain - Working with Recurrent Networks

循环网络和前馈网络相同，其唯一的区别在于您需要记住在每个步骤中的数据。每个步骤的历史记录都必须保存。

我们将学习如何：

Create a Recurrent Network
Adding Modules and Connection

Creating a Recurrent Network

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

rn.py

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

python rn.py

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

我们可以看到循环网络的新连接称为循环连接。目前没有可用数据。

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

Adding Modules and Connection

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

以下是具有模块和连接的循环网络的代码。

rn.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)

python 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方法激活该网络，如下所示：

rn.py

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

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

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

python rn.py

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

Training Network Using Optimization Algorithms

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

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

from pybrain.optimization.populationbased.ga import GA

Example

下面是一个使用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]))

Output

网络针对输入的激活方法几乎与以下所示的输出匹配：

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

PyBrain - Layers

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

我们将在本章中了解图层的以下详细信息：

Understanding layer
Creating Layer using Pybrain

Understanding layers

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

TanhLayer
SoftmaxLayer

Example using TanhLayer

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

testnetwork.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)

Output

以上代码的输出如下 −

python testnetwork.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)

Example using 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)

Output

输出如下 −

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)

Creating Layer in Pybrain

在 Pybrain 中，您可以按照如下方式创建自己的层：

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

Example

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

要创建层，我们需要实现两种方法：_forwardImplementation() 和 _backwardImplementation()。

The _forwardImplementation() takes in 2 arguments 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

以上多项式函数的最终层类为：

testlayer.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

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

testlayer1.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)。如果层运行良好，它将输出“Perfect Gradient”。

Output

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

PyBrain - Connections

连接类似于层；唯一的不同是，它在网络中将数据从一个节点转移到另一个节点。

在此章节，我们将学习：

Understanding Connections
Creating Connections

Understanding Connections

下面是一个在创建网络时使用连接的工作示例。

Example

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)

Output

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'>]

Creating Connections

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

Example

connect.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() 和 _backwardImplementation()。

_forwardImplementation() 在输入模块的输出缓冲器（即 inbuf）和输出模块的输入缓冲器（即 outbuf）中调用。inbuf 被添加到输出模块 outbuf。

_backwardImplementation() 在 outerr、inerr 和 inbuf 中调用。输出模块错误在 _backwardImplementation() 中添加到输入模块错误中。

现在让我们在网络中使用 YourConnection 。

testconnection.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from connect import YourConnection

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 = YourConnection(inputLayer, hiddenLayer)
hidden_to_output = YourConnection(hiddenLayer, outputLayer)

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

print(network)

Output

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

PyBrain - Reinforcement Learning Module

强化学习（RL）是机器学习中一个重要部分。强化学习根据来自环境的输入使智能体学习自己的行为。

强化过程中相互交互的组件如下：

Environment
Agent
Task
Experiment

强化学习的布局如下：

在 RL 中，智能体以迭代方式与环境对话。在每个迭代中，智能体接收具有奖励的观察结果。然后它选择动作并将其发送到环境中。环境在每次迭代中移动到新的状态，并且每次收到的奖励都会被保存。

RL 智能体的目标是尽可能多地收集奖励。在迭代之间，智能体的表现与表现优良的智能体进行比较，并且表现差异会引起奖励或失败。RL 主要用于问题解决任务，如机器人控制、电梯、电信、游戏等。

让我们看看如何在 Pybrain 中使用 RL。

我们将处理迷宫 environment ，它将使用 2 维 numpy 数组表示，其中 1 是墙壁，0 是自由场。智能体的责任是在自由场上移动并找到目标点。

以下是处理迷宫环境的分步流程。

Step 1

使用以下代码导入我们需要的包：

from scipy import *
import sys, time
import matplotlib.pyplot as pylab # for visualization we are using mathplotlib

from pybrain.rl.environments.mazes import Maze, MDPMazeTask
from pybrain.rl.learners.valuebased import ActionValueTable
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport
from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport
from pybrain.rl.experiments import Experiment
from pybrain.rl.environments import Task

Step 2

使用以下代码创建迷宫环境：

# create the maze with walls as 1 and 0 is a free field
mazearray = array(
   [[1, 1, 1, 1, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 0, 0, 0, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 1, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 0, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 1, 1]]
)
env = Maze(mazearray, (7, 7)) # create the environment, the first parameter is the
maze array and second one is the goal field tuple

Step 3

下一步是创建智能体。

智能体在 RL 中起着重要作用。它将使用 getAction() 和 integrateObservation() 方法与迷宫环境进行交互。

代理有一个控制器（负责将状态映射到动作）和一个学习器。

PyBrain 中的控制器像一个模块，输入的是状态，输出的是动作。

controller = ActionValueTable(81, 4)
controller.initialize(1.)

ActionValueTable 需要 2 个输入，即：状态和动作的数量。标准迷宫环境有 4 个动作：北、南、东、西。

现在我们要创建一个学习器。我们将使用 SARSA() 学习算法，让学习器与代理一起使用。

learner = SARSA()
agent = LearningAgent(controller, learner)

Step 4

这一步是将代理添加到环境中。

要将代理连接到环境中，我们需要一个特殊组件，称为任务。 task 的作用是在环境中寻找目标，以及代理如何通过动作获得奖励。

环境有它自己的任务。我们使用的迷宫环境有 MDPMazeTask 任务。MDP 指的是 “markov decision process” ，意思是代理知道自己在迷宫中的位置。环境将成为任务的参数。

task = MDPMazeTask(env)

Step 5

在将代理添加到环境中后，下一步是创建实验。

现在我们需要创建实验，以便任务和代理相互协调。

experiment = Experiment(task, agent)

现在我们将运行 1000 次实验，如下所示：

for i in range(1000):
   experiment.doInteractions(100)
   agent.learn()
   agent.reset()

当执行以下代码时，环境将在代理和任务之间运行 100 次：

experiment.doInteractions(100)

在每次迭代之后，它会将一个新状态返回给任务，由任务决定将哪些信息和奖励传递给代理。我们准备在 for 循环中学习并重新设置代理之后绘制一张新表格。

for i in range(1000):
   experiment.doInteractions(100)
   agent.learn()
   agent.reset()
   pylab.pcolor(table.params.reshape(81,4).max(1).reshape(9,9))
   pylab.savefig("test.png")

以下是完整代码：

Example

maze.py

from scipy import *
import sys, time
import matplotlib.pyplot as pylab

from pybrain.rl.environments.mazes import Maze, MDPMazeTask
from pybrain.rl.learners.valuebased import ActionValueTable
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport
from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport
from pybrain.rl.experiments import Experiment
from pybrain.rl.environments import Task

# create maze array
mazearray = array(
   [[1, 1, 1, 1, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 0, 0, 0, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 1, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 0, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 1, 1]]
)
env = Maze(mazearray, (7, 7))

# create task
task = MDPMazeTask(env)

#controller in PyBrain is like a module, for which the input is states and
convert them into actions.
controller = ActionValueTable(81, 4)
controller.initialize(1.)

# create agent with controller and learner - using SARSA()
learner = SARSA()

# create agent
agent = LearningAgent(controller, learner)

# create experiment
experiment = Experiment(task, agent)

# prepare plotting
pylab.gray()
pylab.ion()

for i in range(1000):
experiment.doInteractions(100)

agent.learn()
agent.reset()

pylab.pcolor(controller.params.reshape(81,4).max(1).reshape(9,9))
pylab.savefig("test.png")

Output

python maze.py

自由场的颜色在每次迭代时都会改变。

PyBrain - API & Tools

现在我们知道如何构建网络并训练它了。在本章中，我们将了解如何创建和保存网络，以及在需要时使用网络。

Save and Recover Network

我们将使用 Pybrain 工具中的 NetworkWriter 和 NetworkReader，即：pybrain.tools.customxml。

以下是一个实际示例：

from pybrain.tools.shortcuts import buildNetwork
from pybrain.tools.customxml import NetworkWriter
from pybrain.tools.customxml import NetworkReader

net = buildNetwork(2,1,1)
NetworkWriter.writeToFile(net, 'network.xml')
net = NetworkReader.readFrom('network.xml')

网络保存在 network.xml 中。

NetworkWriter.writeToFile(net, 'network.xml')

要读取所需的 xml，我们可以使用以下代码：

net = NetworkReader.readFrom('network.xml')

下面是创建的 network.xml 文件：

<?xml version="1.0" ?>
<PyBrain>
   <Network class="pybrain.structure.networks.feedforward.FeedForwardNetwork" name="FeedForwardNetwork-8">
      <name val="'FeedForwardNetwork-8'"/>
      <Modules>
         <LinearLayer class="pybrain.structure.modules.linearlayer.LinearLayer" inmodule="True" name="in">
            <name val="'in'"/>
            <dim val="2"/>
         </LinearLayer>

         <LinearLayer class="pybrain.structure.modules.linearlayer.LinearLayer" name="out" outmodule="True">
            <name val="'out'"/>
            <dim val="1"/>
         </LinearLayer>

         <BiasUnit class="pybrain.structure.modules.biasunit.BiasUnit" name="bias">
            <name val="'bias'"/>
         </BiasUnit>

         <SigmoidLayer class="pybrain.structure.modules.sigmoidlayer.SigmoidLayer" name="hidden0">
            <name val="'hidden0'"/>
            <dim val="1"/>
         </SigmoidLayer>
      </Modules>

      <Connections>
         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-6">
            <inmod val="bias"/>
            <outmod val="out"/>
            <Parameters>[1.2441093186965146]</Parameters>
         </FullConnection>

         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-7">
            <inmod val="bias"/>
            <outmod val="hidden0"/>
            <Parameters>[-1.5743530012126412]</Parameters>
         </FullConnection>

         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-4">
            <inmod val="in"/>
            <outmod val="hidden0"/>
            <Parameters>[-0.9429546042034236, -0.09858196752687162]</Parameters>
         </FullConnection>

         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-5">
            <inmod val="hidden0"/>
            <outmod val="out"/>
            <Parameters>[-0.29205472354634304]</Parameters>
         </FullConnection>
      </Connections>

   </Network>
</PyBrain>

API

以下是本教程中使用的 API 列表。

For Networks

activate(input) - 它采用参数，即要测试的值。它将根据给定的输入返回结果。
activateOnDataset(dataset) - 它将在给定的数据集上进行迭代并返回输出。
addConnection(c) - 添加连接到网络。
addInputModule(m) - 添加给定模块到网络并将其标记为输入模块。
addModule(m) - 添加给定模块到网络。
addOutputModule(m) - 添加模块到网络并将其标记为输出模块。
reset() - 重置模块和网络。
sortModules() - 通过在内部进行排序来准备网络以进行激活。必须在激活前调用它。

For Supervised Datasets

addSample(inp, target) - 添加新输入和目标样本。
splitWithProportion(proportion=0.5) - 将数据集分成两部分，第一部分包含比例部分数据，下一组包含其余部分。

For Trainers

trainUntilConvergence(dataset=None, maxEpochs=None, verbose=None, continueEpochs=10, validationProportion=0.25) - 用于在数据集上训练模块直到它收敛。如果没有给出数据集，它将尝试训练在开始时使用的已训练数据集。

PyBrain - Examples

在本章中，列出了使用 PyBrain 执行的所有可能的示例。

Example 1

使用 NOR 真值表并对其进行正确性测试。

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)

Output

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)

Example 2

对于数据集，我们将使用来自 sklearn 数据集的数据集，如下所示：请参阅 sklearn 的 load_digits 数据集： scikit-learn.org

它有 10 类，即从 0 到 9 要预测的数字。

输入数据的总量为 64。

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

# 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
test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

#Splitting the datasets 25% as testdata and 75% as trained data
# Using splitWithProportion() method on dataset converts the dataset to
#superviseddataset, so we will convert the dataset back to classificationdataset
#as shown in above step.
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
)
#creating a network wherein the input and output are used from the training data.
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01
)
#Training the Network
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)

#Visualizing the error and validation data
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']
))

Output

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