-aportaciones a la fase 3
-aportaciones a la parte de Backpropagation le ayude a mi companera blanca a realizar el codigo.
Para lo del backpropagation me base en el siguiente pdf:http://webdelprofesor.ula.ve/economia/gcolmen/programa/redes_neuronales/capitulo2_backpropagation.pdf
codigo :
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from random import uniform | |
from sys import argv | |
from math import exp | |
from numpy import* | |
from subprocess import call | |
import os | |
###### | |
class Red(object): | |
def __init__(self,dimension,cantidadCapas,cantidadEntradas,aprendizaje,salidaDeseada): | |
self.capas=list() | |
self.capa=1 | |
self.salidaDeseada=salidaDeseada | |
self.cantidadCapas=cantidadCapas | |
self.entradasCapaSalida=list() | |
self.listaZ=list() | |
self.listaN=list() | |
for numCapa in range(cantidadCapas): | |
self.agregarCapas(numCapa,dimension,cantidadCapas,cantidadEntradas,aprendizaje) | |
def calcularN(self,entradas,pesos): | |
return sum(entradas*pesos) | |
def calcularZ(self,n): | |
return 1/(1+exp(-n)) | |
def calcularSalida(self,entradasCapaSalida): | |
entradasCapaSalida.append(1) | |
for neurona in self.capas[1].neuronas: | |
n=self.calcularN(neurona.pesos,entradasCapaSalida) | |
z=self.calcularZ(n) | |
#print 'n',n | |
#print 'z',z | |
self.s1=self.calcularS1(z) | |
#print 's1',self.s1 | |
def agregarCapas(self,numCapa,dimension,cantidadCapas,cantidadEntradas,aprendizaje): | |
print "Ingrese la cantidad de neuronas para la capa",numCapa | |
cantidadNeuronas=int(raw_input("")) | |
self.capa=Capa(numCapa,dimension,cantidadNeuronas,aprendizaje,cantidadEntradas) | |
self.capas.append(self.capa) | |
def calcularS1(self,z): | |
return z*((1-z)*(self.salidaDeseada-z)) | |
def calcularS2(self,peso,z): | |
#print z,'*((1-',z,')*(',self.s1,'*',peso,'))' | |
return z*((1-z)*(self.s1*peso)) | |
###### | |
class Capa(object): | |
def __init__(self,numCapa,dimension,cantidadNeuronas,aprendizaje,cantidadEntradas): | |
tamano=dimension+1 | |
self.neuronas=list() | |
for i in range(cantidadNeuronas): | |
print "agregando neurona",i | |
self.agregarNeurona(numCapa,tamano,aprendizaje,cantidadEntradas) | |
def agregarNeurona(self,numCapa,tamano,aprendizaje,cantidadEntradas): | |
self.neurona=Neurona(numCapa,tamano,aprendizaje,cantidadEntradas,) | |
#print "Pesos:\n",self.neurona.pesos | |
#print "Entradas:\n",self.neurona.entradas | |
self.neuronas.append(self.neurona) | |
###### | |
class Neurona(object): | |
def __init__(self,numCapa,tamano,aprendizaje,cantidadEntradas): | |
if numCapa !=1: | |
self.pesos = self.generar(tamano,cantidadEntradas) | |
self.entradas = self.generarEntradas(tamano,cantidadEntradas) | |
else: | |
self.pesos=self.generar(tamano,cantidadEntradas) | |
pass | |
def generar(self,tamano,cantidadEntradas): | |
w = zeros([cantidadEntradas,tamano],float) | |
for x in range(cantidadEntradas): | |
for j in range(3): | |
#w[x][j] =random.uniform(-1,1) | |
w[x][j] = 1 | |
return w | |
def generarEntradas(self,tamano,cantidadEntradas): | |
vectorEntradas=zeros([cantidadEntradas,tamano],float) | |
for x in range(cantidadEntradas): | |
for j in range(2): | |
vectorEntradas[x][j]=random.uniform(-1,1) | |
vectorEntradas[x][2]=1 | |
return vectorEntradas | |
##### | |
def main(): | |
dimension=2 | |
salidaDeseada=1 | |
cantidadCapas=2 | |
cantidadEntradas=1 | |
aprendizaje=.01 | |
red = Red(dimension,cantidadCapas,cantidadEntradas,aprendizaje,salidaDeseada) | |
for neurona in red.capas[0].neuronas: | |
for x in range(cantidadEntradas): | |
n=red.calcularN(neurona.entradas[x],neurona.pesos[x]) | |
z=red.calcularZ(n) | |
red.listaN.append(n) | |
red.listaZ.append(z) | |
red.entradasCapaSalida.append(z) | |
#print 'n',x,'=',n | |
#print 'z',x,'=',z | |
print '\n' | |
red.calcularSalida(red.entradasCapaSalida) | |
red.listaZ.append(1) | |
#calculo el error | |
pesosNuevos_capaSalida=list() | |
for neurona in red.capas[1].neuronas: | |
for j in range(3): | |
#calcula los pesos nuevos de la capa de salida | |
print 'pesos nuevos en capa de salida',neurona.pesos[x][j]*red.s1*red.listaZ[j] | |
pesosNuevos_capaSalida.append(neurona.pesos[x][j]*red.s1*red.listaZ[j]) | |
listaS2=list() | |
#guardo los pesos nuevo de la capa de salida | |
red.capas[1].neurona.pesos=pesosNuevos_capaSalida | |
print red.capas[1].neurona.pesos | |
for neurona in red.capas[0].neuronas: | |
for peso in neurona.pesos: | |
listaS2.append(red.calcularS2(peso[x],red.listaZ[x])) | |
#print red.calcularS2(peso[x],red.listaZ[x]) | |
pesosNuevos_capaOculta=list() | |
for k,neurona in enumerate(red.capas[0].neuronas): | |
for j,entrada in enumerate(neurona.entradas): | |
for x in range(3): | |
#print entrada[x],listaS2[0] | |
#nuevos pesos de la capa oculta | |
print 'pesos nuevos en capa oculta' | |
print 'peso nuevo',entrada[x]*listaS2[k] | |
pesosNuevos_capaOculta.append(entrada[x]*listaS2[k]) | |
#guardo los pesos nuevo de la capa oculta | |
neurona.pesos=pesosNuevos_capaOculta | |
main() |
Aqui el repositorio del equipo:
https://github.com/iosdsv/Redes-Neuronales--Final-