protected int NN(int nSel, double conj[][], double ejemplo[]) {
double mindist, dist;
int nneigh = -1;
mindist = Double.POSITIVE_INFINITY;
for (int i = 0; i < nSel; i++) {
dist = KNN.distancia(conj[i], ejemplo);
if (dist < mindist) {
mindist = dist;
nneigh = i;
}
}
return nneigh;
}
public void ejecutar() {
int i, j, l, m;
double alfai;
int nClases;
int claseObt;
boolean marcas[];
boolean notFound;
int init;
int clasSel[];
int baraje[];
int pos, tmp;
String instanciasIN[];
String instanciasOUT[];
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++;
/* Shuffle the train set */
baraje = new int[datosTrain.length];
Randomize.setSeed(semilla);
for (i = 0; i < datosTrain.length; i++) baraje[i] = i;
for (i = 0; i < datosTrain.length; i++) {
pos = Randomize.Randint(i, datosTrain.length - 1);
tmp = baraje[i];
baraje[i] = baraje[pos];
baraje[pos] = tmp;
}
/*
* Inicialization of the flagged instaces vector for a posterior
* elimination
*/
marcas = new boolean[datosTrain.length];
for (i = 0; i < datosTrain.length; i++) marcas[i] = false;
if (datosTrain.length > 0) {
// marcas[baraje[0]] = true; //the first instance is included always
nSel = n_p;
if (nSel < nClases) nSel = nClases;
} else {
System.err.println("Input dataset is empty");
nSel = 0;
}
clasSel = new int[nClases];
System.out.print("Selecting initial neurons... ");
// at least, there must be 1 neuron of each class at the beginning
init = nClases;
for (i = 0; i < nClases && i < datosTrain.length; i++) {
pos = Randomize.Randint(0, datosTrain.length - 1);
tmp = 0;
while ((clasesTrain[pos] != i || marcas[pos]) && tmp < datosTrain.length) {
pos = (pos + 1) % datosTrain.length;
tmp++;
}
if (tmp < datosTrain.length) marcas[pos] = true;
else init--;
// clasSel[i] = i;
}
for (i = init; i < Math.min(nSel, datosTrain.length); i++) {
tmp = 0;
pos = Randomize.Randint(0, datosTrain.length - 1);
while (marcas[pos]) {
pos = (pos + 1) % datosTrain.length;
tmp++;
}
// if(i<nClases){
// notFound = true;
// do{
// for(j=i-1;j>=0 && notFound;j--){
// if(clasSel[j] == clasesTrain[pos])
// notFound = false;
// }
// if(!notFound)
// pos = Randomize.Randint (0, datosTrain.length-1);
// }while(!notFound);
// }
// clasSel[i] = clasesTrain[pos];
marcas[pos] = true;
init++;
}
nSel = init;
System.out.println("Initial neurons selected: " + nSel);
/* Building of the S set from the flags */
conjS = new double[nSel][datosTrain[0].length];
clasesS = new int[nSel];
for (m = 0, l = 0; m < datosTrain.length; m++) {
if (marcas[m]) { // the instance must be copied to the solution
for (j = 0; j < datosTrain[0].length; j++) {
conjS[l][j] = datosTrain[m][j];
}
clasesS[l] = clasesTrain[m];
l++;
}
}
alfai = alpha;
boolean change = true;
/* Body of the LVQ algorithm. */
// Train the network
for (int it = 0; it < T && change; it++) {
change = false;
alpha = alfai;
for (i = 1; i < datosTrain.length; i++) {
// search for the nearest neuron to training instance
pos = NN(nSel, conjS, datosTrain[baraje[i]]);
// nearest neuron labels correctly the class of training
// instance?
if (clasesS[pos] != clasesTrain[baraje[i]]) { // NO - repel
// the neuron
for (j = 0; j < conjS[pos].length; j++) {
conjS[pos][j] = conjS[pos][j] - alpha * (datosTrain[baraje[i]][j] - conjS[pos][j]);
}
change = true;
} else { // YES - migrate the neuron towards the input vector
for (j = 0; j < conjS[pos].length; j++) {
conjS[pos][j] = conjS[pos][j] + alpha * (datosTrain[baraje[i]][j] - conjS[pos][j]);
}
}
alpha = nu * alpha;
}
// Shuffle again the training partition
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, datosTrain.length - 1);
tmp = baraje[i];
baraje[i] = baraje[pos];
baraje[pos] = tmp;
}
}
System.out.println(
"LVQ " + relation + " " + (double) (System.currentTimeMillis() - tiempo) / 1000.0 + "s");
// Classify the train data set
instanciasIN = new String[datosReferencia.length];
instanciasOUT = new String[datosReferencia.length];
for (i = 0; i < datosReferencia.length; i++) {
/* Classify the instance selected in this iteration */
Attribute a = Attributes.getOutputAttribute(0);
int tipo = a.getType();
claseObt = KNN.evaluacionKNN2(1, conjS, clasesS, datosReferencia[i], nClases);
if (tipo != Attribute.NOMINAL) {
instanciasIN[i] = new String(String.valueOf(clasesReferencia[i]));
instanciasOUT[i] = new String(String.valueOf(claseObt));
} else {
instanciasIN[i] = new String(a.getNominalValue(clasesReferencia[i]));
instanciasOUT[i] = new String(a.getNominalValue(claseObt));
}
}
escribeSalida(
ficheroSalida[0], instanciasIN, instanciasOUT, entradas, salida, nEntradas, relation);
// Classify the test data set
normalizarTest();
instanciasIN = new String[datosTest.length];
instanciasOUT = new String[datosTest.length];
for (i = 0; i < datosTest.length; i++) {
/* Classify the instance selected in this iteration */
Attribute a = Attributes.getOutputAttribute(0);
int tipo = a.getType();
claseObt = KNN.evaluacionKNN2(1, conjS, clasesS, datosTest[i], nClases);
if (tipo != Attribute.NOMINAL) {
instanciasIN[i] = new String(String.valueOf(clasesTest[i]));
instanciasOUT[i] = new String(String.valueOf(claseObt));
} else {
instanciasIN[i] = new String(a.getNominalValue(clasesTest[i]));
instanciasOUT[i] = new String(a.getNominalValue(claseObt));
}
}
escribeSalida(
ficheroSalida[1], instanciasIN, instanciasOUT, entradas, salida, nEntradas, relation);
// Print the network to a file
printNetworkToFile(ficheroSalida[2], referencia.getHeader());
}
/**
* 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);
}
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);
}
