예제 #1
0
파일: ENNRS.java 프로젝트: TheMurderer/keel
  public void ejecutar() {

    int i, j, l, m, o;

    int nClases;

    int claseObt;

    boolean marcas[];

    double conjS[][];

    int clasesS[];

    int eleS[], eleT[];

    int bestAc, aciertos;

    int temp[];

    int pos, tmp;

    long tiempo = System.currentTimeMillis();

    /*Getting the number of different classes*/

    nClases = 0;

    for (i = 0; i < clasesTrain.length; i++) if (clasesTrain[i] > nClases) nClases = clasesTrain[i];

    nClases++;

    /*Inicialization of the flagged instance vector of the S set*/

    marcas = new boolean[datosTrain.length];

    for (i = 0; i < datosTrain.length; i++) marcas[i] = false;

    /*Allocate memory for the random selection*/

    m = (int) ((porcentaje * datosTrain.length) / 100.0);

    eleS = new int[m];

    eleT = new int[datosTrain.length - m];

    temp = new int[datosTrain.length];

    for (i = 0; i < datosTrain.length; i++) temp[i] = i;

    /** Random distribution of elements in each set */
    Randomize.setSeed(semilla);

    for (i = 0; i < eleS.length; i++) {

      pos = Randomize.Randint(i, datosTrain.length - 1);

      tmp = temp[i];

      temp[i] = temp[pos];

      temp[pos] = tmp;

      eleS[i] = temp[i];
    }

    for (i = 0; i < eleT.length; i++) {

      pos = Randomize.Randint(m + i, datosTrain.length - 1);

      tmp = temp[m + i];

      temp[m + i] = temp[pos];

      temp[pos] = tmp;

      eleT[i] = temp[m + i];
    }

    for (i = 0; i < eleS.length; i++) marcas[eleS[i]] = true;

    /*Building of the S set from the flags*/

    conjS = new double[m][datosTrain[0].length];

    clasesS = new int[m];

    for (o = 0, l = 0; o < datosTrain.length; o++) {

      if (marcas[o]) { // the instance will be evaluated

        for (j = 0; j < datosTrain[0].length; j++) {

          conjS[l][j] = datosTrain[o][j];
        }

        clasesS[l] = clasesTrain[o];

        l++;
      }
    }

    /*Evaluation of the S set*/

    bestAc = 0;

    for (i = 0; i < datosTrain.length; i++) {

      claseObt = KNN.evaluacionKNN2(k, conjS, clasesS, datosTrain[i], nClases);

      if (claseObt == clasesTrain[i]) // correct clasification
      bestAc++;
    }

    /*Body of the ENNRS algorithm. Change the S set in each iteration for instances
    of the T set until get a complete sustitution*/

    for (i = 0; i < n; i++) {

      /*Preparation the set to interchange*/

      for (j = 0; j < eleS.length; j++) {

        pos = Randomize.Randint(j, eleT.length - 1);

        tmp = eleT[j];

        eleT[j] = eleT[pos];

        eleT[pos] = tmp;
      }

      /*Interchange of instances*/

      for (j = 0; j < eleS.length; j++) {

        tmp = eleS[j];

        eleS[j] = eleT[j];

        eleT[j] = tmp;

        marcas[eleS[j]] = true;

        marcas[eleT[j]] = false;
      }

      /*Building of the S set from the flags*/

      for (o = 0, l = 0; o < datosTrain.length; o++) {

        if (marcas[o]) { // the instance will evaluate

          for (j = 0; j < datosTrain[0].length; j++) {

            conjS[l][j] = datosTrain[o][j];
          }

          clasesS[l] = clasesTrain[o];

          l++;
        }
      }

      /*Evaluation of the S set*/

      aciertos = 0;

      for (j = 0; j < datosTrain.length; j++) {

        claseObt = KNN.evaluacionKNN2(k, conjS, clasesS, datosTrain[j], nClases);

        if (claseObt == clasesTrain[j]) // correct clasification
        aciertos++;
      }

      if (aciertos > bestAc) { // keep S

        bestAc = aciertos;

      } else { // undo changes

        for (j = 0; j < eleS.length; j++) {

          tmp = eleS[j];

          eleS[j] = eleT[j];

          eleT[j] = tmp;

          marcas[eleS[j]] = true;

          marcas[eleT[j]] = false;
        }
      }
    }

    /*Building of the S set from the flags*/
    /*Building of the S set from the flags*/

    for (o = 0, l = 0; o < datosTrain.length; o++) {

      if (marcas[o]) { // the instance will evaluate

        for (j = 0; j < datosTrain[0].length; j++) {

          conjS[l][j] = datosTrain[o][j];
        }

        clasesS[l] = clasesTrain[o];

        l++;
      }
    }

    System.out.println(
        "ENNRS " + relation + " " + (double) (System.currentTimeMillis() - tiempo) / 1000.0 + "s");

    // COn conjS me vale.
    int trainRealClass[][];
    int trainPrediction[][];

    trainRealClass = new int[datosTrain.length][1];
    trainPrediction = new int[datosTrain.length][1];

    // Working on training
    for (i = 0; i < datosTrain.length; i++) {
      trainRealClass[i][0] = clasesTrain[i];
      trainPrediction[i][0] = KNN.evaluate(datosTrain[i], conjS, nClases, clasesS, this.k);
    }

    KNN.writeOutput(ficheroSalida[0], trainRealClass, trainPrediction, entradas, salida, relation);

    // Working on test
    int realClass[][] = new int[datosTest.length][1];
    int prediction[][] = new int[datosTest.length][1];

    // Check  time

    for (i = 0; i < realClass.length; i++) {
      realClass[i][0] = clasesTest[i];
      prediction[i][0] = KNN.evaluate(datosTest[i], conjS, nClases, clasesS, this.k);
    }

    KNN.writeOutput(ficheroSalida[1], realClass, prediction, entradas, salida, relation);
  }
