Está en la página 1de 18

Informe Redes Neuronales

Luis Alfredo Sullca Huaracca


May 2017

1 Introduction
Lo primero que se viene a la mente cuando uno escucha sobre inteligencia arti-
ficial es un robot pensante como nosotros , que tiene un cerebro que le permite
tomar dichas decisiones ... esto del todo no esta mal , puesto a que los robots
no poseen cerebros biologicos como nosotros, sin embargo tienen ciertos mecan-
ismos con los cuales lo pueden simular muy bien. Uno de estos mecanismo del
como un programa de computadora puede simular el cerebro humano son las
redes neuronales. Tal y como podemos leer, este mecanismo simulara las tan-
tas cientas , miles , etc de neuronas que nosotros tenemos. El objetivo de este
proyecto es informar el uso de diferentes tipos de redes neuronales, asi como su
implementacion.
Tipos de Redes Neuronales :
Red Neuronal Perceptron

Red Neuronal Adeline


Red Neuronal Multicapa
Aqui es el momento decisivo donde uno decide como construir la red neu-
ronal y como entrenarla. Tal y como lo habiamos mencionado se utilizara
una red multicapa, el cual tendra solamente 2 capas. La primera capa
tendra como funcion de activacion la funcion sigmoidea y la segunda capa
tendra como funcion de activacion la funcion lineal , esto se hace de tal
manera que los valores de salida sean muy flexibles y tengan ciertas car-
acteristicas que mas adelante detallare.
El algoritmo de entrenamiento usado para esta red neuronal es , el al-
goritmo descenso por gradiente , es mas el algoritmo que use se llama
backpropagation en cual hace uso de secuencias ascendiente y descendi-
entes para actualizar sus pesos sinapticos con el fin de reducir la funcion
a optimizar.

De todas estas usaremos la red neuronal multicapa para el reconocimiento


de rostros humanos y de anomalias cardiacas.

1
Contents
1 Introduction 1

2 Tipos de Neuronas 4
2.1 Neurona Natural . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Neurona Artificial . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Definiciones previas : . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3.1 Entradas y Salidas . . . . . . . . . . . . . . . . . . . . . . 5
2.3.2 Pesos Sinapticos . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.3 Regla de Propagacion . . . . . . . . . . . . . . . . . . . . 6
2.3.4 Funcion de activacion . . . . . . . . . . . . . . . . . . . . 6
2.3.5 Funcion de salida . . . . . . . . . . . . . . . . . . . . . . . 6

3 Arquitectura de un red Neuronal 7


3.1 Aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.1.1 Fase de entrenamiento . . . . . . . . . . . . . . . . . . . . 7
3.1.2 Fase de Operacion o validacion . . . . . . . . . . . . . . . 8

4 Tipos de Redes 8
4.1 Red Perceptron . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Red Adeline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3 Red Multicapa . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3.1 Librerias Necesarias . . . . . . . . . . . . . . . . . . . . . 9
4.3.2 Funcion necesaria para el algoritmo : . . . . . . . . . . . . 9
4.3.3 Definiendo las capaz . . . . . . . . . . . . . . . . . . . . . 10
4.3.4 Definiendo los patrones de entrada de prueba y las salidas
esperadas . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.3.5 Inicio de entrenamiento . . . . . . . . . . . . . . . . . . . 11
4.3.6 Verificacion de entrenamiento . . . . . . . . . . . . . . . . 11

5 Reconocimiento de Rostros 11
5.1 Tratamiento de Imagenes . . . . . . . . . . . . . . . . . . . . . . 11
5.1.1 Escala de grises . . . . . . . . . . . . . . . . . . . . . . . . 12
5.1.2 Recorte de Cara . . . . . . . . . . . . . . . . . . . . . . . 12
5.1.3 Redimensionando y pixeleado . . . . . . . . . . . . . . . . 12
5.1.4 Convirtiendo de matriz a vector . . . . . . . . . . . . . . 13
5.2 Entrenamiento y validacion . . . . . . . . . . . . . . . . . . . . . 13
5.2.1 Entrenando Red Neuronal . . . . . . . . . . . . . . . . . . 13
5.2.2 Validando nuevas entradas . . . . . . . . . . . . . . . . . . 15

6 Reconocimiento de Anomalias Cardiacas 15


