Ejemplo n.º 1
0
  /**
   * The main method of the class that includes the operations of the algorithm. It includes all the
   * operations that the algorithm has and finishes when it writes the output information into
   * files.
   */
  public void run() {

    int nPos = 0;
    int nNeg = 0;
    int i, j, l, m;
    int tmp;
    int posID;
    int positives[];
    int overs[];
    double conjS[][];
    int clasesS[];
    int tamS;

    long tiempo = System.currentTimeMillis();

    /*Count of number of positive and negative examples*/
    for (i = 0; i < clasesTrain.length; i++) {
      if (clasesTrain[i] == 0) nPos++;
      else nNeg++;
    }
    if (nPos > nNeg) {
      tmp = nPos;
      nPos = nNeg;
      nNeg = tmp;
      posID = 1;
    } else {
      posID = 0;
    }

    /*Localize the positive instances*/
    positives = new int[nPos];
    for (i = 0, j = 0; i < clasesTrain.length; i++) {
      if (clasesTrain[i] == posID) {
        positives[j] = i;
        j++;
      }
    }

    /*Obtain the oversampling array taking account the previous array*/
    overs = new int[nNeg - nPos];
    Randomize.setSeed(semilla);
    for (i = 0; i < overs.length; i++) {
      tmp = Randomize.Randint(0, nPos - 1);
      overs[i] = positives[tmp];
    }

    tamS = 2 * nNeg;
    /*Construction of the S set from the previous vector S*/
    conjS = new double[tamS][datosTrain[0].length];
    clasesS = new int[tamS];
    for (j = 0; j < datosTrain.length; j++) {
      for (l = 0; l < datosTrain[0].length; l++) conjS[j][l] = datosTrain[j][l];
      clasesS[j] = clasesTrain[j];
    }
    for (m = 0; j < tamS; j++, m++) {
      for (l = 0; l < datosTrain[0].length; l++) conjS[j][l] = datosTrain[overs[m]][l];
      clasesS[j] = clasesTrain[overs[m]];
    }

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

    OutputIS.escribeSalida(ficheroSalida[0], conjS, clasesS, entradas, salida, nEntradas, relation);
    OutputIS.escribeSalida(ficheroSalida[1], test, entradas, salida, nEntradas, relation);
  }
