PyBrain - Guia rápido

Pybrain é uma biblioteca de código aberto para aprendizado de máquina implementada usando python. A biblioteca oferece alguns algoritmos de treinamento fáceis de usar para redes, conjuntos de dados, treinadores para treinar e testar a rede.

A definição de Pybrain conforme apresentada em sua documentação oficial é a seguinte -

PyBrain é uma biblioteca modular de aprendizado de máquina para Python. Seu objetivo é oferecer algoritmos flexíveis, fáceis de usar, mas ainda assim poderosos, para tarefas de aprendizado de máquina e uma variedade de ambientes predefinidos para testar e comparar seus algoritmos.

PyBrain é a abreviação de Python-Based Reinforcement Learning, Artificial Intelligence, and Neural Network Library. Na verdade, nós inventamos o nome primeiro e depois fizemos a engenharia reversa deste "Backronym" bastante descritivo.

Características do Pybrain

A seguir estão as características do Pybrain -

Redes

Uma rede é composta por módulos e eles são conectados por meio de conexões. Pybrain suporta redes neurais como Rede Feed-Forward, Rede Recorrente, etc.

feed-forward networké uma rede neural, onde as informações entre os nós se movem na direção para frente e nunca viajarão para trás. A rede Feed Forward é a primeira e a mais simples entre as redes disponíveis na rede neural artificial.

A informação é passada dos nós de entrada, próximos aos nós ocultos e depois ao nó de saída.

Recurrent Networkssão semelhantes à Rede Feed Forward; a única diferença é que ele precisa lembrar os dados em cada etapa. O histórico de cada etapa deve ser salvo.

Conjuntos de dados

Conjuntos de dados são os dados a serem fornecidos para testar, validar e treinar em redes. O tipo de conjunto de dados a ser usado depende das tarefas que faremos com o aprendizado de máquina. Os conjuntos de dados mais comumente usados ​​que o Pybrain suporta sãoSupervisedDataSet e ClassificationDataSet.

SupervisedDataSet - Consiste em campos de input e target. É a forma mais simples de um conjunto de dados e usado principalmente para tarefas de aprendizagem supervisionada.

ClassificationDataSet- É usado principalmente para lidar com problemas de classificação. Leva eminput, targetcampo e também um campo extra chamado "classe" que é um backup automatizado dos alvos fornecidos. Por exemplo, a saída será 1 ou 0 ou a saída será agrupada com os valores baseados na entrada fornecida, ou seja, ou cairá em uma classe particular.

Treinador

Quando criamos uma rede, ou seja, uma rede neural, ela será treinada com base nos dados de treinamento fornecidos a ela. Agora, se a rede é treinada adequadamente ou não, dependerá da previsão dos dados de teste testados nessa rede. O conceito mais importante no Pybrain Training é o uso de BackpropTrainer e TrainUntilConvergence.

BackpropTrainer - É um treinador que treina os parâmetros de um módulo de acordo com um conjunto de dados supervisionado ou ClassificationDataSet (potencialmente sequencial) por retropropagação dos erros (ao longo do tempo).

TrainUntilConvergence −É usado para treinar o módulo no conjunto de dados até que ele converta.

Ferramentas

Pybrain oferece módulos de ferramentas que podem ajudar a construir uma rede importando o pacote: pybrain.tools.shortcuts.buildNetwork

Visualização

Os dados do teste não podem ser visualizados usando o pybrain. Mas Pybrain pode trabalhar com outros frameworks como Mathplotlib, pyplot para visualizar os dados.

Vantagens do Pybrain

As vantagens do Pybrain são -

• Pybrain é uma biblioteca gratuita de código aberto para aprender Aprendizado de Máquina. É um bom começo para qualquer iniciante interessado em aprendizado de máquina.

• Pybrain usa python para implementá-lo e isso o torna mais rápido no desenvolvimento em comparação com linguagens como Java / C ++.

• Pybrain funciona facilmente com outras bibliotecas de python para visualizar dados.

• Pybrain oferece suporte para redes populares como Rede Feed-Forward, Redes Recorrentes, Redes Neurais, etc.

• Trabalhar com .csv para carregar conjuntos de dados é muito fácil no Pybrain. Também permite o uso de conjuntos de dados de outra biblioteca.

• O treinamento e o teste de dados são fáceis com os treinadores Pybrain.

Limitações do Pybrain

Pybrain oferece menos ajuda para quaisquer problemas enfrentados. Existem algumas questões sem resposta emstackoverflow e em Google Group.

