Inteligencia Artificial 2

CAIM

CAIM en MATLAB
Ttulo del proyecto: Tarea nmero tres de MATLAB Implementacin de CAIM. Nmero del proyecto: 4 Nmero del curso: 2 Estudiante: Fermn Jess Pitol Reyes Fecha de vencimiento: martes 26 de enero 12:01 hrs Fecha de entrega: martes 26 de enero 10:00 hrs Abstract La discretizacin es el proceso de incluir valores de un conjunto de datos continuo en depsitos para que haya un nmero discreto de estados posibles. Los depsitos se tratan como si fueran valores ordenados y discretos. Una de las grandes ventajas de realizar esta tarea es el poder estudiar con mayor facilidad grandes cantidades de datos donde normalmente es dificil encontrar alguna distribucin o al menos esta no es tan aparente. CAIM es uno de los ms reciente mtodos de discre zacin dando muy buenos resultados en un empo de cmputo bastante reducido. Este mtodo divide el rango de la variable en un nmero muy pequeo de intervalos que podra se encontrados autom camente. Este trabajo ejecuta el algoritmo de CAIM con la base de datos iris , asi mismo, se crea una modificacin del mismo tomando como valor de referencia la entropia de Shannon y compara el resultado de ambas.

Discusin Tcnica
Para comenzar el desarrollo de este proyecto fue necesario cargar una base de datos , MATLAB propociona una llamada iris la cual cuenta con 4 columnas de atributos continuos, haciendola eficiente para este trabajo, la forma de cargarla fue la siguiente:
load 'fisheriris';

Este comando nos entrega dos matrices, una llamada meas que contiene 4 columnas con los datos y otra de nombre species que contiene los valores de las mismas, cuenta con 3 clases numeradas del 1 al 3 que representan el resultado del analisis de las 4 columnas anteriores. Al empezar a tratarla fue necesario cambiar su estructura para poder tener un mejor manejo de ella,ya que aparte de tenerla dividida en dos matrices es mejor trabajar columna por columna, asi que se partio de tomar una a una las columnas y fusionarlas con la matris de species,el siguiente codigo muestra el proceso:
F = [meas(:,2) grp2idx(species)]; S = unique(grp2idx(species)); M = length(F); [dn dnindice] = max(F(:,1)); [do doindice] = min(F(:,1)); Faux = sort(F(:,1)); B = unique(Faux); for x = 1: length(F) F_T(x,1) = F(x,1); for z=1:length(S) if F(x,2) == z F_T(x,z + 1) = 1; end end end

Una vez teniendo esto comenzamos a aplicar el algoritmo de CAIM mostrado en el paper CAIM Discretization Algorithm Lukasz A. Kurgan , debio a que el articulo antes mencionado no es muy preciso en su algoritmo ya que pide valores tentativos este se siguio al pie de la letra para evitar posibles malas interpretaciones, el algoritmo es el siguiente junto con el codigo implementado: 1.1 Encontrar el valor maximo (dn) y valor minimo (do)

[dn dnindice] = max(F(:,1)); [do doindice] = min(F(:,1));

1.2 forma un conjunto de todos los valores distintos en fi en orden ascente e inicializa todos los posibles limites de intervalos B con minimo, maximo y todos los puntos intermedios
SortedInterval = unique( OriginalData( :,p ) ); B = zeros( 1,length( SortedInterval )-1 ); Len = length( B ); for q = 1:Len B( q ) = ( SortedInterval( q ) + SortedInterval( q+1 ) )/ 2; end D = zeros( 1,MaxNumF );

1.3 Obten la discretizacion original D[do,dn] y establece una variable CAIM = 0

GlobalCAIM = -Inf; % pora facilitar el trabajo y dado que el objetivo de cero es que no exista un numero mas pequeo desidi colocar un valor inf

