Академический Документы
Профессиональный Документы
Культура Документы
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
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
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
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.
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)
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.
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.
ni = i (wij , xj )
X
ni = wij xj
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.
yi = Fi (ai ) = ai (2)
6
Figure 3: (Funciones de activacion)
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.
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.
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)
Xn
ai = f( wij xj ); f = lineal
j
n
X
ai = wij xj
j
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:
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
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
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
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 ) )
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)
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:
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
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 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 ) )
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 ( )
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
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)
18