Instituto Politcnico Nacional

Unidad Profesional Interdisciplinaria de Ingeniera y Tecnologas Avanzadas

Materia: Visin Artificial Aplicada

Profesor: Abarca Jimnez Griselda Stephany

Tema: Reconocimiento de nmeros, segunda parte (MAO)

Fecha: 25 de febrero de 2014

Objetivo.
Reconocer una serie de nmeros del 0 al 9- de diferentes caligrafas -3 tipos de fuente diferentes, por medio de tcnicas basadas en redes neuronales no supervisadas, en particular la tcnica de mapas auto-organizados.

Introduccin.
Para la segunda parte de esta prctica, se utiliz una tcnica de redes neuronales no supervisadas, especficamente el algoritmo de aprendizaje del profesor finlands Teuvo Kohonen, llamados mapas auto-organizados. Se trata de una red competitiva que sirve para la clasificacin de datos, est basada en distancia euclideana. La primera fase de trabajo de la red, como en la mayora de las redes neuronales artificiales, se hace un entrenamiento de la red. Acto seguido, se hace un mapeo con los patrones de prueba para evaluar el funcionamiento y convergencia de la red.

Desarrollo:
Se leen los patrones de entrenamiento y de prueba (30 patrones en total):
%Patrones de entrenamiento patron1 = vect_bin(imread('0b.jpg')); %Familia de prueba 1 prueba2_1 = vect_bin(imread('0k.jpg')); %Familia de prueba 2 prueba1_1 = vect_bin(imread('0i.jpg')); Donde la funcin vect_bin es la responsable de binarizar, limpiar y convertir en vector las imgenes utilizadas como patrones: function vect_salida = vect_bin (img_entrada) %-----------%Binarizacin %-----------x = 113; y = 125; patron = img_entrada; patron = imresize(patron,[x,y]); patron = im2bw(patron); [x,y] = size(patron); for i=3:x-2 for j=3:y-2 cont = 0; if(patron(i,j) == 1) cont = cont + 1; for ifcadavecino=1:1 if patron(i,j-1) == 1 cont = cont + 1; end if patron(i,j+1) == 1

cont = cont + 1; end if patron(i+1,j) == 1 cont = cont + 1; end if patron(i-1,j) == 1 cont = cont + 1; end if patron(i+1,j-1) == 1 cont = cont + 1; end if patron(i+1,j+1) == 1 cont = cont + 1; end if patron(i-1,j+1) == 1 cont = cont + 1; end if patron(i-1,j-1) == 1 cont = cont + 1; end %--------------------if patron(i,j-2) == 1 cont = cont + 1; end if patron(i,j+2) == 1 cont = cont + 1; end if patron(i+2,j) == 1 cont = cont + 1; end if patron(i-2,j) == 1 cont = cont + 1; end if patron(i+2,j-2) == 1 cont = cont + 1; end if patron(i+2,j+2) == 1 cont = cont + 1; end if patron(i-2,j+2) == 1 cont = cont + 1; end if patron(i-2,j-2) == 1 cont = cont + 1; end end end if cont > 8 patron(i,j) = 1; else patron(i,j) = 0; end end

end %Vectorizacin pos = 1; for i=1:x for j=1:y p_vect(pos) = patron(i,j); pos = pos + 1; end end vect_salida = p_vect; end

Regresando al programa principal:

[x y] = size(patron1); %Se obtiene el tamao de la matriz n = 10; %nmero de patrones m = y; %tamao de los patrones ep = 10; %nmero de epocas alfa = 10; %coeficiente de aprendizaje r = 0; %radio de vecindad m_pesos = rand(m,n)*100; %matriz de pesos aleatoria pesos_old = m_pesos; pesos_new = pesos_old; Se procede a entrenar a la red, actualizando la matriz de pesos por cada iteracin, se utiliz la caligafa ms difcil de identificar (manuscrita) para el proceso de entrenamiento: while ep > 0 %Para el patron 21 pesos_new = update_pesos(pesos_old,prueba1_1,alfa); pesos_old = pesos_new; %Para el patron 22 pesos_new = update_pesos(pesos_old,prueba1_2,alfa); pesos_old = pesos_new; %Para el patron 23 pesos_new = update_pesos(pesos_old,prueba1_3,alfa); pesos_old = pesos_new; %Para el patron 24 pesos_new = update_pesos(pesos_old,prueba1_4,alfa); pesos_old = pesos_new; %Para el patron 25 pesos_new = update_pesos(pesos_old,prueba1_5,alfa); pesos_old = pesos_new;