Cabe aclarar que para D se creo un for el cual le ira asignando posteriormente os valos, ya que de entrada solo era necesario que esta tuviera un tamao, este codigo lo mostrare en el punto 2.4 2.1 2.2 -2.3 Inicializar K = 1 , tentativamente agregar un limite interno que no este en D de B y calcular el valor CAIM(en nuestro caso este puede cambiar por Shannon),Aceptar la tentavia con el valor mas alto de CAIM; Para CAIM
CAIM = - Inf; Local = 0; for q = 1:Len if isempty( find( D( 1:k )==B(q), 1 ) ) == 1 DTemp = D; DTemp( k+1 ) = B( q ); DTemp( 1:( k+1 ) ) = sort( DTemp( 1:( k+1 ) ) ); CAIMValue = CAIM_Evaluation( OriginalData,C,p,DTemp( 1:( k+1 ) ) ); hold on; plot(q,CAIMValue,'bo'); if CAIM < CAIMValue CAIM = CAIMValue; Local= q; end end

Para Shannon
for q = 1:Len if isempty( find( D( 1:k )==B(q), 1 ) ) == 1 DTemp = D; DTemp( k+1 ) = B( q ); DTemp( 1:( k+1 ) ) = sort( DTemp( 1:( k+1 ) ) ); [CAIMValue F_t] = shanon2(F_t,S); hold on; plot(q,CAIMValue,'bo'); Local = q; end end

2.4 2.5 Si CAIM > GlobalCAIM k<S entonces actualiza D con el valor aceptado en el paso 2.3 y coloca el limite de GlobalCaim = CAIM, aumenta k en uno y ve al paso 2.2, si no se cumple esto termina el algoritmo .
if GlobalCAIM < CAIM && k < MaxNumF GlobalCAIM = CAIM; k = k + 1; D( k ) = B( Local ); D( 1:k ) = sort( D( 1:k ) ); elseif k <= MaxNumF && k <= C k = k + 1; D( k ) = B( Local ); D( 1:k ) = sort( D( 1:k ) ); else break; end

Para regresar al paso se cuenta con un while que cubre a too los pasos de la forma while true , y este terminara exclusivamente hatas que el algotirmo entre a la sentencia break.

Discusin de resultados
En este apartado me limitare a explicar solo un par de columnas de la matriz y la comparare con los resultados de la misma bajo el algoritmo de Shannon y en el siguiente punto manejare los resultados generales de todas las columnas. Al correr la discretizacion con el algoritmo de caim de la segunda columna se obtuvieron los siguientes resultados: Para CAIM

Y con Shanon

Aqu no se logra apreciar cambios significativos, incluso con diferentes parametros arroja el mismo numero de intervalos, esto es debido a que este comportamiento esta obligado por una variable impuesta, en ambos estos son muy conservadores, es decir, son intervalos cerrados, en donde el tamao de su expansion es minimo, sin embargo no es posible apreciar los mismos resultados para la columna 1: Para CAIM:

Para Shannon:

En esta se puede observar como Shannon fue mucho menos conservador que CAIM sobre todo en el primer intervalo, mientras que CAIM presento 4.3 -5.45 , Shannon determino este en 4.3-7.35, de hecho analizando los datos originales Shanon siempre intenta crear los primeros dos intervalos maximizandolos casi hasta un 90- 95 % de los datos , mientras qe CAIM busca equilibrar este resultado hasta en los primeros tres. En ambos casos los intervalos son coherentes al revisarlos con los datos originales, sim embargo, y a gusto personal CAIM actu de mejor manera, ya que procuro no tener intervalos de espectro tan grande como Shannon, esta aseveracin es meramente subjetiva debido a mi poco conocimiento en esta are de investigacin, aunque como presentare mas adelante en los ploteos de los valores de CAIM y Shannon, este ultimo realiza un numero menor de pasos que CAIM, lo cual en terminos computacionales es mejor, de hecho analizando estas imgenes se nota a Shannon un poco mas conservador que CAIM, esto puede deberse al dato tentativo al que CAIM te obliga y motivo por el cual desconfio de este algoritmo.

Resultados

A continuacin muestros los ploteos generados a partir de los numero de CAIM y Shannon de las columnas uno y dos, aqu es facil observar el numero de pasos que necesito cada algoritmo para determinar los intervalos , es de notarse rapidamente que Shannon fue mas eficaz en este aspecto ya que requirio un menor numero de pasos y de hecho fue mas sistematico que CAIM el cual llega a presentar desde un punto de vista personal datos casi desordenados siempre en busca del valor mayor:

Figure 1 Valores ploteados de CAIM para la columna uno

Figure 2 Valores de CAIM ploteados para la columna dos

Mientras que para Shannon

Figure 3 Valores ploteados para la columna una con Shannon