6.1 Tratamiento de datos . . . . . . . . . . . . . . . . . . . . . . . . . 15
6.2 Leer el archivo ECG.mat . . . . . . . . . . . . . . . . . . . . . . . 15
6.2.1 Impresion de ECG.mat . . . . . . . . . . . . . . . . . . . 16
6.3 Entrenamiento y validacion . . . . . . . . . . . . . . . . . . . . . 17

2
6.3.1 Entrenando Red Neuronal . . . . . . . . . . . . . . . . . . 17
6.3.2 Validacion de nuevas entradas . . . . . . . . . . . . . . . . 18

3
2 Tipos de Neuronas
2.1 Neurona Natural
Una neurona es una celula viva y como tal posee todos los elementos comunes de
las celulas biol
ogicas. A su vez, las neuronas tienen caractersticas propias que
le permiten comunicarse entre ellas, lo que las diferencia del resto de las celulas
biol
ogicas. La figura 1 muestra la estructura tpica de una neurona biologica.

Figure 1: N euronaN atural

De la figura se observa que la neurona biologica esta compuesta por un


cuerpo celular o soma, del cual se desprende arbol de ramificaciones llamado
arbol dendrtico, compuesto por las dendritas. Del soma tambien parte una

fibra tubular, llamada ax on, el cual suele ramificarse cerca de su extremo. Las
dendritas act uan como un canal de entrada de se nales provenientes desde el
exterior hacia la neurona, mientras que el axon act ua como un canal de sal-
ida. El espacio entre dos neuronas vecinas se denomina sinapsis. En el cortex
cerebral se observa una organizacion horizontal en capas, as como tambien una
organizacion vertical en columnas de neuronas. La intensidad de una sinapsis
no es fija, sino que puede ser modificada en base a la informacion proveniente
del medio. De esta manera la estructura del cerebro no permanece fija sino que
se va modificando por la formacion de nuevas conexiones, ya sean excitadoras
o inhibidoras, la destruccion de conexiones, la modificacion de la intensidad de
la sinapsis, o incluso por muerte neuronal. Desde un punto de vista funcional,
las neuronas conforman un procesador de informacion sencillo. Constan de un
subsistema de entrada (dendritas), un subsistema de procesamiento (el soma) y
un subsistema de salida (ax on)

2.2 Neurona Artificial


La neurona artificial es un elemento de procesamiento simple que a partir de un
vector de entradas produce una u nica salida. En general podemos encontrar tres
tipos de neuronas artificiales, donde cada una de las cuales tiene su contraparte
en el sistema nervioso:

4
Las que reciben informacion directamente desde el exterior, a las cuales
se las denomina neuronas de entrada.
Las que reciben informacion desde otras neuronas artificiales, a las cuales
se las denomina neuronas ocultas. Es en estas neuronas, en particular en
sus sinapsis, donde se realiza la representacion de la informacion almace-
nada.
Las que reciben la informacion procesada y las devuelven al exterior. A
estas neuronas se las denomina neuronas de salida.

Figure 2: (N euronaArtif icial)

Patron de entrada , xi (t) Estas provienen del exterior o de otras neu-


ronas.
Peso Sinaptico , wij Representan el grado de comunicacion entre : la
entrada pj y la neurona i.
Regla de propagacion, i (wij , xj ) Integra la informacion proveniente
de las distintas neuronas artificiales y proporciona el valor del potencial
postsin
aptico de la neurona i.
Funcion de activacion, fi (ni ) , Donde ni es la entrada neta segun los
patrones de entrada y los pesos sinapticos. Provee el estado de activacion
de la neurona i
Funcion de salida, Fi (ai ). Donde ai es el valor de estado de la
neurona i. ai = fi (ni )

2.3 Definiciones previas :


2.3.1 Entradas y Salidas
Clasificacion de entradas y salidas:
Binarias Solo admiten dos valores posibles, entre los mas comunes son 0
y 1 o -1 y 1.
Continuas Estas admiten valores dentro de un determinado rango, que
en general puede definirse como [0,1] o [-1,1]