Ejemplo n.º 2
0
  /** Executes the algorithm */
  public void ejecutar() {

    int i, j, l;
    int nClases;
    double conjS[][];
    double conjR[][];
    int conjN[][];
    boolean conjM[][];
    int clasesS[];
    int nSel = 0;
    Cromosoma poblacion[];
    int ev = 0;
    double prob[];
    double NUmax = 1.5;
    double NUmin = 0.5; // used for lineal ranking
    double aux;
    double pos1, pos2;
    int sel1, sel2, comp1, comp2;
    Cromosoma newPob[];

    long tiempo = System.currentTimeMillis();

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

    /*Random inicialization of the population*/
    Randomize.setSeed(semilla);
    poblacion = new Cromosoma[tamPoblacion];
    for (i = 0; i < tamPoblacion; i++) poblacion[i] = new Cromosoma(datosTrain.length);

    /*Initial evaluation of the population*/
    for (i = 0; i < tamPoblacion; i++)
      poblacion[i].evalua(
          datosTrain,
          realTrain,
          nominalTrain,
          nulosTrain,
          clasesTrain,
          alfa,
          kNeigh,
          nClases,
          distanceEu);

    if (torneo) {
      while (ev < nEval) {
        newPob = new Cromosoma[2];

        /*Binary tournament selection*/
        comp1 = Randomize.Randint(0, tamPoblacion - 1);
        do {
          comp2 = Randomize.Randint(0, tamPoblacion - 1);
        } while (comp2 == comp1);
        if (poblacion[comp1].getCalidad() > poblacion[comp2].getCalidad()) sel1 = comp1;
        else sel1 = comp2;
        comp1 = Randomize.Randint(0, tamPoblacion - 1);
        do {
          comp2 = Randomize.Randint(0, tamPoblacion - 1);
        } while (comp2 == comp1);
        if (poblacion[comp1].getCalidad() > poblacion[comp2].getCalidad()) sel2 = comp1;
        else sel2 = comp2;

        if (Randomize.Rand() < pCruce) { // there is cross
          crucePMX(poblacion, newPob, sel1, sel2);
        } else { // there is not cross
          newPob[0] = new Cromosoma(datosTrain.length, poblacion[sel1]);
          newPob[1] = new Cromosoma(datosTrain.length, poblacion[sel2]);
        }

        /*Mutation of the cromosomes*/
        for (i = 0; i < 2; i++) newPob[i].mutacion(pMutacion1to0, pMutacion0to1);

        /*Evaluation of the population*/
        for (i = 0; i < 2; i++)
          if (!(newPob[i].estaEvaluado())) {
            newPob[i].evalua(
                datosTrain,
                realTrain,
                nominalTrain,
                nulosTrain,
                clasesTrain,
                alfa,
                kNeigh,
                nClases,
                distanceEu);
            ev++;
          }

        /*Replace the two worst*/
        Arrays.sort(poblacion);
        poblacion[tamPoblacion - 2] = new Cromosoma(datosTrain.length, newPob[0]);
        poblacion[tamPoblacion - 1] = new Cromosoma(datosTrain.length, newPob[1]);
      }
    } else {
      /*Get the probabilities of lineal ranking in case of not use binary tournament*/
      prob = new double[tamPoblacion];
      for (i = 0; i < tamPoblacion; i++) {
        aux = (double) (NUmax - NUmin) * ((double) i / (tamPoblacion - 1));
        prob[i] = (double) (1.0 / (tamPoblacion)) * (NUmax - aux);
      }
      for (i = 1; i < tamPoblacion; i++) prob[i] = prob[i] + prob[i - 1];

      while (ev < nEval) {
        /*Sort the population by quality criterion*/
        Arrays.sort(poblacion);

        newPob = new Cromosoma[2];
        pos1 = Randomize.Rand();
        pos2 = Randomize.Rand();
        for (j = 0; j < tamPoblacion && prob[j] < pos1; j++) ;
        sel1 = j;
        for (j = 0; j < tamPoblacion && prob[j] < pos2; j++) ;
        sel2 = j;

        if (Randomize.Rand() < pCruce) { // there is cross
          crucePMX(poblacion, newPob, sel1, sel2);
        } else { // there is not cross
          newPob[0] = new Cromosoma(datosTrain.length, poblacion[sel1]);
          newPob[1] = new Cromosoma(datosTrain.length, poblacion[sel2]);
        }

        /*Mutation of the cromosomes*/
        for (i = 0; i < 2; i++) newPob[i].mutacion(pMutacion1to0, pMutacion0to1);

        /*Evaluation of the population*/
        for (i = 0; i < 2; i++)
          if (!(newPob[i].estaEvaluado())) {
            newPob[i].evalua(
                datosTrain,
                realTrain,
                nominalTrain,
                nulosTrain,
                clasesTrain,
                alfa,
                kNeigh,
                nClases,
                distanceEu);
            ev++;
          }

        /*Replace the two worst*/
        poblacion[tamPoblacion - 2] = new Cromosoma(datosTrain.length, newPob[0]);
        poblacion[tamPoblacion - 1] = new Cromosoma(datosTrain.length, newPob[1]);
      }
    }

    nSel = poblacion[0].genesActivos();

    /*Building of S set from the best cromosome obtained*/
    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 (poblacion[0].getGen(i)) { // the instance must 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(
        "SGA " + relation + " " + (double) (System.currentTimeMillis() - tiempo) / 1000.0 + "s");

    OutputIS.escribeSalida(
        ficheroSalida[0], conjR, conjN, conjM, clasesS, entradas, salida, nEntradas, relation);
    OutputIS.escribeSalida(ficheroSalida[1], test, entradas, salida, nEntradas, relation);
  } // end-method
