tutorial - redes neuronales python pdf

El entrenamiento de la red neuronal con PyBrain no convergerá

Question

Tengo el siguiente código, del tutorial de PyBrain:

from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure.modules import TanhLayer
ds = SupervisedDataSet(2, 1)
ds.addSample((0,0), (0,))
ds.addSample((0,1), (1,))
ds.addSample((1,0), (1,))
ds.addSample((1,1), (0,))
net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds)
for inp, tar in ds:
print [net.activate(inp), tar]
errors = trainer.trainUntilConvergence()
for inp, tar in ds:
print [net.activate(inp), tar]

Sin embargo, el resultado es una red neuronal que no está bien entrenada. Al observar el resultado del error, la red se entrena correctamente, pero utiliza el argumento ''continueEpochs'' para entrenar un poco más y la red está empeorando nuevamente. Entonces la red está convergiendo, pero no hay forma de obtener la mejor red entrenada. La documentación de PyBrain implica que se devuelve la red que está mejor entrenada, sin embargo, devuelve una tupla de errores.

Los pasos que siguen continúan hasta 0. Obtengo un error (ValueError: max () arg es una secuencia vacía) así que continueEpochs debe ser mayor que 0.

Es realmente PyBrain mantenido porque parece que hay una gran diferencia en la documentación y el código.

Answer 1

Después de excavar un poco más, descubrí que el ejemplo del tutorial de PyBrain está completamente fuera de lugar.

Cuando miramos la firma del método en el código fuente encontramos:

def trainUntilConvergence(self, dataset=None, maxEpochs=None, verbose=None, continueEpochs=10, validationProportion=0.25):

Esto significa que el 25% del conjunto de entrenamiento se usa para la validación. A pesar de que es un método muy válido al entrenar una red en datos, no lo hará cuando tenga a su disposición el rango completo de posibilidades, es decir, un conjunto de soluciones XOR 2-in-1-out de 4 filas. Cuando uno quiere entrenar un conjunto XOR y elimina una de las filas para la validación que tiene como consecuencia inmediata que obtiene un conjunto de entrenamiento muy escaso donde se omite una de las posibles combinaciones resultando automáticamente en aquellos pesos que no están entrenados.

Normalmente, cuando se omite el 25% de los datos para la validación, se hace esto suponiendo que ese 25% cubre la "mayoría" del espacio de solución que la red ya ha encontrado más o menos. En este caso, esto no es cierto y cubre el 25% del espacio de solución completamente desconocido para la red desde que lo eliminó para su validación.

Entonces, el capacitador estaba entrenando a la red correctamente, pero al omitir el 25% del problema XOR, esto resulta en una red mal entrenada.

Un ejemplo diferente en el sitio web de PyBrain como inicio rápido sería muy útil, porque este ejemplo es simplemente incorrecto en este caso XOR específico. Tal vez se pregunte si ellos mismos probaron el ejemplo, ya que solo genera redes mal entrenadas al azar.

Answer 2

trainer = BackpropTrainer(net, ds, learningrate = 0.9, momentum=0.0, weightdecay=0.0, verbose=True)
trainer.trainEpochs(epochs=1000)

De esta manera puede converger. si la tasa de aprendizaje es demasiado pequeña (por ejemplo, 0.01), perdió en el mínimo local. Como lo he probado, la tasa de aprendizaje en 0.3-30, puede converger.

Answer 3

Lo siguiente parece dar consistentemente los resultados correctos:

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
#net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)
net = buildNetwork(2, 3, 1, bias=True)
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
trainer = BackpropTrainer(net, ds, learningrate=0.001, momentum=0.99)
trainer.trainUntilConvergence(verbose=True)
print net.activate([0,0])
print net.activate([0,1])
print net.activate([1,0])
print net.activate([1,1])

Answer 4

Tomé la excelente clase de Machine Aprendizaje en Coursera , impartida por Andrew Ng, y una parte de la clase cubrió el entrenamiento de una pequeña red neuronal para reconocer xor. Así que estaba un poco preocupado por el ejemplo de Pybrain basado en partes del inicio rápido que no convergían.

Creo que hay muchas razones, incluida la anterior, sobre el conjunto mínimo de datos que se divide en capacitación y validación. En un momento del curso, Andrew dijo que "no es la persona con el mejor algoritmo que gana, es el que tiene la mayor cantidad de datos. Y explicó que la explosión en la disponibilidad de datos en los 2000 es parte de la razón por la cual resurgimiento en AI, ahora llamado Machine Learning.

Entonces, con todo eso en mente, descubrí que

1. el conjunto de validación puede tener 4 muestras, porque eso viene después de la fase de entrenamiento.
2. la red solo necesita 2 nodos en la capa oculta, como aprendí en la clase,
3. la tasa de aprendizaje debe ser muy pequeña en este caso, como 0.005, o de lo contrario el entrenamiento saltará la respuesta (este es un punto importante de la clase que confirmé al jugar con los números).
4. cuanto menor es la velocidad de aprendizaje, más pequeños pueden ser los MaxEpochs. Una pequeña tasa de aprendizaje significa que la convergencia toma pasos más pequeños a lo largo del gradiente hacia la minimización. Si es más grande, necesita un MaxEpochs más grande para que espere más tiempo antes de decidir que haya alcanzado un mínimo.
5. Necesita un sesgo = Verdadero en la red (que agrega un nodo constante 1 a la entrada y capas ocultas). Lee las respuestas a esta pregunta sobre el sesgo.
6. Finalmente, y lo más importante, necesitas un gran conjunto de entrenamiento. 1000 convergieron en la respuesta correcta aproximadamente el 75% del tiempo. Sospecho que esto tiene que ver con el algoritmo de minimización. Los números más pequeños fallarían con frecuencia.

Así que aquí hay un código que funciona:

from pybrain.datasets import SupervisedDataSet
dataModel = [
[(0,0), (0,)],
[(0,1), (1,)],
[(1,0), (1,)],
[(1,1), (0,)],
]
ds = SupervisedDataSet(2, 1)
for input, target in dataModel:
ds.addSample(input, target)
# create a large random data set
import random
random.seed()
trainingSet = SupervisedDataSet(2, 1);
for ri in range(0,1000):
input,target = dataModel[random.getrandbits(2)];
trainingSet.addSample(input, target)
from pybrain.tools.shortcuts import buildNetwork
net = buildNetwork(2, 2, 1, bias=True)
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, ds, learningrate = 0.001, momentum = 0.99)
trainer.trainUntilConvergence(verbose=True,
trainingData=trainingSet,
validationData=ds,
maxEpochs=10)
print ''0,0->'', net.activate([0,0])
print ''0,1->'', net.activate([0,1])
print ''1,0->'', net.activate([1,0])
print ''1,1->'', net.activate([1,1])