5
2.3.2 Pesos Sinapticos
El peso sinaptico wij define la fuerza de una conexion sinaptica entre la entrada
j y la neurona i. Los pesos sinapticos pueden tomar valores positivos, negativos
o cero. En caso de una entrada positiva, un peso positivo act ua como excitador,
mientras que un peso negativo act ua como inhibidor. En caso de que el peso sea
cero, no existe comunicaci on entre el par de neuronas. Mediante el ajuste de los
pesos sinapticos la red es capaz de adaptarse a cualquier entorno y realizar una
determinada tarea.

2.3.3 Regla de Propagacion


La regla de propagaci
on determina el potencial resultante de la interaccion del
patron de entrada con la neurona i.

ni = i (wij , xj )
X
ni = wij xj
j=1

2.3.4 Funcion de activacion


La funci
on de activaci
on determina el estado de activacion actual de la neurona
en base al potencial resultante ni .
X
ai = fi (ni ) ; ni = wij xj (1)
j=1

Existe muy distintas funciones de activacion, uno es libre a la hora de elegir que
tipo de funcion de activacion usar de las cuales las podemos ver en la figura 3.

2.3.5 Funcion de salida


La funci on de salida proporciona el valor de salida de la neurona, en base al
estado de activacion de la neurona. En general se utiliza la funcion identidad,
es decir:

yi = Fi (ai ) = ai (2)

6
Figure 3: (Funciones de activacion)

3 Arquitectura de un red Neuronal


La organizaci
on y disposicion de las neuronas dentro de una red neuronal se
denomina topologa, y viene dada por :
Numero de capas, donde las capas son una composicion de neuronas en
forma paralela.

Cantidad de Neuronas por capa, las cuales se encuentras uno detras de


otra capa similar a un conexion en serie
Grado de conectividad
Tipo de conexion entre neuronas

3.1 Aprendizaje
Durante la operatoria de una red neuronal podemos distinguir claramente dos
fases o modos de operaci on: la fase de aprendizaje o entrenamiento, y la fase
de operacion o ejecuci
on. Durante la primera fase, la fase de aprendizaje, la
red es entrenada para realizar un determinado tipo de procesamiento. Una vez
alcanzado un nivel de entrenamiento adecuado, se pasa a la fase de operacion,
donde la red es utilizada para llevar a cabo la tarea para la cual fue entrenada.

3.1.1 Fase de entrenamiento


Partiendo de un conjunto de pesos sinapticos aleatorio, el proceso de aprendizaje
busca un conjunto de pesos que permitan a la red desarrollar correctamente una

7
determinada tarea. Durante el proceso de aprendizaje se va refinando iterativa-
mente la soluci
on hasta alcanzar un nivel de operacion suficientemente bueno.
Existen 3 tipos de aprendizaje:
Aprendizaje Supervizado : Se presenta a la red un conjunto de
patrones de entrada junto con la salida esperada. Los pesos se van modif-
icando de manera proporcional al error que se produce entre la salida real
de la red y la salida esperada.
Aprendizaje No Supervizado : Se presenta ala red un conjunto
de patrones de entrada. No hay informacion disponible sobre la salida
esperada. El proceso de entrenamiento en este caso debera ajustar sus
pesos en base a la correlacion existente entre los datos de entrada.
Aprendizaje Por Refuerzo : Este tipo de aprendizaje se ubica entre
medio de los dos anteriores. Se le presenta a la red un conjunto de patrones
de entrada y se le indica a la red si la salida obtenida es o no correcta. Sin
embargo, no se le proporciona el valor de la salida esperada. Este tipo de
aprendizaje es muy u til en aquellos casos en que se desconoce cual es la
salida exacta que debe proporcionar la red.

3.1.2 Fase de Operacion o validacion


Una vez finalizada la fase de aprendizaje, la red puede ser utilizada para re-
alizar la tarea para la que fue entrenada. Una de las principales ventajas que
posee este modelo es que la red aprende la relacion existente entre los datos,
adquiriendo la capacidad de generalizar conceptos. De esta manera, una red
neuronal puede tratar con informacion que no le fue presentada durante de la
fase de entrenamiento.

