informe tarea n°1 - u-cursos · 2014-06-30 · 0.5, se descarta dicho dato. el método considera...

Universidad de Chile

Facultad de Ciencias Físicas y Matemáticas

Departamento de Ingeniería Eléctrica

EL4106 – Inteligencia Computacional

INFORME TAREA N°1

CLASIFICADOR BAYESIANO DE VINOS

Nombre Alumno : Sebastián Gálvez

Profesor : Javier Ruiz del Solar

Profesor Auxiliar : Daniel Herrmann

Felipe Valdés

Fecha : 14/04/2014

Santiago, Chile.

Contenido

Contenido ....................................................................................................... II

1. Introducción .............................................................................................. 1

2. Desarrollo ................................................................................................. 2

2.1. Base de datos .................................................................................................. 2

2.2. Clasificador en base a modelo con histogramas ................................................ 6

2.3. Clasificador en base a modelo gaussiano ....................................................... 12

2.4. Comparación de modelos ............................................................................... 15

3. Conclusiones ........................................................................................... 17

4. Anexos .................................................................................................... 18

EL4106 – Clasificador Bayesiano de Vinos

U. de Chile. FCFM. DIE ~1~

Introducción

1. Introducción

El objetivo de la tarea es implementar un clasificador Bayesiano de vinos, para determinar

de forma probabilística si se trata de un vino tinto o un vino blanco.

Para esto se utilizará la base de datos Wine Quality Data Set, que forma parte del UC Irvine

Machine Learning Repository. Esta base de dato contiene 11 características fisicoquímicas

medidas para 2506 muestras de vino. Las características medidas son:

1. Fixed acidity

2. Volatile acidity

3. Citric acid

4. Residual sugar

5. Chlorides

6. Free sulfur dioxide

7. Total sulfur dioxide

8. Density

9. pH

10. Sulphates

11. Alcohol

Además, en la base de datos se indica para cada muestra con un ‘1’ si esta pertenece a la

clase “Vino Tinto” y con un ‘0’ si la muestra pertenece a la clase “Vino Blanco”.

En la tarea se pide programar, entrenar y calibrar el clasificador Bayesiano, cuya regla de

decisión está dada por: ( | )

( | ) ,

Donde es un umbral que depende de los costos asociados a cada decisión (cb y ct) y de las

probabilidades a priori, de la siguiente forma:

( )

( )

En este caso no se cuenta con información sobre los costos asociados ni sobre las

probabilidades a priori, por lo que el valor del umbral se puede ir variando para generar las

curvas ROC.

En el desarrollo de la tarea se debió estimar las verosimilitudes (distribuciones de

probabilidad) con dos modelos distintos: Aproximando con histogramas normalizados y

calculando una distribución gaussiana. En la siguiente sección del informe se detallan los

desarrollos realizados para implementar el clasificador Bayesiano.



Desarrollo

2. Desarrollo

Observación: Para mayor información sobre cómo utilizar cualquiera de las funciones

implementadas, utilizar el comando de MATLAB “help nombredelafuncion”

2.1. Base de datos a) Función y posibles subconjuntos de entrenamiento y prueba

Para llevar a cabo la implementación del clasificador, lo primero es verificar si existen “datos dudosos” o “outliers”, que son muestras que cuentan con valores fuera de rango por posibles errores de medición o errores tipográficos al crear la base de datos. Estos datos se deben descartar para que el clasificador funcione correctamente. En segundo lugar, se necesita realizar una división de la base de datos en un conjunto de entrenamiento y un conjunto de prueba. La importancia de realizar este proceso recae en para que el clasificador funcione, se deben ajustar sus parámetros para calcular las verosimilitudes, como la media y la covarianza en el caso del modelo gaussiano. Además, en el modelo con histogramas, se deben aproximar las densidades de probabilidad por intervalos en base al conjunto de muestras de entrenamiento. Para probar la efectividad del clasificador se deben utilizar muestras distintas a las utilizadas para entrenarlo, por lo que se deben guardar una cierta cantidad de datos del conjunto original para este propósito.

Los posibles conjuntos a generar son variados, pero se recomienda ser cauto y buscar que cada uno de ellos se parezca lo más posible al conjunto completo. En primer lugar, se consideraron subconjuntos independientes para las muestras que pertenecen a la clase Vino Tinto y para la clase Vino Blanco, y se decidió utilizar una relación de 80% de los datos para el conjunto de entrenamiento y 20% para el conjunto de prueba, para cada subconjunto por separado. Además, se decidió mediante heurística que los siguientes parámetros de cada conjunto en promedio debían mantenerse parecidos a los de la base de datos original: Media, Desviación estándar, Valor máximo, Valor mínimo, Rango de las muestras y Proporción entre clases. Con esto, se asegura que la representatividad de estos conjuntos sea parecida con un error tolerado a definir en el programa.



Desarrollo

b) División de la base de datos. El programa generado en el archivo “basededatos.m” contiene una función “[entren, prueba]= basededatos(data,repr_err)”, que tiene como objetivo descartar “outliers” y luego dividir la base de datos en los conjuntos de entrenamiento y prueba, para retornarlos en las matrices respectivas. El argumento “data” contiene la matriz con la base de datos. El criterio utilizado para descartar “outliers” es el llamado Criterio de Chauvenet, que consiste en asumir que los datos corresponden a un proceso aleatorio con distribución de probabilidad Gaussiana, por lo que se calculan la Media y la Desviación estándar, y para cada muestra se calcula la probabilidad de que se haya generado el dato observado en ese valor, en base a la distribución normal utilizando la Media y Desviación estándar calculadas. Esta probabilidad se multiplica por el número total de datos, y si el resultado es menor a 0.5, se descarta dicho dato. El método considera la cantidad de desviaciones estándar a las que se encuentra el dato en cuestión respecto de la media, por tanto si un dato está muy alejado de los otros, su probabilidad calculada será muy pequeña, y al multiplicar por el número de datos no se superará el umbral de 0.5. Si bien existen otros métodos, se decidió utilizar este criterio debido a su simplicidad y a que efectivamente elimina los datos que se encuentran totalmente alejados del resto. El código implementado para descartar “outliers” se muestra a continuación:

u_x=mean(data); sgm_x=std(data); noutliers=0; descartar=zeros(72,1); %se detectaron 72 "outliers" con este método. for j=1:nfeats for i=1:N chauv=pdf('norm',data(i,j),u_x(j),sgm_x(j))*N; if(chauv<0.5) %sprintf('Outlier en %d,%d',i,j); noutliers=noutliers+1; descartar(noutliers)=i; end end end descartar=sort(descartar); %noutliers %descomentar para ver el número de outliers.

%descarto los datos dudosos de la matriz ‘data’. for l=noutliers-(1:noutliers) +1 data(descartar(l),:)=[]; end



Desarrollo

Como podemos apreciar en los comentarios, al ejecutar este código se lograron identificar 72 “outliers” de la base de datos, de los cuales inicialmente se verificaron algunos manualmente al visualizar sus índices con sprintf('Outlier en %d,%d',i,j);.

Para ejemplificar los resultados obtenidos al utilizar el Criterio de Chauvenet, en la

Tabla 1 se muestran el número de “outliers” detectados al ir cambiando el valor del umbral. Como se puede apreciar, al disminuir este umbral se “relaja” el criterio, descartando una menor cantidad de datos.

Umbral N° de Outliers detectados

0.1 42

0.2 55

0.3 58

0.4 66

0.5 72

0.6 81

0.7 86

0.8 98

0.9 103

Tabla 1: Número de Outliers detectados con distintos umbrales. Posteriormente, se calcula el nuevo número de datos disponibles, y conociendo que se

encuentran ordenados en base a su clase, se detectan la cantidad de datos de clase Vino y de la clase Vino Blanco, utilizando el siguiente bloque:

N2=length(data(:,1)); %nuevo numero de muestras a utilizar ndiv=find(data(:,12),1,'last'); siztint=length(1:ndiv); sizblanc=length(ndiv+1:N2);

A continuación, luego de calcular los parámetros de representatividad definidos anteriormente para el conjunto completo, se debió calcular el número de muestras a utilizar para el conjunto de prueba y para el conjunto de entrenamiento. Esto se hizo calculando el 20% de las muestras de clase Vino Tinto y el 20% de las muestras de clase Vino Blanco.

Con el objetivo de asegurar que el error de representatividad fuera a lo más el indicado

por el usuario (o por defecto menor a 0.5%), se hizo un bloque de iteraciones con tal de generar distintos conjuntos de prueba y entrenamiento mediante la elección al azar de muestras, hasta completar el número de datos calculados previamente para el conjunto de prueba, luego los datos restantes constituyeron el conjunto de entrenamiento.



Desarrollo

Sin el bloque iterativo, se lograban errores en promedio de 1.5%, y al implementar esta metodología se lograron satisfactoriamente errores menores a 0.5% con tan sólo un promedio de 5 iteraciones. Cuando se pide una cota superior de 0.3%, el algoritmo debe realizar más iteraciones, demorándose entre 10 y 250 iteraciones, por lo que se decidió poner un escape del algoritmo cuando se llegan a repetir 300 iteraciones sin lograr el error deseado.

La extracción de datos aleatorios para el conjunto de prueba se realiza con el siguiente

bloque, donde se utiliza la función “randi([inicio fin])”, la cual genera un número pseudoaleatorio en el rango indicado en su argumento, y se extrae ese elemento del conjunto completo, el proceso se hace por separado para las clases Vino Tinto y Vino Blanco.

prueba=zeros(sizpr,12); %inicializo el conjunto de prueba.

for i=1:pr_nblanc fin=length(data(:,1))-i+1; j=randi([ndiv+1 fin]); prueba(i,:)=data(j,:); data(j,:)=[]; end

for i=1:pr_ntint fin=ndiv-i+1; j=randi([1 fin]); prueba(i+pr_nblanc,:)=data(j,:); data(j,:)=[]; end

entren=data;

Finalmente, se calculan los parámetros de representatividad para cada conjunto y se comparan con los del conjunto original, promediando los errores y evaluando si este error de representatividad es menor a la cota indicada por el usuario. Cuando se logra lo deseado, la función retorna las matrices ‘prueba’ y ‘entren’ con lo que la separación de la base de datos está completada.



Desarrollo

2.2. Clasificador en base a modelo con histogramas a) Aproximación de Naive Bayes

Para lograr aproximar las verosimilitudes de cada dato utilizando histogramas se requiere

utilizar Naive Bayes o en español “Bayes ingenuo”, que se basa en la suposición de que cada

una de las 11 características que se deben estudiar cuenta con una distribución de

probabilidad independiente de las otras, por ejemplo, que el valor del ‘pH’ medido de una

muestra no incide en la ‘acidez cítrica’ de la misma. De aquí viene el nombre de “ingenuo”,

puesto que este clasificador no considera que exista una relación entre las distintas

características que definen una clase o la otra.

Al tomar este supuesto, mediante las propiedades de las distribuciones probabilísticas

independientes, al considerar que:

( | ) ( | )

( | ) ( | ),

donde cada Ci es una característica observada, se pueden calcular las verosimilitudes para