Fluxo de Trabalho de Pybrain

De acordo com a documentação do Pybrain, o fluxo do aprendizado de máquina é mostrado na figura a seguir -

No início, temos dados brutos que, após o pré-processamento, podem ser usados ​​com o Pybrain.

O fluxo do Pybrain começa com conjuntos de dados que são divididos em dados treinados e de teste.

• a rede é criada e o conjunto de dados e a rede são fornecidos ao treinador.

• o treinador treina os dados na rede e classifica as saídas como erro treinado e erro de validação que podem ser visualizados.

• os dados testados podem ser validados para ver se a saída corresponde aos dados treinados.

Terminologia

Existem termos importantes a serem considerados ao trabalhar com o Pybrain para aprendizado de máquina. Eles são os seguintes -

Total Error- Refere-se ao erro mostrado após o treinamento da rede. Se o erro continuar mudando a cada iteração, isso significa que ainda precisa de tempo para se resolver, até que comece a mostrar um erro constante entre as iterações. Assim que começar a mostrar os números de erros constantes, significa que a rede convergiu e permanecerá a mesma independentemente de qualquer treinamento adicional ser aplicado.

Trained data - São os dados usados ​​para treinar a rede Pybrain.

Testing data - São os dados usados ​​para testar a rede Pybrain treinada.

Trainer- Quando criamos uma rede, ou seja, uma rede neural, ela será treinada com base nos dados de treinamento que lhe foram fornecidos. Agora, se a rede é treinada adequadamente ou não, dependerá da previsão dos dados de teste testados nessa rede. O conceito mais importante no Pybrain Training é o uso de BackpropTrainer e TrainUntilConvergence.

BackpropTrainer - É um treinador que treina os parâmetros de um módulo de acordo com um conjunto de dados supervisionado ou ClassificationDataSet (potencialmente sequencial) por retropropagação dos erros (ao longo do tempo).

TrainUntilConvergence - É usado para treinar o módulo no conjunto de dados até que converta.

Layers - Camadas são basicamente um conjunto de funções usadas em camadas ocultas de uma rede.

Connections- Uma conexão funciona como uma camada; uma única diferença é que ele transfere os dados de um nó para outro em uma rede.

Modules - Módulos são redes que consistem em buffer de entrada e saída.

Supervised Learning- Nesse caso, temos uma entrada e uma saída, e podemos fazer uso de um algoritmo para mapear a entrada com a saída. O algoritmo é feito para aprender sobre os dados de treinamento fornecidos e iterados nele e o processo de iteração para quando o algoritmo prevê os dados corretos.

Unsupervised- Neste caso, temos entrada, mas não sabemos a saída. O papel do aprendizado não supervisionado é ser treinado tanto quanto possível com os dados fornecidos.

Neste capítulo, trabalharemos na instalação do PyBrain. Para começar a trabalhar com o PyBrain, precisamos primeiro instalar o Python. Então, vamos trabalhar para seguir -

• Instale Python
• Instale o PyBrain

Instalando Python

Para instalar o Python, acesse o site oficial do Python: www.python.org/downloads conforme mostrado abaixo e clique na versão mais recente disponível para Windows, Linux / Unix e macOS. Baixe Python de acordo com seu sistema operacional de 64 ou 32 bits disponível com você.

Depois de fazer o download, clique no .exe arquivo e siga as etapas para instalar o python em seu sistema.

O gerenciador de pacotes python, ou seja, pip também será instalado por padrão com a instalação acima. Para fazer funcionar globalmente em seu sistema, adicione diretamente a localização do python à variável PATH, o mesmo é mostrado no início da instalação para lembrar de marcar a caixa de seleção que diz ADD to PATH. Caso você se esqueça de verificar, siga os passos abaixo indicados para adicionar ao PATH.

Adicionar ao PATH

Para adicionar ao PATH, siga as etapas abaixo -

• Clique com o botão direito no ícone do seu computador e clique em propriedades -> Configurações avançadas do sistema.

• Ele exibirá a tela conforme mostrado abaixo

• Clique em Variáveis ​​de ambiente como mostrado acima. Ele exibirá a tela conforme mostrado abaixo

Selecione o caminho e clique no botão Editar, adicione o caminho da localização do seu python no final. Agora vamos verificar a versão do python.

Verificando a versão do Python

O código a seguir nos ajuda a verificar a versão do Python -

E:\pybrain>python --version
Python 3.7.3

