REPÚBLICA DEL ECUADOR

UNIVERSIDAD METROPOLITANA
CARRERA DE INGENIERIA EN SISTEMAS DE INFORMACIÒN

ELABORE UN CLASIFICADOR, UTILIZANDO UNA TÉCNICA DE

APRENDIZAJE SUPERVISADO, QUE PERMITA RESOLVER EL
PROBLEMA DE CLASIFICAR DE FORMA AUTOMÁTICA.

PROPUESTO POR:

DOUGLAS AYALA BRAVO.

ASIGNATURA:

INTELEGENCIA ARTIFICAL.

DOCENTE:

DR. DIDIOSKY BENÍTEZ ERICE.

FEBRERO DE 2017
 Índice
Diseño del corpus de entrenamiento ..................................................................................4

Definiendo las clases .....................................................................................................4

Creando el archivo del corpus de entrenamiento ...........................................................5

Diseño del proyecto de clasificación .................................................................................7

Crear el proyecto en NetBeans ......................................................................................7

Definición de clases .......................................................................................................9

Diseño del formulario ..................................................................................................15

Figuras
Fig. 1. Conjunto de clases del corpus de entrenamiento ...................................................4
Fig. 2. Guardar archivo en formato arff.............................................................................5
Fig. 3. Corpus de entrenamiento arff .................................................................................7
Fig. 4. Crear un nuevo proyecto en NetBeans ...................................................................8
Fig. 5. Seleccionar el tipo de proyecto a generar...............................................................8
Fig. 6. Elegir un nombre para el proyecto a generar .........................................................9
Fig. 7. Estructura de directorios del proyecto generado ....................................................9
Fig. 8. Crear una nueva clase en el paquete proyectoclasificacion .................................10
Fig. 9. Escribir un nombre para la clase ..........................................................................10
Fig. 10. Clases agregadas al paquete proyectoclasificacion ............................................11
Fig. 11. Propiedades del proyecto ...................................................................................11
Fig. 12. Propiedades del proyecto ...................................................................................12
Fig. 13. Seleccionar la librería weka.jar ..........................................................................12
Fig. 14. Librería agregada al proyecto .............................................................................13
Fig. 15. Librería weka.jar en el proyecto .........................................................................13
Fig. 16. Crear un nuevo paquete en el proyecto ..............................................................16
Fig. 17. Elegir un nombre para el paquete nuevo ............................................................16
Fig. 18. Paquete formularios ...........................................................................................17
Fig. 19. Crear un nuevo JFrame Form en el paquete formularios ...................................17
Fig. 20. Nombrar el nuevo formulario .............................................................................18
Fig. 21. Formulario agregado al proyecto .......................................................................18
Fig. 22. Formulario principal...........................................................................................19
Fig. 23. Cambiar a vista de código ..................................................................................19
Fig. 24. Código para abrir archivos .................................................................................20
Fig. 25. Cambiar el nombre de la variable a un cuadro de texto ....................................21
Fig. 26. Asignar un nuevo nombre de variable a un cuadro de texto ..............................21
Fig. 27. Nombres de los cuadros de texto........................................................................22
Fig. 28. Generar el método para el botón abrir ................................................................22
Fig. 29. Generar el método para el botón abrir ................................................................23
Fig. 30. Generar el método para el botón clasificar.........................................................23
Fig. 31. Generar el método para el botón seleccionar .....................................................24
 DISEÑO DEL CORPUS DE ENTRENAMIENTO

Definiendo las clases

El corpus de entrenamiento es un archivo donde debemos introducir los valores o datos
que corresponden a "ciertas" clases. Es decir, si queremos clasificar un conjunto de datos,
primeramente debemos agrupar estos datos en clases distintas. Para esto debemos definir
el conjunto de clases que conformará nuestro corpus de entrenamiento y posteriormente
definir qué datos contendrá cada clase.

En la Fig. 1 podemos observar que tenemos 3 agrupaciones; a estas agrupaciones les