cada observación ‘k’ como:

( | ) ∏ ( | ) (1)

( | ) ∏ ( | ) (2)

Así cada probabilidad P(Ci|Blanco) se calcula evaluando en qué intervalo del histograma

normalizado generado según el conjunto de entrenamiento se encuentra la observación ‘k’

de la característica Ci. Se realiza un análisis análogo para la verosimilitud de la clase Tinto.

Cabe mencionar que es importante que el histograma generado para cada característica

en el entrenamiento sea normalizado, ya que así se representa la distribución de

probabilidad de esa característica, para cada clase por separado.



Desarrollo

b) Generación de histogramas

En el archivo “histogramas.m” se declaró la función “[f1,f2,edgs]=histogramas(entren,nbins)”, donde el vector “f1” contiene los histogramas normalizados para la clase Vino Tinto, y “f2” los de la clase Vino Blanco. Para generar los respectivos histogramas para cada clase, en cada característica distinta, se utilizó la función “histc(datos,edges)”, donde el vector “edges” contenía los bordes de cada intervalo del histograma. Este vector se generó utilizando los valores máximo y mínimo para cada característica, generando una equipartición con “nbins” intervalos. La función recibe el conjunto “entren” de entrenamiento generado anteriormente.

La parte principal del código generado se muestra a continuación, donde se destaca que para no tener problemas se agregó un margen de ±delta en los extremos del dominio utilizado. Esto se hizo ya que el conjunto de entrenamiento no representa absolutamente todos los casos, por lo que puede haber algunos valores que se escapen del mínimo o máximo del conjunto. Además, la matriz “edgs”, contiene los 11 vectores con intervalos generados, uno para cada característica, y esta matriz es retornada por la función para utilizarse posteriormente en la clasificación. En la Figura 1 se muestran gráficamente los histogramas generados.

for j=1:nfeats

a=min(xdat(:,j)); b=max(xdat(:,j)); delta=(b-a)/((nbins-1)-2); edgs(j,:)=a-delta:delta:b+delta; f1(j,:)=histc(xtinto(:,j),edgs(j,:)); f1(j,:)=f1(j,:)/sum(f1(j,:)); f2(j,:)=histc(xblanco(:,j),edgs(j,:)); f2(j,:)=f2(j,:)/sum(f2(j,:));

%para graficar ingresar 'graf' distinto de 0

if(graf~=0) subplot(3,4,j); stairs(edgs(j,:),f1(j,:),'m') hold on; stairs(edgs(j,:),f2(j,:),'g') title(headers(j)); hold off;

end

end



Desarrollo

Figura 1: Histogramas generados con ‘nbins’=15, para las 11 características medidas.

c) Calculo de verosimilitudes

Debido a que el modelo utiliza la aproximación de Naive Bayes, para cada muestra del

conjunto de prueba se debe utilizar el par de ecuaciones (1) y (2). Para lo que se necesita

encontrar a qué intervalo pertenece cada valor de cada muestra, y calcular las

verosimilitudes a cada clase como un producto del valor asociado a ese intervalo en los

histogramas de cada característica.

En el archivo “clasificador_hst.m” se define la función “[clase,verif]=clasificador_hst(prueba,f1,f2,edgs,umb)” donde se entregan los argumentos retornados por la función “histogramas(…)” más el conjunto de prueba y un parámetro “umb”, que representa el valor umbral Ɵ con el que se comparan las verosimilitudes en el criterio de decisión del clasificador Bayesiano. Esta función realiza el proceso de clasificación para todo el conjunto de prueba y retorna los vectores “clase” y “verif”, donde el primero contiene la clase que le asigna el clasificador (“1” si es Vino Tinto, “0” si es Vino Blanco), y el segundo contiene la 12a columna de la matriz “prueba”, es decir, la clase real de las muestras.

Lo principal del código de esta función es encontrar las verosimilitudes a cada clase, lo

que se hace con los siguientes comandos para cada muestra “i”. Para encontrar el intervalo al que pertenece cada valor de las características se generó la función “findbin(dato,edges)” en el archivo “findbin.m”.



Desarrollo

for i=1:sizpr for j=1:nfeats xb=findbin(prueba(i,j),edgs(j,:)); if(f1(j,xb)>0) vers_tint(i)=vers_tint(i)*f1(j,xb); end if(f2(j,xb)>0) vers_blanc(i)=vers_blanc(i,:)*f2(j,xb); end end if vers_blanc(i)/vers_tint(i)>=umb; %regla de decisión clase(i)=0; else clase(i)=1; end end

Como podemos ver, en los vectores “vers_tint(i)” o “vers_blanc(i)” se van almacenando

las probabilidades guardadas en los histogramas “f1(j,xb)” o “f2(j,xb)” que se van

multiplicando para que al terminar el ciclo interno del “for” se tengan las verosimilitudes a

cada clase, cuyo cociente se compara con el umbral ingresado por el usuario.

d) Clasificación y Curva ROC

Finalmente, para implementar el clasificador en un solo archivo, en “tarea1p1.m” se creó

un script que carga la base de datos, la separa con la función descrita en 2.1)b), genera los

histogramas y clasifica con las funciones “histogramas(…)” y “clasificador_hst(…)”, para luego

calcular la Tasa de Verdaderos Positivos (TPR) y la Tasa de Falsos Positivos (FPR), para

distintos umbrales y así generar la curva ROC.

El código para calcular los distintos TPR y FPR se muestra a continuación, junto con la

curva ROC generada (Figura 2), considerando histogramas con 15 bins. Como se puede

apreciar, se utilizó un vector de umbrales con valores desde 10^-10 hasta 10^10, variando la

