PyBrain 快速指南

上一页
下一页

PyBrain - 概述

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

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

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

PyBrain 是 Python-Based Reinforcement Learning, Artificial Intelligence, and Neural Network Library 的缩写。事实上，我们首先想出了这个名字，后来才反向设计了这个相当具有描述性的“首字母缩略词”。

Pybrain 的特性

以下是 Pybrain 的特性：

网络

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

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

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

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

数据集

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

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

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

训练器

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

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

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

工具

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

可视化

无法使用 pybrain 可视化测试数据。但 Pybrain 可以与其他框架（如 Mathplotlib、pyplot）一起工作以可视化数据。

Pybrain 的优势

Pybrain 的优势在于：

  • Pybrain 是一个学习机器学习的开源免费库。对于任何对机器学习感兴趣的新手来说，这是一个不错的起点。

  • Pybrain 使用 Python 来实现它，这使得它在开发方面比 Java/C++ 等语言快。

  • Pybrain 可以轻松地与其他 Python 库一起工作以可视化数据。

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

  • 使用 .csv 加载数据集在 Pybrain 中非常容易。它还允许使用来自其他库的数据集。

  • 使用 Pybrain 训练器进行数据训练和测试很容易。

Pybrain 的局限性

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

Pybrain 的工作流程

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

Workflow Of Pybrain

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

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

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

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

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

术语

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

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

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

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

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

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

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

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

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

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

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

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

PyBrain - 环境设置

在本章中，我们将介绍 PyBrain 的安装。要开始使用 PyBrain，我们需要首先安装 Python。因此，我们将执行以下操作：

  • 安装 Python
  • 安装 PyBrain

安装 Python

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

Installing Python

下载完成后，点击.exe文件，然后按照步骤在您的系统上安装 python。

Setup Progress

python 包管理器（即 pip）也将与上述安装一起默认安装。为了使其在您的系统上全局运行，请直接将 python 的位置添加到 PATH 变量中，在安装开始时会显示相同的内容，请记住选中“添加到 PATH”复选框。如果您忘记选中它，请按照以下步骤添加到 PATH。

添加到 PATH

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

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

  • 它将显示如下屏幕

System Properties

  • 单击上面显示的“环境变量”。它将显示如下屏幕

Environment Variables

选择 Path 并单击“编辑”按钮，将 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 开发的机器学习库。机器学习中有一些重要的概念，其中之一是网络。网络由模块组成，它们通过连接连接起来。

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

Simple Neural Network

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

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

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

Feed Forward Network

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

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

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

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

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

这是一个简单的循环网络布局：

Recurrent Networks

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 A XOR B
0 0 0
0 1 1
1 0 1
1 1 0

给定的输入类似于二维数组，我们得到 1 个输出。因此，这里的输入成为大小，目标是输出，即 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 的目标。

向数据集添加数据

现在让我们向数据集添加样本数据。

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() 方法，该方法接收输入和目标。

要向 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

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

以下是您如何在代码中使用它的示例：

from pybrain.datasets import SupervisedDataSet

SupervisedDataSet 上可用的方法如下：

addSample(inp, target)

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

splitWithProportion(proportion=0.10)

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

copy() - 返回数据集的深拷贝。

clear() - 清空数据集。

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

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

示例

这是一个使用 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)

输出

上述程序的输出如下：

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

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

输出

Classification DataSet. 
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.cn/stable/datasets/toy_dataset.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 File

以下是如何从 .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 - 在网络上训练数据集

到目前为止，我们已经了解了如何创建网络和数据集。要将数据集和网络一起使用，我们必须借助训练器来实现。

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

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 类的 Dataset。我们使用 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)

输出

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

现在让我们测试它。

输出

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 - 测试网络

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

我们将使用以下训练器：

BackpropTrainer

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

TrainUntilConvergence

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

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

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

测试我们的网络

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

  • 导入所需的 PyBrain 和其他包
  • 创建 ClassificationDataSet
  • 将数据集拆分为 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.cn/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() 方法会将数据集转换为 superviseddataset，因此我们将数据集转换回 classificationdataset，如上一步所示。

步骤 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 个 epoch。它将返回训练误差和验证误差，我们已将其绘制如下。蓝线表示训练误差，红线表示验证误差。

Training Data

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

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 都变得更好。

