/** Calculates the necessary statistical data and creates KEEL out-put files */
private void generaSalida() {
Fichero f = new Fichero();
String cad = "";
String miSalida = new String("");
miSalida = train.copiaCabeceraTest();
// System.out.println("\n Estas son las reglas encontradas:");
// conjReglasFinal.print();
conjunto_reglas.adjuntaNombreClases(clases);
conjunto_reglas.adjuntaNombreClase(nombre_atributos[train.getnentradas()]);
cad = conjunto_reglas.printString();
/*cad += "\n\n" + evReg.printString() + "\n\n Time (seconds); " +
(tiempo / 1000);*/
f.escribeFichero(ficheroSalida, cad);
f.escribeFichero(ficheroSalidaTr, miSalida + evReg.salida(datosTrain));
f.escribeFichero(ficheroSalidaTst, miSalida + evReg.salida(datosTest));
}
/**
* Constructor with all the attributes to initialize
*
* @param ficheroTrain Train file
* @param ficheroTest Test file
* @param fSalidaTr Out-put train file
* @param fSalidaTst Out-put test file
* @param fsalida Out-put file
* @param semilla seed
*/
public Prism(
String ficheroTrain,
String ficheroTest,
String fSalidaTr,
String fSalidaTst,
String fsalida,
long semilla) {
ficheroSalida = fsalida;
ficheroSalidaTr = fSalidaTr;
ficheroSalidaTst = fSalidaTst;
seed = semilla;
datosTrain = new ConjDatos(); // datosEval = new ConjDatos();
datosTest = new ConjDatos();
train = new Dataset();
test = new Dataset();
s = new Selector(0, 0, 0.);
conjunto_reglas = new ConjReglas();
try {
Randomize.setSeed(seed);
System.out.println("la semilla es " + seed);
train.leeConjunto(ficheroTrain, true);
test.leeConjunto(ficheroTest, false); //
if (train.hayAtributosContinuos() /*|| train.hayAtributosDiscretos()*/) {
System.err.println("\nPrism may not work properly with real or integer attributes.\n");
// System.exit(-1);
hayContinuos = true;
}
if (!hayContinuos) {
train.calculaMasComunes(); // eval.calculaMasComunes();
test.calculaMasComunes();
datosTrain =
creaConjunto(
train); // Leemos los datos de entrenamiento (todos seguidos como un
// String)//datosEval = creaConjunto(eval);
datosTest = creaConjunto(test);
valores = train.getX2(); // obtengo los valores nominales
clases = train.getC2();
clasitas = train.getC();
/*System.out.println(train.getndatos());
System.out.println(train.getnentradas());
for(int i=0;i<train.getndatos();i++){
for(int j=0;j<train.getnentradas();j++)
System.out.print(valores[i][j]);
System.out.print(clases[i]);System.out.println(clasitas[i]);}*/
// COMENZAMOS EL ALGORITMO PRISM
// FOR EACH CLASS C
clases = train.dameClases();
int unavez = 0, candidato;
for (int i = 0; i < train.getnclases(); i++) {
System.out.println("CLASE :" + clases[i] + "\n");
// initialize E to the instance set
/*Cuando haya que inicializar de nuevo el conjunto de instancias no es necesario insertar aquellas que se eliminaron, sino que nos va a bastar con inicializar otra vez el conjunto mediante el fichero de entrenamiento. Por eso hay un metodo para insertar una instancia*/
train.leeConjunto(ficheroTrain, false);
nombre_atributos = train.dameNombres();
instancias = train.getInstanceSet();
// While E contains instances in class C
while (train.hayInstanciasDeClaseC(i)) {
// Create a rule R with an empty left-hand side that predicts class C
regla = new Complejo(train.getnclases());
regla.setClase(i);
regla.adjuntaNombreAtributos(nombre_atributos);
// esto lo hacemos solo aqui pq luego vamos quitando selectores del almacen
almacen = hazSelectores(train);
almacen.adjuntaNombreAtributos(nombre_atributos);
do {
// FOR EACH ATTRIBUTE A NOT MENTIONED IN R, AND EACH VALUE V
accuracy_ant = -1.;
p = 0;
int seleccionados[] = new int[almacen.size()];
for (int jj = 0; jj < almacen.size(); jj++) seleccionados[jj] = 0;
System.out.println();
for (int j = 0; j < almacen.size(); j++) {
// tenemos que quitar el selector anterior
if (j > 0) regla.removeSelector(s);
s = almacen.getSelector(j);
// if(i==0)
s.print();
// CONSIDER ADDING THE CONDITION A=V TO THE LHS OF R
regla.addSelector(s);
accuracy = getAccuracy(i);
// if(i==0) {
System.out.println("correctas " + num_correctas + " cubiertas " + num_cubiertas);
System.out.println("Acurracy " + accuracy);
// }
if ((accuracy > accuracy_ant)
|| ((accuracy == accuracy_ant) && (num_correctas > p))) {
// if((accuracy==accuracy_ant) &&(num_correctas>p)){
// System.out.println("atn "+accuracy_ant);
// System.out.println("ahora "+accuracy);
accuracy_ant = accuracy;
seleccionado = j;
p = num_correctas;
// si se encuentra un superior hay que quitar
// todo lo q se hay ido almacenando en esta iteracion
for (int jj = 0; jj < almacen.size(); jj++) seleccionados[jj] = 0;
// }
} else {
if ((accuracy == accuracy_ant) && (num_correctas == p)) {
seleccionados[seleccionado] = 1;
seleccionados[j] = 1;
}
}
}
// seleccionamos uno de los seleccionados en el caso de empate
int contador = 0;
for (int jj = 0; jj < almacen.size(); jj++) {
if (seleccionados[jj] == 1) {
contador++;
System.out.println("OPCION " + jj);
}
}
if (contador > 0) {
candidato = Randomize.RandintClosed(1, contador);
contador = 0;
for (int jj = 0; jj < almacen.size(); jj++) {
if (seleccionados[jj] == 1) {
contador++;
if (contador == candidato) seleccionado = jj;
}
}
}
System.out.println("ELEGIDO " + seleccionado);
// antes hay que quitar el q metimos
regla.removeSelector(s);
s = almacen.getSelector(seleccionado);
s.print();
// ADD A=V TO R
regla.addSelector(s);
/*AHORA HAY QUE QUITAR DEL ALMACEN SE SELECTORES AQUELLOS QUE
HACEN REFERENCIA AL ATRIBUTO SELECCIONADO*/
// obtener el atributo del selector ganador
atributo = s.getAtributo();
// se borran todos los q tengan ese atributo
// System.out.println("ALMACEN");almacen.print();
almacen.removeSelectorAtributo(atributo);
reglaPerfecta = perfectRule(regla, train);
} while (!reglaPerfecta && (regla.size() < train.getnentradas()));
System.out.println("\n");
System.out.println("\nREGLA............................................");
regla.print();
System.out.println("\n");
/*necesitamos evaluar la regla para obtener la salida del metodo
para compararla con la salida esperada*/
evaluarComplejo(regla, datosTrain);
// INCLUIMOS ESTA REGLA YA PARA EL CONJUNTO FINAL DE REGLAS
conjunto_reglas.addRegla(regla);
// REMOVE THE INSTANCES COVERED BY R FROM E
// Instance instancia;
/*for(int k=0;k<instancias.getNumInstances();k++){
instancia=instancias.getInstance(k);
System.out.print(k+" ");
instancia.print();
System.out.println();
}*/
removeInstancesCovered(i);
for (int k = 0; k < instancias.getNumInstances(); k++) {
instancia = instancias.getInstance(k);
clase = instancia.getOutputNominalValuesInt(0);
if (clase == i) {
System.out.print(k + " ");
instancia.print();
System.out.println();
}
}
// instancias.print();
System.out.println("\n");
} // del while
} // del for de las clases
// EVALUAMOS LA CALIDAD DE LAS REGLAS
int[] clasesEval;
clasesEval = train.getC();
muestPorClaseEval = new int[train.getnclases()];
for (int j = 0; j < train.getnclases(); j++) {
muestPorClaseEval[j] = 0;
for (int i = 0; i < datosTrain.size(); i++) {
if (
/*valorClases[j]*/ j == clasesEval[i]) {
muestPorClaseEval[j]++;
}
}
}
conjunto_reglas.eliminaRepetidos(1);
evReg =
new EvaluaCalidadReglas(
conjunto_reglas,
datosTrain,
datosTest,
muestPorClaseEval,
muestPorClaseEval,
clases);
// GENERAMOS LA SALIDA
generaSalida();
System.out.println("la semilla es " + seed);
} // del if
} catch (IOException e) {
System.err.println("There was a problem while trying to read the dataset files:");
System.err.println("-> " + e);
// System.exit(0);
}
}
/**
* Add a set of rules to the list
*
* @param r ConjReglas The set of rules
*/
public void addReglas(ConjReglas r) {
for (int i = 0; i < r.size(); i++) {
Complejo regla = r.getRegla(i);
reglas.add(regla);
}
}