potencia de 10 utilizada, para tener información completa en el dominio (FPR,TPR).

pot=-10:10; umbr=10.^pot; %rango de umbrales con potencias de 10^-10 hasta 10^10

for j=1:length(umbr) [clase, verif]=clasificador_hst(prueba,f1,f2,edgs,umbr(j)); for i=1:sizpr if verif(i)==1 true1(j)=true1(j)+1; end if verif(i)==0 true0(j)=true0(j)+1; end



Desarrollo

if clase(i)==1 && verif(i) ==1 TPR(j)=TPR(j)+1; end if clase(i)==1 && verif(i) == 0 FPR(j)=FPR(j)+1; end end end

TPR=TPR./true1; FPR=FPR./true0;

Figura 2: Curva ROC del modelo con Histogramas, para “nbins”=15.

e) Efecto del número de bins en los histogramas

El número de muestras del conjunto de prueba es de 486 datos, por lo que, probando

varios valores de “nbins” se observó varios fenómenos interesantes, de los que se destacan

los siguientes:

1.- El mínimo número de bins permitido es “nbins”=4, debido a la forma en que se

definieron los bordes de los intervalos, y con este número se logra una curva ROC

correspondiente a la de un clasificador aleatorio.

2.- Para “nbins”=130, aproximadamente 1/15 del tamaño del conjunto de

entrenamiento, se logra un comportamiento parecido al del clasificador aleatorio, y al

continuar aumentando el número, el clasificador presenta una curva ROC que indica un

comportamiento peor que el aleatorio.

3.- Se identificó como cantidad óptima de bins, el “nbins”=17, debido a que su curva

ROC es la más parecida a un clasificador ideal, y al aumentar o disminuir “nbins”, la curva

se aleja de este comportamiento.



Desarrollo

En la Figura 3 se muestran los fenómenos identificados, por lo que se determinó que

“nbins” = 17, es decir, aproximadamente 1/100 del tamaño del conjunto de entrenamiento,

es el número óptimo de bins para los histogramas.

Figura 3: Curvas ROC para modelo con histogramas con distinta cantidad de bins.

Finalmente, se concluye que la cantidad de bins utilizados en los histogramas influye de

manera determinante en el rendimiento del clasificador bayesiano ingenuo, y si bien no se

logró determinar una relación estrecha y notoria entre el número de muestras del conjunto

de entrenamiento y la cantidad óptima de bins, es claro que un número muy bajo de

intervalos no conviene para clasificar de manera estricta, y un número muy alto de bins

puede contener muy poca información de la muestra de entrenamiento por intervalo, por lo

que finalmente no aproxima bien la distribución de probabilidad. La relación encontrada de

1/100 permite especular que al tomar 100 datos del conjunto de entrenamiento, estos se

reparten entre los intervalos definidos según la distribución de probabilidad del fenómeno

medido. Sin embargo, esto no constituye más que una heurística sin fundamentos sólidos.



Desarrollo

2.3. Clasificador en base a modelo gaussiano a) Función de densidad de una gaussiana multidimensional

La distribución gaussiana multidimensional, también conocida como normal

multivariable, consiste en una generalización a ‘n’ dimensiones de la distribución normal

conocida para una sola dimensión. Como es sabido, la distribución gaussiana define una

densidad de probabilidad dada por la fórmula:

( )

√

( )

, (3) Donde los parámetros son µ y σ2 se llaman “media” y la “desviación estándar”, y son

suficientes para caracterizar por completo la densidad de probabilidad, por lo que si se

desea aproximar una gaussiana unidimensional a una muestra, se puede demostrar que la

mejor estimación de los parámetros se hace calculando la media y desviación estándar de la

muestra.

Para el caso multivariable, debido a que se trata de una generalización, la función de

densidad de probabilidad en esencia posee la misma forma que (3), sólo que ahora los

parámetros que la caracterizan son la “media” como vector n-dimensional y la desviación

estándar se reemplaza por una matriz cuadrada de n x n, llamada “matriz de covarianza”. En

la ecuación (4) se muestra la función de densidad de la gaussiana multidimensional (con

dimensión ‘n’).

( )

( ) ⁄ | | ⁄ (

( ) ( )) , (4)

Donde es el vector con las ‘n’ medias (una por cada dimensión), y representa la matriz

de covarianza, que tiene la forma:

(

),

Donde la diagonal contiene las varianzas y el resto de los términos son las

covarianzas.

En MATLAB existen las funciones “mean(X)” y “cov(X)”, que estiman estos parámetros a

partir de una matriz con los datos. Además, existe la función “mvnpdf(x,MEAN,COV)”, que

retorna el valor de probabilidad del dato x utilizando una distribución normal multivariable

con parámetros MEAN y COV.



Desarrollo

b) y c) Entrenamiento del modelo gaussiano y cálculo de verosimilitudes.

En el caso del clasificador con un modelo gaussiano se generó en “clasificador_mvn.m”, la función “[clase, verif]=clasificador_mvn(entren,prueba,umb)”. Al igual que el caso del modelo con histogramas se retornan el vector ‘clase’ y ‘verif’ de la misma manera, y los argumentos en este caso son el conjunto de entrenamiento, el de prueba y el umbral umb.

A continuación se presenta la parte del código de esta función que separa el conjunto de entrenamiento en los datos de clase Vino Tinto y de clase Vino Blanco, para calcular los vectores de la Media y las matrices de Covarianza respectivas.

sizpr=length(prueba(:,1)); ndiv=find(entren(:,12),1,'last'); xdat=entren(:,1:11); xtinto=xdat(1:ndiv,:); xblanco=xdat(ndiv+1:end,:);