llamamos clases. Cada agrupación, a su vez, contiene un número definido de datos. Para
este ejemplo, estamos definiendo que el clima será caluroso si la temperatura es próxima
a ese conjunto de datos (30, 33, 38, 44, 48); y así para cada una de las clases. Si por
ejemplo, nuestro dato de entrada en la clasificación fuera de 35; el sistema lo clasificaría
en caluroso debido a la cercanía que tiene el valor 35 con los valores que conforman la
clase caluroso.

Fig. 1. Conjunto de clases del corpus de entrenamiento

En este ejemplo, el corpus de entrenamiento está compuesto, como se dijo anteriormente,

por 3 clases (frío, fresco, caluroso), y cada clase contiene 5 datos; sin embargo, esto no
está limitado y entre más datos se tengan dentro de las clases, mayor será el promedio de
éxito de la clasificación.

Además con las temperaturas ingresadas se podrá pronosticar la temperatura del día
siguiente, lo que indica que pronosticar el clima es un algoritmo basado en el clasificador
utilizado.
Creando el archivo del corpus de entrenamiento

El archivo del corpus de entrenamiento tiene un formato especial, sin embargo, lo

podemos generar utilizando cualquier editor de textos (notepad de Windows, por
ejemplo). Abriremos el bloc de notas de Windows (notepad) y guardaremos el archivo
con el nombre temperatura.arff. Para que Windows respete la extensión arff debemos
seleccionar la opción Todos los archivos en el cuadro de diálogo Guardar (Fig. 2).

Fig. 2. Guardar archivo en formato arff

El archivo del corpus de entrenamiento estará dividido en tres partes. La primera de

ellas nos va a indicar el nombre del archivo y se define con la siguiente línea:

@relation nombre_archivo

nombre_archivo: Es el nombre del archivo que le daremos al corpus de entrenamiento,

puede ser cualquiera evitando utilizar acentos o caracteres especiales.

La segunda sección deberá contener los atributos (incluidas las clases que vamos a
definir) que definiremos para generar el corpus de entrenamiento. Esto se define con la
siguiente línea:

@attribute nombre_atributo tipo

nombre_atributo: Es el nombre del atributo y puede ser cualquiera evitando utilizar
acentos o caracteres especiales; es muy similar a una variable de programación.

tipo: Es el tipo de datos que almacenará el atributo. Es muy similar al valor definido en
una variable de programación.

Las clases se definen primeramente y llevan el siguiente formato:

@attribute nombre_clase {nombre_clase1, nombre_clase2, nombre_clase3...n}

Finalmente, la tercera sección estará compuesta por los datos que llenarán cada una de las
clases definidas. Se define con la siguiente línea:

@data

Los datos se introducen inmediatamente después de la instrucción @data y en el orden

en que se definieron los atributos. En base a lo explicado anteriormente, vamos a generar
el archivo del corpus de entrenamiento.

@relation clima

En la línea anterior estoy definiendo que el archivo se llamará clima.

@attribute clima {caluroso, fresco, frio}

En la línea anterior estoy definiendo 3 clases (caluroso, fresco, frío) que serán accedidas
a través del parámetro clima.

@attribute temperatura numeric

En la línea anterior estoy definiendo un parámetro llamado temperatura que será de tipo
numerico (numeric).

@data

En la línea anterior estoy definiendo que a partir de aquí vendrán los datos de cada una
de las clases.

frio, 3

frio, 5
 frio, 7

frio, 10

frio, 15

Las líneas anteriores corresponden con los valores para la clase frio. Esto no
necesariamente tiene que ir en orden, pero es más fácil leer el archivo de entrenamiento
si lo tenemos ordenado. Primeramente escribimos el nombre de la clase a la que haremos
referencia (frio), luego separamos por una "coma" seguido del valor de la temperatura
que corresponderá con esa clase (3, 5, 7, 10 y 15). Esto se hace también para las clases
restantes.

