I.

INTRODUCCION:

En los ltimos aos la inteligencia artificial viene brindando soluciones en muchos aspectos
en la vida diaria de la persona. Uno de los temas de la IA que ha alcanzado trascendental
importancia es redes neuronales artificiales y en dicho tema, una de las aplicaciones ms
importantes es el reconocimiento de patrones.

El reconocimiento de patrones es el reconocimiento de caractersticas nicas que
identifican un sujeto de los dems de la misma especie. Un patrn es una entidad a la que
se le puede dar un nombre y que est representada por un conjunto de propiedades
medidas y las relaciones entre ellas.

Un sistema de reconocimiento de patrones tiene uno de los siguientes objetivos:
Identificar el patrn como miembro de una clase ya definida (clasificacin supervisada).
Asignar el patrn a una clase todava no definida (clasificacin no supervisada,
agrupamiento o clustering).

II. OBJETIVOS:

Plantear un sistema de reconocimiento de patrones en una matriz de 9x7.
Usar el Toolkit de Matlab de Redes Neuronales para implementar el sistema .
Tener un mayor entendimiento de RNA y su programacin en Matlab adems de entender como
programar el GUIDE de Matlab y adaptarlo a las matrices del programa

III. MARCO TEORICO:

Redes Neuronales Artificiales (RNA) :

Son modelos matemticos construidos basndose en el funcionamiento de las redes
neuronales biolgicas (sistema nervioso), por consiguiente, las unidades de procesamiento
fundamental de una RNA, sern las neuronas artificiales.
Una red neuronal artificial la definiremos como un conjunto de unidades de procesamiento
llamados neuronas, clulas o nodos, interconectados entre s por varias ligaduras de
comunicacin directa llamadas conexiones, con la finalidad de recibir seales de entrada,
procesarlas y emitir seales de salida. Cada conexin est asociada a un peso, que
representan la informacin utilizada por las neuronas para resolver un problema.

Perceptron:

Es un tipo de red neural artificial. Tambin puede entenderse como perceptron la neurona
artificial y unidad bsica de inferencia en forma de discriminador lineal. ste consiste en una
suma de las seales de entrada, multiplicadas por unos valores de pesos escogidos
inicialmente en forma aleatoria. En una fase en la que ste aprende, la entrada se compara
con un patrn preestablecido para determinar la salida de la red. Si en la comparacin la
suma de las entradas multiplicadas por los pesos es mayor o igual que el patrn
preestablecido.





Como se muestra en la figura: Las entradas representadas por la variable "X", los pesos para
cada entrada representado por "w", el perceptron que utilizara una funcin de pertenencia
y finalmente la salida o respuesta esperada luego del aprendizaje.



Entrenamiento de la Red:

Se denomina entrenamiento al proceso de configuracin de una red neuronal para que las
entradas produzcan las salidas deseadas a travs del fortalecimiento de las conexiones. Una
forma de llevar esto acabo es a partir del establecimiento de pesos conocidos con
anterioridad, y otro mtodo implica el uso de tcnicas de retroalimentacin y patrones de
aprendizaje que cambian los pesos hasta encontrar los adecuados.
Adems, el aprendizaje puede dividirse en supervisado o asociativo y no supervisado o auto-
organizado.
En el primer caso se introducen entradas que corresponden a determinadas salidas, ya sea
por un agente externo o por el mismo sistema. En el segundo caso el entrenamiento se
enfoca a encontrar caractersticas estadsticas entre agrupamientos de patrones en las
entradas. Un tipo de regla que se usa para el entrenamiento mediante el ajuste de pesos es
la Hebbiana, propuesta por Hebb en 1949 y que ha dado pie a diversas variantes
propuestas en el transcurso del tiempo. Si dos unidades j y k estn activas al mismo tiempo,
la conexin entre las dos debe ser fortalecida mediante la modificacin del peso:

donde "" es una constante de proporcionalidad positiva que representa la tasa de
aprendizaje. Otra regla usada comnmente implica el ajuste de los pesos a travs de la
diferencia entre la activacin actual y la deseada; se le conoce como Regla Delta:

Las redes de una capa , presentan las entradas directamente conectadas a las salidas
mediante pesos. Cada unidad como las que muestra la figura produce salidas de la forma:



