예제 #1
0
파일: Prism.java 프로젝트: Navieclipse/KEEL
  /** 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;
  }
예제 #2
0
파일: Prism.java 프로젝트: Navieclipse/KEEL
  /** 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;
  }
예제 #3
0
 /** 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();
   }
 }
예제 #4
0
파일: Prism.java 프로젝트: Navieclipse/KEEL
  /**
   * 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();
  }
예제 #5
0
 /**
  * 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;
 }
예제 #6
0
 /** 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--;
         }
       }
     }
   }
 }
예제 #7
0
 /**
  * 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)
       }
     }
   }
 }
예제 #8
0
파일: Prism.java 프로젝트: Navieclipse/KEEL
  /**
   * 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;
  }
예제 #9
0
파일: Prism.java 프로젝트: Navieclipse/KEEL
  /**
   * 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;
        // }
      }
    }
  }
예제 #10
0
  /**
   * 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)
        }
      }
    }
  }
예제 #11
0
파일: Prism.java 프로젝트: Navieclipse/KEEL
  /**
   * 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);
    }
  }