%Para el patron 26 pesos_new = update_pesos(pesos_old,prueba1_6,alfa); pesos_old = pesos_new; %Para el patron 27 pesos_new = update_pesos(pesos_old,prueba1_7,alfa); pesos_old = pesos_new; %Para el patron 28 pesos_new = update_pesos(pesos_old,prueba1_8,alfa); pesos_old = pesos_new; %Para el patron 29 pesos_new = update_pesos(pesos_old,prueba1_9,alfa); pesos_old = pesos_new; %Para el patron 30 pesos_new = update_pesos(pesos_old,prueba1_10,alfa); pesos_old = pesos_new; if alfa > 0.01 alfa = alfa*0.5; end ep = ep - 1; end

La funcin update_pesos actualiza la matriz de pesos de acuerdo al algoritmo de entrenamiento deseado, recibe la matriz de pesos anterior, el patrn de entrenamiento y el coeficiente de entrenamiento, y regresa la matriz de pesos actualizada:
function pesos_new = update_pesos(pesos_old,vect_patron,alfa)

[m,n] = size(pesos_old); pesos_new = pesos_old; d = zeros(1,10); for k=1:m D1(k) = ((vect_patron(1,k)-pesos_old(k,1))^2); D2(k) = ((vect_patron(1,k)-pesos_old(k,2))^2); D3(k) = ((vect_patron(1,k)-pesos_old(k,3))^2); D4(k) = ((vect_patron(1,k)-pesos_old(k,4))^2); D5(k) = ((vect_patron(1,k)-pesos_old(k,5))^2); D6(k) = ((vect_patron(1,k)-pesos_old(k,6))^2); D7(k) = ((vect_patron(1,k)-pesos_old(k,7))^2); D8(k) = ((vect_patron(1,k)-pesos_old(k,8))^2); D9(k) = ((vect_patron(1,k)-pesos_old(k,9))^2); D10(k) = ((vect_patron(1,k)-pesos_old(k,10))^2); end d(1) = sum(D1); d(2) = sum(D2); d(3) = sum(D3);

d(4) = sum(D4); d(5) = sum(D5); d(6) = sum(D6); d(7) = sum(D7); d(8) = sum(D8); d(9) = sum(D9); d(10) = sum(D10); d_min = min(d); for i=1:10 if d_min == d(i) i; for j=1:m pesos_new(j,i) = pesos_old(j,i)*(1-alfa) + alfa*vect_patron(j)); end end end

Ya entrenada la red, se procede a ralizar pruebas para evaluar el funcionamiento de la red:

% %Etapa de prueba vect_sol1 = [patron1*pesos_new,... patron2*pesos_new,... patron3*pesos_new,... patron4*pesos_new,... patron5*pesos_new,... patron6*pesos_new,... patron7*pesos_new,... patron8*pesos_new,... patron9*pesos_new,... patron10*pesos_new]; solucion(1) = prueba_mao(vect_sol1,patron1,pesos_new); solucion(2) = prueba_mao(vect_sol1,patron2,pesos_new); solucion(3) = prueba_mao(vect_sol1,patron3,pesos_new); solucion(4) = prueba_mao(vect_sol1,patron4,pesos_new); solucion(5) = prueba_mao(vect_sol1,patron5,pesos_new); solucion(6) = prueba_mao(vect_sol1,patron6,pesos_new); solucion(7) = prueba_mao(vect_sol1,patron7,pesos_new); solucion(8) = prueba_mao(vect_sol1,patron8,pesos_new); solucion(9) = prueba_mao(vect_sol1,patron9,pesos_new); solucion(10) = prueba_mao(vect_sol1,patron10,pesos_new);

Y as con cada familia...

La funcin prueba_mao recibe el vector de la multiplicacin de los patrones por la matriz de pesos y evala cada patrn para decidir a qu clase pertenece.
function valor = prueba_mao(vect_prueba,patron_prueba,pesos_entrenada) vect1 = patron_prueba*pesos_entrenada;

pos = 1; for i = 1:10 for j=1:10 d(i) = (vect1(j)-vect_prueba(pos))^2; pos = pos + 1; end end [x,valor] = min(d); end

La salida de la red es la siguiente: solucion = 1 2 3 4 5 6 7 8 9 10

solucion1 = 1 2 3 4 5 6 7 8 9 10

solucion2 = 1 2 3 4 5 6 7 8 9 10

Con una efectividad de un 100% en 13.32 segundos.

Conclusiones.
Se pudo comprobar el funcionamiento de ambas redes neuronales y evaluar cual result ser ms efectiva. De hecho, contrario a lo esperado, la red no supervisada, es decir, la de mapas autoorganizados se desempe mucho mejor que la perceptrn, con todo y que en el caso de perceptrn se especifica el tipo de salida deseada. Lo mejor de esta prctica, fue que ya tenamos el algoritmo de binarizacin y limpieza de las imgenes perfeccionado, por lo que el resto de la programacin se facilit en gran medida.