El algoritmo de aprendizaje del perceptrn funciona para aprender funciones binarias
linealmente separables, ya que de otra manera el algoritmo no convergera ni producira la
mejor solucin. Debido a que las salidas son binarias, se emplean unidades lineales de
umbral. Cada unidad calcula la suma "u" con pesos de las "N" entradas x
j
, j = 1N, y genera
una salida binaria "y":

{




De una forma alterna, se tiene en un intervalo de cero a uno,


{




El algoritmo se define como:
1)Fijar pesos iniciales, con valores aleatorios
2) Establecer los valores de entradas x1,x2..,xn
3) calcular la salida de la neurona
(

)
4) Actualizar los pesos



5) continuar hasta


En caso de no cumplir con la condicin del paso 5, se regresa de nuevo al punto 3.


Otros tipos de Funciones de pertenencia:















IV. PLANTEAMIENTO DEL PROYECTO

El proyecto planteado con redes neuronales para el reconocimiento de patrones (cuadrado,
rectngulo, circulo, rombo, elipse). Se plantea la matriz de 9x7 donde se ingresaran los datos,
adems se plantean los patrones para cada uno de 3 tres patrones entrenados.

Usando el GUIDE de Matlab se crea una matriz de 9x7 adems se crea botones para activar el
entrenamiento de la red neuronal, el reconocimiento del patrn ingresado y Limpiar la matriz
ingresada.

El cdigo de programacin nos planteamos en tres partes:

El Guide hecho en Matlab programado para el ingreso de datos de la matriz para comparar
la entrada con los patrones.
Patrones que se ingresaran para comparar con el ingreso de la matriz de entrada.
Programa de la red neuronal, basado en el Toolkit de Matlab para entrenar.

Interfaz Grafica con GUIDE en MATLAB











Patrones que se plantean para la Red Neuronal

