Weka with Data Mining done in java

Utilizando la libreria de weka.jar, la pueden descargar en Pagina Oficial Weka



Weka es un software programado en Java que está orientado a la extracción de conocimientos desde bases de datos con grandes cantidades de información, se tiene mucho algoritmos echos para Redes Neuronales, Minería de Datos, Problemas de Clasificación, Redes Bayesianas, entre otras...

En este caso voy a poner el código de un ejemplo donde utilizo la librería weka.jar llamada desde JAVA

En este caso utilizo 5 algoritmos que son usados para clasificación: Ridor, ZeroR, PART, NNge, M5Rules

CODIGO:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package wekadatamining;
/**
 *
 * @a{
            DataSource ar = new DataSource(ruta);
            coleccion = ar.getDataSet();
            coleccion.setClassIndex(coleccion.numAttributes() - 1);
            //presentar la coleccion s.Evaluation;
import weka.classifiers.rules.M5Rules;
import weka.classifiers.rules.NNge;
import weka.classifiers.rules.PART;
import weka.classifiers.rules.Ridor;
import weka.classifiers.rules.ZeroR;
import weka.core.Debug.Random;
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;

public class Algoritmos {
    //variable de resultados
    String resultado = "\n";
    //variable de datos del archivo xxxx.arff
    String datosarchivo = "\n";
    //variable de la ruta del archivo
    String ruta;
    //variable de las Instances del archivo
    Instances coleccion;
    //variable del fold del cross-validation
    int crossValidation;
    //variable de tipo de evaluacion
    int tipo;
    public int getTipo() {
        return tipo;
    }
    public void setTipo(int tipo) {
        this.tipo = tipo;
    }
    public int getCrossValidation() {
        return crossValidation;
    }
    public void setCrossValidation(int crossValidation) {
        this.crossValidation = crossValidation;
    }
    public Algoritmos(String ruta) {
        this.ruta = ruta;
    }
    //Conjunto de datos del archivo .arrf
    public String datos() {
        try ;
        } catch (Exception exception) {
            resultado = exception.toString();
            mostrarMsj();
        }
        return resultado;
    }
//algoritmo Part
    public String ejede entrenamiento
            datosarchivo = datosarchivo + "\nColeccion de entrenamiento:\n";
            datosarchivo = datosarchivo + coleccion.toString();
        } catch (Exception ex) {
            datosarchivo = ex.toString();
        }
        return datosarchivo;
    }
//algoritmo RIDOR
    public String ejecutarRidor() {
        resultado = "\n";
        Ridor ridor = new Ridor();
        try {
            //Construyendo el clasificador
            ridor.buildClassifier(coleccion);
            //llama al metodo para obtener la matrixConfusion
            String matrix = matrixConfusion(ridor);
            resultado = resultado + ridor.toString();
            resultado = resultado + matrix;
        } catch (Exception exception) {
            resultado = exception.toString();
            mostrarMsj();
        }
        return resultado;
    }
//algoritmo ZeroR
    public String ejecutarZeroR() {
        resultado = "\n";
        ZeroR zeror = new ZeroR();
        try {
            zeror.buildClassifier(coleccion);
            String matrix = matrixConfusion(zeror);
            resultado = resultado + zeror.toString();
            resultado = resultado + matrixm5rules.toString();
            resultado = resultado + matrix;
        } catch (Exception exception) {
            resultado = exception.toString();
            mostrarMsj();
        }
        recutarPart() {
        resultado = "\n";
        PART part = new PART();
        try {
            part.buildClassifier(coleccion);
            String matrix = matrixConfusion(part);
            resultado = resultado + part.toString();
            resultado = resultado + matrix;
        } catch (Exception exception) {
            resultado = exception.toString();
            mostrarMsj();
        }
        return resultado;
    }
//algoritmo NNge
    public String ejecutarNNge() {
        resultado = "\n";
        NNge nnge = new NNge();
        try {
            nnge.buildClassifier(coleccion);
            String matrix = matrixConfusion(nnge);
            resultado = resultado + nnge.toString();
            resultado = resultado + matrix;
        } catch (Exception exception) {

            resultado = exception.toString();
            mostrarMsj();
        }
        return resultado;
    }
//algoritmo M5Rules
    public String ejecutarM5Rules() {
        resultado = "\n";
        M5Rules m5rules = new M5Rules();
        try {
            m5rules.buildClassifier(coleccion);
            String matrix = matrixConfusion(m5rules);
            resultado = resultado + m5rules.toString();
            resultado = resultado + matrix;
        } catch (Exception exception) {
            resultado = exception.toString();
            mostrarMsj();
        }
        return resultado;
    }
    public void mostrarMsj() {
        JOptionPane.showMessageDialog(null, "Trate de ejecutar con otro algoritmo", "Error", JOptionPane.ERROR_MESSAGE);
    }
//Metodo para matrixConfusion
    public String matrixConfusion(Classifier classifier) {
        String matrix = "\n";
        //Modelo de Test
        Evaluation eTest;
        try {
            eTest = new Evaluation(coleccion);
            // es 1 si utiliza cross validation caso contrario utiliza todo
            // el conjungo de datos para evaluar el modelo
            if (tipo != 1) {
                Random rand = new Random(1);
                //los FOLDS para cross-validation
                int folds = getCrossValidation();
                //llamando al metodo cross-validation
                eTest.crossValidateModel(classifier, coleccion, folds, rand);
            } else {
                eTest.evaluateModel(classifier, coleccion);
            }
            //Muestra el resumen de la evaluacion
            String strSummary = eTest.toSummaryString();
            matrix = matrix + " ===== SUMARY =====\n" + strSummary;
            // obtener confusion matrix
            matrix = matrix + eTest.toMatrixString();
        } catch (Exception ex) {
            JOptionPane.showMessageDialog(null, ex.toString(), "ERROR", JOptionPane.ERROR_MESSAGE);
        }
        return matrix;
    }
}

En uno de los métodos se está obteniendo la matriz de Confusión (CONFUSION MATRIX), una de las partes muy importantes al momento de clasificar.

Y también algo importante es la obtención de las reglas de decisión (el conocimiento extraído de la BD para tomar decisiones).

Tendrán que ejecutarlo para que puedan ver los resultados, son diferentes algoritmos para que se pueda utilizar el mejor.

La aplicación que hice fue muy pequeña, pero lo importante es que funciona y se pueden ver los resultados del clasificador.



A los que les interesa el tema y si quieres todo el sistema completo esta aquí DataMining pesa 5.6MB subido en MediaFire

Fuentes:

http://www.cs.waikato.ac.nz/ml/weka/

http://rp-www.cs.usyd.edu.au/~sakshib/Weka/