La Fig. 3 muestra cómo quedaría el archivo de entrenamiento, sólo basta con guardar los
cambios y tendríamos listo este primer paso.

Fig. 3. Corpus de entrenamiento arff

DISEÑO DEL PROYECTO DE CLASIFICACIÓN

Crear el proyecto en NetBeans

Primeramente vamos a crear el proyecto en el IDE de NetBeans, para ello, una vez abierto
NetBeans 8.0, procedemos a desplegar el menú File/New Project como se muestra a
continuación:
 Fig. 4. Crear un nuevo proyecto en NetBeans

En la ventana que aparece a continuación, debemos buscar y seleccionar la carpeta Java

dentro del apartado de Categorías; y dentro del apartado de Proyectos debemos
seleccionar Aplicación Java y presionar el botón Next:

Fig. 5. Seleccionar el tipo de proyecto a generar

En la ventana que aparece a continuación, debemos elegir un nombre para el proyecto; en

este caso le llamaremos ProyectoClasificación, y presionaremos el botón Finish:
 Fig. 6. Elegir un nombre para el proyecto a generar

Con esto se generará una estructura de directorios del lado izquierdo de la pantalla:

Fig. 7. Estructura de directorios del proyecto generado

Definición de clases
En este proyecto utilizaremos 3 clases que tendrán funciones específicas. Para esto
presionamos el botón derecho del mouse sobre el paquete proyectoclasificacion y del
menú contextual elegimos la opción New y a continuación Java Class...:
 Fig. 8. Crear una nueva clase en el paquete proyectoclasificacion

En la ventana que aparece a continuación, debemos elegir el nombre de la clase; para este
caso llamaremos a la clase clsClasificacion. La clase clsClasificacion se encargará de
clasificar el dato de entrada en alguna de las clases definidas en el corpus de
entrenamiento (frio, fresco, caluroso):

Fig. 9. Escribir un nombre para la clase

Debemos seguir los dos pasos anteriores para crear las dos clases restantes: clsModelo y
clsInstanciaWeka. Si todo ha ido bien, deberíamos ver las tres clases agregadas al
paquete proyectoclasificacion:

Fig. 10. Clases agregadas al paquete proyectoclasificacion

Ahora vamos a proceder a agregar la librería de Weka para poder utilizar los métodos que
esta provee. Presionamos el botón derecho del mouse sobre el nombre del proyecto
ProyectoClasificacion y elegimos la opción Properties:

Fig. 11. Propiedades del proyecto

En la ventana que aparece a continuación debemos ir a la sección Libraries y presionar
el botón Add JAR/Folder:

Fig. 12. Propiedades del proyecto

En la ventana que aparece a continuación, debemos buscar la librería weka.jar y

presionar el botón Abrir:

Fig. 13. Seleccionar la librería weka.jar

Con esto, deberíamos ver la librería agregada en la siguiente ventana; ahora solo basta
con presionar el botón OK para continuar con el proyecto:
 Fig. 14. Librería agregada al proyecto

Sólo para corroborar que la librería se ha añadido al proyecto, podemos desplegar la

carpeta de libraries de nuestro proyecto, y ahí deberíamos ver la librería weka.jar:

Fig. 15. Librería weka.jar en el proyecto

Ahora vamos a proceder a abrir la clase llamada clsModelo y eliminar todo el código que
haya en esta, y pegar el código siguiente:
 package proyectoclasificacion;

import weka.classifiers.Classifier;
import weka.classifiers.functions.SMO;
import weka.core.Instances;
import weka.core.converters.ConverterUtils;

public class clsModelo {

private final Classifier Classifier = new SMO();
private final Instances train;

public clsModelo(String rutaCorpus) throws Exception {

train = ConverterUtils.DataSource.read(rutaCorpus);
train.setClassIndex(0);
}

public void generarModelo(String rutaDestino)throws Exception{

if(train.numInstances()==0)
throw new Exception("No classifier available");
weka.core.SerializationHelper.write(rutaDestino, Classifier);
}
}