Instalando PyBrain

Agora que instalamos o Python, vamos instalar o Pybrain. Clone o repositório pybrain conforme mostrado abaixo -

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.

Agora execute cd pybrain e execute o seguinte comando -

python setup.py install

Este comando irá instalar o pybrain em seu sistema.

Uma vez feito isso, para verificar se o pybrain está instalado ou não, abra o prompt da linha de comando e inicie o interpretador Python conforme mostrado abaixo -

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

Podemos adicionar pybrain de importação usando o código abaixo -

>>> import pybrain
>>>

Se o pybrain de importação funcionar sem erros, significa que o pybrain foi instalado com sucesso. Agora você pode escrever seu código para começar a trabalhar com o pybrain.

PyBrain é uma biblioteca desenvolvida para aprendizado de máquina com Python. Existem alguns conceitos importantes em Aprendizado de Máquina e um deles é Redes. Uma rede é composta por módulos e eles são conectados por meio de conexões.

O layout de uma rede neural simples é o seguinte -

Pybrain oferece suporte a redes neurais, como Rede Feed-Forward, Rede Recorrente, etc.

UMA feed-forward networké uma rede neural, onde as informações entre os nós se movem na direção para frente e nunca viajarão para trás. A rede Feed Forward é a primeira e a mais simples entre as redes disponíveis na rede neural artificial. A informação é passada dos nós de entrada, próximos aos nós ocultos e depois ao nó de saída.

Aqui está um layout de rede de feed forward simples.

Os círculos são chamados de módulos e as linhas com setas são conexões com os módulos.

Os nós A, B, C e D são nós de entrada

H1, H2, H3, H4 são nós ocultos e O é a saída.

Na rede acima, temos 4 nós de entrada, 4 camadas ocultas e 1 saída. O número de linhas mostrado no diagrama indica os parâmetros de peso no modelo que são ajustados durante o treinamento.

Recurrent Networkssão semelhantes à Rede Feed Forward, com a única diferença de que ela deve lembrar os dados em cada etapa. O histórico de cada etapa deve ser salvo.

Aqui está um layout simples de rede recorrente -

Uma rede é composta por módulos e eles são conectados por meio de conexões. Neste capítulo, aprenderemos a -

• Criar Rede
• Analisar rede

Criando Rede

Vamos usar o interpretador python para executar nosso código. Para criar uma rede no pybrain, temos que usarbuildNetwork api como mostrado abaixo -

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

Criamos uma rede usando buildNetwork () e os parâmetros são 2, 3, 1, o que significa que a rede é composta por 2 entradas, 3 ocultas e uma única saída.

Abaixo estão os detalhes da rede, ou seja, Módulos e Conexões -

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

Os módulos consistem em camadas e as conexões são feitas a partir de objetos FullConnection. Portanto, cada um dos módulos e conexão são nomeados conforme mostrado acima.

Analisando rede

Você pode acessar as camadas do módulo e a conexão individualmente, referindo-se a seus nomes da seguinte forma -

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

Conjuntos de dados são dados de entrada a serem fornecidos para testar, validar e treinar redes. O tipo de conjunto de dados a ser usado depende das tarefas que faremos com o aprendizado de máquina. Neste capítulo, vamos dar uma olhada no seguinte -

• Criando conjunto de dados
• Adicionando dados ao conjunto de dados

Vamos primeiro aprender como criar um conjunto de dados e testar o conjunto de dados com a entrada fornecida.

Criando conjunto de dados

Para criar um conjunto de dados, precisamos usar o pacote de conjunto de dados pybrain: pybrain.datasets.

Pybrain suporta classes de conjuntos de dados como SupervisedDataset, SequentialDataset, ClassificationDataSet. Vamos fazer uso deSupervisedDataset , para criar nosso conjunto de dados. O conjunto de dados a ser usado depende da tarefa de aprendizado de máquina que o usuário está tentando implementar. O conjunto de dados supervisionado é o mais simples e vamos usar o mesmo aqui.

UMA SupervisedDataset datasetprecisa de entrada e destino de parâmetros. Considere uma tabela de verdade XOR, conforme mostrado abaixo -

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

As entradas fornecidas são como uma matriz bidimensional e obtemos 1 saída. Portanto, aqui a entrada torna-se o tamanho e o destino é a saída, que é 1. Portanto, as entradas que irão para nosso conjunto de dados serão 2,1.

createdataset.py

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

Isso é o que obtemos quando executamos o código acima python createdataset.py -

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

