def buildClassifier(self, data):
porcentajeParticionado = 0.85
particionado = DivisionPorcentual()
particionado.setPorcentajeTrain(porcentajeParticionado)
particion = particionado.generaParticionesProporcional(data, True)
# instancias = data.getListInstances()
data = particion.getTrain()
# inicializacion
for i in range(0, self.nIndividuos):
indv = IndividuoRedPalabras()
indv.buildClassifier(data)
self.listaIndividuos.append(indv)
mejorIndividuo = None
mejorEpocas = 0
instancias = particion.getTest().getListInstances()
for epoca in range(0, self.nEpocas):
if epoca % 2 == 0:
print epoca
# cruce
# for i in range(0, self.nIndividuos, 2):
# self.listaIndividuos[i].cruce(self.listaIndividuos[i+1])
# mutacion
for indv in self.listaIndividuos:
indv.mutacion()
mejorEpoca = 0
mejorIndvEpoca = None
arrayCorrectas = []
sumaCorrectas = 0.0
for indv in self.listaIndividuos:
correctas = self.privateClasificaInstanciasReTCount(indv, instancias)
if correctas > mejorEpoca:
mejorEpoca = correctas
mejorIndvEpoca = indv.duplica()
sumaCorrectas += correctas
arrayCorrectas.append(correctas)
if mejorEpoca > mejorEpocas:
print mejorEpoca
mejorEpocas = mejorEpoca
mejorIndividuo = mejorIndvEpoca
# print mejorEpoca / float(data.getNumeroInstances())
# print sumaCorrectas
for i in range(0, len(arrayCorrectas)):
arrayCorrectas[i] = arrayCorrectas[i] / sumaCorrectas
# for correcta in arrayCorrectas:
# print correcta
nuevaListaIndv = []
for i in range(0, self.nIndividuos - (self.nNuevosIndvPorEpoca + self.nMaxElite)):
posicion = 0
suma = 0.0
aleat = random.random()
while True:
suma += arrayCorrectas[posicion]
# print suma
if suma >= aleat:
nuevaListaIndv.append(self.listaIndividuos[posicion])
break
posicion += 1
self.listaIndividuos = nuevaListaIndv
for i in range(0, self.nNuevosIndvPorEpoca):
indv = IndividuoRedPalabras()
indv.buildClassifier(data)
self.listaIndividuos.append(indv)
for i in range(0, self.nMaxElite):
# print mejorIndividuo.correctas(data)/ float(data.getNumeroInstances())
self.listaIndividuos.append(mejorIndividuo.duplica())
random.shuffle(self.listaIndividuos)
print mejorEpocas / float(data.getNumeroInstances())
# for indv in self.listaIndividuos:
# print indv.correctas(data) / float(data.getNumeroInstances())
self.modelo = mejorIndividuo.duplica()
print self.modelo.pesoNoConexion
print self.modelo.pesoNoPalabra
print mejorEpocas / float(data.getNumeroInstances())
procentajeError = error / float(instances.getNumeroInstances())
return procentajeError
if __name__ == '__main__':
#random.seed(2)
lector = LectorARFF()
instances = lector.leerFichero("../data/entrenamiento.arff")
instances.normaliza()
porcentajeParticionado = float(0.50)
particionado = DivisionPorcentual()
particionado.setPorcentajeTrain(porcentajeParticionado)
particion = particionado.generaParticionesProporcional(instances)
print "Multilayer Perceptron"
clasificador = RedNeuronalBlist()
clasificador.setParameters('nNeuronas=' + str(50))
clasificador.setParameters('alpha=' + str(0.01))
clasificador.setParameters('nEpocas=500')
clasificador.setDebug(False)
start_time = time()
if porcentajeParticionado != 1.0:
clasificador.buildClassifier(particion.getTrain())
else:
clasificador.buildClassifier(particion.getTrain())
def buildClassifier(self, data, test=None):
self.clases = list(data.getClases())
self.nClases = len(self.clases)
self.columnas = list(data.getColumnasList())
self.nColumnas = len(self.columnas)
if data.getNumeroInstances() >= 100000:
self.activo_control_fin = True
particionado = DivisionPorcentual()
particionado.setPorcentajeTrain(0.8)
particion = particionado.generaParticionesProporcional(data)
data = particion.getTrain()
self.conjuntoValidacion = particion.getTest()
self.nInstaces = data.getNumeroInstances()
#creamos las neuronas de entrada
self.capaEntrada = [1 for x in range(0, self.nColumnas + 1)]
#self.capaEntrada = map((lambda x: 1), range(0, self.nColumnas + 1))
#inicializamos los pesos de manera aleatoria
#por cada neurona de la capa oculta
for indNeurona in range(0, self.neuronasCapaOculta):
#por cada neurona de la capa de entrada
self.pesosCapaOculta.append([])
self.pesosCapaOculta[indNeurona] = map(
(lambda x: (random.random() - 0.5)),
range(0, self.nColumnas + 1))
#inicializamos los pesos de la capa de salida
for indNeurona in range(0, self.nClases):
self.pesosCapaSalida.append([])
self.pesosCapaSalida[indNeurona] = map(
(lambda x: (random.random() - 0.5)),
range(0, self.neuronasCapaOculta + 1))
#self.NguyenWidrow()
#generamos todos los vectores objetivos
vectoresObjetivos = {}
for instancia in data.getListInstances():
vectoresObjetivos[instancia] = self.generaVectorObjetivoSalida(
instancia)
instancias = data.getListInstances()
cuadratico_epoca_anterior = float("inf")
# Cabecera para el fichero
if self.debug:
self.debugFile.write("Época\t")
if test is not None:
self.debugFile.write("Error de test\t")
self.debugFile.write("Error train\tArray de pesos\n")
cuadratico_anterior = 1000
#paso1
for epoca in range(0, self.nEpocas):
cuadratico_epoca = 0
#print epoca
#paso2 por cada instancia en train
for instancia in instancias:
#***********inicio de Feedforward**********************************
#paso 3, valores de entrada
for indNeurona in range(1, self.nColumnas + 1):
self.capaEntrada[indNeurona] = instancia.getElementAtPos(
indNeurona - 1)
#paso 4, salida neuronas capa oculta, vector Z
#z0 siempre es 1
salidaCapaOculta = [1]
#por cada neurona realizamos una salida
for indNeurona in range(0, self.neuronasCapaOculta):
suma = 0
for indNeuronaEntr in range(0, self.nColumnas + 1):
suma += (
self.pesosCapaOculta[indNeurona][indNeuronaEntr] *
self.capaEntrada[indNeuronaEntr])
#aplicamos la sigmoidal a la suma, esto nos da la salida de la neurona
if self.bipolar == False:
#f1
if suma > 400:
salidaCapaOculta.append(1.0)
elif suma < -400:
salidaCapaOculta.append(0.0)
else:
salidaCapaOculta.append(1.0 /
(1.0 + math.exp(-suma)))
else:
#f2
if suma > 400:
salidaCapaOculta.append(1.0)
elif suma < -400:
salidaCapaOculta.append(-1.0)
else:
salidaCapaOculta.append((2.0 /
(1.0 + math.exp(-suma))) -
1.0)
#paso 5, calculamos las respuestas de las neuronas de la capa de salida, vector Y
salidaFinal = []
for indNeurona in range(0, self.nClases):
suma = 0
for indNeuronaOculta in range(0,
self.neuronasCapaOculta + 1):
suma += (
self.pesosCapaSalida[indNeurona][indNeuronaOculta]
* salidaCapaOculta[indNeuronaOculta])
#aplicamos la sigmoidal a la suma, esto nos da la salida de la neurona
if self.bipolar == False:
#f1
if suma > 400:
salidaFinal.append(1.0)
elif suma < -400:
salidaFinal.append(0.0)
else:
salidaFinal.append(1.0 / (1.0 + math.exp(-suma)))
else:
#f2
if suma > 400:
salidaFinal.append(1.0)
elif suma < -400:
salidaFinal.append(-1.0)
else:
salidaFinal.append((2.0 /
(1.0 + math.exp(-suma))) - 1.0)
#***********fin de Feedforward **********************************
#calculo del error cuadratico medio
cuadratico_instancia = reduce(
add,
map((lambda x, y: (x - y)**2),
vectoresObjetivos[instancia], salidaFinal))
cuadratico_epoca += cuadratico_instancia
#***********inicio Retropropagación del error *******************
#paso 6
if self.bipolar == False:
#Tk - Yk * f1`(Yin)
deltaMinusculaK = map(
(lambda x, y: (x - y) * (y * (1.0 - y))),
vectoresObjetivos[instancia], salidaFinal)
else:
#Tk - Yk * f2`(Yin)
deltaMinusculaK = map((lambda x, y: (x - y) * (0.5 * (
(1.0 + y) * (1.0 - y)))), vectoresObjetivos[instancia],
salidaFinal)
deltaMayusculaJK = []
for indNeuronaSalida in range(0, self.nClases):
#calculamos delta mayuscula
deltaMayusculaJK.append([])
aux = deltaMinusculaK[indNeuronaSalida] * self.alpha
deltaMayusculaJK[indNeuronaSalida] = map(
(lambda x: aux * x), salidaCapaOculta)
#paso 7
deltaMinInj = [0 for x in range(0, self.neuronasCapaOculta)]
for indNeurona in range(0, self.nClases):
for indNeuronaOculta in range(1,
self.neuronasCapaOculta + 1):
deltaMinInj[
indNeuronaOculta -
1] += self.pesosCapaSalida[indNeurona][
indNeuronaOculta] * deltaMinusculaK[indNeurona]
deltaMinusculaJ = []
if self.bipolar == False:
#f`1
deltaMinusculaJ = map((lambda x, y: x * (y * (1.0 - y))),
deltaMinInj, salidaCapaOculta[1:])
else:
#f`2
deltaMinusculaJ = map((lambda x, y: x *
(0.5 * ((1.0 + y) * (1.0 - y)))),
deltaMinInj, salidaCapaOculta[1:])
deltaMayusculaIJ = []
for indNeuronaOculta in range(0, self.neuronasCapaOculta):
deltaMayusculaIJ.append([])
aux = self.alpha * deltaMinusculaJ[indNeuronaOculta]
deltaMayusculaIJ[indNeuronaOculta] = map(
(lambda x: aux * x), self.capaEntrada)
#paso 8
#Actualizar pesos y sesgos
for indiceClase in range(0, self.nClases):
self.pesosCapaSalida[indiceClase] = map(
add, self.pesosCapaSalida[indiceClase],
deltaMayusculaJK[indiceClase])
for indiceNOculta in range(0, self.neuronasCapaOculta):
self.pesosCapaOculta[indiceNOculta] = map(
add, self.pesosCapaOculta[indiceNOculta],
deltaMayusculaIJ[indiceNOculta])
#comprobar condicion de finalizacion
#fin de bucle de instancias
cuadratico_epoca = cuadratico_epoca / float(
self.nInstaces * self.nClases)
if self.debug == True:
if test is None:
self.debugFile.write(
str(epoca) + '\t' +
str(self.getErrorFromInstances(data)) + '\t')
else:
self.debugFile.write(
str(epoca) + '\t' +
str(self.getErrorFromInstances(test)) + '\t' +
str(self.getErrorFromInstances(data)) + '\t')
#for indiceNOculta in range(0, self.neuronasCapaOculta):
# map(lambda x: self.debugFile.write(str(x) + '\t'), self.pesosCapaOculta[indiceNOculta])
#for indiceClase in range(0, self.nClases):
# map(lambda x: self.debugFile.write(str(x) + '\t'), self.pesosCapaSalida[indiceClase])
self.debugFile.write('\n')
difErrCuadratico = abs(
(cuadratico_epoca - self.errorCuadraticoMedio_old) /
self.errorCuadraticoMedio_old)
#print difErrCuadratico
if difErrCuadratico < 0.00000001:
return
self.errorCuadraticoMedio_old = cuadratico_epoca
if self.activo_control_fin == True and epoca % 50 == 0:
error = self.getECMFromInstances(self.conjuntoValidacion)
print self.lastError
print error
#error = self.getErrorFromInstances(self.conjuntoValidacion)
if self.lastError < error:
break
else:
#print str(epoca)+ '\t' + str(error)
self.lastError = error
def buildClassifier(self, data, test=None):
self.clases = list(data.getClases())
self.nClases = len(self.clases)
self.columnas = list(data.getColumnasList())
self.nColumnas = len(self.columnas)
if data.getNumeroInstances() >= 100:
self.activo_control_fin = True
particionado = DivisionPorcentual()
particionado.setPorcentajeTrain(0.8)
particion = particionado.generaParticionesProporcional(data)
data = particion.getTrain()
self.conjuntoValidacion = particion.getTest()
self.nInstaces = data.getNumeroInstances()
#creamos las neuronas de entrada
self.capaEntrada = [1 for x in range(0, self.nColumnas + 1)]
#self.capaEntrada = map((lambda x: 1), range(0, self.nColumnas + 1))
#inicializamos los pesos de manera aleatoria
#por cada neurona de la capa oculta
for indNeurona in range(0, self.neuronasCapaOculta):
#por cada neurona de la capa de entrada
self.pesosCapaOculta.append([])
self.pesosCapaOculta[indNeurona] = map((lambda x: (random.random() - 0.5)), range(0, self.nColumnas + 1))
#inicializamos los pesos de la capa de salida
for indNeurona in range(0, self.nClases):
self.pesosCapaSalida.append([])
self.pesosCapaSalida[indNeurona] = map((lambda x: (random.random() - 0.5)), range(0, self.neuronasCapaOculta + 1))
self.NguyenWidrow()
#generamos todos los vectores objetivos
vectoresObjetivos = {}
for instancia in data.getListInstances():
vectoresObjetivos[instancia] = self.generaVectorObjetivoSalida(instancia.getClase())
instancias = data.getListInstances()
cuadratico_epoca_anterior = float("inf")
# Cabecera para el fichero
if self.debug:
self.debugFile.write("Época\t")
if test is not None:
self.debugFile.write("Error de test\t")
self.debugFile.write("Error train\tArray de pesos\n")
cuadratico_anterior = 1000
#paso1
for epoca in range(0, self.nEpocas):
if epoca % 50 == 0:
print epoca
cuadratico_epoca = 0
#paso2 por cada instancia en train
for instancia in instancias:
#***********inicio de Feedforward**********************************
#paso 3, valores de entrada
for indNeurona in range(1, self.nColumnas + 1):
self.capaEntrada[indNeurona] = instancia.getElementAtPos(indNeurona - 1)
#paso 4, salida neuronas capa oculta, vector Z
#z0 siempre es 1
salidaCapaOculta = [1]
#por cada neurona realizamos una salida
for indNeurona in range(0, self.neuronasCapaOculta):
suma = 0
for indNeuronaEntr in range(0, self.nColumnas + 1):
suma += (self.pesosCapaOculta[indNeurona][indNeuronaEntr] * self.capaEntrada[indNeuronaEntr])
#aplicamos la sigmoidal a la suma, esto nos da la salida de la neurona
if self.bipolar == False:
#f1
if suma > 200:
salidaCapaOculta.append(1)
elif suma < -40:
salidaCapaOculta.append(0)
else:
salidaCapaOculta.append(1.0/(1.0 + math.exp( - suma)))
else:
#f2
if random.random() <= self.probSinapsis:
if suma > 200:
salidaCapaOculta.append(1)
elif suma < -200:
salidaCapaOculta.append(-1)
else:
salidaCapaOculta.append((2.0/(1.0 + math.exp( - suma))) - 1.0)
else:
salidaCapaOculta.append(0.0)
#paso 5, calculamos las respuestas de las neuronas de la capa de salida, vector Y
salidaFinal = []
for indNeurona in range(0, self.nClases):
suma = 0
for indNeuronaOculta in range(0, self.neuronasCapaOculta + 1):
suma += (self.pesosCapaSalida[indNeurona][indNeuronaOculta] * salidaCapaOculta[indNeuronaOculta])
#aplicamos la sigmoidal a la suma, esto nos da la salida de la neurona
if self.bipolar == False:
#f1
if suma > 200:
salidaFinal.append(1)
elif suma < -40:
salidaFinal.append(0)
else:
salidaFinal.append(1.0/(1.0 + math.exp( - suma)))
else:
#f2
if suma > 200:
salidaFinal.append(1)
elif suma < -200:
salidaFinal.append(-1)
else:
salidaFinal.append((2.0/(1.0 + math.exp( - suma))) - 1.0)
#***********fin de Feedforward **********************************
#calculo del error cuadratico medio
cuadratico_instancia = reduce(add, map((lambda x, y: (x - y)**2), vectoresObjetivos[instancia], salidaFinal))
cuadratico_epoca += cuadratico_instancia
#***********inicio Retropropagación del error *******************
#paso 6
if self.bipolar == False:
#Tk - Yk * f1`(Yin)
deltaMinusculaK = map((lambda x, y: (x - y) * (y * (1.0 - y))), vectoresObjetivos[instancia], salidaFinal)
else:
#Tk - Yk * f2`(Yin)
deltaMinusculaK = map((lambda x, y: (x - y) * (0.5 * ((1 + y) * (1.0 - y)))), vectoresObjetivos[instancia], salidaFinal)
deltaMayusculaJK = []
for indNeuronaSalida in range(0, self.nClases):
#calculamos delta mayuscula
deltaMayusculaJK.append([])
aux = deltaMinusculaK[indNeuronaSalida] * self.alpha
deltaMayusculaJK[indNeuronaSalida] = map((lambda x: aux*x), salidaCapaOculta)
#paso 7
deltaMinInj = [0 for x in range(0, self.neuronasCapaOculta)]
for indNeurona in range(0, self.nClases):
for indNeuronaOculta in range(1, self.neuronasCapaOculta + 1):
deltaMinInj[indNeuronaOculta - 1] += self.pesosCapaSalida[indNeurona][indNeuronaOculta]
for indNeuronaOculta in range(0, self.neuronasCapaOculta):
deltaMinInj[indNeuronaOculta] *= deltaMinusculaK[indNeurona]
deltaMinusculaJ = []
if self.bipolar == False:
#f`1
deltaMinusculaJ = map((lambda x, y: x * (y * (1.0 - y))),deltaMinInj, salidaCapaOculta[1:])
else:
#f`2
deltaMinusculaJ = map((lambda x, y: x *(0.5* ((1.0 + y) * (1.0 - y)))),deltaMinInj, salidaCapaOculta[1:])
"""deltaMayusculaIJ = []
for indNeuronaOculta in range(0, self.neuronasCapaOculta):
deltaMayusculaIJ.append([])
aux = self.alpha*deltaMinusculaJ[indNeuronaOculta]
deltaMayusculaIJ[indNeuronaOculta] = map((lambda x: aux*x), self.capaEntrada)
"""
#paso 8
#Actualizar pesos y sesgos
for indiceClase in range(0, self.nClases):
self.pesosCapaSalida[indiceClase] = map(add, self.pesosCapaSalida[indiceClase], deltaMayusculaJK[indiceClase])
"""
for indiceNOculta in range(0, self.neuronasCapaOculta):
if random.random() <= self.probAct:
self.pesosCapaOculta[indiceNOculta] = map(add, self.pesosCapaOculta[indiceNOculta] ,deltaMayusculaIJ[indiceNOculta])
"""
#comprobar condicion de finalizacion
#fin de bucle de instancias
cuadratico_epoca = cuadratico_epoca/float(self.nInstaces * self.nClases)
if self.debug == True:
if test is None:
self.debugFile.write(str(epoca) + '\t' + str(cuadratico_epoca) + '\t') #+ str(self.getErrorFromInstances(data)) + '\t')
else:
self.debugFile.write(str(epoca) + '\t' + str(self.getErrorFromInstances(test)) + '\t' + str(self.getErrorFromInstances(data)) + '\t')
#for indiceNOculta in range(0, self.neuronasCapaOculta):
# map(lambda x: self.debugFile.write(str(x) + '\t'), self.pesosCapaOculta[indiceNOculta])
#for indiceClase in range(0, self.nClases):
# map(lambda x: self.debugFile.write(str(x) + '\t'), self.pesosCapaSalida[indiceClase])
self.debugFile.write('\n')
difErrCuadratico = abs((cuadratico_epoca - self.errorCuadraticoMedio_old)/self.errorCuadraticoMedio_old)
#print difErrCuadratico
if difErrCuadratico < 0.00000001:
return
self.errorCuadraticoMedio_old = cuadratico_epoca
if self.activo_control_fin == True and epoca % 1 == 0:
#error = self.getECMFromInstances(self.conjuntoValidacion)
#print self.lastError
#print error
error = self.getErrorFromInstances(self.conjuntoValidacion)
if error > self.lastError:
break
else:
#print str(epoca)+ '\t' + str(error)
self.lastError = error
print 'Error medio: ' + str(procentajeError)
for clase in instances.getClases():
sumaAux = float(erroresPorClase[clase] + aciertosPorClase[clase])
print '\t' + clase + ': ' + str(
erroresPorClase[clase]) + ' aciertos: ' + str(
aciertosPorClase[clase]) + ' porcentaje: ' + str(
erroresPorClase[clase] / sumaAux)
"""pruebas unitarias"""
if __name__ == '__main__':
lector = LectorNeuro()
instances = lector.leerFichero('../data/nand.txt')
porcentajeParticionado = 1.0
particionado = DivisionPorcentual()
particionado.setPortcentajeTrain(porcentajeParticionado)
particion = particionado.generaParticionesProporcional(instances)
print "Adaline"
clasificador = Adaline()
clasificador.setDebug(True)
clasificador.buildClassifier(particion.getTrain())
print "Error TRAIN:"
calculaError(clasificador, particion.getTrain())
if porcentajeParticionado != 1.0:
print "Error TEST:"
calculaError(clasificador, particion.getTest())
print "Perceptron"
clasificador = Perceptron()
goodFile = f_in + '_' + str(na) + '-' + str(ns)
if not os.path.isfile(goodFile):
f1 = open(f_in, 'r')
f2 = open(goodFile, 'w')
adaptaFicheroSerie(f1, f2, na, ns)
f1.close()
f2.close()
lector = LectorNeuroContinuo()
instances = lector.leerFichero(goodFile)
particionado = DivisionPorcentual()
particionado.setPorcentajeTrain(porcentajeParticionado)
particion = particionado.generaParticiones(instances, False)
print "Multilayer Perceptron"
clasificador = RedNeuronalTemporal()
clasificador.setParameters('nNeuronas=' + nNeuronas)
clasificador.setParameters('alpha=' + alpha)
clasificador.setParameters('nEpocas=1000')
clasificador.setParameters('debugFile=' + debugFile)
clasificador.setDebug(True)
start_time = time()
clasificador.buildClassifier(particion.getTrain())
elapsed_time = time() - start_time
print("Elapsed time: %0.10f seconds." % elapsed_time)
def buildClassifier(self, data, test=None):
self.clases = list(data.getClases())
self.nClases = len(self.clases)
self.columnas = list(data.getColumnasList())
self.nColumnas = len(self.columnas)
if data.getNumeroInstances() >= 1000:
self.activo_control_fin = True
particionado = DivisionPorcentual()
particionado.setPorcentajeTrain(0.9)
particion = particionado.generaParticionesProporcional(data)
data = particion.getTrain()
self.conjuntoValidacion = particion.getTest()
self.nInstaces = data.getNumeroInstances()
#creamos las neuronas de entrada
self.capaEntrada = np.ones(self.nColumnas + 1)
#self.capaEntrada = map((lambda x: 1), xrange(0, self.nColumnas + 1))
#inicializamos los pesos de manera aleatoria
#por cada neurona de la capa oculta
for indNeurona in xrange(0, self.neuronasCapaOculta):
#por cada neurona de la capa de entrada
self.pesosCapaOculta.append([])
self.pesosCapaOculta[indNeurona] = np.random.uniform(-0.5,0.5,size=(self.nColumnas + 1))
#self.pesosCapaOculta[indNeurona] = map((lambda x: (random.random() - 0.5)), xrange(0, self.nColumnas + 1))
#inicializamos los pesos de la capa de salida
for indNeurona in xrange(0, self.nClases):
self.pesosCapaSalida.append([])
self.pesosCapaSalida[indNeurona] = np.random.uniform(-0.5,0.5,size=(self.neuronasCapaOculta + 1))
#self.pesosCapaSalida[indNeurona] = map((lambda x: (random.random() - 0.5)), xrange(0, self.neuronasCapaOculta + 1))
#self.NguyenWidrow()
#generamos todos los vectores objetivos
vectoresObjetivos = {}
for instancia in data.getListInstances():
vectoresObjetivos[instancia] = self.generaVectorObjetivoSalida(instancia.getClase())
instancias = data.getListInstances()
cuadratico_epoca_anterior = float("inf")
salidaCapaOculta = np.ones(self.neuronasCapaOculta+1)
salidaFinal = np.zeros(self.nClases)
#paso1
for epoca in xrange(0, self.nEpocas):
cuadratico_epoca = 0
print epoca
#paso2 por cada instancia en train
for instancia in instancias:
#***********inicio de Feedforward**********************************
#paso 3, valores de entrada
for indNeurona in xrange(1, self.nColumnas + 1):
self.capaEntrada[indNeurona] = instancia.getElementAtPos(indNeurona - 1)
#paso 4, salida neuronas capa oculta, vector Z
#z0 siempre es 1
#salidaCapaOculta = [1]
#por cada neurona realizamos una salida
for indNeurona in xrange(0, self.neuronasCapaOculta):
suma = reduce((lambda sum, y: sum+y), self.pesosCapaOculta[indNeurona] * self.capaEntrada)
#aplicamos la sigmoidal a la suma, esto nos da la salida de la neurona
#f2
if suma > 200:
salidaCapaOculta[indNeurona + 1] = 1
elif suma < -200:
salidaCapaOculta[indNeurona + 1] = -1
else:
salidaCapaOculta[indNeurona + 1] = (2.0/(1.0 + math.exp( - suma))) - 1.0
#paso 5, calculamos las respuestas de las neuronas de la capa de salida, vector Y
#salidaFinal = []
for indNeurona in xrange(0, self.nClases):
suma = reduce((lambda sum, y: sum+y), self.pesosCapaSalida[indNeurona] * salidaCapaOculta)
#aplicamos la sigmoidal a la suma, esto nos da la salida de la neurona
#f2
if suma > 200:
salidaFinal[indNeurona] = 1
elif suma < -200:
salidaFinal[indNeurona] = -1
else:
salidaFinal[indNeurona] = (2.0/(1.0 + math.exp( - suma))) - 1.0
#***********fin de Feedforward **********************************
#***********inicio Retropropagación del error *******************
#paso 6
#Tk - Yk * f2`(Yin)
deltaMinusculaK = map((lambda x, y: (x - y) * (0.5 * ((1.0 + y) * (1.0 - y)))), vectoresObjetivos[instancia], salidaFinal)
deltaMayusculaJK = []
for indNeuronaSalida in xrange(0, self.nClases):
#calculamos delta mayuscula
deltaMayusculaJK.append([])
aux = deltaMinusculaK[indNeuronaSalida] * self.alpha
deltaMayusculaJK[indNeuronaSalida] = salidaCapaOculta * aux
#paso 7
deltaMinInj = np.zeros(self.neuronasCapaOculta)
for indNeurona in xrange(0, self.nClases):
for indNeuronaOculta in xrange(1, self.neuronasCapaOculta + 1):
deltaMinInj[indNeuronaOculta - 1] += (self.pesosCapaSalida[indNeurona][indNeuronaOculta] * deltaMinusculaK[indNeurona])
#f`2
deltaMinusculaJ = map((lambda x, y: x *(0.5* ((1.0 + y) * (1.0 - y)))),deltaMinInj, salidaCapaOculta[1:])
deltaMayusculaIJ = []
for indNeuronaOculta in xrange(0, self.neuronasCapaOculta):
deltaMayusculaIJ.append([])
aux = self.alpha*deltaMinusculaJ[indNeuronaOculta]
deltaMayusculaIJ[indNeuronaOculta] = aux * self.capaEntrada
#paso 8
#Actualizar pesos y sesgos
for indiceClase in xrange(0, self.nClases):
self.pesosCapaSalida[indiceClase] = self.pesosCapaSalida[indiceClase] + deltaMayusculaJK[indiceClase]
for indiceNOculta in xrange(0, self.neuronasCapaOculta):
self.pesosCapaOculta[indiceNOculta] = self.pesosCapaOculta[indiceNOculta] + deltaMayusculaIJ[indiceNOculta]
#fin de bucle de instancias
if self.activo_control_fin == True and epoca % 5 == 0:
#error = self.getECMFromInstances(self.conjuntoValidacion)
#print self.lastError
#print error
error = self.getErrorFromInstances(self.conjuntoValidacion)
if self.lastError < error:
break
else:
#print str(epoca)+ '\t' + str(error)
self.lastError = error