%entreno la media y covarianza u_tint=mean(xtinto); E_tint=cov(xtinto);

u_blanc=mean(xblanco); E_blanc=cov(xblanco);

Con esto ya se puede caracterizar la función de densidad de probabilidad normal

multivariable, por lo que se procede a la clasificación de los elementos de prueba.

ptint=zeros(sizpr,1); pblanc=zeros(sizpr,1); clase=zeros(sizpr,1); %calculo verosimilitudes. for i=1:sizpr ptint(i)=mvnpdf(prueba(i,1:11),u_tint,E_tint); %verosimilitud a

clase vino tinto del dato i pblanc(i)=mvnpdf(prueba(i,1:11),u_blanc,E_blanc); %verosiilitud a

clase vino blanco del dato i if pblanc(i)/ptint(i)>=umb; clase(i)=0; else clase(i)=1; end end verif=prueba(:,12);

Se aprecia que basta utilizar la función “mvnpdf(…)” para cada dato del conjunto de

prueba con los parámetros “entrenados” anteriormente para calcular las verosimilitudes a

cada clase y posteriormente evaluar la regla de decisión con el cociente de las mismas.



Desarrollo

d) Curvas ROC y cálculo de TPR y FPR

Al igual que en el modelo con histogramas se generó un script para calcular las tasas y

graficar la curva ROC, esto se encuentra en el archivo “tarea1p2.m”, básicamente se trata

del mismo código, pero no se invoca la función de “histogramas(…)”, y en vez de invocar

“clasificador_hst(…)”, se invoca “clasificador_mvn(entren,prueba,umb(j))” en las iteraciones.

La curva ROC generada se muestra en la Figura 4.

Figura 4: Curva ROC del modelo gaussiano.

Como se aprecia en la imagen, se tiene un comportamiento relativamente cercano al de

un clasificador ideal.



Desarrollo

2.4. Comparación de modelos a) Ventajas y desventajas de cada método

Como principal ventaja del modelo gaussiano se aprecia que se requiere tener poca

información almacenada, esto es, sólo las medias y la matriz de covarianza para cada clase,

lo que se contrasta con la principal desventaja del modelo con histogramas, el cual debe

almacenar la información de la frecuencia relativa para cada intervalo para cada

característica, lo que requiere un mayor volumen de información almacenada, que en casos

con más características o más datos puede significar un problema.

La gran ventaja que se identifica en el modelo con histogramas es su simplicidad, ya que

al asumir el modelo de Naive Bayes, basta identificar a qué intervalo pertenece el dato en

cuestión y realizar las multiplicaciones, mientras que en el modelo gaussiano se debe evaluar

una función de densidad de probabilidad multidimensional, lo que presenta una mayor

complejidad computacional y puede llevar a mayores tiempos de demora en la clasificación.

Por último, en la Figura 5 se observa que el rendimiento de ambos modelos se encuentra

en un rango aceptable al comparar las curvas ROC. Sin embargo, el modelo del clasificador

gaussiano es el que en este caso posee un mayor rendimiento, debido a que su curva ROC

asociada siempre está por sobre la otra. Esto es, claramente, en el contexto de los datos del

problema resuelto, ya que si se implementa un modelo gaussiano donde los valores para

cada característica son fenómenos que no cumplen una distribución normal, el aproximar

una densidad normal multivariable sería un error que se traduciría en un clasificador de

rendimiento pobre.

Figura 5: Curvas ROC de los dos modelos utilizados, con “nbins=17”.



Desarrollo

b) Función tarea1(entrenamiento,prueba)

Finalmente, en el archivo “tarea1.m” se implementó la función pedida, la cual se utilizó

para generar el gráfico de la Figura 5. El código básicamente consiste en la mezcla de los

script “tarea1p1.m” y “tarea1p2.m”, sin la separación realizada con

“basededatos(data,repr_err)”. Además, a esta función se le puede agregar un tercer

argumento que corresponde al valor a utilizar para ‘nbins’.



Conclusiones

3. Conclusiones

Al analizar los resultados obtenidos al clasificar el conjunto de prueba generado, tanto

para el modelo con aproximación de Naive Bayes con histogramas, como para el modelo gaussiano, se logra una clasificación que dependiendo del umbral puede lograr un valor aceptable de la Tasa de Verdaderos Positivos y de la Tasa de Falsos Positivos, por lo que finalmente el diseño realizado será efectivo dependiendo de la aplicación que se requiera, ya que sólo en ese momento se pueden fijar los costos y las probabilidades a priori, fijando a su vez el punto de operación o umbral.

Luego de observar las curvas ROC de ambos modelos se concluye que el modelo del

clasificador bayesiano con distribución gaussiana multivariable es el que posee un mejor rendimiento entre los dos modelos implementados. Sin embargo, se hace la distinción de que es para el contexto en que los datos de la muestra corresponden a un fenómeno con distribución gaussiana.

Además, en el caso del modelo con histogramas, se concluye que la cantidad de bins

definidos para los histogramas incide fuertemente en el rendimiento del clasificador, haciendo determinante la buena elección de esta cantidad al momento de diseñar el clasificador.

Finalmente, al ser ambos modelos representaciones de clasificadores Bayesianos, con esta

tarea se comprueba que el método de Bayes es una forma muy efectiva de realizar clasificación, al menos para casos donde se requiere clasificar dos clases.



Anexos

4. Anexos

A continuación se muestran los códigos contenidos en cada uno de los archivos

entregados en la tarea.

“basededatos.m”

function [entren, prueba]= basededatos(data,repr_err) %[entren, prueba]= basededatos(data,repr_err) recibe la matriz 'data' con