A continuación debemos abrir la clase llamada clsInstanciaWeka y eliminar el código

que contenga, y pegar el código siguiente:

package proyectoclasificacion;

import java.io.IOException;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;

public class clsInstanciaWeka {

public Instance crearInstancia(Float temperatura, Instances train) throws IOException{
/* El número 2, es el número de atributos que aparecen en el corpus (clima y temperatura). */
Instance instance = new Instance(2);

/* Se escribe sólo los atributos sin considerar las clases, en este caso, solo queda temperatura */
Attribute atributo = train.attribute("temperatura");

instance.setValue(atributo, temperatura);

instance.setDataset(train);

return instance;
}
}
A continuación procederemos a abrir la clase llamada clsClasificacion y eliminar el
código que contiene esta para copiar y pegar el siguiente:

package proyectoclasificacion;

import weka.classifiers.Classifier;
import weka.classifiers.functions.SMO;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.converters.ConverterUtils;

public class clsClasificacion {

private static Instances train;
Classifier Classifier;
Instances data;

public clsClasificacion(String corpus, String modelo) throws Exception{

Classifier = (SMO) weka.core.SerializationHelper.read(modelo);
train = ConverterUtils.DataSource.read(corpus);
train.setClassIndex(0);
data = new Instances(train);
}

public String clasificar(Float temperatura) throws Exception{

double predicted;
Instance instance;
clsInstanciaWeka instancia = new clsInstanciaWeka();

if(train.numInstances()==0){
throw new Exception("No classifier available");
}

instance = instancia.crearInstancia(temperatura, data);

Classifier.buildClassifier(data);
predicted = Classifier.classifyInstance(instance);

return train.classAttribute().value((int)predicted);
}
}

Diseño del formulario

A continuación vamos a generar el formulario para utilizar las clases anteriormente

creadas. Para esto presionamos el botón derecho del mouse sobre la carpeta Source
Packages y elegimos la opción New y a continuación Java Package:
 Fig. 16. Crear un nuevo paquete en el proyecto

En la ventana que aparece a continuación debemos elegir un nombre para el paquete a

crear; para este caso llamaremos al paquete formularios y presionamos el botón Finish:

Fig. 17. Elegir un nombre para el paquete nuevo

Con esto deberíamos ver un nuevo paquete en el proyecto:

Fig. 18. Paquete formularios

Ahora presionamos el botón derecho del mouse sobre el paquete formularios y elegimos
la opción New y a continuación JFrame Form:

Fig. 19. Crear un nuevo JFrame Form en el paquete formularios

En la ventana siguiente debemos elegir el nombre del formulario a generar; para este caso
el nombre será frmPrincipal:
 Fig. 20. Nombrar el nuevo formulario

Con esto deberíamos poder ver el nuevo formulario agregado en nuestro proyecto:

Fig. 21. Formulario agregado al proyecto

Ahora vamos a agregar los elementos correspondientes para que el formulario se vea de
la siguiente manera:
 Fig. 22. Formulario principal

Ahora debemos ir al modo código; para esto presionamos el botón source como se
muestra a continuación:

Fig. 23. Cambiar a vista de código

Ahora debemos localizar el constructor del formulario (aproximadamente en la línea 21)
y debajo de este método habremos de pegar o escribir el código siguiente:

Fig. 24. Código para abrir archivos

Este es el código anterior para poder copiar y pegarlo debajo del constructor del
formulario:

private String abrirArchivo(){

JFileChooser fc = new JFileChooser();
int respuesta = fc.showOpenDialog(this);
if (respuesta == JFileChooser.APPROVE_OPTION)
{
File archivoElegido = fc.getSelectedFile();
return archivoElegido.getAbsolutePath();
}
else
return null;
}