%Patrones a utilizar
%funcion cuadrado
cua1=[ 1 1 1 1 1 1 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 1 1 1 1 1 1;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
cua2=[ 0 0 0 0 0 0 0;
1 1 1 1 1 1 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 1 1 1 1 1 1;
0 0 0 0 0 0 0];
cua3=[ 0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 1 1 1 1 0 0;
0 1 0 0 1 0 0;
0 1 0 0 1 0 0;
0 1 0 0 1 0 0;
0 1 1 1 1 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
%funcion rectangulo
rec1=[ 1 1 1 1 1 1 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 1 1 1 1 1 1];
rec2=[ 1 1 1 1 1 1 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 1 1 1 1 1 1;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
rec3=[ 0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
1 1 1 1 1 1 1;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
1 1 1 1 1 1 1];
%funcion rombo
rom1=[ 0 0 0 1 0 0 0;
0 0 1 0 1 0 0;
0 1 0 0 0 1 0;
1 0 0 0 0 0 1;
0 1 0 0 0 1 0;
0 0 1 0 1 0 0;
0 0 0 1 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
rom2=[ 0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 1 0 0 0;
0 0 1 0 1 0 0;
0 1 0 0 0 1 0;
1 0 0 0 0 0 1;
0 1 0 0 0 1 0;
0 0 1 0 1 0 0;
0 0 0 1 0 0 0];
rom3=[ 0 0 0 0 0 0 0;
0 0 0 1 0 0 0;
0 0 1 0 1 0 0;
0 1 0 0 0 1 0;
1 0 0 0 0 0 1;
0 1 0 0 0 1 0;
0 0 1 0 1 0 0;
0 0 0 1 0 0 0;
0 0 0 0 0 0 0];
%funcion circulo
cir1=[ 0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 1 1 1 0 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 0 1 1 1 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
cir2=[ 0 0 1 1 1 0 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 0 1 1 1 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
cir3=[ 0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 1 1 1 0 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 1 0 0 0 1 0;
0 0 1 1 1 0 0];
%funcion elipse
eli1=[ 0 0 1 1 1 0 0;
0 1 0 0 0 1 0;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
0 1 0 0 0 1 0;
0 0 1 1 1 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
eli2=[ 0 0 0 0 0 0 0;
0 0 1 1 1 0 0;
0 1 0 0 0 1 0;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
0 1 0 0 0 1 0;
0 0 1 1 1 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
eli3=[ 0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 1 1 1 0 0;
0 1 0 0 0 1 0;
1 0 0 0 0 0 1;
1 0 0 0 0 0 1;
0 1 0 0 0 1 0;
0 0 1 1 1 0 0];

Programa de entrenamiento de Red Neuronal:

%Matriz P para presentar los patrones de entrada de la red neuronal a entrenar
P=[cua1(:) cua2(:) cua3(:) rec1(:) rec2(:) rec3(:) rom1(:) rom2(:) rom3(:) cir1(:) cir2(:) cir3(:) eli1(:)
eli2(:) eli3(:)];
%Matriz T para las salidas asignadas a cada uno de los valores de entrada respectivamente
T=[ 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 ;
0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 ;
0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 ];
V=[0 1 0 1];
%Los valores mnimos y mximo de cada entrada son
PR=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1;
0 1;0 1;0 1;0 1;0 1;0 1;0 1];
[R,Q]=size(P);
[S,Q]=size(T);
%Inicializacion de red y planteamiento de aleatorio de sus valores de sus pesos y bias
red=newp(PR,S);
red.inputweights{1,1}.initFcn= 'rands';
red.biases{1}.initFcn='rands';
red=init(red);

disp_freq=1;
max_epoch=10000;
W=red.IW{1,1};
B=red.b{1};
pesos1=[W(1,1)];
pesos2=[W(1,2)];
umbrales = [B];
%FASE DE PRESENTACIN
%Correccin de la red mediante los errores de confrontacion de las salidas esperadas con las
obtenidas.
A=sim(red,P);
e=T-A;
for epoch=1:max_epoch
%FASE DE REVISION
if all(e==0),epoch=epoch-1; break, end
%FASE DE APRENDIZAJE
dW=learnp(W,P,[],[],[],[],e,[],[],[],[],[]);
dB=learnp(B,ones(1,Q),[],[],[],[],e,[],[],[],[],[]);
W=W+dW;
B=B+dB;
red.IW{1,1}=W;
red.b{1}=B;
A=sim(red,P);
e=T-A;
end
% Resumen de resultados
%==================
[a,b]=size(T);
fprintf('Entrenada en %0.0f iteraciones. \n',epoch)
fprintf('Red de clasificada: ');
if all(sim(red,P)==T)
msgbox('Red clasificada Correctamente');
else
disp('Incorrectamente.')
end

Desarrollo experimental:

Ingreso de rectngulos a la red con respuestas



Figura para Rectangulo 1






Figura para Rectangulo 2



Figura para Rectangulo 3






Ingreso de crculos a la red con respuestas



Figura para Circulo 1



Figura para Circulo 2



Figura para Circulo 3

Ingreso de rombo a la red con respuestas



Figura para Rombo 1







Figura para Rombo 2



Figura para Rombo 3




RESULTADO FINAL:

Los resultados como podemos ver en las imgenes mostradas son satisfactorios, donde
diferentes patrones introducidos producen diferentes respuestas y son adecuadas.
El entrenamiento de las redes permite un desarrollo de sistema ms optimo de acuerdo al
nmero de patrones base que se plantean al inicio del entrenamiento.

V. CONCLUSIONES:

El programa que se desarrollo cumple como se desea.
Aumentar los patrones para cada figura aumenta la posibilidad de aumentar la precisin del
sistema.
En caso de aumentar en exceso el entrenamiento puede resultar en un error mayor de la
red neuronal.
Las redes neuronales nos permiten clasificar diferentes elementos, solo hay que saber
considerar los patrones que interfieren o ruidos que hallan en las entradas.

VI. BIBLIOGRAFIA

http://cvb.ehu.es/open_course_ware/castellano/tecnicas/redes_neuro/contenidos/pdf/libro-
del-curso.pdf
http://halweb.uc3m.es/esp/Personal/personas/jmmarin/esp/DM/tema3dm.pdf
http://www.iac.es/sieinvens/SINFIN/Sie_Courses_PDFs/NNets/confiac.pdf

Documentos

Robot Seguidor de Contorno
Inteligencia Artificial Aplicaciones a la Ingenieria, Pedro Ponce Cruz
Neural Network Design - Martin Hagan
Manual Matlab The Language of Technical Computing