Reconocimiento de caracteres El reconocimiento de caracteres es una aplicación que permite reconocer los caracteres de un documento que haya sido previamente escaneado. El método usado puede extenderse al reconocimiento de formas en imágenes digitales. El primer paso es "limpiar" el documento escaneado, por lo que pueden ser útil este algoritmo. Supóngase letras que se hayan definido en una matriz de 7x5. Por ejemplo la representación de las letras A y B se presenta a continuación | 0 | 0 | 1 | 0 | 0 | | 0 | 1 | 0 | 1 | 0 | | 0 | 1 | 0 | 1 | 0 | | 1 | 0 | 0 | 0 | 1 | | 1 | 1 | 1 | 1 | 1 | | 1 | 0 | 0 | 0 | 1 | | 1 | 0 | 0 | 0 | 1 |
| | 1 | 1 | 1 | 1 | 0 | | 1 | 0 | 0 | 0 | 1 | | 1 | 0 | 0 | 0 | 1 | | 1 | 1 | 1 | 1 | 0 | | 1 | 0 | 0 | 0 | 1 | | 1 | 0 | 0 | 0 | 1 | | 1 | 1 | 1 | 1 | 0 |
|
Los ceros y unos que representan a una letra se pueden recomponer para definir una matriz de entrada equivalente a 26 letras del abecedario. Para ello se ubica cada fila de la matriz de puntos a continuación de la fila previa, por ejemplo, A y B se representarían de la siguiente forma A = 0 0 1 0 0 0 1 0 1 0 0 1 0 1 0 1 0 0 0 1 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 B = 1 1 1 1 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 0 Cuando se reconoce caracteres, estos se han leído con soportes digitales que incorporan ruído, por lo que la matriz representativa serán variaciones en torno a los ceros y unos, por ejemplo lo cual equivale a las matrices G = 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 G_ruidosa = 0.1337 0.9859 1.0447 1.0773 -0.5392 1.0712 0.0547 0.0860 -0.0817 0.9028 0.6783 0.0299 0.3474 -0.0147 0.1335 1.2666 0.0991 0.3885 -0.2928 0.1002 1.0181 -0.0948 0.0390 0.8881 0.9455 0.8147 0.0208 0.4779 0.1484 1.2493 -0.2367 0.9407 1.0204 1.0842 -0.2981 Para reconocer las posibles variaciones de la letra se utiliza el aprendizaje supervisado, siendo la entrada la matriz de códigos que representan a las letras y la salida una matriz donde cada fila represente a una letra. Las letras se diferencian en la matriz de salida por la posición de un uno, por ejemplo A = 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 B = 0 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 Nótese que para representar 26 letras será necesario una matriz de tamaño [26, 26]. Podria reducirse la combinación de códigos de salida a 5 cifras (puede representar hasta 32 combinaciones). Una vez que se define la matriz de entrada-salida objeto de identificación, se aplica el algoritmo de aprendizaje supervisado de la siguiente forma: 1.- Se aprende con una matriz de entrada-salida donde se supone que las letras son ideales (sin ruído). 2.- Se intercalan matrices con representaciones de entrada-salida de letras con ruído y sin ruído. 3.- Se vuelve aprender de la matriz que represente a las letras sin ruído, para garantizar que cuando estas se apliquen al sistema resultante, puedan ser identificadas. Con respecto a la selección de los núcleos estimadores, sería conveniente que la salida de la red sea en el intervalo [0, 1], de no ser así se tendría que normalizar la salida. A continuación se muestra un programa que reconoce letras utilizando conceptos basados en redes neuronales %Reconocimiento de caracteres
%Adaptación basada en:
%#########################################################
%APPCR1 Character recognition.
% Mark Beale, 12-15-93
% Copyright 1992-2005 The MathWorks, Inc.
% $Revision: 1.15.2.1 $ $Date: 2005/11/15 01:14:56 $
%#########################################################
% Definición de matrices y constantes
[alphabet,targets] = prprob;
[R,Q] = size(alphabet);
% 10 capas intermedias, 26 de salida (S2)
S1 = 10;
[S2,Q] = size(targets);
% Define la red
net = newff(minmax(alphabet),[S1 S2],{'logsig' 'logsig'},'traingdx');
% Reduce los valores iniciales de los parámetros de la capa de salida
net.LW{2,1} = net.LW{2,1}*0.01;
net.b{2} = net.b{2}*0.01;
% Entrena la red sin ruído
% ==================================
% Condiciones de entrenamiento
net.performFcn = 'sse'; % Validación por error medio cuadrático
net.trainParam.goal = 0.1; % Error medio cuadrático deseado
net.trainParam.show = 20; % Frecuencia de visualización (en épocas)
net.trainParam.epochs = 5000; % Épocas
net.trainParam.mc = 0.95; % Constante de momento
% Entrena la red
P = alphabet;
T = targets;
[net,tr] = train(net,P,T);
% Entrena la red con ruído
% ===============================
% Parámetros de entrenamiento
net.trainParam.goal = 0.6; % Error medio cuadrático deseado
net.trainParam.epochs = 300; % Número de épocas
% Se entrena con 10 conjuntos de datos que representan letras
% ruidosas y no ruidosas intercaladas
T = [targets targets targets targets];
for pass = 1:10
fprintf('Pass = %.0f\n',pass);
P = [alphabet, alphabet, ...
(alphabet + randn(R,Q)*0.1), ...
(alphabet + randn(R,Q)*0.2)];
[net,tr] = train(net,P,T);
end
% Entrena la red sin ruído
% =========================================
net.trainParam.goal = 0.1; % Error medio cuadrático deseado
net.trainParam.epochs = 500; % Número de épocas
net.trainParam.show = 5; % Frecuencia de visualización (en épocas)
P = alphabet;
T = targets;
[net,tr] = train(net,P,T);
% Prueba sobre letra ruidosa
%################################################
noisyJ = alphabet(:,17)+randn(35,1) * 0.2;
plotchar(noisyJ);
A2 = sim(net,noisyJ);
% Devuelve índice del mayor valor devuelto por la red
A22 = compet(A2);
answer = find(compet(A22) == 1);
figure;
plotchar(alphabet(:,answer)); |
El resultado de identificar la letra Q(17) se muestra a continuación Referencia: |