Ejemplo n.º 3
0
  /**
   * The main method of the class that includes the operations of the algorithm. It includes all the
   * operations that the algorithm has and finishes when it writes the output information into
   * files.
   */
  public void run() {

    int S[];
    int i, j, l, m;
    int nPos = 0, nNeg = 0;
    int posID;
    int nClases;
    int pos;
    int baraje[];
    int tmp;
    double conjS[][];
    int clasesS[];
    int tamS = 0;
    int claseObt;
    int cont;
    int busq;
    boolean marcas[];
    int nSel;
    double conjS2[][];
    int clasesS2[];
    double minDist, dist;

    long tiempo = System.currentTimeMillis();

    /*CNN PART*/

    /*Count of number of positive and negative examples*/
    for (i = 0; i < clasesTrain.length; i++) {
      if (clasesTrain[i] == 0) nPos++;
      else nNeg++;
    }
    if (nPos > nNeg) {
      tmp = nPos;
      nPos = nNeg;
      nNeg = tmp;
      posID = 1;
    } else {
      posID = 0;
    }

    /*Inicialization of the candidates set*/
    S = new int[datosTrain.length];
    for (i = 0; i < S.length; i++) S[i] = Integer.MAX_VALUE;

    /*Inserting an element of mayority class*/
    Randomize.setSeed(semilla);
    pos = Randomize.Randint(0, clasesTrain.length - 1);
    while (clasesTrain[pos] == posID) pos = (pos + 1) % clasesTrain.length;
    S[tamS] = pos;
    tamS++;

    /*Insert all subset of minority class*/
    for (i = 0; i < clasesTrain.length; i++) {
      if (clasesTrain[i] == posID) {
        S[tamS] = i;
        tamS++;
      }
    }

    /*Algorithm body. We resort randomly the instances of T and compare with the rest of S.
    If an instance doesn´t classified correctly, it is inserted in S*/
    baraje = new int[datosTrain.length];
    for (i = 0; i < datosTrain.length; i++) baraje[i] = i;
    for (i = 0; i < datosTrain.length; i++) {
      pos = Randomize.Randint(i, clasesTrain.length - 1);
      tmp = baraje[i];
      baraje[i] = baraje[pos];
      baraje[pos] = tmp;
    }

    for (i = 0; i < datosTrain.length; i++) {
      if (clasesTrain[i] != posID) { // only for mayority class instances
        /*Construction of the S set from the previous vector S*/
        conjS = new double[tamS][datosTrain[0].length];
        clasesS = new int[tamS];
        for (j = 0; j < tamS; j++) {
          for (l = 0; l < datosTrain[0].length; l++) conjS[j][l] = datosTrain[S[j]][l];
          clasesS[j] = clasesTrain[S[j]];
        }

        /*Do KNN to the instance*/
        claseObt = KNN.evaluacionKNN(k, conjS, clasesS, datosTrain[baraje[i]], 2);
        if (claseObt != clasesTrain[baraje[i]]) { // fail in the class, it is included in S
          Arrays.sort(S);
          busq = Arrays.binarySearch(S, baraje[i]);
          if (busq < 0) {
            S[tamS] = baraje[i];
            tamS++;
          }
        }
      }
    }

    /*Construction of the S set from the previous vector S*/
    conjS = new double[tamS][datosTrain[0].length];
    clasesS = new int[tamS];
    for (j = 0; j < tamS; j++) {
      for (l = 0; l < datosTrain[0].length; l++) conjS[j][l] = datosTrain[S[j]][l];
      clasesS[j] = clasesTrain[S[j]];
    }

    /*TOMEK LINKS PART*/

    /*Inicialization of the instance flagged vector of the S set*/
    marcas = new boolean[conjS.length];
    for (i = 0; i < conjS.length; i++) {
      marcas[i] = true;
    }
    nSel = conjS.length;

    for (i = 0; i < conjS.length; i++) {
      minDist = Double.POSITIVE_INFINITY;
      pos = 0;
      for (j = 0; j < conjS.length; j++) {
        if (i != j) {
          dist = KNN.distancia(conjS[i], conjS[j]);
          if (dist < minDist) {
            minDist = dist;
            pos = j;
          }
        }
      }
      if (clasesS[i] != clasesS[pos]) {
        if (clasesS[i] != posID) {
          if (marcas[i] == true) {
            marcas[i] = false;
            nSel--;
          }
        } else {
          if (marcas[pos] == true) {
            marcas[pos] = false;
            nSel--;
          }
        }
      }
    }

    /*Construction of the S set from the flags*/
    conjS2 = new double[nSel][conjS[0].length];
    clasesS2 = new int[nSel];
    for (m = 0, l = 0; m < conjS.length; m++) {
      if (marcas[m]) { // the instance will evaluate
        for (j = 0; j < conjS[0].length; j++) {
          conjS2[l][j] = conjS[m][j];
        }
        clasesS2[l] = clasesS[m];
        l++;
      }
    }

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

    OutputIS.escribeSalida(
        ficheroSalida[0], conjS2, clasesS2, entradas, salida, nEntradas, relation);
    OutputIS.escribeSalida(ficheroSalida[1], test, entradas, salida, nEntradas, relation);
  }