Ahora debemos modificar el nombre de las variables de los cuadros de texto. Para hacer
esto, vamos a ir uno por uno, de arriba hacia abajo. Primero debemos presionar el botón
derecho del mouse sobre un cuadro de texto y del menú contextual elegir la opción
Change Variable Name y a continuación elegir el nombre de la nueva variable para el
cuadro de texto:
 Fig. 25. Cambiar el nombre de la variable a un cuadro de texto

En la ventana que aparece a continuación debemos escribir el nombre de la variable para

el cuadro de texto elegido y presionar el botón OK:

Fig. 26. Asignar un nuevo nombre de variable a un cuadro de texto

Con estos pasos asignaremos cada uno de los nombres para los cuadros de texto como
se muestra en la figura siguiente:
 Fig. 27. Nombres de los cuadros de texto

Nota: Los botones no serán renombrados.

A continuación vamos a programar los botones; para ello presionamos doble clic sobre el
botón abrir que se encuentra en la línea que indica la ruta del corpus:

Doble clic

Fig. 28. Generar el método para el botón abrir

Esto nos llevará a la vista código y se nos ha generado un método para el botón; dentro
de este método tenemos que escribir o copiar y pegar el siguiente código:

txtRutaCorpus.setText(abrirArchivo());

Ahora hacemos lo mismo pero para el siguiente botón, el que se encuentra a la altura de
Ruta del modelo:
 Doble clic

Fig. 29. Generar el método para el botón abrir

Ahora debemos copiar y pegar el código siguiente en el método que se generó para el
botón abrir:

txtRutaModelo.setText(abrirArchivo());

A continuación vamos a generar el método para el botón Clasificar:

Doble clic

Fig. 30. Generar el método para el botón clasificar

En el método generado vamos a copiar y pegar el siguiente código:

 if(txtRutaCorpus.getText().trim().equals(""))
JOptionPane.showMessageDialog(null, "La ruta del corpus no está especificada. No se puede
clasificar.");
else if(txtRutaModelo.getText().trim().equals(""))
JOptionPane.showMessageDialog(null, "La ruta del modelo no está especificada. No se puede
clasificar.");
else if(txtTemperatura.getText().trim().equals(""))
JOptionPane.showMessageDialog(null, "La temperatura no ha sido definida. No se puede
clasificar.");
else{
try {
clsClasificacion clasificacion = new clsClasificacion(txtRutaCorpus.getText().trim(),
txtRutaModelo.getText().trim());
String resultado = clasificacion.clasificar(Float.parseFloat(txtTemperatura.getText().trim()));
txtaResultado.setText(resultado);
} catch (Exception ex) {
Logger.getLogger(frmPrincipal.class.getName()).log(Level.SEVERE, null, ex);
}
}

Ahora vamos a generar el método para el botón de seleccionar que se encuentra a la altura
de Ruta de destino:

Doble clic

Fig. 31. Generar el método para el botón seleccionar

Debemos copiar y pegar el siguiente código en el método generado anteriormente:

txtRutaDestino.setText(abrirArchivo());

Finalmente vamos a generar el método para el botón de Generar modelo:

Doble clic

Ahora copiamos y pegamos el código siguiente en el método generado del botón:

 if(txtRutaDestino.getText().trim().equals(""))
JOptionPane.showMessageDialog(null, "Debe especificar una ruta de destino para almacenar
el modelo.");
else if(txtRutaCorpus.getText().trim().equals(""))
JOptionPane.showMessageDialog(null, "Debe seleccionar el corpus de entrenamiento para
generar el modelo.");
else{
try {
clsModelo modelo = new clsModelo(txtRutaCorpus.getText().trim());
modelo.generarModelo(txtRutaDestino.getText().trim());
JOptionPane.showMessageDialog(null, "Modelo generado.");
} catch (Exception ex) {
Logger.getLogger(frmPrincipal.class.getName()).log(Level.SEVERE, null, ex);
}
}