Control.Classificador.java Source code

Java tutorial

Introduction

Here is the source code for Control.Classificador.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package Control;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import weka.classifiers.Evaluation;
import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.lazy.IB1;
import weka.classifiers.lazy.IBk;
import weka.classifiers.trees.Id3;
import weka.classifiers.trees.J48;
import weka.core.Instances;
import weka.core.UnsupportedAttributeTypeException;

/**
 *
 * @author Marco
 */
public class Classificador {

    ArrayList<Resultado> resultados = new ArrayList<>();

    public ArrayList<Resultado> getResultados() {
        return resultados;
    }

    public void setResultados(ArrayList<Resultado> resultados) {
        this.resultados = resultados;
    }

    public ArrayList<Resultado> classificar(Plano plano, Arquivo arq) {
        try {
            FileReader leitor = new FileReader(arq.arquivo);
            Instances conjunto = new Instances(leitor);
            conjunto.setClassIndex(conjunto.numAttributes() - 1);
            Evaluation avaliacao = new Evaluation(conjunto);
            conjunto = conjunto.resample(new Random());

            Instances baseTreino = null, baseTeste = null;
            Random rand = new Random(1);

            if (plano.eHoldOut) {
                baseTeste = conjunto.testCV(3, 0);
                baseTreino = conjunto.trainCV(3, 0);
            } else {
                baseTeste = baseTreino = conjunto;
            }

            if (plano.IBK) {
                try {
                    IB1 vizinho = new IB1();
                    vizinho.buildClassifier(baseTeste);
                    avaliacao.crossValidateModel(vizinho, baseTeste,
                            (plano.eHoldOut) ? 4 : baseTeste.numInstances(), rand);
                    Resultado resultado = new Resultado("NN",
                            avaliacao.toMatrixString("Algortmo Vizinho Mais Prximo - Matriz de Confuso"),
                            avaliacao.toClassDetailsString("kNN"));
                    resultado.setTaxaErro(avaliacao.errorRate());
                    resultado.setTaxaAcerto(1 - avaliacao.errorRate());
                    resultado.setRevocacao(recallToDouble(avaliacao, baseTeste));
                    resultado.setPrecisao(precisionToDouble(avaliacao, baseTeste));
                    this.resultados.add(resultado);
                } catch (UnsupportedAttributeTypeException ex) {
                    Mensagem.erro("Algortmo IB1 no suporta atributos numricos!", "MTCS - ERRO");
                }
            }
            if (plano.J48) {
                try {
                    J48 j48 = new J48();
                    j48.buildClassifier(baseTeste);
                    avaliacao.crossValidateModel(j48, baseTeste, (plano.eHoldOut) ? 4 : baseTeste.numInstances(),
                            rand);
                    Resultado resultado = new Resultado("J48",
                            avaliacao.toMatrixString("Algortmo J48 - Matriz de Confuso"),
                            avaliacao.toClassDetailsString("J48"));
                    resultado.setTaxaErro(avaliacao.errorRate());
                    resultado.setTaxaAcerto(1 - avaliacao.errorRate());
                    resultado.setRevocacao(recallToDouble(avaliacao, baseTeste));
                    resultado.setPrecisao(precisionToDouble(avaliacao, baseTeste));
                    this.resultados.add(resultado);
                } catch (UnsupportedAttributeTypeException ex) {
                    Mensagem.erro("Algortmo J48 no suporta atributos nominais!", "MTCS - ERRO");
                }
            }
            if (plano.KNN) {
                try {
                    IBk knn = new IBk(3);
                    knn.buildClassifier(baseTeste);
                    avaliacao.crossValidateModel(knn, baseTeste, (plano.eHoldOut) ? 4 : baseTeste.numInstances(),
                            rand);
                    Resultado resultado = new Resultado("KNN",
                            avaliacao.toMatrixString("Algortmo KNN - Matriz de Confuso"),
                            avaliacao.toClassDetailsString("kNN"));
                    resultado.setTaxaErro(avaliacao.errorRate());
                    resultado.setTaxaAcerto(1 - avaliacao.errorRate());
                    resultado.setRevocacao(recallToDouble(avaliacao, baseTeste));
                    resultado.setPrecisao(precisionToDouble(avaliacao, baseTeste));
                    this.resultados.add(resultado);
                } catch (UnsupportedAttributeTypeException ex) {
                    Mensagem.erro("Algortmo KNN no suporta atributos numricos!", "MTCS - ERRO");
                }

            }
            if (plano.Naive) {
                NaiveBayes naive = new NaiveBayes();
                naive.buildClassifier(baseTeste);
                avaliacao.crossValidateModel(naive, baseTeste, (plano.eHoldOut) ? 4 : baseTeste.numInstances(),
                        rand);
                Resultado resultado = new Resultado("Naive",
                        avaliacao.toMatrixString("Algortmo NaiveBayes - Matriz de Confuso"),
                        avaliacao.toClassDetailsString("kNN"));
                resultado.setTaxaErro(avaliacao.errorRate());
                resultado.setTaxaAcerto(1 - avaliacao.errorRate());
                resultado.setRevocacao(recallToDouble(avaliacao, baseTeste));
                resultado.setPrecisao(precisionToDouble(avaliacao, baseTeste));
                this.resultados.add(resultado);
            }
            if (plano.Tree) {
                try {
                    Id3 id3 = new Id3();
                    id3.buildClassifier(baseTeste);
                    avaliacao.crossValidateModel(id3, baseTeste, (plano.eHoldOut) ? 4 : baseTeste.numInstances(),
                            rand);
                    Resultado resultado = new Resultado("ID3",
                            avaliacao.toMatrixString("Algortmo ID3 - Matriz de Confuso"),
                            avaliacao.toClassDetailsString("kNN"));
                    resultado.setTaxaErro(avaliacao.errorRate());
                    resultado.setTaxaAcerto(1 - avaliacao.errorRate());
                    resultado.setRevocacao(recallToDouble(avaliacao, baseTeste));
                    resultado.setPrecisao(precisionToDouble(avaliacao, baseTeste));
                    this.resultados.add(resultado);
                } catch (UnsupportedAttributeTypeException ex) {
                    Mensagem.erro("Algortmo Arvore de Deciso no suporta atributos numricos!",
                            "MTCS - ERRO");

                }
            }

        } catch (FileNotFoundException ex) {

            Logger.getLogger(Classificador.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Classificador.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NullPointerException ex) {
            Mensagem.erro("Selecione um arquivo para comear!", "MTCS - ERRO");
            Logger.getLogger(Classificador.class.getName()).log(Level.SEVERE, null, ex);
        } catch (Exception ex) {
            Logger.getLogger(Classificador.class.getName()).log(Level.SEVERE, null, ex);
        }

        return this.resultados;
    }

    public String resultadoToString() {
        String resultadoStr = "";

        for (Resultado resultado : resultados) {
            resultadoStr += ("\n" + /*resultado.resultado +*/ resultado.matriz + "\nAcurcia: "
                    + Utils.porcentagem(resultado.taxaAcerto) + "\nErro:" + Utils.porcentagem(resultado.taxaErro)
                    + "\nRevocao:" + Utils.porcentagem(resultado.revocacao) + "\nPreciso:"
                    + Utils.porcentagem(resultado.precisao));
            resultadoStr += ("\n====================================================================\n");
        }
        return resultadoStr;
    }

    public double recallToDouble(Evaluation avaliacao, Instances base) {
        double resultadoDbl = 0;
        for (int i = 0; i < base.numClasses(); i++) {
            resultadoDbl += avaliacao.recall(i);
        }
        return resultadoDbl / base.numClasses();
    }

    public double precisionToDouble(Evaluation avaliacao, Instances base) {
        double resultadoDbl = 0;
        for (int i = 0; i < base.numClasses(); i++) {
            resultadoDbl += avaliacao.precision(i);
        }
        return resultadoDbl / base.numClasses();
    }

    public static Resultado getVencedor(ArrayList<Resultado> resultados) {
        Resultado maior = new Resultado("Nenhum", 0.00);
        for (Resultado resultado : resultados) {
            if (((resultado.precisao + resultado.taxaAcerto + resultado.revocacao) / 3) > maior.pontuacao) {
                resultado.setPontuacao(((resultado.precisao + resultado.taxaAcerto + resultado.revocacao) / 3));
                maior = resultado;
            }
        }
        return maior;
    }
}