Ele exibe a entrada de tamanho 2 e o destino de tamanho 1 conforme mostrado acima.

Adicionando dados ao conjunto de dados

Vamos agora adicionar os dados de amostra ao conjunto de dados.

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

Criamos uma matriz XORModel conforme mostrado abaixo -

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

Para adicionar dados ao conjunto de dados, estamos usando o método addSample () que recebe a entrada e o destino.

Para adicionar dados ao addSample, faremos um loop pela matriz xorModel conforme mostrado abaixo -

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

Após a execução, o seguinte é a saída que obtemos -

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

Você pode obter os detalhes de entrada e destino do conjunto de dados criado simplesmente usando o índice de entrada e destino conforme mostrado abaixo -

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

Conjuntos de dados são dados a serem fornecidos para testar, validar e treinar em redes. O tipo de conjunto de dados a ser usado depende das tarefas que faremos com o aprendizado de máquina. Discutiremos os vários tipos de conjuntos de dados neste capítulo.

Podemos trabalhar com o conjunto de dados adicionando o seguinte pacote -

pybrain.dataset

SupervisedDataSet

SupervisedDataSet consiste em campos de input e target. É a forma mais simples de um conjunto de dados e usado principalmente para tarefas de aprendizagem supervisionada.

Abaixo está como você pode usá-lo no código -

from pybrain.datasets import SupervisedDataSet

Os métodos disponíveis em SupervisedDataSet são os seguintes -

addSample (inp, target)

Este método adicionará uma nova amostra de entrada e destino.

splitWithProportion (proporção = 0,10)

Isso dividirá os conjuntos de dados em duas partes. A primeira parte terá a% do conjunto de dados fornecida como entrada, ou seja, se a entrada for 0,10, então será 10% do conjunto de dados e 90% dos dados. Você pode decidir a proporção de acordo com sua escolha. Os conjuntos de dados divididos podem ser usados ​​para testar e treinar sua rede.

copy() - Retorna uma cópia profunda do conjunto de dados.

clear() - Limpe o conjunto de dados.

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

Salve o objeto em um arquivo fornecido por filename.

Exemplo

Aqui está um exemplo de trabalho usando um 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)

Resultado

A saída para o programa acima é a seguinte -

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

Este conjunto de dados é usado principalmente para lidar com problemas de classificação. Ele recebe a entrada, o campo de destino e também um campo extra chamado "classe" que é um backup automático dos destinos fornecidos. Por exemplo, a saída será 1 ou 0 ou a saída será agrupada com os valores baseados na entrada fornecida, ou seja, ela cairá em uma classe particular.

Aqui está como você pode usá-lo no código -

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

Os métodos disponíveis em ClassificationDataSet são os seguintes -

addSample(inp, target) - Este método adicionará uma nova amostra de entrada e destino.

splitByClass() - Este método dará dois novos conjuntos de dados, o primeiro conjunto de dados terá a classe selecionada (0..nClasses-1), o segundo terá amostras restantes.

_convertToOneOfMany() - Este método irá converter as classes de destino em uma representação 1-de-k, mantendo os antigos destinos como uma classe de campo

Aqui está um exemplo prático de ClassificationDataSet.

Exemplo

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

O conjunto de dados usado no exemplo acima é um conjunto de dados de dígitos e as classes vão de 0 a 9, portanto, há 10 classes. A entrada é 64, o destino é 1 e as classes, 10.

O código treina a rede com o conjunto de dados e gera o gráfico para erro de treinamento e erro de validação. Ele também fornece a porcentagem de erro em dados de teste, que é a seguinte -

Resultado

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

Neste capítulo, aprenderemos como fazer com que os dados funcionem com os conjuntos de dados Pybrain.

Os mais comumente usados ​​são os conjuntos de dados -

• Usando sklearn
• Do arquivo CSV

Usando sklearn

Usando sklearn

Aqui está o link que contém detalhes dos conjuntos de dados do sklearn:https://scikit-learn.org/stable/datasets/index.html

Aqui estão alguns exemplos de como usar conjuntos de dados do sklearn -

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

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

Do arquivo CSV

Também podemos usar os dados do arquivo csv da seguinte maneira -

Aqui estão dados de amostra para a tabela verdade xor: datasettest.csv

Aqui está o exemplo de trabalho para ler os dados do arquivo .csv para o conjunto de dados.

Exemplo

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)

O Panda é usado para ler dados do arquivo csv conforme mostrado no exemplo.