Ejemplo n.º 4
0
  public void ejecutar() {

    double conjS[][];
    double conjR[][];
    int conjN[][];
    boolean conjM[][];
    int clasesS[];

    int S[]; /* Binary Vector, to decide if the instance will be included*/
    int i, j, l, cont;
    int nClases;
    int tamS;
    int transformations;

    int claseObt[];
    int clasePredominante;

    long tiempo = System.currentTimeMillis();

    transformations = 0;
    /*Getting the number of different classes*/

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

    if (nClases < 2) {
      System.err.println("Input dataset is empty");
      nClases = 0;
    }

    /*Algorithm body.
      First, S=TS.
      Then, for each instance of TS, the first step is to repeat the aplication of the k-nn, and then
      we decide if we need to change the label of the instance or we don't need it.

    */

    /*Inicialization of the candidates set, S=X, where X is the original Training Set*/
    S = new int[datosTrain.length];
    for (i = 0; i < S.length; i++) S[i] = 1; /* All included*/

    tamS = datosTrain.length;

    System.out.print("K= " + k + "\n");
    System.out.print("K'= " + k2 + "\n");

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

      /* I need find the k-nn of   i in X - {i}, so I make conjS without i*/
      conjS = new double[datosTrain.length - 1][datosTrain[0].length];
      conjR = new double[datosTrain.length - 1][datosTrain[0].length];
      conjN = new int[datosTrain.length - 1][datosTrain[0].length];
      conjM = new boolean[datosTrain.length - 1][datosTrain[0].length];
      clasesS = new int[datosTrain.length - 1];

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

        if (i != j) {
          for (l = 0; l < datosTrain[0].length; l++) {

            conjS[cont][l] = datosTrain[j][l];
            conjR[cont][l] = realTrain[j][l];
            conjN[cont][l] = nominalTrain[j][l];
            conjM[cont][l] = nulosTrain[j][l];
          }

          clasesS[cont] = clasesTrain[j];
          cont++;
        }
      }

      /*Do KNN to the instance*/
      claseObt =
          KNN.evaluacionKNN3(
              k,
              conjS,
              conjR,
              conjN,
              conjM,
              clasesS,
              datosTrain[i],
              realTrain[i],
              nominalTrain[i],
              nulosTrain[i],
              nClases,
              distanceEu);

      /*
      System.out.print("Las clases de los k vecinos m�s cercanos son\n");
      for(int m=0;m<k;m++){
      	System.out.print(claseObt[m]+ "  ");
      }
      System.out.print("\n-----------------------------------------------\n");

       */

      /*Now, we must check that we have at least k2 neighboors with the same class. */
      int max = 0;
      clasePredominante = 0;

      for (int m = 0; m < claseObt.length; m++) {
        int claseDeInstancia = claseObt[m]; // Select one class.
        int iguales = 0;

        for (j = 0; j < claseObt.length; j++) { // Check numbers of instances with this class
          if (j != m) { // I can't count the same.
            if (claseObt[j] == claseDeInstancia) {
              iguales++;
            }
          }
        }

        // I must check if there is another class with more instances.
        if (iguales > max) {
          max = iguales;
          clasePredominante = claseObt[m];
        }
      }

      // System.out.print("max " + max +"\n");
      // System.out.print("Clase Predominante: "+clasePredominante+"\n");

      /* Max+1 = number of neighbours with the same class*/
      if ((max) >= k2) {
        /* if there are at least k2 neighbour, we change the class in S, */

        if (clasePredominante != clasesTrain[i]) transformations++;

        clasesTrain[i] = clasePredominante;
        S[i] = 1;

      } else {
        /* Discard.*/
        tamS--;
        S[i] = 0;
      }
    }

    System.out.print("S size resultante= " + tamS + "\n");
    System.out.print("Transformations = " + transformations + "\n");

    /*Construction of the S set from the previous vector S*/
    conjS = new double[tamS][datosTrain[0].length];
    conjR = new double[tamS][datosTrain[0].length];
    conjN = new int[tamS][datosTrain[0].length];
    conjM = new boolean[tamS][datosTrain[0].length];
    clasesS = new int[tamS];

    cont = 0; /* To establish the sets' sizes */
    for (j = 0; j < datosTrain.length; j++) {

      if (S[j] == 1) {
        /* Checking the instance is included*/
        for (l = 0; l < datosTrain[0].length; l++) {

          conjS[cont][l] = datosTrain[j][l];
          conjR[cont][l] = realTrain[j][l];
          conjN[cont][l] = nominalTrain[j][l];
          conjM[cont][l] = nulosTrain[j][l];
        }

        clasesS[cont] = clasesTrain[j];
        cont++;
      }
    }

    System.out.println(
        "Time elapse: " + (double) (System.currentTimeMillis() - tiempo) / 1000.0 + "s");

    OutputIS.escribeSalida(
        ficheroSalida[0], conjR, conjN, conjM, clasesS, entradas, salida, nEntradas, relation);
    OutputIS.escribeSalida(ficheroSalida[1], test, entradas, salida, nEntradas, relation);
  }