/**
* 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();
}
/**
* Creates a set of data(attribute/class)
*
* @param mis_datos Must be a set of data readen from the file (see doc Dataset.java)
* @return The set of data created, a list of examples (see ConjDatos.java and Muestra.java)
*/
private ConjDatos creaConjunto(Dataset mis_datos) {
ConjDatos datos = new ConjDatos(); // Creo un nuevo conjunto de datos
int tam =
mis_datos
.getnentradas(); // Pillo el nmero de atributos de entrada (suponemos una sola salida
// [clase])
double[] vars =
new double
[tam]; // Creamos el vector que guardar�los valores de los atributos (aun siendo
// enteros o enum)
double[][] X;
int[] C;
int clase = 0; // Variable que contendr�el valor para la clase
X = mis_datos.getX();
C = mis_datos.getC();
for (int i = 0; i < mis_datos.getndatos(); i++) {
// System.out.print("\n"+i+":");
for (int j = 0; (j < tam); j++) {
// System.out.print(" "+X[i][j]);
if (mis_datos.isMissing(i, j)) {
vars[j] = mis_datos.masComun(j);
} else { // CAMBIAR POR OTROS METODOS DE MANEJO DE VALORES PERDIDOS (15-NN).
vars[j] =
X[i][
j]; // Double.parseDouble(mis_datos.getDatosIndex(i, j)); //pillo el valor del
// atributo j para el ejemplo i
}
}
// if (!salir) {
clase = C[i]; // Integer.parseInt(mis_datos.getDatosIndex(i, tam));
Muestra m =
new Muestra(
vars, clase,
tam); // Creo un nuevo dato del conjunto con sus variables, su clase y el num
// variables
m.setPosFile(i);
datos.addDato(m);
// }
}
return datos;
}
/** 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;
}
/**
* 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);
}
}