Resultado

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)

Até agora, vimos como criar uma rede e um conjunto de dados. Para trabalhar com conjuntos de dados e redes juntos, temos que fazer isso com a ajuda de treinadores.

Abaixo está um exemplo prático para ver como adicionar um conjunto de dados à rede criada e posteriormente treinada e testada com treinadores.

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)

Para testar a rede e o conjunto de dados, precisamos do BackpropTrainer. BackpropTrainer é um treinador que treina os parâmetros de um módulo de acordo com um conjunto de dados supervisionado (potencialmente sequencial) por retropropagação dos erros (ao longo do tempo).

Criamos 2 conjuntos de dados da classe - SupervisedDataSet. Estamos fazendo uso do modelo de dados NOR, que é o seguinte -

UMA	B	A NOR B
0	0	1
0	1	0
1	0	0
1	1	0

O modelo de dados acima é usado para treinar a rede.

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

A seguir está o conjunto de dados usado para testar -

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

O treinador é usado da seguinte forma -

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

Para testar o conjunto de dados, podemos usar o código abaixo -

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

Resultado

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)

Se você verificar a saída, os dados de teste quase correspondem ao conjunto de dados que fornecemos e, portanto, o erro é 0,008.

Vamos agora alterar os dados de teste e ver um erro médio. Alteramos a saída conforme mostrado abaixo -

A seguir está o conjunto de dados usado para testar -

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

Vamos agora testá-lo.

Resultado

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)

Estamos obtendo o erro de 0,36, o que mostra que nossos dados de teste não correspondem totalmente à rede treinada.

Neste capítulo, veremos alguns exemplos em que vamos treinar os dados e testar os erros nos dados treinados.

Vamos fazer uso de treinadores -

BackpropTrainer

BackpropTrainer é um treinador que treina os parâmetros de um módulo de acordo com um conjunto de dados supervisionado ou ClassificationDataSet (potencialmente sequencial) por retropropagação dos erros (através do tempo).

TrainUntilConvergence

Ele é usado para treinar o módulo no conjunto de dados até que ele converta.

Quando criamos uma rede neural, ela será treinada com base nos dados de treinamento fornecidos a ela. Agora, se a rede é treinada corretamente ou não, dependerá da previsão dos dados de teste testados nessa rede.

Vejamos um exemplo de trabalho passo a passo onde construiremos uma rede neural e preveremos os erros de treinamento, erros de teste e erros de validação.

Testando nossa rede

A seguir estão as etapas que seguiremos para testar nossa rede -

• Importando PyBrain e outros pacotes necessários
• Criar ClassificationDataSet
• Dividir os conjuntos de dados em 25% como dados de teste e 75% como dados treinados
• Convertendo Testdata e dados treinados de volta como ClassificationDataSet
• Criação de uma rede neural
• Treinando a Rede
• Visualizando os dados de erro e validação
• Porcentagem de erro de dados de teste

Step 1

Importando PyBrain e outros pacotes necessários.

Os pacotes de que precisamos são importados conforme mostrado abaixo -

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

A próxima etapa é criar ClassificationDataSet.

Para conjuntos de dados, vamos usar conjuntos de dados sklearn como mostrado abaixo -

Consulte conjuntos de dados load_digits de sklearn no link abaixo -

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

Dividindo os conjuntos de dados 25% como dados de teste e 75% como dados treinados -

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

Então, aqui, usamos um método no conjunto de dados chamado splitWithProportion () com valor 0,25, ele dividirá o conjunto de dados em 25% como dados de teste e 75% como dados de treinamento.

Step 4

Convertendo Testdata e dados treinados de volta como 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()

Usar o método splitWithProportion () no conjunto de dados converte o conjunto de dados em conjunto de dados supervisionado, portanto, converteremos o conjunto de dados de volta em conjunto de dados de classificação, conforme mostrado na etapa acima.

Step 5

A próxima etapa é criar uma rede neural.

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

Estamos criando uma rede em que a entrada e a saída são usadas a partir dos dados de treinamento.

Step 6

Treinando a Rede

Agora, a parte importante é treinar a rede no conjunto de dados, conforme mostrado abaixo -

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

Estamos usando o método BackpropTrainer () e usando dataset na rede criada.

Step 7

A próxima etapa é visualizar o erro e validação dos dados.

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