4 Tipos de Redes
4.1 Red Perceptron
El perceptron es una red neuronal monocapa el cual tiene como funcion de acti-
vacion a Escalon, y es de mucha importancia debido a que fue el primer modelo
que tuvo un mecanismo de entrenamiento que permitia determinar automatica-
mente los pesos sinapticos.
El perceptron es usado para casos donde exista separabilidad lineal y segun
el tamano de las neuronas de salida (S) las puede clasificar en 2S clases, ademas
solo asegura encontrar una respuesta de separabilidad lineal , mas no la mas
eficiente u optima.
El algoritmo que usa para su entrenamiento se llama, algoritmo por correc-
cion de errores. Este algoritmo ajusta los pesos de manera proporcional a la
diferencia entre la salida actual y la salida objetivo.
Xn
ai = f ( wij xj ); f = escalon (3)
j

8
En forma matricial seria :
a = f (W x + b) (4)

4.2 Red Adeline


Es muy similar al perceptron , con el hecho que tambien es una red neuronal
monocapa , sin embargo su funcion de activacion es lineal, esto es debido a que
las se
nales de entrada pueden ser continuas.

Xn
ai = f( wij xj ); f = lineal
j
n
X
ai = wij xj
j

En forma matricial seria :


a = Wx + b (5)

4.3 Red Multicapa


Es muy similar a los ejemplos anteriores , con la simple diferencia que esta red
neuronal usa mas de 2 capaz (capa de entrada y salida) , sino tambien usa capaz
intermedias las cuales no podremos ver por la cual se llamaran capaz ocultas.

a3 = f 3 (W 3 f 2 (W 2 f 1 (W 1 p + b1 ) + b2 ) + b3 ) (6)
Podria hablar mucho mas de la demostracion del algoritmo de retropropa-
gacion para el entrenamiento de la red multicapa, mejor lo muestro defrente su
implementacion:

4.3.1 Librerias Necesarias

1 import numpy a s np
2 import m a t p l o t l i b . p y p l o t a s p l t

4.3.2 Funcion necesaria para el algoritmo :

1 def d i a g ( x , f = None ) :
2 n = len ( x )
3 temp = np . z e r o s ( [ n , n ] )
4 f o r i in range ( n ) :
5 i f f !=None :
6 temp [ i , i ] = f ( x [ i ] )
7 else :
8 temp [ i , i ] = x [ i ]
9 return temp

9
4.3.3 Definiendo las capaz

1 #Tamano de p a t r o n e n t r a d a :
2 r = 1
3 #Tamano de p a t r o n s a l i d a :
4 s0 = 1
5
6 s = {}
7 W = {}
8 b = {}
9 f = {}
10 df = {}
11
12 a = {}
13 S = {}
14 n = {}
15
16 #La c a n t i d a d de CAPAS
17 M= 2
18
19 s [ 1] = r
20 #D e f i n i e n d o primera capa
21 s [0] = 2
22 W[ 0 ] = np . random . random ( [ s [ 0 ] , s [ 1 ] ] ) ( 2 )1 #Ya e s t a t r a n s p u e s t o
23 b [ 0 ] = np . random . random ( [ s [ 0 ] , 1 ] ) ( 2 )1
24
25 f [ 0 ] = lambda n : 1/(1+np . exp(n ) )
26 d f [ 0 ] = lambda n : (1n ) n
27
28 #D e f i n i e n d o l a segunda capa
29 s [1] = 1
30 W[ 1 ] = np . random . random ( [ s [ 1 ] , s [ 0 ] ] ) 21
31 b [ 1 ] = np . random . random ( [ s [ 1 ] , 1 ] ) 21
32 f [ 1 ] = lambda n : n
33 d f [ 1 ] = lambda n : 1

4.3.4 Definiendo los patrones de entrada de prueba y las salidas


esperadas

1
2 #Problema : Crear una r e d n e u r o n a l c a p a z de aproximar l a s g t
funcion
3 #g ( p ) = 1 + s i n ( np . p i /4 p ) ; 2<=p<=2
4 def g ( p ) :
5 return 1+ np . s i n ( np . p i p / 4 )
6
7 #Generar P con 21 p u n t o s
8 Q = 21
9 P = np . z e r o s ( [ r ,Q] )
10 temp = np . l i n s p a c e ( 2 , 2 , 2 1 )
11 f o r q in range (Q) :
12 P [ : , q ] = temp [ q ]

10
4.3.5 Inicio de entrenamiento