los datos de %los vinos, elimina los posibles outliers con el Criterio de Chauvenet y %genera dos conjuntos representativos 'entren' con el 80% de los datos y %'prueba' con el 20%. 'repr_err' es el %(porcentaje) de la media del error

de los %parametros de representatividad (media, desv estandar, max, min, rango y

proporcion de clases) %con respecto al conjunto completo una vez descartados los outliers. % %Se recomienda usar 'repr_err'>=0.5 % (si se elige un % menor, puede que

se %requieran demasiadas iteraciones y se active el escape, por lo que no se %asegura el error) % %Se puede llamar como basededatos(data), y se utiliza el valor por defecto %de repr_err=0.5.

if nargin<2 repr_err=0.5; end

N=length(data(:,1)); nfeats=11; % n° de caracteristicas

%chequear "Outliers" y descartarlos (Criterio de Chauvenet)

u_x=mean(data); sgm_x=std(data); noutliers=0; descartar=zeros(72,1); %se detectaron 72 "outliers" con este método. for j=1:nfeats for i=1:N chauv=pdf('norm',data(i,j),u_x(j),sgm_x(j))*N; if(chauv<0.5) %sprintf('Outlier en %d,%d',i,j); noutliers=noutliers+1; descartar(noutliers)=i; end end end



Anexos

descartar=sort(descartar); %noutliers %descomentar para visualizar el n° de outliers en la

consola.

%descarto los datos dudosos de la matriz. for l=noutliers-(1:noutliers) +1 data(descartar(l),:)=[]; end

%divido conjuntos de datos de vino tinto y vino blanco N2=length(data(:,1)); %nuevo numero de muestras a utilizar ndiv=find(data(:,12),1,'last'); siztint=length(1:ndiv); sizblanc=length(ndiv+1:N2);

%vectores de parametros de representatividad del conjunto completo.

u_data=mean(data); sgm_data=std(data); max_data=max(data); min_data=min(data); rang_data=max_data-min_data; ratetint_data=siztint/N2;

%calculo n° de datos a extraer por cada tipo de vino pr_ntint=round(siztint*0.2); pr_nblanc=round(sizblanc*0.2); en_ntint=siztint-pr_ntint; en_nblanc=sizblanc-pr_nblanc;

%tamaño de cada conjunto sizpr=pr_ntint+pr_nblanc; sizen=en_ntint+en_nblanc;

%inicio el conjunto. prueba=zeros(sizpr,12);

eps=100; cnt=0; xdat=data; %guardo el conjunto inicial

while(eps>=repr_err) %aseguro promedio de error de a lo más repr_err%

(porcentaje) de la representatividad (calculado mas abajo) %de los conjuntos de entrenamiento y prueba con

respecto al conjunto original. data=xdat; %reinicializo el conjunto completo.



Anexos

%extraigo pr_nblanc datos aleatorios entre los datos de vino blanco %y pr_ntint datos aleatorios entre los datos de vino tinto

prueba=zeros(sizpr,12); %inicializo el conjunto de prueba. for i=1:pr_nblanc fin=length(data(:,1))-i+1; j=randi([ndiv+1 fin]); prueba(i,:)=data(j,:); data(j,:)=[]; end

for i=1:pr_ntint fin=ndiv-i+1; j=randi([1 fin]); prueba(i+pr_nblanc,:)=data(j,:); data(j,:)=[]; end

entren=data;

%verifico representatividad de los conjuntos u_en=mean(entren); sgm_en=std(entren); max_en=max(entren); min_en=min(entren); rang_en=max_en-min_en;

u_pr=mean(prueba); sgm_pr=std(prueba); max_pr=max(prueba); min_pr=min(prueba); rang_pr=max_pr-min_pr;

%proporcion de clases (en particular de vino tinto) ndiv_en=find(entren(:,12),1,'last'); siztint_en=length(1:ndiv_en); sizblanc_en=length(ndiv_en+1:length(entren(:,1)));

ndiv_pr=find(prueba(:,12),1,'first'); sizblanc_pr=length(1:ndiv_pr-1); siztint_pr=length(ndiv_pr:length(prueba(:,1)));

ratetint_en=siztint_en/sizen; %conjunto entrenamiento ratetint_pr=siztint_pr/sizpr; %conjunto prueba

%calculo errores respecto de cada parametro del conjunto original err=zeros(2,5); err(1,1)=abs(u_data-u_en)/u_data; err(2,1)=abs(u_data-u_pr)/u_data; err(1,2)=abs(sgm_data-sgm_en)/sgm_data; err(2,2)=abs(sgm_data-sgm_pr)/sgm_data; err(1,3)=abs(max_data-max_en)/max_data; err(2,3)=abs(max_data-max_pr)/max_data; err(1,4)=abs(min_data-min_en)/min_data;



Anexos

err(2,4)=abs(min_data-min_pr)/min_data; err(1,5)=abs(rang_data-rang_en)/rang_data; err(2,5)=abs(rang_data-rang_pr)/rang_data; rate_error=mean([abs(ratetint_data -ratetint_en) abs(ratetint_data-

ratetint_pr)]); %error de Proporción de clases.

eps=mean([mean2(err) rate_error])*100; %porcentaje final de error de

representatividad de la división.

