PyBrain - Rede de Teste

Neste capítulo, veremos algum exemplo onde 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

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

Vamos ver 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 para 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 de 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()

O uso do 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

O próximo passo é 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 traçamos conforme 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']
))