步骤 8

测试数据误差百分比

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

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

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 - 使用前馈网络

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

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

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

创建前馈网络

您可以使用您选择的 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:
[]

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

添加模块和连接

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

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 类，如下所示：

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:
[]

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

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

添加模块和连接

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

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

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]

使用优化算法训练网络

我们已经了解了如何在 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]))

输出

网络对输入的 activate 方法的结果与输出几乎匹配，如下所示：

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

PyBrain - 层

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

在本章中，我们将详细了解以下关于层的内容：

  • 理解层
  • 使用 Pybrain 创建层

理解层

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

  • TanhLayer
  • SoftmaxLayer

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

输出

上述代码的输出如下：

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)

使用 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

要创建层，我们需要实现两个方法：_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

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

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”。

输出

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 中，我们可以使用 connection 模块创建连接，如下所示：

示例

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

要创建连接，有两种方法：_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)

输出

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 - 强化学习模块

强化学习 (RL) 是机器学习中的一个重要部分。强化学习使智能体能够根据环境的输入学习其行为。

在强化学习过程中相互作用的组件如下：

  • 环境
  • 智能体
  • 任务
  • 实验

强化学习的布局如下所示：

Reinforcement Learning Module

在 RL 中，智能体与环境进行迭代交互。在每次迭代中，智能体都会收到一个包含奖励的观察结果。然后它选择动作并发送到环境中。环境在每次迭代中都会转移到一个新的状态，并且每次收到的奖励都会被保存。

RL 智能体的目标是收集尽可能多的奖励。在迭代之间，智能体的性能会与以良好方式执行动作的智能体的性能进行比较，并且性能差异会导致奖励或失败。RL 主要用于解决机器人控制、电梯、电信、游戏等问题。

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

我们将使用迷宫 **环境**，该环境将使用二维 numpy 数组表示，其中 1 是墙壁，0 是空闲区域。智能体的职责是在空闲区域移动并找到目标点。

以下是使用迷宫环境的分步流程。

步骤 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

步骤 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

步骤 3

下一步是创建智能体。

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

智能体有一个控制器（将状态映射到动作）和一个学习器。

PyBrain 中的控制器就像一个模块，其输入是状态，并将它们转换为动作。

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

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

现在我们将创建一个学习器。我们将使用 SARSA() 学习算法作为学习器，以便与智能体一起使用。

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

步骤 4

此步骤是将智能体添加到环境中。

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

环境有自己的任务。我们使用的迷宫环境具有 MDPMazeTask 任务。MDP 代表 **“马尔可夫决策过程”**，这意味着智能体知道自己在迷宫中的位置。环境将作为任务的参数。

task = MDPMazeTask(env)

步骤 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")

以下是完整代码：

示例

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

输出

python maze.py

Python Maze

空闲区域的颜色将在每次迭代时更改。

PyBrain - API 和工具

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

保存和恢复网络

我们将使用 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 列表。

对于网络

  • **activate(input)** - 它接受参数，即要测试的值。它将根据给定的输入返回结果。

  • **activateOnDataset(dataset)** - 它将遍历给定的数据集并返回输出。

  • **addConnection(c)** - 将连接添加到网络。

  • **addInputModule(m)** - 将给定的模块添加到网络并将其标记为输入模块。

  • **addModule(m)** - 将给定的模块添加到网络。

  • **addOutputModule(m)** - 将模块添加到网络并将其标记为输出模块。

  • **reset()** - 重置模块和网络。

  • **sortModules()** - 它通过内部排序来准备网络进行激活。必须在激活之前调用它。

对于监督数据集

  • **addSample(inp, target)** - 添加输入和目标的新样本。

  • **splitWithProportion(proportion=0.5)** - 将数据集分成两部分，第一部分包含比例部分数据，下一部分包含其余数据。

对于训练器

**trainUntilConvergence(dataset=None, maxEpochs=None, verbose=None, continueEpochs=10, validationProportion=0.25)** - 用于在模块收敛之前对其进行训练。如果未给出数据集，它将尝试训练在开始时使用的训练数据集。

PyBrain - 示例

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

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

输出

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)

示例 2

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

它有 10 个类别，即需要预测的数字 0-9。

X 中的总输入数据为 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']
))

输出

Datasets From 
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
打印页面
上一页
下一页
广告