PyBrain - Red de prueba

En este capítulo, veremos un ejemplo en el que vamos a entrenar los datos y probar los errores en los datos entrenados.

Vamos a hacer uso de entrenadores -

BackpropTrainer

BackpropTrainer es un entrenador que entrena los parámetros de un módulo de acuerdo con un conjunto de datos supervisado o ClassificationDataSet (potencialmente secuencial) propagando los errores (a través del tiempo).

TrenHasta Convergencia

Se utiliza para entrenar el módulo en el conjunto de datos hasta que converja.

Cuando creamos una red neuronal, se entrenará en función de los datos de entrenamiento que se le proporcionen. Ahora bien, si la red está entrenada correctamente o no, dependerá de la predicción de los datos de prueba probados en esa red.

Veamos un ejemplo de trabajo paso a paso donde se construirá una red neuronal y se predecirán los errores de entrenamiento, los errores de prueba y los errores de validación.

Probando nuestra red

Los siguientes son los pasos que seguiremos para probar nuestra red:

Importación de PyBrain y otros paquetes necesarios
Crear ClassificationDataSet
Dividir los conjuntos de datos un 25% como datos de prueba y un 75% como datos entrenados
Conversión de datos de prueba y datos entrenados como ClassificationDataSet
Creando una red neuronal
Entrenando la Red
Visualización de los datos de validación y error
Porcentaje de error de datos de prueba

Step 1

Importar PyBrain requerido y otros paquetes.

Los paquetes que necesitamos se importan como se muestra a continuación:

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

El siguiente paso es crear ClassificationDataSet.

Para los conjuntos de datos, vamos a utilizar conjuntos de datos de sklearn conjuntos de datos como se muestra a continuación:

Consulte los conjuntos de datos load_digits de sklearn en el siguiente enlace:

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

Dividir los conjuntos de datos en un 25% como datos de prueba y en un 75% como datos entrenados:

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

Entonces, aquí, hemos utilizado un método en el conjunto de datos llamado splitWithProportion () con valor 0.25, dividirá el conjunto de datos en 25% como datos de prueba y 75% como datos de entrenamiento.

Step 4

Conversión de Testdata y Trained de nuevo 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()

El uso del método splitWithProportion () en el conjunto de datos convierte el conjunto de datos en un conjunto de datos supervisado, por lo que convertiremos el conjunto de datos nuevamente en un conjunto de datos de clasificación como se muestra en el paso anterior.

Step 5

El siguiente paso es crear una red neuronal.

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

Estamos creando una red en la que la entrada y la salida se utilizan a partir de los datos de entrenamiento.

Step 6

Entrenando la Red

Ahora, la parte importante es entrenar la red en el conjunto de datos como se muestra a continuación:

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

Estamos usando el método BackpropTrainer () y usando un conjunto de datos en la red creada.

Step 7

El siguiente paso es visualizar el error y la validación de los datos.

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

Usaremos un método llamado trainUntilConvergence en datos de entrenamiento que convergerán para épocas de 10. Devolverá el error de entrenamiento y el error de validación que hemos trazado como se muestra a continuación. La línea azul muestra los errores de entrenamiento y la línea roja muestra el error de validación.

El error total recibido durante la ejecución del código anterior se muestra a continuación:

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

El error comienza en 0.04 y luego baja para cada época, lo que significa que la red se está entrenando y mejora para cada época.

Step 8

Porcentaje de error de datos de prueba

Podemos verificar el error porcentual usando el método percentError como se muestra a continuación:

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

Percent Error on testData - 3.34075723830735

Obtenemos el porcentaje de error, es decir, 3,34%, lo que significa que la red neuronal tiene una precisión del 97%.

A continuación se muestra el 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']
))

↰ Previous page Next page ↱