1 #I n i c i o de e n t r e n a m i e n t o de r e d Neuronal
2 Epocas = 1000
3 sigma = 0 . 0 0 1
4 converge = False
5 J = 0
6 epoca = 0
7 while epoca < Epocas and c o n v e r g e != True :
8 s = 0
9 f o r q in range (Q) :
10 temp = np . z e r o s ( [ r , 1 ] )
11 temp [ : , 0 ] = P [ : , q ]
12 #C a l c u l a n d o a , p r o p a g a c i o n
13 a [ 1 ] = temp
14 f o r m in range (M) :
15 n [m] = W[m ] . dot ( a [m1])+b [m]
16 a [m] = f [m] ( n [m] )
17 e r r = g ( temp ) a [M1]
18 s += e r r . T . dot ( e r r )
19 #C a l c u l a n d o S , r e t r o p r o p a g a c i o n
20 S [M1] = 2 d i a g ( n [M 1 ] , d f [M1]) . dot ( e r r )
21 f o r m in range (M2,1,1) :
22 S [m] = d i a g ( a [m] , d f [m] ) . dot (W[m+ 1 ] .T) . dot ( S [m+1])
23 f o r m in range (M) :
24 W[m] = W[m] sigma S [m ] . dot ( a [m 1 ] .T)
25 b [m] = b [m] sigma S [m]
26 J = s /2
27 print ( J )
28 if J < 0.01:
29 c o n v e g e = True
30 break
31 epoca += 1
32
33 print Despues de c o n v e r g e r . . . nos t o c a v e r i f i c a r

4.3.6 Verificacion de entrenamiento

1 print g (P)
2 a = np . a r r a y ( [ [ 0 ] ] )
3 f o r m in range (M) :
4 n = W[m ] . dot ( a )+b [m]
5 a = f [m] ( n )
6 print ( a )

5 Reconocimiento de Rostros
5.1 Tratamiento de Imagenes
El primer paso para el reconocimiento de imagenes estandarizar todas las ima-
genes a tratar con el fin de que todas estas tengan la misma cantidad de pixeles
y solo muestre los datos mas relevantes.

11
1 prepararFotos ()
2 transformarFotos ()
3 toVector ()
4
5 p i c k l e . dump( m a t r i z I m a g e n e s , open ( m a t r i z I m a g e n e s , wb ) )
6 p i c k l e . dump( data , open ( m a t r i z V e c t o r I m g , wb ) )
7 p i c k l e . dump( f o t o s , open ( f o t o s , wb ) )

5.1.1 Escala de grises


Para comenzar primero todas las imagenes que tenemos las debemos pasar a
gris, con el fin de obtener solo la informacion mas importante. En mi caso con
python se haria de la siguiente manera :
1
2 def p r e p a r a r F o t o s ( ) :
3 c a n t F o t o s = len ( f o t o s )
4 f o r i in range ( c a n t F o t o s ) :
5 f o r j in range ( 4 ) :
6 i n d i c e = 4 i + j
7 nombre = . / i m a g e n e s / + f o t o s [ i ] + s t r ( j +1) + . j p g
8 i m a g e n e s . append ( Image . open ( nombre ) . c o n v e r t ( L ) )
9 m a t r i z I m a g e n e s . append ( np . a s a r r a y ( i m a g e n e s [ i n d i c e ] , dtype
=f l o a t ) )

5.1.2 Recorte de Cara


Para el recorte se puede hacer de distintas man-
eras , pero en mi caso opte usar un editor de fo-
tos, gimp con el cual obtuve facilmente las fotos
de las personas con el fin que solo se enfoque la
cara.

5.1.3 Redimensionando y pixeleado


Todas las fotos fueron redimensionadas a un unico tama no de 40 pixeles fila
y 30 pixeles columna. Pero para hacer esto posible se hizo necesario recurrir
al pixeleado , es decir tomar un cierto sector de la matriz original , sacar un
promedio entre ellas , comprobar si dicho valor promedio superaba el umbral o
no , si lo superaba entonces su valor seria 1 en caso contrario seria 0 y llenar en
la matriz imagen nueva con dicho valor. En python esto se haria de la siguiente
forma:
1 def t r a n s f o r m a r ( m a t r i z , newH ,newW) :
2 ( h e i g h t , width ) = m a t r i z . shape
3 print h e i g h t , width

