PyBrain - Testing Network

In questo capitolo, vedremo alcuni esempi in cui addestreremo i dati e testeremo gli errori sui dati addestrati.

Ci serviremo di trainer -

BackpropTrainer

BackpropTrainer è un trainer che addestra i parametri di un modulo in base a un set di dati supervisionato o ClassificationDataSet (potenzialmente sequenziale) retropropagando gli errori (nel tempo).

TrainUntilConvergence

Viene utilizzato per addestrare il modulo sul set di dati finché non converge.

Quando creiamo una rete neurale, verrà addestrata in base ai dati di addestramento che le vengono forniti. Ora se la rete è addestrata correttamente o meno dipenderà dalla previsione dei dati di test testati su quella rete.

Vediamo un esempio funzionante passo dopo passo che costruirà una rete neurale e prevederà gli errori di addestramento, gli errori di test e gli errori di convalida.

Testare la nostra rete

Di seguito sono riportati i passaggi che seguiremo per testare la nostra rete:

  • Importazione di PyBrain e altri pacchetti richiesti
  • Crea ClassificationDataSet
  • Suddivisione dei set di dati del 25% come dati di test e del 75% come dati addestrati
  • Conversione di dati di test e dati addestrati come ClassificationDataSet
  • Creazione di una rete neurale
  • Formazione della rete
  • Visualizzazione dell'errore e dei dati di convalida
  • Percentuale di errore dei dati di prova

Step 1

Importazione di PyBrain e altri pacchetti richiesti.

I pacchetti di cui abbiamo bisogno vengono importati come mostrato di seguito:

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

Il passaggio successivo consiste nel creare ClassificationDataSet.

Per i set di dati, utilizzeremo set di dati da set di dati sklearn come mostrato di seguito -

Fare riferimento ai set di dati load_digits da sklearn nel collegamento sottostante -

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

Suddivisione dei set di dati del 25% come dati di test e del 75% come dati addestrati -

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

Quindi qui, abbiamo utilizzato un metodo sul set di dati chiamato splitWithProportion () con valore 0,25, dividerà il set di dati in 25% come dati di test e 75% come dati di addestramento.

Step 4

Conversione di dati di test e dati addestrati come 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()

L'utilizzo del metodo splitWithProportion () sul set di dati converte il set di dati in set di dati supervisionato, quindi riconvertiremo il set di dati in set di dati di classificazione come mostrato nel passaggio precedente.

Step 5

Il prossimo passo è creare una rete neurale.

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

Stiamo creando una rete in cui l'input e l'output vengono utilizzati dai dati di addestramento.

Step 6

Formazione della rete

Ora la parte importante è addestrare la rete sul set di dati come mostrato di seguito:

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

Stiamo utilizzando il metodo BackpropTrainer () e il set di dati sulla rete creata.

Step 7

Il passaggio successivo consiste nella visualizzazione dell'errore e nella convalida dei dati.

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

Useremo un metodo chiamato trainUntilConvergence sui dati di addestramento che convergeranno per le epoche di 10. Restituirà l'errore di addestramento e l'errore di convalida che abbiamo tracciato come mostrato di seguito. La linea blu mostra gli errori di addestramento e la linea rossa mostra l'errore di convalida.

Di seguito è riportato l'errore totale ricevuto durante l'esecuzione del codice precedente:

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

L'errore inizia a 0,04 e successivamente diminuisce per ogni epoca, il che significa che la rete viene addestrata e migliora per ogni epoca.

Step 8

Percentuale di errore nei dati di test

Possiamo controllare l'errore percentuale usando il metodo percentError come mostrato di seguito -

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

Percent Error on testData - 3.34075723830735

Stiamo ottenendo la percentuale di errore, ovvero 3,34%, il che significa che la rete neurale è precisa al 97%.

Di seguito è riportato il codice 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']
))