/** Creates the total selector's set for get all the possible rules */
private Complejo hazSelectores(Dataset train) {
Complejo almacenSelectores;
int nClases = train.getnclases();
almacenSelectores =
new Complejo(nClases); // Aqui voy a almacenar los selectores (numVariable,operador,valor)
Attribute[] atributos = null;
int num_atributos, type;
Vector nominalValues;
atributos = Attributes.getAttributes();
num_atributos = Attributes.getNumAttributes();
Selector s;
for (int i = 0; i < train.getnentradas(); i++) {
type = atributos[i].getType();
switch (type) {
case 0: // NOMINAL
nominalValues = atributos[i].getNominalValuesList();
// System.out.print("{");
for (int j = 0; j < nominalValues.size(); j++) {
// System.out.print ((String)nominalValues.elementAt(j)+" ");
s = new Selector(i, 0, (String) nominalValues.elementAt(j), true); // [atr,op,valor]
// incluimos tb los valores en double para facilitar algunas funciones
s.setValor((double) j);
almacenSelectores.addSelector(s);
// s.print();
}
// System.out.println("}");
break;
}
// System.out.println(num_atributos);
}
return almacenSelectores;
}
/** Returns True if the rule is perfect for the data set. */
public boolean perfectRule(Complejo regla, Dataset train) {
ConjDatos datosTrain;
datosTrain = new ConjDatos();
datosTrain = creaConjunto(train);
boolean perfecta = false;
/*Muestra m = datosTrain.getDato(3);//la primera instancia basicamente
System.out.println(m.getClase());*/
Muestra m;
ConjDatos cubiertas;
cubiertas = new ConjDatos();
/*todas las instancias que cubra la regla las metemos en un conjunto*/
for (int i = 0; i < train.getndatos(); i++) {
m = datosTrain.getDato(i);
if (regla.cubre(m)) {
cubiertas.addDato(m);
}
}
/*perfecta sera true si todos los ejemplos del conjunto 'cubiertas' tienen la misma clase que predice la regla*/
for (int i = 0; i < cubiertas.size(); i++) {
if (cubiertas.getDato(i).getClase() != regla.getClase()) {
perfecta = false;
return perfecta;
} else perfecta = true;
}
return perfecta;
}
/** Prints on the screen the set of rules */
public void print() {
for (int i = 0; i < reglas.size(); i++) {
Complejo c = (Complejo) reglas.get(i);
System.out.print("\nRule " + (i + 1) + ": IF ");
c.print();
System.out.print(" THEN " + nombreClase + " -> " + valorNombreClases[c.getClase()] + " ");
c.printDistribucion();
}
}
/**
* Evaluation of the complex over the example's set for see witch match all the class
*
* @param c Complex to evaluate
* @param e Set of data
*/
private void evaluarComplejo(Complejo c, ConjDatos e) {
c.borraDistrib();
for (int i = 0; i < e.size(); i++) {
int cl = e.getDato(i).getClase();
if (c.cubre(e.getDato(i))) {
c.incrementaDistrib(cl);
}
}
c.calculaLaplaciano();
}
/**
* Prints on a string the set of rules
*
* @return A strign that stores the set of rules
*/
public String printString() {
String cad = "";
for (int i = 0; i < reglas.size(); i++) {
Complejo c = (Complejo) reglas.get(i);
cad += "\nRule " + (i + 1) + ": IF ";
cad += c.printString();
cad += " THEN " + nombreClase + " -> " + valorNombreClases[c.getClase()] + " ";
cad += c.printDistribucionString();
}
return cad;
}
/** Remove complex with repetitive attributes */
public void eliminaNulos() {
boolean salir;
for (int i = 0; i < this.size(); i++) {
Complejo aux = this.getRegla(i);
salir = false;
for (int j = 0; (j < aux.size() - 1) && (!salir); j++) {
Selector s = aux.getSelector(j);
for (int h = j + 1; (h < aux.size()) && (!salir); h++) {
Selector s2 = aux.getSelector(h);
if (s.compareTo(s2) < 2) { // mismo atributo
this.deleteRegla(i); // borrando
salir = true;
i--;
}
}
}
}
}
/**
* Remove rules are the same ina semantic way(At = 1, At <> 0, At = [0,1])
*
* @param tam int Size of the star
*/
public void eliminaSubsumidos(int tam) {
// for (int i = 0; i < this.size() - 1; i++) {
for (int i = 0; i < tam; i++) {
Complejo aux = this.getRegla(i);
boolean seguir = true;
for (int j = i + 1; (j < this.size()) && (seguir); j++) {
Complejo aux2 = this.getRegla(j);
seguir = false;
boolean parar = false;
for (int l = 0; (l < aux.size()) && (!parar); l++) {
Selector s = aux.getSelector(l);
boolean salir = false;
for (int h = 0; (h < aux2.size()) && (!salir); h++) {
Selector s2 = aux2.getSelector(h);
if ((s.compareTo(s2) == -3) || (s.compareTo(s2) == 0)) { // mirar compareTo en Selector
salir = true; // paso a ver el siguiente selector (si eso)
if ((l == aux.size() - 1)
&& (aux.getDistribucionClase(0) == aux2.getDistribucionClase(0))) {
// if (l == aux.size() - 1) {
/*
System.out.println("\nEstos son los complejos subsumidos:");
aux.print();
aux2.print();
*/
seguir = false;
this.deleteRegla(
i); // tienen los mismos atributos y misma distribucion (son semanticament =)
i--;
}
}
}
parar = !salir; // si salir == true -> no paro (parar = false)
}
}
}
}
/**
* Returns the fraction of correct instances of the instance's set for the rule 'regla'
*
* @param i Number of the rule
* @return Fraction of correct instances of the instance's set for the rule 'regla'
*/
private double getAccuracy(int i) {
Instance instancia;
double Accuracy;
num_cubiertas = 0;
num_correctas = 0;
for (int k = 0; k < instancias.getNumInstances(); k++) {
instancia = instancias.getInstance(k);
cubierta = regla.reglaCubreInstancia(instancia);
if (cubierta) {
num_cubiertas++;
clase = instancia.getOutputNominalValuesInt(0);
if (clase == i) num_correctas++;
}
}
Accuracy = (double) num_correctas / (double) num_cubiertas;
if (num_cubiertas == 0) Accuracy = 0;
return Accuracy;
}
/**
* Removes from the instance's set those instances that matches with the rule
*
* @param i Numebr of the rule
*/
private void removeInstancesCovered(int i) {
for (int k = 0; k < instancias.getNumInstances(); k++) {
instancia = instancias.getInstance(k);
/*System.out.print(k+" ");
instancia.print();
System.out.println();*/
cubierta = regla.reglaCubreInstancia(instancia);
if (cubierta) {
// System.out.println("CUBIERTA");
clase = instancia.getOutputNominalValuesInt(0);
// if(clase==i){
instancias.removeInstance(k);
instancia.print();
System.out.println();
k = k - 1;
// }
}
}
}
/**
* Remove repetitive complex(at1 = 0 ^ at2 = 0 -- at2 = 0 ^ at1 = 0)
*
* @param tam Size of the star
*/
public void eliminaRepetidos(int tam) {
for (int i = 0; i < this.size() - 1; i++) {
// for (int i = 0; i < tam; i++) {
Complejo aux = this.getRegla(i);
boolean seguir = true;
for (int j = i + 1; (j < this.size()) && (seguir); j++) {
Complejo aux2 = this.getRegla(j);
// seguir = false;
boolean parar = false;
for (int l = 0; (l < aux.size()) && (!parar); l++) {
Selector s = aux.getSelector(l);
boolean salir = false;
for (int h = 0; (h < aux2.size()) && (!salir); h++) {
Selector s2 = aux2.getSelector(h);
// System.out.println("Comparando ");
if (s.compareTo(s2) == 0) { // son iguales
salir = true; // paso a ver el siguiente selector (si eso)
/* System.out.println("selectores iguales");
System.out.println("regla "+(i+1)+" y "+(j+1));
s.print();s2.print();*/
if (l == aux.size() - 1) {
/* System.out.println("\nEstos son los complejos repetidos:");
aux.print();
aux2.print();*/
seguir = false;
this.deleteRegla(i); // borro porque est�repe totalmente
/*System.out.println("Se borra la regla "+(i+1));
aux.print();*/
i--;
}
}
}
parar = !salir; // si salir == true -> no paro (parar = false)
}
}
}
}
/**
* 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);
}
}