12
4 e s c a l a X = f l o a t ( width ) /newW
5 e s c a l a Y = f l o a t ( h e i g h t ) /newH
6 print e s c a l a X , e s c a l a Y
7 temp = np . z e r o s ( [ newH ,newW] , dtype = f l o a t )
8
9 f o r i in range (newH) :
10 f o r j in range (newW) :
11 i i = escalaY i
12 j j = escalaX j
13 mean = np . mean ( m a t r i z [ i i : i i +e s c a l a Y , j j : j j +e s c a l a X ] )
14 i f mean <132:
15 mean = 0
16 else :
17 mean = 1
18 temp [ i , j ] = mean
19 return temp

1 def t r a n s f o r m a r F o t o s ( ) :
2 c a n t F o t o s = len ( f o t o s )
3 f o r i in range ( c a n t F o t o s ) :
4 f o r j in range ( 4 ) :
5 i n d i c e = 4 i + j
6 matrizImagenes [ i n d i c e ] = transformar ( matrizImagenes [
indice ] ,40 ,30)

5.1.4 Convirtiendo de matriz a vector


Esta fase es importantisima para el manejo de los patrones de entrada en la red
neuronal.
1 data = [ ]
2 def t o V e c t o r ( ) :
3 c a n t F o t o s = len ( f o t o s )
4 f o r i in range ( c a n t F o t o s ) :
5 f o r j in range ( 4 ) :
6 i n d i c e = 4 i + j
7 #t r a n s f o r m a r temp en un v e c t o r de 1200
8 matriz = matrizImagenes [ i n d i c e ]
9 vector = [ ]
10 f o r i i in range ( 4 0 ) :
11 i f i i %2==0:
12 f o r j j in range ( 3 0 ) :
13 v e c t o r . append ( m a t r i z [ i i , j j ] )
14 else :
15 f o r j j in range (29 , 1 , 1) :
16 v e c t o r . append ( m a t r i z [ i i , j j ] )
17 data . append ( v e c t o r )

5.2 Entrenamiento y validacion


5.2.1 Entrenando Red Neuronal
Con el uso del codigo anteriormente mostrado, podemos cambiar simplemente
la seccion de datos de entrada y las salidas esperadas teniendo asi ya nuestro

13
programa que entrena una red para el reconocimiento de rostros. Este a difer-
encia del otro, guardara los pesos sinapticos obtenidos con la finalidad a que
estos pesos sinapticos dejen de ser recalculados nuevamente. Con esto, los uni-
cos cambios serian lo siguiente:

Redefiniendo las capas


1 #Tamano de p a t r o n e n t r a d a :
2 r = 1200
3 #Tamano de p a t r o n s a l i d a :
4 s 0 = len ( f o t o s )
5 #S e s g o , e s l a mitad d e l rango de una d i s t r i b u c i o n uniforme
6 sesgo = 0.001
7 #La c a n t i d a d de CAPAS
8 M= 2
9
10 s [ 1 ] = r #e l tamano d e l p a t r o n de e n t r a d a
11 #D e f i n i e n d o primera capa
12 s [ 0 ] = 2 len ( f o t o s ) #l a c a n t i d a d de neuronas de l a s segunda capa
13 W[ 0 ] = np . random . random ( [ s [ 0 ] , s [ 1 ] ] ) 2 s e s g o s e s g o #Ya e s t a
transpuesto
14 b [ 0 ] = np . random . random ( [ s [ 0 ] , 1 ] ) 2 s e s g o s e s g o
15 f [ 0 ] = lambda n : 1/(1+np . exp(n ) )
16 d f [ 0 ] = lambda n : (1n ) n
17
18 #D e f i n i e n d o l a segunda capa
19 s [ 1 ] = s 0 #La c a n t i d a d de neuronas en l a segunda capa , p e r o como
s o l o tenemos dos c a p a z e n t o n c e s tambn d e f i n e l a s a l i d a
20 W[ 1 ] = np . random . random ( [ s [ 1 ] , s [ 0 ] ] ) 2 s e s g o s e s g o
21 b [ 1 ] = np . random . random ( [ s [ 1 ] , 1 ] ) 2 s e s g o s e s g o
22 f [ 1 ] = lambda n : n
23 d f [ 1 ] = lambda n : 1

Redefiniendo los datos de entrada