cnt=cnt+1; if cnt>300 %escape por si debe realizar muchas iteraciones. sprintf('Superado el límite de iteraciones, por favor intente

nuevamente o aumente el error de representatividad permitido, se sugiere

0.5%') break end end %cnt %descomentar para ver cuantas iteraciones necesitó.



Anexos

“histogramas.m”

function [f1, f2, edgs]=histogramas(entren,nbins,graf) %entrega en cada fila del vector f1 los histogramas con 'nbins' cantidad de

bins %correspondientes a las caracteristicas de los vinos tintos del conjunto de %entrenamiento 'entren', y en f2 los correspondientes a los vinos blancos. %adicionalmente, en 'edgs' entrega un vector de tamaño 'nbins' con los

rangos %utilizados para los bins de cada histograma. %'graf' distinto de '0' mostrará los histogramas generados en una figura. %si se omite el argumento NO se mostrarán los histogramas. if nargin<3 graf=0; end ndiv=find(entren(:,12),1,'last'); xdat=entren(:,1:11); xtinto=xdat(1:ndiv,:); xblanco=xdat(ndiv+1:end,:); nfeats=11;

f1=zeros(nfeats,nbins); f2=zeros(nfeats,nbins); edgs=zeros(nfeats,nbins); headers={'fixed acidity' 'volatile acidity' 'citric acid' 'residual sugar'

'chlorides' 'free sulfur dioxide' 'total sulfur dioxide' 'density' 'pH'

'sulphates' 'alcohol'};

for j=1:nfeats

a=min(xdat(:,j)); b=max(xdat(:,j)); delta=(b-a)/((nbins-1)-2); edgs(j,:)=a-delta:delta:b+delta; f1(j,:)=histc(xtinto(:,j),edgs(j,:)); f1(j,:)=f1(j,:)/sum(f1(j,:)); f2(j,:)=histc(xblanco(:,j),edgs(j,:)); f2(j,:)=f2(j,:)/sum(f2(j,:)); %para graficar ingresar 'graf' distinto de 0 if(graf~=0) subplot(3,4,j); stairs(edgs(j,:),f1(j,:),'m') hold on; stairs(edgs(j,:),f2(j,:),'g') title(headers(j)); hold off; end end

if(graf~=0) legend('vino tinto','vino blanco','Location', 'BestOutside') end



Anexos

“findbin.m” function bin=findbin(dato,s) %retorna el indice del bin al que pertenece 'dato' dentro de los

intervalos %definidos por los bordes de cada rango en 's'. Se supone que 's' está %particionado equitativamente.

aux=-1; if ((dato < s(1) && dato>s(1)/2) ||dato==s(1)) aux=1; end

if ((dato > s(end) && dato<2*s(end)) || dato==s(end)) aux=length(s)-1; end

for i=1:length(s)-1 if(dato>s(i) && dato<=s(i+1)) aux=i; break end end

bin=aux;



Anexos

“clasificador_hst.m” function [clase, verif]=clasificador_hst(prueba,f1,f2,edgs,umb) %[clase,verif]=clasificador_hst(prueba,f1,f2,edgs,umb) %retorna una columna con las clases asignadas a cada muestra (fila) del %conjunto de prueba 'prueba'. %se utilizan los vectores de histogramas para cada característica, f1

contiene %las de vinos tintos y f2 de vinos blancos. %El argumento 'edgs' contiene un vector con los rangos utilizados para

definir los bins %de cada histograma. %Se retorna además el vector 'verif', que indica la clase real de los

datos con %un "1" si el dato es de la clase vino tinto o un "0" si es de la clase

vino blanco.

sizpr=length(prueba(:,1)); nfeats=11; vers_tint=ones(sizpr,1); vers_blanc=ones(sizpr,1); clase=zeros(sizpr,1); %calculo verosimilitudes. for i=1:sizpr for j=1:nfeats xb=findbin(prueba(i,j),edgs(j,:)); if(f1(j,xb)>0) vers_tint(i)=vers_tint(i)*f1(j,xb); end if(f2(j,xb)>0) vers_blanc(i)=vers_blanc(i,:)*f2(j,xb); end end if vers_blanc(i)/vers_tint(i)>=umb; %regla de decisión clase(i)=0; else clase(i)=1; end end verif=prueba(:,12);



Anexos

“tarea1p1.m”

clear all; load base_de_datos_Tarea1; a=wine_data; nfeats=11; %genero conjuntos de entrenamiento y prueba

[entren,prueba]=basededatos(a,0.5); %aseguro promedio de error de a lo más 0.5% de

representatividad %de los conjuntos de entrenamiento y prueba con respecto al

conjunto original.

sizpr=length(prueba(:,1)); %n° de datos de prueba

%generar histogramas normalizados. nbins=17; %minimo:4 (clasificador aleatorio) óptimo:17, máximo:130

(vuelve a ser parecido al aleatorio), con más se vuelve peor que el

clasificador aleatorio. [f1,f2,edgs]=histogramas(entren,nbins);

%Clasifico y calculo TPR y FPR para distintos umbrales

pot=-10:10; umbr=10.^pot; %rango de umbrales con potencias de 10^-10 hasta 10^10 true1=zeros(length(umbr),1); true0=zeros(length(umbr),1); TPR=zeros(length(umbr),1); FPR=zeros(length(umbr),1); for j=1:length(umbr) [clase, verif]=clasificador_hst(prueba,f1,f2,edgs,umbr(j)); for i=1:sizpr if verif(i)==1 true1(j)=true1(j)+1; end if verif(i)==0 true0(j)=true0(j)+1; end if clase(i)==1 && verif(i) ==1 TPR(j)=TPR(j)+1; end if clase(i)==1 && verif(i) == 0 FPR(j)=FPR(j)+1; end end end TPR=TPR./true1; FPR=FPR./true0; figure plot(FPR,TPR,'LineWidth',2) title('Curva ROC Modelo Con Histogramas') xlabel('FPR') ylabel('TPR')



Anexos

“clasificador_mvn.m”

function [clase, verif]=clasificador_mvn(entren,prueba,umb) %[clase,verif]=clasificador_mvn(entren,prueba,umb) retorna una columna

'clase' %con las clases asignadas a cada muestra (fila) del conjunto de prueba

'prueba'. %Se utiliza una densidad de probabilidad normal multivariable que

aproxima %los datos de la matriz 'entren' para determinar las verosimilitudes, y %utiliza el umbral 'umb' para la regla de decisión. %Se retorna además el vector 'verif', que contiene la clase real de cada %dato, identificada con un "1" si es vino tinto y con un "0" si es vino %blanco.

sizpr=length(prueba(:,1)); ndiv=find(entren(:,12),1,'last'); xdat=entren(:,1:11); xtinto=xdat(1:ndiv,:); xblanco=xdat(ndiv+1:end,:);

%entreno la media y covarianza u_tint=mean(xtinto); E_tint=cov(xtinto);

u_blanc=mean(xblanco); E_blanc=cov(xblanco);

ptint=zeros(sizpr,1); pblanc=zeros(sizpr,1); clase=zeros(sizpr,1); %calculo verosimilitudes. for i=1:sizpr ptint(i)=mvnpdf(prueba(i,1:11),u_tint,E_tint); %verosimilitud a

clase vino tinto del dato i pblanc(i)=mvnpdf(prueba(i,1:11),u_blanc,E_blanc); %verosiilitud a

clase vino blanco del dato i if pblanc(i)/ptint(i)>=umb; clase(i)=0; else clase(i)=1; end end verif=prueba(:,12);



Anexos

“tarea1p2.m”

close all; clear all; load base_de_datos_Tarea1; a=wine_data; nfeats=11; %genero conjuntos de entrenamiento y prueba

[entren,prueba]=basededatos(a,0.5); %aseguro promedio de error de a lo más 0.5% de

representatividad %de los conjuntos de entrenamiento y prueba con respecto al

conjunto original.

%Clasifico y calculo TPR y FPR para distintos umbrales

sizpr=length(prueba(:,1)); %n° de datos de prueba pot=-10:10; umbr=10.^pot;%rango de umbrales con potencias de 10^-10 hasta 10^10 true1=zeros(length(umbr),1); true0=zeros(length(umbr),1); TPR=zeros(length(umbr),1); FPR=zeros(length(umbr),1); for j=1:length(umbr) [clase, verif]=clasificador_mvn(entren,prueba,umbr(j)); for i=1:sizpr if verif(i)==1 true1(j)=true1(j)+1; end if verif(i)==0 true0(j)=true0(j)+1; end if clase(i)==1 && verif(i) ==1 TPR(j)=TPR(j)+1; end if clase(i)==1 && verif(i) == 0 FPR(j)=FPR(j)+1; end end end

TPR=TPR./true1; FPR=FPR./true0; figure plot(FPR,TPR,'r','LineWidth',2) title('Curva ROC Modelo Gaussiano') xlabel('FPR') ylabel('TPR')



Anexos

“tarea1.m” function tarea1(entrenamiento,prueba,nbins)

close all; %n° de datos de prueba sizpr=length(prueba(:,1)); %se puede invocar con 2 argumentos tarea1(entrenamiento,prueba) con el %valor 'nbins' óptimo por defecto. if nargin<3 nbins=17; end

%Generar histogramas normalizados.

%nbins: %minimo:4 (clasificador aleatorio) %óptimo:17 (mejor curva ROC) %máximo:130 (vuelve a ser parecido al aleatorio), %con más se vuelve peor que el clasificador aleatorio.

[f1,f2,edgs]=histogramas(entrenamiento,nbins,1); %sacar el tercer argumento, o hacerlo '0' para no mostrar %histogramas.

%Clasifico y calculo TPR y FPR para distintos umbrales, con los dos %métodos. pot=-10:10; umbr=10.^pot;%rango de umbrales con potencias de 10^-10 hasta 10^10 true1=zeros(length(umbr),2); true0=zeros(length(umbr),2); TPR=zeros(length(umbr),2); FPR=zeros(length(umbr),2); for j=1:length(umbr) [clase, verif]=clasificador_hst(prueba,f1,f2,edgs,umbr(j));

%clasificador con histogramas [clase2, verif2]=clasificador_mvn(entrenamiento,prueba,umbr(j));

%clasificador con gaussiana for i=1:sizpr if verif(i)==1 true1(j,1)=true1(j,1)+1; end if verif(i)==0 true0(j,1)=true0(j,1)+1; end if clase(i)==1 && verif(i) ==1 TPR(j,1)=TPR(j,1)+1; end if clase(i)==1 && verif(i) == 0 FPR(j,1)=FPR(j,1)+1; end

if verif2(i)==1 true1(j,2)=true1(j,2)+1;



Anexos

end if verif2(i)==0 true0(j,2)=true0(j,2)+1; end if clase2(i)==1 && verif2(i) ==1 TPR(j,2)=TPR(j,2)+1; end if clase2(i)==1 && verif2(i) == 0 FPR(j,2)=FPR(j,2)+1; end end

end

TPR(:,1)=TPR(:,1)./true1(:,1); FPR(:,1)=FPR(:,1)./true0(:,1); TPR(:,2)=TPR(:,2)./true1(:,2); FPR(:,2)=FPR(:,2)./true0(:,2); figure plot(FPR(:,1),TPR(:,1),'LineWidth',2) hold on plot(FPR(:,2),TPR(:,2),'r','LineWidth',2) title('Curvas ROC') xlabel('FPR') ylabel('TPR') legend('Modelo con Histogramas','Modelo Gaussiano')

informe tarea n°1 - u-cursos · 2014-06-30 · 0.5, se descarta dicho dato. el método considera...

Documents