Prica 3: Reconocimiento de

Caracteres (Vocales)
Llanes Snchez Ronnie David
ronniellanes@hotmail.com
Lara Serrano Jairo Miguel
Jairo-lara@live.com
Universidad de Cuenca
Facultad de Ingeniera
Escuela de Electrnica y Telecomunicaciones
I.

Reconocimiento de Caracteres: Vocales

La siguiente prctica tiene como objetivo el reconocimiento de caracteres (vocales), a travel co de Back
Propagation que se ha empleado en prcticas anteriores, para lo cual se deber tener en consideraci la simulaci
clculo de los pesos y bias mos a partir de la matriz ingresada al sistema con respecto del vector de salida
deseada a travel nmero de capas ocultas que el usuario lo desee, donde cabe resaltar que segn la propuesta para
la realizaci esta prctica, se debe de leer archivos bmp para cada letra, donde se explicar manera detallada de
como ha sido implementado el programa, mediante la realizacin del GUIDE en
, para lo cual se utiliza
el mdo llamado Perceptrlticapa.

Matlab

El perceptrlticapa es una red neuronal articial (RNA) formada por capas, que se clasican como la
capa de entrada, las capas ocultas y la capa de salida, permitiendole resolver problemas que no son linealmente
separables, siendo que este puede ser totalmente o localmente conectado. Las propiedades de cada capa son:
1) Capa de entrada: Son aquellas neuronas que conforman el patr entrada de la red
2) Capas ocultas: Son aquellas neuronas en las cuales sus entradas corresponden de las capas anteriores y las
salidas de estas van a ser las entradas de las capas siguientes.
3) Capa de Salida: Son las neuronas que obtienen los resultados correspondientes, dependiendo del ansis o
entrenamiento de la red.
La estructura de esta red se lo puede observar grcamente en la Figura 1.

Figura 1: Arquitectura de la red

El set de entrenamiento para esta prctica consiste en 10 diferentes muestras o patrones para cada una de las
vocales, siendo una imagen binaria o bmp de 8x8 pixel. De manera se debe de tomar en cuenta que los pxeles
que denotan el fondo blanco, se representan con un 1, y los demomo un 0, como se observa en la gura 2.
El aprendizaje de esta red esta dada de la siguiente forma:
1

Figura 2: Reprecentacin de caracteres

1) Inicializar los pesos y los umbrales iniciales de cada neurona. Hay varias posibilidades de inicializaciiendo
la ms comn la que se introducen valores aleatorios peque
2) Para cada patrl conjunto de los datos de entrenamiento
a) Obtener la respuesta de la red ante ese patrsta parte se consigue propagando la entrada hacia adelante,
ya que este tipo de red es feedforward. Las salidas de una capa sirven como entrada a las neuronas de
la capa siguiente, procesando de acuerdo a la regla de propagacia funci activacirrespondientes.
b) Calcular los errores asociados mediante ecuaciones.
c) Calcular los incrementos parciales. Estos incrementos dependen de los errores calculados en 2.b
3) Calcular el incremento total ,para todos los patrones, de los pesos y los umbrales segn las expresiones en
las ecuaciones.
4) Actualizar pesos y umbrales
5) Calcular el error actual y volver al paso 2 si no es satisfactorio.
En el principio del co se observa los partros y funciones propios al momento de generar el GUIDE en el
software de
en los cuales tomar los parametros por default del programa si el usuario no ha realizado
cambios en el nombre del las variables del cuadro de texto o de los botones, si el usuario produce cambios en
las llamadas a esos cuadros, deber el usuario de estar pendiente en el momento de llamar a un valor colocado
en un cuadro o ponerlo, ya que debe de identicar los nombres correctamente para no generar errores. No se
profundizar en detalle las funciones que se crea por default, sino en la implementacin del programa. En la
siguiente gura se mostrar el guide utilizado para esta prctica.

Matlab

Figura 3: Guide Reconocimiento de caracteres.