Figure 4 Valores ploteados para la columna 2 con Shannon

Es facil de ver como Shannon toma un enfasis especial en las clases de mayor entropia, en este caso tres e intenta agruparlas, mientras que CAIM va generando datos tentaivos hasta obtener valores que maximecen a su variable. Los datos de los intervalos de todas las columnas son los siguientes: CAIM

Figure 5 Columna uno CAIM

Figure 6 Columna dos CAIM

Figure 7 Columna tres de CAIM

Figure 8 Columna 4 de CAIM

Shannon:

Figure 9 Columna uno Shannon

Figure 10 Columna dos Shannon

Figure 11 Columna tres Shannon

Figure 12 Columna 4 Shannon

Apendice

Funciones creadas en MATLAB:

Nombre ControlCenter Uso Interfaz que permite mandar a llamr la columna a discretizar y presenta los intervalos de forma apropiada al usuario Es la funcion principal que contiene todo el codigo del algoritmo de CAIM El proceso que crea las matrices quanta y va creando a la variable D Proporciona el valor de CAIM Proporciona el valor de Shannon Crea la matriz quanta Determina la frecuencia de los datos, es necesaria para crear la matriz quanta

Caim_discretization Discretewithinterval Caim_Evaluation Shannon Crea_Quanta Frecuencia

Codigo fuente:
clear all; close all; %% cargamos la base de datos load 'fisheriris'; %% inicializamos las variables F = [meas(:,4) grp2idx(species)]; S = unique(grp2idx(species)); M = length(F); [dn dnindice] = max(F(:,1)); [do doindice] = min(F(:,1)); Faux = sort(F(:,1)); B = unique(Faux); for x = 1: length(F) F_T(x,1) = F(x,1); for z=1:length(S) if F(x,2) == z F_T(x,z + 1) = 1; end end

end OriginalData = F_T; %% comenzamos elproceso de discretizacion [ DiscretData,DiscretizationSet1 ] = CAIM_Discretization( OriginalData, 3,F,S ); longitud = length(find(DiscretizationSet1 > 0)); %% entrega la salida en formato idoneo al usuario if DiscretizationSet1(1) > do D(1,:) = [do DiscretizationSet1(1)]; for i=2:longitud D(i,1) = DiscretizationSet1(i-1); D(i,2) = DiscretizationSet1(i); end end function [s datos] = shanon2(F,S) %%ejecuta la funcion de SHannon, esta es equivalente a wentropy de MATLAB matrizShanon = zeros(length(S)); matrizShanonFinal = zeros(length(S));

if ~isempty(F) dat = unique(F(:,2)); datos = []; valor =0; for i=1:length(dat) Encuentra = find(F(:,2) ==dat(i)); entropia= (length(Encuentra)/(length(F))); entropia = entropia * log2(entropia)*(-1); matriz(i,1) = entropia; matriz(i,2) = dat(i); if i > 1 valor = valor - entropia; else valor = entropia; end end [val indice] = min(matriz(:,1));

aux = 1; %%elimina la columna de mayor entropia for i=1:length(F) if F(i,2) ~= F(indice,2); datos(aux,:) = F(i,:); aux = aux + 1; end end if isempty(datos) datos = []; end s = val;

X = F(:,2); s = wentropy(X,'shannon'); else s = 0; datos = []; end end function [ Frec ] = frecuencia(F,minv,max,clase) %%cuenta la frecuencia de aparaicion para la matrix quanta tam = length(F); minF = min(F(:,1)); cont = 0; for i=1:tam if minF == minv if(F(i,2)== clase && F(i,1) >= minv && F(i,1) <= max) cont = cont +1; end else if(F(i,2)== clase && F(i,1) > minv && F(i,1) <= max) cont = cont +1; end end

end;

Frec = cont;

End function [ DiscretData,QuantaMatrix ] = DiscretWithInterval( OriginalData,C,Column,DiscretInterval ) %%crea le llamado a la generacion de matrices quanta

M = size( OriginalData,1 ); k = length( DiscretInterval ); F = size( OriginalData,2 ) - C; DiscretData = zeros( M,1 );

for p = 1:M for t = 1:k if OriginalData( p,Column ) <= DiscretInterval( t ) DiscretData( p ) = t-1; break; elseif OriginalData( p,Column ) > DiscretInterval( k ) DiscretData( p ) = k; end end end