1 Q = len ( f o t o s ) 4
2 print Q
3 print len ( m a t r i z V e c t o r I m g )
4 P = np . z e r o s ( [ r ,Q] )
5 #Cargar l a s c a r a s en P
6 temp = m a t r i z V e c t o r I m g
7 #
8 f o r q in range (Q) :
9 P [ : , q ] = temp [ q ]
10 #D e f i n i e n d o l o s v a l o r e s de s a l i d a e s p e r a d a
11 t = np . a r r a y ( [
12 #0 1 2 3 4 5 6 7 8
13 [1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
14 [1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
15 [1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
16 [1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
17 [0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
18 [0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
19 [0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
20 [0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0] ,
21 [0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0] ,
22 [0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0] ,

14
23 [0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0] ,
24 [0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0] ,
25 [0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0] ,
26 [0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0] ,
27 [0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0] ,
28 [0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0] ,
29 [0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0] ,
30 [0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0] ,
31 [0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0] ,
32 [0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0] ,
33 [0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0] ,
34 [0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0] ,
35 [0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0] ,
36 [0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0] ,
37 [0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0] ,
38 [0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0] ,
39 [0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0] ,
40 [0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0] ,
41 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0] ,
42 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0] ,
43 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0] ,
44 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0] ,
45 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1] ,
46 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1] ,
47 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1] ,
48 [0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1] ,
49 ] )
50 # t e s l a t r a n s p u e s t a de t
51 t = t . T

5.2.2 Validando nuevas entradas


Aqui es donde se cargara los pesos sinapticos previamente guardados en el pro-
grama anterior de entrenamiento los cuales se volveran a usar para validar nuevas
entradas muy diferentes a las cuales se presentaron. Tenemos dos opciones para
esta validacion:
Presentar una nueva foto de alguno de los personas con cuales entrenamos
a la red pero con gesto diferentes.
Presentar una foto modificada de alguno de las personas con las cuales
entrenamos a la red.

6 Reconocimiento de Anomalias Cardiacas


6.1 Tratamiento de datos
6.2 Leer el archivo ECG.mat
Para la lectura de este archivo .mat proveniente del lenguaje de MathLab , use
el siguiente codigo :

15
1 import s c i p y . i o
2 import numpy a s np
3 import m a t p l o t l i b . p y p l o t a s p l t
4 import p i c k l e
5 mat = s c i p y . i o . loadmat ( . / ECGVilla . mat )
6 c a n t = len ( mat )

Luego de obtener dicha variable pase a imprimir su valor, el cual me dio un


vector de matrices de tama
no 4048x1, pero no todos eran matrices, habian datos
que no eran por lo cual pase a filtrarlos segun sus nombre usando el siguiente
vector de cadenas:
1 indices = [ # Normal Anomalia1 Anomalia2 Anomalia3
2 yy1 , yy1r1 , yy1r2 , yy1r3 ,
3 yy2 , yy2r1 , yy2r2 , yy2r3 ,
4 yy3 , yy3r1 , yy3r2 , yy3r3 ,
5 yy4 , yy4r1 , yy4r2 , yy4r3 ,
6 yy5 , yy5r1 , yy5r2 , yy5r3
7 ]

Luego de ello pase a imprimir las funciones respectivas de los datos segun el
tiempo y obtuve que en cada grafica habian 7 periodos. Por lo cual es facil
deducir cuantos datos tomar por periodo. 4048/7 = 686
Por lo cual nuestro objetivo era tomar una cierta cantidad de datos igual a
600 , pero como 600 y 686 son relativamente cercanos , entonces opte por tomar
los 686 datos.
El codigo final de Lectura de el archivo ECG.mat es :
1 #Cantidad de e n t r a d a s
2 r = 686 # por p e r i o d o
3 o f f s e t = 415
4 x = np . a r r a y ( [ 4 8 0 8 , 1 ] )
5 x = mat [ time ] [ : , 0 ]
6 x = x [ o f f s e t : o f f s e t +686]
7 tiposDeOndas = 5
8 min = 0
9 data = [ ]
10 f o r i in range ( tiposDeOndas ) :
11 f o r j in range ( 4 ) :
12 i n d e x = 4 i + j
13 y = mat [ i n d i c e s [ i n d e x ] ] [ : , 0 ]
14 y = y [ o f f s e t : o f f s e t +686]
15 data . append ( y )
16 p i c k l e . dump( data , open ( a n o m a l i a s , wb ) )

6.2.1 Impresion de ECG.mat