Usaremos um método chamado trainUntilConvergence nos dados de treinamento que convergirão para épocas de 10. Ele retornará o erro de treinamento e o erro de validação que plotamos como mostrado abaixo. A linha azul mostra os erros de treinamento e a linha vermelha mostra o erro de validação.

O erro total recebido durante a execução do código acima é mostrado abaixo -

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

O erro começa em 0,04 e depois diminui para cada época, o que significa que a rede está sendo treinada e fica melhor a cada época.

Step 8

Porcentagem de erro de dados de teste

Podemos verificar a porcentagem de erro usando o método percentError conforme mostrado abaixo -

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

Percent Error on testData - 3,34075723830735

Estamos obtendo a porcentagem de erro, ou seja, 3,34%, o que significa que a rede neural tem 97% de precisão.

Abaixo está o código completo -

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

Uma rede feed-forward é uma rede neural, onde as informações entre os nós se movem na direção para frente e nunca viajam para trás. A rede Feed Forward é a primeira e a mais simples entre as redes disponíveis na rede neural artificial. A informação é passada dos nós de entrada, próximos aos nós ocultos e depois ao nó de saída.

Neste capítulo, vamos discutir como -

• Criar redes feed-forward
• Adicionar conexão e módulos ao FFN

Criação de uma rede feed Forward

Você pode usar o IDE python de sua escolha, ou seja, PyCharm. Neste, estamos usando o Visual Studio Code para escrever o código e executaremos o mesmo no terminal.

Para criar uma rede feedforward, precisamos importá-la de pybrain.structure como mostrado abaixo -

ffn.py

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

Execute ffn.py conforme mostrado abaixo -

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

Não adicionamos módulos e conexões à rede feedforward. Portanto, a rede mostra arrays vazios para Módulos e Conexões.

Adicionando Módulos e Conexões

Primeiro, criaremos camadas de entrada, ocultas e de saída e as adicionaremos aos módulos, conforme mostrado abaixo -

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)

Resultado

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

Ainda estamos obtendo os módulos e conexões como vazios. Precisamos fornecer uma conexão para os módulos criados conforme mostrado abaixo -

Aqui está o código onde criamos uma conexão entre as camadas de entrada, ocultas e de saída e adicionamos a conexão à rede.

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)

Resultado

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

Ainda não conseguimos obter os módulos e as conexões. Vamos agora adicionar a etapa final, ou seja, precisamos adicionar o método sortModules () como mostrado abaixo -

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)

Resultado

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

Agora podemos ver os módulos e os detalhes das conexões para feedforwardnetwork.

Redes recorrentes são iguais a redes feed-forward, com a única diferença de que você precisa se lembrar dos dados em cada etapa. O histórico de cada etapa deve ser salvo.

Vamos aprender como -

• Crie uma rede recorrente
• Adicionando Módulos e Conexão

Criação de uma rede recorrente

Para criar uma rede recorrente, usaremos a classe RecurrentNetwork conforme mostrado abaixo -

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

Podemos ver uma nova conexão chamada Conexões recorrentes para a rede recorrente. No momento, não há dados disponíveis.

Vamos agora criar as camadas e adicionar aos módulos e criar conexões.

Adicionando Módulos e Conexão

Vamos criar camadas, ou seja, entrada, oculta e saída. As camadas serão adicionadas ao módulo de entrada e saída. A seguir, criaremos a conexão de entrada para oculto, oculto para saída e uma conexão recorrente entre oculto para oculto.

Aqui está o código para a rede recorrente com módulos e conexões.

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

Na saída acima, podemos ver os Módulos, Conexões e Conexões Recorrentes.

Vamos agora ativar a rede usando o método de ativação conforme mostrado abaixo -

rn.py

Adicione o código abaixo ao criado anteriormente -

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

Vimos como treinar uma rede usando treinadores em pybrain. Neste capítulo, usaremos algoritmos de otimização disponíveis com Pybrain para treinar uma rede.

No exemplo, usaremos o algoritmo de otimização GA que precisa ser importado conforme mostrado abaixo -

from pybrain.optimization.populationbased.ga import GA

Exemplo

Abaixo está um exemplo funcional de uma rede de treinamento usando um algoritmo de otimização 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]))

Resultado

O método de ativação na rede para as entradas quase corresponde à saída, conforme mostrado abaixo -

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

Camadas são basicamente um conjunto de funções usadas em camadas ocultas de uma rede.

Percorreremos os seguintes detalhes sobre camadas neste capítulo -

• Camada de compreensão
• Criando Camada usando Pybrain

Camadas de compreensão