CState = C; FState = length( DiscretInterval ) + 1; QuantaMatrix = zeros( CState,FState ); for p = 1:M for q = 1:C if OriginalData( p,F+q ) == 1 Row = q; Column = DiscretData( p )+1; QuantaMatrix( Row,Column ) = QuantaMatrix( Row,Column ) + 1; end end

end

end function [Q] = crea_Quanta(F,D,S) %UNTITLED2 Summary of this function goes here % Detailed explanation goes here

Q_tmp(1,1) = S(1); Q_tmp(2,1) = S(2); Q_tmp(3,1) = S(3);

clases = length(S);

[D_rows D_cols] = size(D);

for tmp = 1:clases for tmp_row = 1: D_rows Q_tmp(tmp,tmp_row + 1) = frecuencia(F,D(tmp_row,1),D(tmp_row,2),S(tmp)); end end

Q = Q_tmp;

End function CAIMValue = CAIM_Evaluation( OriginalData, C, Feature, DiscretInterval )

k = length( DiscretInterval ); [ DiscretData,QuantaMatrix ] = DiscretWithInterval( OriginalData,C,Feature,DiscretInterval );

SumQuantaMatrix = sum( QuantaMatrix,1 ); CAIMValue = 0 ;

for p = 1:k if max( QuantaMatrix(:,p) ) > 0 CAIMValue = CAIMValue + ( max( QuantaMatrix(:,p) ) )^2/SumQuantaMatrix(p) ;

end end

CAIMValue = CAIMValue/k ; End function [ DiscreData,DiscretizationSet ] = CAIM_Discretization( OriginalData, C,F_t ,S )

F = size( OriginalData,2 ) - C ; M = size( OriginalData,1 ); DiscreData = zeros( M,C+F ); DiscreData( :,F+1:F+C ) = OriginalData( :,F+1:F+C ); MaxNumF = floor(M/(3*C)); DiscretizationSet = zeros( MaxNumF,F );

for p = 1:F SortedInterval = unique( OriginalData( :,p ) ); B = zeros( 1,length( SortedInterval )-1 ); Len = length( B ); for q = 1:Len B( q ) = ( SortedInterval( q ) + SortedInterval( q+1 ) )/ 2; end %B D = zeros( 1,MaxNumF ); GlobalCAIM = -Inf;

k=0; while true CAIM = - Inf; Local = 1; for q = 1:Len if isempty( find( D( 1:k )==B(q), 1 ) ) == 1 DTemp = D; DTemp( k+1 ) = B( q ); DTemp( 1:( k+1 ) ) = sort( DTemp( 1:( k+1 ) ) ); [CAIMValue F_t] = shanon2(F_t,S); hold on; plot(q,CAIMValue,'bo');

Local = q;

end end

if ~isempty(F_t) GlobalCAIM = CAIM; k = k + 1; D( k ) = B( Local ); D( 1:k ) = sort( D( 1:k ) ); elseif k <= MaxNumF && k <= C k = k + 1; D( k ) = B( Local ); D( 1:k ) = sort( D( 1:k ) ); else break; end end DiscretizationSet( 1:k,p )= D( 1:k )'; DiscreData( :,p ) = DiscretWithInterval( OriginalData,C,p,D( 1:k ) ); end end

Caim con busqueda de A*

Basicamente consistiria en el mismo algoritmo de CAIM, pero en lugar de buscar siempre el dato maximo y valores tentativos se agregaria una heuristica la cual serviria de apoyo para maximizar la eficiencia del resultado de los intervalos Encontrar el valor maximo (dn) y valor minimo (do) Formar un conjunto de todos los valores distintos en fi en orden ascente e inicializa todos los posibles limites de intervalos B con minimo, maximo y todos los puntos intermedios Obten la discretizacion original D[do,dn] y establece una variable CAIM = 0 Inicializar K = 1 Meidiante una heurstica rapida y funcional, usar una bsqueda A* que arroje el valor que maximice positivamente el valor de CAIM y asignar un peso del valor encontrado Si el peso del valor de CAIM es mayor entonces actualizar el esquema D con los valores aceptados en el paso anterior y tomar este peso para comparar con la siguiente entrada, incrementar k = k + 1 y regresar a la heuristica en caso contrario terminar.