예제 #2
0
  public void ejecutar() {

    int i, j, l;
    boolean marcas[];
    boolean marcas2[];
    boolean marcastmp[];
    boolean incorrect[];
    int nSel;
    double conjS[][];
    double conjR[][];
    int conjN[][];
    boolean conjM[][];
    int clasesS[];
    Vector<Integer> vecinos[];
    int next;
    int maxneigh;
    int pos;
    int borrado;
    int claseObt;
    int nClases;

    long tiempo = System.currentTimeMillis();

    /*Getting the number of differents classes*/
    nClases = 0;
    for (i = 0; i < clasesTrain.length; i++) if (clasesTrain[i] > nClases) nClases = clasesTrain[i];
    nClases++;

    /*Inicialization of the flagged instances vector for a posterior copy*/
    marcas = new boolean[datosTrain.length];
    marcas2 = new boolean[datosTrain.length];
    incorrect = new boolean[datosTrain.length];
    marcastmp = new boolean[datosTrain.length];
    Arrays.fill(marcas, true);
    Arrays.fill(marcas2, true);
    Arrays.fill(incorrect, false);
    Arrays.fill(marcastmp, true);
    vecinos = new Vector[datosTrain.length];
    for (i = 0; i < datosTrain.length; i++) vecinos[i] = new Vector<Integer>();

    for (i = 0; i < datosTrain.length; i++) {
      next = nextNeighbour(marcas, datosTrain, i, vecinos[i]);
      for (j = 0; j < datosTrain.length; j++) marcastmp[j] = marcas[j];
      while (next >= 0 && clasesTrain[next] == clasesTrain[i]) {
        vecinos[i].add(new Integer(next));
        marcastmp[next] = false;
        next = nextNeighbour(marcastmp, datosTrain, i, vecinos[i]);
      }
    }

    maxneigh = vecinos[0].size();
    pos = 0;
    for (i = 1; i < datosTrain.length; i++) {
      if (vecinos[i].size() > maxneigh) {
        maxneigh = vecinos[i].size();
        pos = i;
      }
    }

    while (maxneigh > 0) {
      for (i = 0; i < vecinos[pos].size(); i++) {
        borrado = vecinos[pos].elementAt(i).intValue();
        marcas[borrado] = false;
        for (j = 0; j < datosTrain.length; j++) {
          vecinos[j].removeElement(new Integer(borrado));
        }
        vecinos[borrado].clear();
      }
      vecinos[pos].clear();

      maxneigh = vecinos[0].size();
      pos = 0;
      for (i = 1; i < datosTrain.length; i++) {
        if (vecinos[i].size() > maxneigh) {
          maxneigh = vecinos[i].size();
          pos = i;
        }
      }
    }

    /*Building of the S set from the flags*/
    nSel = 0;
    for (i = 0; i < datosTrain.length; i++) if (marcas[i]) nSel++;

    conjS = new double[nSel][datosTrain[0].length];
    conjR = new double[nSel][datosTrain[0].length];
    conjN = new int[nSel][datosTrain[0].length];
    conjM = new boolean[nSel][datosTrain[0].length];
    clasesS = new int[nSel];
    for (i = 0, l = 0; i < datosTrain.length; i++) {
      if (marcas[i]) { // the instance will be copied to the solution
        for (j = 0; j < datosTrain[0].length; j++) {
          conjS[l][j] = datosTrain[i][j];
          conjR[l][j] = realTrain[i][j];
          conjN[l][j] = nominalTrain[i][j];
          conjM[l][j] = nulosTrain[i][j];
        }
        clasesS[l] = clasesTrain[i];
        l++;
      }
    }

    for (i = 0; i < datosTrain.length; i++) {
      /*Apply 1-NN to the instance*/
      claseObt =
          KNN.evaluacionKNN2(
              1,
              conjS,
              conjR,
              conjN,
              conjM,
              clasesTrain,
              datosTrain[i],
              realTrain[i],
              nominalTrain[i],
              nulosTrain[i],
              nClases,
              true);
      if (claseObt != clasesTrain[i]) {
        incorrect[i] = true;
      }
    }

    for (i = 0; i < datosTrain.length; i++) vecinos[i] = new Vector<Integer>();

    for (i = 0; i < datosTrain.length; i++) {
      if (incorrect[i]) {
        next = nextNeighbour(marcas2, datosTrain, i, vecinos[i]);
        for (j = 0; j < datosTrain.length; j++) marcastmp[j] = marcas2[j];
        while (next >= 0 && clasesTrain[next] == clasesTrain[i]) {
          vecinos[i].add(new Integer(next));
          marcastmp[next] = false;
          next = nextNeighbour(marcastmp, datosTrain, i, vecinos[i]);
        }
      }
    }

    maxneigh = vecinos[0].size();
    pos = 0;
    for (i = 1; i < datosTrain.length; i++) {
      if (vecinos[i].size() > maxneigh) {
        maxneigh = vecinos[i].size();
        pos = i;
      }
    }

    while (maxneigh > 0) {
      for (i = 0; i < vecinos[pos].size(); i++) {
        borrado = vecinos[pos].elementAt(i).intValue();
        marcas2[borrado] = false;
        for (j = 0; j < datosTrain.length; j++) {
          vecinos[j].removeElement(new Integer(borrado));
        }
        vecinos[borrado].clear();
      }
      vecinos[pos].clear();

      maxneigh = vecinos[0].size();
      pos = 0;
      for (i = 1; i < datosTrain.length; i++) {
        if (vecinos[i].size() > maxneigh) {
          maxneigh = vecinos[i].size();
          pos = i;
        }
      }
    }

    for (i = 0; i < marcas.length; i++) marcas[i] |= (marcas2[i] & incorrect[i]);

    /*Building of the S set from the flags*/
    nSel = 0;
    for (i = 0; i < datosTrain.length; i++) if (marcas[i]) nSel++;

    conjS = new double[nSel][datosTrain[0].length];
    conjR = new double[nSel][datosTrain[0].length];
    conjN = new int[nSel][datosTrain[0].length];
    conjM = new boolean[nSel][datosTrain[0].length];
    clasesS = new int[nSel];
    for (i = 0, l = 0; i < datosTrain.length; i++) {
      if (marcas[i]) { // the instance will be copied to the solution
        for (j = 0; j < datosTrain[0].length; j++) {
          conjS[l][j] = datosTrain[i][j];
          conjR[l][j] = realTrain[i][j];
          conjN[l][j] = nominalTrain[i][j];
          conjM[l][j] = nulosTrain[i][j];
        }
        clasesS[l] = clasesTrain[i];
        l++;
      }
    }

    System.out.println(
        "Reconsistent "
            + relation
            + " "
            + (double) (System.currentTimeMillis() - tiempo) / 1000.0
            + "s");

    // COn conjS me vale.
    int trainRealClass[][];
    int trainPrediction[][];

    trainRealClass = new int[datosTrain.length][1];
    trainPrediction = new int[datosTrain.length][1];

    // Working on training
    for (i = 0; i < datosTrain.length; i++) {
      trainRealClass[i][0] = clasesTrain[i];
      trainPrediction[i][0] = KNN.evaluate(datosTrain[i], conjS, nClases, clasesS, 1);
    }

    KNN.writeOutput(ficheroSalida[0], trainRealClass, trainPrediction, entradas, salida, relation);

    // Working on test
    int realClass[][] = new int[datosTest.length][1];
    int prediction[][] = new int[datosTest.length][1];

    // Check  time

    for (i = 0; i < realClass.length; i++) {
      realClass[i][0] = clasesTest[i];
      prediction[i][0] = KNN.evaluate(datosTest[i], conjS, nClases, clasesS, 1);
    }

    KNN.writeOutput(ficheroSalida[1], realClass, prediction, entradas, salida, relation);
  }