Vimos exemplos anteriores em que usamos camadas como segue -

• TanhLayer
• SoftmaxLayer

Exemplo usando TanhLayer

Abaixo está um exemplo onde usamos TanhLayer para construir uma rede -

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)

Resultado

A saída para o código acima é a seguinte -

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)

Exemplo usando SoftMaxLayer

Abaixo está um exemplo onde usamos SoftmaxLayer para construir uma rede -

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)

Resultado

O resultado é o seguinte -

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)

Criando Camada no Pybrain

No Pybrain, você pode criar sua própria camada da seguinte maneira -

Para criar uma camada, você precisa usar NeuronLayer class como a classe base para criar todos os tipos de camadas.

Exemplo

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

Para criar uma camada, precisamos implementar dois métodos: _forwardImplementation () e _backwardImplementation () .

The _forwardImplementation() takes in 2 arguments inbufe outbuf, que são matrizes Scipy. Seu tamanho depende das dimensões de entrada e saída das camadas.

O _backwardImplementation () é usado para calcular a derivada da saída em relação à entrada fornecida.

Então, para implementar uma camada no Pybrain, este é o esqueleto da classe de camada -

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

Caso você queira implementar uma função polinomial quadrática como uma camada, podemos fazer da seguinte maneira -

Considere que temos uma função polinomial como -

f(x) = 3x2

A derivada da função polinomial acima será a seguinte -

f(x) = 6 x

A classe da camada final para a função polinomial acima será a seguinte -

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

Agora vamos usar a camada criada conforme mostrado abaixo -

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 () testará se a camada está funcionando bem ou não. Precisamos passar a rede onde a camada é usada para o gradientCheck (n). Ele dará a saída como “Gradiente Perfeito” se a camada estiver funcionando bem.

Resultado

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

Uma conexão funciona de forma semelhante a uma camada; uma única diferença é que ele transfere os dados de um nó para outro em uma rede.

Neste capítulo, vamos aprender sobre -

• Entendendo as conexões
• Criação de conexões

Entendendo as conexões

Aqui está um exemplo prático de conexões usadas durante a criação de uma rede.

Exemplo

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)

Resultado

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

Criação de conexões

No Pybrain, podemos criar conexões usando o módulo de conexão como mostrado abaixo -

Exemplo

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

Para criar uma conexão, existem 2 métodos - _forwardImplementation () e _backwardImplementation () .

O _forwardImplementation () é chamado com o buffer de saída do módulo de entrada que está inbuf , e o buffer de entrada do módulo de saída chamado outbuf . O inbuf é adicionado ao módulo de saída outbuf .

O _backwardImplementation () é chamado com outerr , inerr e inbuf . O erro do módulo de saída é adicionado ao erro do módulo de entrada em _backwardImplementation () .

Vamos agora usar o YourConnection em uma rede.

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)

Resultado

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

Aprendizado por Reforço (RL) é uma parte importante do Aprendizado de Máquina. O aprendizado por reforço faz com que o agente aprenda seu comportamento com base nas informações do ambiente.

Os componentes que interagem uns com os outros durante o reforço são os seguintes -

• Environment
• Agent
• Task
• Experiment

O layout do Aprendizado por Reforço é fornecido abaixo -

Na RL, o agente conversa com o ambiente em iteração. A cada iteração, o agente recebe uma observação que tem a recompensa. Em seguida, ele escolhe a ação e envia para o ambiente. O ambiente em cada iteração muda para um novo estado e a recompensa recebida cada vez é salva.

O objetivo do agente RL é coletar o máximo de recompensas possível. No intervalo entre as iterações, o desempenho do agente é comparado com o do agente que age de maneira positiva e a diferença no desempenho dá origem à recompensa ou ao fracasso. RL é basicamente usado na resolução de problemas de tarefas como controle de robô, elevador, telecomunicações, jogos, etc.

Vamos dar uma olhada em como trabalhar com RL em Pybrain.

Vamos trabalhar no labirinto environmentque será representado usando matriz numpy 2 dimensional, onde 1 é uma parede e 0 é um campo livre. A responsabilidade do agente é mover-se sobre o campo livre e encontrar o ponto de gol.

Aqui está um fluxo passo a passo do trabalho com o ambiente de labirinto.

Passo 1

Importe os pacotes de que precisamos com o código abaixo -

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

Passo 2

Crie o ambiente de labirinto usando o código abaixo -

# 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

etapa 3

A próxima etapa é criar o Agente.