Si usted busca ver los datos obtenidos por el archivo puede usar el siguiente
codigo, que imprimira las ondas segun su tipo y anomalia que presentan.
1 f o r i in range ( tiposDeOndas ) :
2 plt . figure ()
3 f o r j in range ( 4 ) :

16
4 i n d e x = 4 i + j
5 y = mat [ i n d i c e s [ i n d e x ] ] [ : , 0 ]
6 y = y [ o f f s e t : o f f s e t +686]
7 data . append ( y )
8 p l t . s u b p l o t ( 2 , 2 , j +1)
9 plt . plot (x , y)
10 p l t . t i t l e ( i n d i c e s [ index ] )
11 p l t . show ( )

6.3 Entrenamiento y validacion


6.3.1 Entrenando Red Neuronal
Asi como en el ejemplo problema anterior del reconocimiento de rostros, es solo
cuestion de cambiar los patrones de entrada y las salidas esperadas(objetivo).
1 import numpy a s np
2 import m a t p l o t l i b . p y p l o t a s p l t
3 import p i c k l e
4
5 a n o m a l i a s = p i c k l e . l o a d ( open ( a n o m a l i a s , rb ) )
6 tipos = 5

1 r = len ( a n o m a l i a s [ 0 ] )
2 print r
3 #Tamano de p a t r o n s a l i d a :
4 s0 = 4

1 Q = len ( a n o m a l i a s )
2 print Q
3 print len ( a n o m a l i a s )
4 P = np . z e r o s ( [ r ,Q] )
5 #Cargar l a s c a r a s en P
6 temp = a n o m a l i a s
7 # p r i n t temp
8 #
9 f o r q in range (Q) :
10 P [ : , q ] = temp [ q ]
11 #D e f i n i e n d o l o s v a l o r e s de s a l i d a e s p e r a d a
12 t = np . a r r a y ( [
13 #0 1 2 3 4 5 6 7 8
14 [1 ,0 ,0 ,0] ,
15 [1 ,1 ,0 ,0] ,
16 [1 ,0 ,1 ,0] ,
17 [1 ,0 ,0 ,1] ,
18 [2 ,0 ,0 ,0] ,
19 [2 ,1 ,0 ,0] ,
20 [2 ,0 ,1 ,0] ,
21 [2 ,0 ,0 ,1] ,
22 [3 ,0 ,0 ,0] ,
23 [3 ,1 ,0 ,0] ,
24 [3 ,0 ,1 ,0] ,
25 [3 ,0 ,0 ,1] ,
26 [4 ,0 ,0 ,0] ,

17
27 [4 ,1 ,0 ,0] ,
28 [4 ,0 ,1 ,0] ,
29 [4 ,0 ,0 ,1] ,
30 [5 ,0 ,0 ,0] ,
31 [5 ,1 ,0 ,0] ,
32 [5 ,0 ,1 ,0] ,
33 [5 ,0 ,0 ,1]
34 ] )
35 t = t .T

6.3.2 Validacion de nuevas entradas

1 import numpy a s np
2 import matplotlib . pyplot as p l t
3 import Image
4 import pickle
5
6 t i p o s = [ I , I I , I I I , IV ]
7
8 a n o m a l i a s = p i c k l e . l o a d ( open ( . . / e n t r e n a m i e n t o / a n o m a l i a s , rb ) )
9 W = p i c k l e . l o a d ( open ( . . / e n t r e n a m i e n t o /W , rb ) )
10 b = p i c k l e . l o a d ( open ( . . / e n t r e n a m i e n t o /b , rb ) )
11
12 M = len (W)

Luego de calcular los patrones de salida, debemos indicar como se imprimiran


y saber que tipo y anomalia presenta .
1 out = P u l s o C a r d i a c o de t i p o + t i p o s [ i n t ( np .
round ( a [ 0 ] 1 ) ) ] +
2
3 E s t a d o s = { 0 : Normal , 1 : Anomalia 1 , 2 : Anomalia 2 , 3 : Anomalia 3 }
4
5 max = 1
6 f o r i in range ( 1 , 4 ) :
7 i f a [ i ] > a [max ] :
8 max = i
9 temp = np . round ( a [max ] )
10 i f temp == 0 :
11 max = 0
12 out += E s t a d o s [max]
13
14 print out

18