A continuaci muestra la programacin del bot en los cuales debernstar con los pesos y bias entrenados
por la red, para que el usuario al momento de comparar los datos en el Panel de comprobacitenga los resultados
deseados, se recomienda al lector que proceda a leer el co de programacia que detalla la consecuci un proceso, la
obtenci partros y los culos necesarios para el programa. Para iniciar el bottrenar se debe de colocar el numero de
Neuronas Ocultas que se desea utilizar, ademas de colocar el partro de aprendizaje (alfa), nmero de interacciones
que se desee, y por ltimo la tolerancia de error que debe de tener el sistema. Co del Bottrenar:
188
189
190
191
192
193

% --- Executes on button press in Entrenar.

function Entrenar_Callback(hObject, eventdata, handles)
% hObject
handle to Entrenar (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles
structure with handles and user data (see GUIDATA)

194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235

%%Establecemos las matrices de imagenes como vectores y las almacenamos en

%%una sola matriz de entradas
%row es el numero que posee cada imagen en el nombre
%vocal es la letra que posee cada imagen
for j=1:50
if j>40
row=j-41;
vocal='u';
elseif j>30
vocal='o';
row=j-31;
elseif j>20
vocal='i';
row=j-21;
elseif j>10
vocal='e';
row=j-11;
else
vocal='a';
row=j-1;
end
pos = int2str(row);
%Lee una imagen y la guarda en X
X=imread(strcat(vocal,pos,'.bmp'));
%Asigna a auxiliar la primera fila de X
aux=X(1,:);
for i =2:8
^^I
%Concatena los dos vectores fila en una sola
aux=cat(2,aux,X(i,:));
end
Entradas(j,:)= aux;
end
%%
%Generamos la matriz que almacena las salidas deseadas
for j=1:50 %50 imagenes de entrenamiento
if j>40 %Cada 10 espacios cambiamos de entrada
vector=[0,0,0,0,1];%Para las salidas de u
elseif j>30
vector=[0,0,0,1,0];%Para las salidas de o
elseif j>20

236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292

vector=[0,0,1,0,0];%Para las salidas de i

elseif j>10
vector=[0,1,0,0,0];%Para las salidas de e
else
vector=[1,0,0,0,0];%Para las salidas de a
end
%A\protect \begingroup \immediate \write \@unused \def \MessageBreak
\let \protect \edef Your command was ignored.\MessageBreak Type I <command> <return> to replace it
(inputenc)
\def \errmessage Package inputenc Error: Unicode char \u8: not set up fo
See the inputenc package documentation for explanation.
Type H <return> for immediate help \endgroup mos el valor a la salida
salidas(j,:)=vector;
end
%%
%En este bloque se realiza el entrenamiento de la red

%----------------------------------------------------------%Declaramos variables globales para los pesos y bias

global WO;
%Pesos capa oculta
global WS;
%Pesos capa de salida
global BiasO; %Bias capa oculta
global BiasS; %Bias capa de salida
%----------------------------------------------------------%Leemos los valores iniciales desde la interfaz
% n: numero de neuronas de la capa oculta
n=str2double(get(handles.nOcultas,'String'));
% maxIter: limitaci\protect \begingroup \immediate \write \@unused \def \MessageBreak
\let \protect \edef Your command was ignored.\MessageBreak Type I <command> <return> to replace it
(inputenc)
\def \errmessage Package inputenc Error: Unicode char \u8: d not set up

See the inputenc package documentation for explanation.

Type H <return> for immediate help \endgroup e iteraciones
maxIter=str2double(get(handles.maxIter,'String'));
% alfa ingresado
alfa=str2double(get(handles.alfa,'String'));
% maxError: Error m\protect \begingroup \immediate \write \@unused \def \MessageBreak
\let \protect \edef Your command was ignored.\MessageBreak Type I <command> <return> to replace it
(inputenc)
\def \errmessage Package inputenc Error: Unicode char \u8:xi not set up
See the inputenc package documentation for explanation.
Type H <return> for immediate help \endgroup mo permitido
maxError=str2double(get(handles.maxError,'String'));
%----------------------------------------------------------%Inicializamos los pesos y bias aleatoriamente entre -1 y 1
WO=rand(64,n)*2-1;
WS=rand(n,5)*2-1;
BiasO=rand(n,1)*2-1;
BiasS=rand(5,1)*2-1;
%----------------------------------------------------------%
contador=0;
for k=1:maxIter
contador=contador+1;
for i=1:50
for j=1:n

^^I%Calculamos la salida de las neuronas de la capa oculta

sOculta(j,1)=(Entradas(i,:)*WO(:,j))+BiasO(j,1);
%Aplicamos la funcion de activacion
sOculta(j,1)=1/(1+exp(-sOculta(j,1)));
end
for j=1:5
^^I%Calcula las salidas de la capa de salida
salidaRed(1,j)=((WS(:,j))'*sOculta(:,1))+BiasS(j,1);
%Aplica la funcion de activacion a las neuronas de salida
salidaRed(1,j)=1/(1+exp(-salidaRed(1,j)));
%Calcula el cuadrado de la diferencia entre la salida deceada y la obtenida
falla(1,j)=(salidas(i,j)-salidaRed(1,j))^2;
end
%Calcula el error de la muestra al sumar todos los valores de la variable falla
ErrorN(i,1)=0.5*(falla*ones(5,1));
for j=1:5
^^I%Calcula los deltas de la ultima capa
deltaS(j,1)=(salidas(i,j)-salidaRed(1,j))*salidaRed(1,j)*(1-salidaRed(1,j));
for l=1:n
^^I%Calculamos los nuevos pesos de las entradas de las neuronas de salida
WS(l,j)=WS(l,j)+alfa*deltaS(j,1)*sOculta(l,1);
end
%Calculamos los nuevos Bias de las neuronas de salida
BiasS(j,1)=BiasS(j)+alfa*deltaS(j,1);
end
for j=1:n
^^I%Calcula los deltas de la capa oculta
deltaO(j,1)=sOculta(j,1)*(1-sOculta(j,1))*(WS(j,:)*deltaS(:,1));
for l=1:64
^^I%Calcula los nuevos pesos de las entradas de las neuronas ocultas
WO(l,j)=WO(l,j)+alfa*deltaO(j,1)*Entradas(i,l);
end
BiasO(j,1)=BiasO(j,1)+alfa*deltaO(j,1);
end

293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339

end

end
%Calcula el error total de una iteracion luego de recorrer todas las muestras
ERROR(k,1)=(1/50)*(ones(1,50)*ErrorN(:,1));
if ERROR(k,1)<maxError
break;
end

set(handles.FinalError,'String',ERROR(contador));
set(handles.TotalIter,'String',contador);
axes(handles.graficaError);
ejex=0:contador-1;
plot(ejex,ERROR);

Se obtiene los valores del guide como se estableci anterioridad, en los cuales pasa a tomar los valores ingresados por el comando str2num(char(get(handles.variable, String ))), ya que este devuelve un valor entero
del cuadro de texto del GUIDE, ya que se ingresa en forma de
, por lo que es necesaria esta conversin,
para proceder a la realizacil clculo de la salida del sistema, logrando despus una parametrizacin del sistema
dando un redondeo del valor obtenido de la salida de la neurona entrenada.

String

Para que el dato generado se muestre en un cuadro de texto de GUIDE se utilizara

set(handles.N ombredelCuadroaColocarelresultado, string , variableaColocar);

En el cual colocar valor de la variable que deseamos en el Nombre establecido por el guide. El programa
nos da como resultado el error nal, las interacciones realizadas y la grca de convergencia de la red, despue
entrenar a la red.
A continuaci mostrar el botobar, para observar el adecuado funcionamiento de la red, comparando la imagen
inicial con la imagen de salida.
188
189
190
191
192
193

% --- Executes on button press in probar.

function probar_Callback(hObject, eventdata, handles)
%% hObject
handle to probar (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles
structure with handles and user data (see GUIDATA)

194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236

%----------------------------------------------------------%Variables globales para los pesos y bias

global WO;
%Pesos capa oculta
global WS;
%Pesos capa de salida
global BiasO; %Bias capa oculta
global BiasS; %Bias capa de salida
%----------------------------------------------------------;% Obtenemos la posicion del slider para operar sobre la vocal en esa posicion
valorSlider=round(get(handles.vocalNum,'Value'))
%n: El valor de las neuronas intermedias
n=str2double(get(handles.nOcultas,'String'));
%Lee una imagen y la guarda en X
%Asigna a aux la primera fila de X
X=imread(strcat('Pattern',int2str(valorSlider),'.bmp'));
vocalProbar=X(1,:);
for i=2:8
^^I%Concatena los dos vectores fila en una sola
vocalProbar=cat(2,vocalProbar,X(i,:));
end
for j=1:n
^^I%Calculamos la salida de las neuronas de la capa oculta
sOculta(j,1)=(vocalProbar(1,:)*WO(:,j))+BiasO(j,1);
%Aplicamos la funcion de activacion
sOculta(j,1)=1/(1+exp(-sOculta(j,1)));
end
for j=1:5
^^I%Calcula las salidas de la capa de salida
salidaRed(1,j)=((WS(:,j))'*sOculta(:,1))+BiasS(j,1);
%Aplica la funcion de activacion a las neuronas de salida
salidaRed(1,j)=1/(1+exp(-salidaRed(1,j)));
end
%Encontramos el indice del mayor valor del array de salidas que sera el
%indice de la posici\protect \begingroup \immediate \write \@unused \def \MessageBreak
\let \protect \edef Your command was ignored.\MessageBreak Type I <command> <return> to replace it
\def \errmessage Package inputenc Error: Unicode char \u8: d not set up
(inputenc)
See the inputenc package documentation for explanation.
Type H <return> for immediate help \endgroup e salida
[a,b]=max(salidaRed);
% Este es el array de salidas que vamos a mostrar en las salidas de la comprobacion
salidaMostrar='AEIOU';

237
238

II.

;%Mostramos la salida de la red

set(handles.SalidaTest,'String',salidaMostrar(b))
SIMULACI

Para la simulaci pasa a desplegar por el slice las vocales con extencin bmp y ser comprada con la imagen
de salida, con el respectivo entrenamiento de la red, en el cual se debe de colocar los partros correspondientes
para entrenar la red, ademe observar la grca de la convergencia de la red para esta practica a mas del numero
de interacciones necesarias para la convergencia, y el error nal que da la red, mostrando en el campo salida de
la neurona el carer que reconoce el sistema.

Figura 4: Guide del Reconocimiento de letras.

Como se observa, los resultados de comprobacirresponden al del sistema deseado, por lo que la red ha
entrenado correctamente, produciendo una grca satisfactoria en la convergencia de la red o del sistema, dando
a conocer los datos utilizados para el correcto ansis, adems de indicar las interacciones que le ha tomado al
programa para su convergencia y el error nal.
III.

CONCLUSIONES

La red del perceptrn multicapa funciona adecuadamente para el reconocimiento de caracteres, dando
sus respectivos valores correctos para la salida deseada. De modo que se pudo disena interfaz grca que resuelve este problema. Por lo que el algoritmo de retropropagaciack propagation funciona bien, para el error asignado.
En algunos casos la red no reconoce el carer correspondiente debido a que si entrena mal la red, el entrenamiento de la red puede ser defectuoso, provocando errores en la salida de la red.
IV.

REFERENCIAS

[1] Galvan Isasi, Redes Neuronales Articiales, Pearson Education, Madrid, 2004.
[2] http://es.wikipedia.org/wiki/Perceptrulticapa