O agente desempenha um papel importante na RL. Ele irá interagir com o ambiente de labirinto usando os métodos getAction () e integrateObservation ().

O agente tem um controlador (que mapeará os estados para ações) e um aluno.

O controlador no PyBrain é como um módulo, para o qual a entrada é estados e os converte em ações.

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

o ActionValueTableprecisa de 2 entradas, ou seja, o número de estados e ações. O ambiente de labirinto padrão tem 4 ações: norte, sul, leste, oeste.

Agora vamos criar um aluno. Vamos usar o algoritmo de aprendizagem SARSA () para o aluno a ser usado com o agente.

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

Passo 4

Esta etapa é adicionar agente ao ambiente.

Para conectar o agente ao ambiente, precisamos de um componente especial chamado tarefa. O papel de umtask é procurar a meta no ambiente e como o agente obtém recompensas pelas ações.

O meio ambiente tem sua própria tarefa. O ambiente Maze que usamos tem a tarefa MDPMazeTask. MDP significa“markov decision process”o que significa que o agente conhece sua posição no labirinto. O ambiente será um parâmetro para a tarefa.

task = MDPMazeTask(env)

Etapa 5

A próxima etapa após adicionar o agente ao ambiente é criar um Experimento.

Agora precisamos criar o experimento, para que possamos ter a tarefa e o agente coordenados um com o outro.

experiment = Experiment(task, agent)

Agora vamos executar a experiência 1000 vezes, conforme mostrado abaixo -

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

O ambiente será executado 100 vezes entre o agente e a tarefa quando o seguinte código for executado -

experiment.doInteractions(100)

Após cada iteração, ele retorna um novo estado para a tarefa que decide quais informações e recompensas devem ser passadas para o agente. Vamos plotar uma nova tabela depois de aprender e redefinir o agente dentro do loop 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")

Aqui está o código completo -

Exemplo

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

Resultado

python maze.py

A cor no campo livre será alterada a cada iteração.

Agora sabemos como construir uma rede e treiná-la. Neste capítulo, entenderemos como criar e salvar a rede e como usar a rede sempre que necessário.

Salvar e recuperar rede

Vamos usar o NetworkWriter e o NetworkReader da ferramenta Pybrain, ou seja, pybrain.tools.customxml.

Aqui está um exemplo prático do mesmo -

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

A rede é salva em network.xml.

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

Para ler o xml quando necessário, podemos usar o código da seguinte maneira -

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

Aqui está o arquivo network.xml criado -

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

Abaixo está uma lista de APIs que usamos ao longo deste tutorial.

Para redes

• activate(input)- Leva parâmetro, ou seja, o valor a ser testado. Ele retornará o resultado com base na entrada fornecida.

• activateOnDataset(dataset) - Ele irá iterar sobre o conjunto de dados fornecido e retornar a saída.

• addConnection(c) - Adiciona conexão à rede.

• addInputModule(m) - Adiciona o módulo fornecido à rede e o marca como módulo de entrada.

• addModule(m) - Adiciona o módulo fornecido à rede.

• addOutputModule(m) - Adiciona o módulo à rede e o marca como módulo de saída.

• reset() - Reinicia os módulos e a rede.

• sortModules()- Prepara a rede para ativação classificando internamente. Ele deve ser chamado antes da ativação.

Para conjuntos de dados supervisionados

• addSample(inp, target) - Adiciona uma nova amostra de entrada e destino.

• splitWithProportion(proportion=0.5) - Divide o conjunto de dados em duas partes, a primeira parte contendo os dados da parte da proporção e o próximo conjunto contendo o restante.

Para treinadores

trainUntilConvergence(dataset=None, maxEpochs=None, verbose=None, continueEpochs=10, validationProportion=0.25)- É usado para treinar o módulo no conjunto de dados até que converta. Se o conjunto de dados não for fornecido, ele tentará treinar no conjunto de dados treinado usado no início.

Neste capítulo, todos os exemplos possíveis que são executados usando PyBrain são listados.

Exemplo 1

Trabalhar com a Tabela Verdade NOR e testá-la para ver se está correta.

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)

Resultado

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)

Exemplo 2

Para conjuntos de dados, vamos usar conjuntos de dados sklearn conforme mostrado abaixo: Consulte conjuntos de dados load_digits em sklearn: scikit-learn.org

Possui 10 classes, ou seja, dígitos a serem previstos de 0-9.

O total de dados de entrada em 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']
))

Resultado

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