/**
* Computes the distance between two instances (without previous normalization)
*
* @param i First instance
* @param j Second instance
* @return The Euclidean distance between i and j
*/
private double distance(Instance i, Instance j) {
double dist = 0;
int in = 0;
int out = 0;
for (int l = 0; l < nvariables; l++) {
Attribute a = Attributes.getAttribute(l);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !i.getInputMissingValues(in)) {
// real value, apply euclidean distance
dist +=
(i.getInputRealValues(in) - j.getInputRealValues(in))
* (i.getInputRealValues(in) - j.getInputRealValues(in));
} else {
if (!i.getInputMissingValues(in)
&& i.getInputNominalValues(in) != j.getInputNominalValues(in)) dist += 1;
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !i.getOutputMissingValues(out)) {
dist +=
(i.getOutputRealValues(out) - j.getOutputRealValues(out))
* (i.getOutputRealValues(out) - j.getOutputRealValues(out));
} else {
if (!i.getOutputMissingValues(out)
&& i.getOutputNominalValues(out) != j.getOutputNominalValues(out)) dist += 1;
}
out++;
}
}
}
return dist;
}
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());
}
protected static void escribeSalida(
String nombreFichero,
String instanciasIN[],
String instanciasOUT[],
Attribute entradas[],
Attribute salida,
int nEntradas,
String relation) {
String cadena = "";
int i, j, k;
int aux;
/* Printing input attributes */
cadena += "@relation " + relation + "\n";
for (i = 0; i < nEntradas; i++) {
cadena += "@attribute " + entradas[i].getName() + " ";
if (entradas[i].getType() == Attribute.NOMINAL) {
cadena += "{";
for (j = 0; j < entradas[i].getNominalValuesList().size(); j++) {
cadena += (String) entradas[i].getNominalValuesList().elementAt(j);
if (j < entradas[i].getNominalValuesList().size() - 1) {
cadena += ", ";
}
}
cadena += "}\n";
} else {
if (entradas[i].getType() == Attribute.INTEGER) {
cadena += "integer";
cadena +=
" ["
+ String.valueOf((int) entradas[i].getMinAttribute())
+ ", "
+ String.valueOf((int) entradas[i].getMaxAttribute())
+ "]\n";
} else {
cadena += "real";
cadena +=
" ["
+ String.valueOf(entradas[i].getMinAttribute())
+ ", "
+ String.valueOf(entradas[i].getMaxAttribute())
+ "]\n";
}
}
}
/* Printing output attribute */
cadena += "@attribute " + salida.getName() + " ";
if (salida.getType() == Attribute.NOMINAL) {
cadena += "{";
for (j = 0; j < salida.getNominalValuesList().size(); j++) {
cadena += (String) salida.getNominalValuesList().elementAt(j);
if (j < salida.getNominalValuesList().size() - 1) {
cadena += ", ";
}
}
cadena += "}\n";
} else {
cadena +=
"integer ["
+ String.valueOf((int) salida.getMinAttribute())
+ ", "
+ String.valueOf((int) salida.getMaxAttribute())
+ "]\n";
}
/* Printing the data */
cadena += "@data\n";
Fichero.escribeFichero(nombreFichero, cadena);
cadena = "";
for (i = 0; i < instanciasIN.length; i++) {
cadena += instanciasIN[i] + " " + instanciasOUT[i];
cadena += "\n";
}
Fichero.AnadirtoFichero(nombreFichero, cadena);
}
/** Process the training and test files provided in the parameters file to the constructor. */
public void process() {
// declarations
double[] outputs;
double[] outputs2;
Instance neighbor;
double dist, mean;
int actual;
Randomize rnd = new Randomize();
Instance ex;
gCenter kmeans = null;
int iterations = 0;
double E;
double prevE;
int totalMissing = 0;
boolean allMissing = true;
rnd.setSeed(semilla);
// PROCESS
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_train_name, true);
int in = 0;
int out = 0;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
X = new String[ndatos][nvariables]; // matrix with transformed data
kmeans = new gCenter(K, ndatos, nvariables);
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
// first, we choose k 'means' randomly from all
// instances
totalMissing = 0;
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
if (inst.existsAnyMissingValue()) totalMissing++;
}
if (totalMissing == ndatos) allMissing = true;
else allMissing = false;
for (int numMeans = 0; numMeans < K; numMeans++) {
do {
actual = (int) (ndatos * rnd.Rand());
ex = IS.getInstance(actual);
} while (ex.existsAnyMissingValue() && !allMissing);
kmeans.copyCenter(ex, numMeans);
}
// now, iterate adjusting clusters' centers and
// instances to them
prevE = 0;
iterations = 0;
do {
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
kmeans.setClusterOf(inst, i);
}
// set new centers
kmeans.recalculateCenters(IS);
// compute RMSE
E = 0;
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
E += kmeans.distance(inst, kmeans.getClusterOf(i));
}
iterations++;
// System.out.println(iterations+"\t"+E);
if (Math.abs(prevE - E) == 0) iterations = maxIter;
else prevE = E;
} while (E > minError && iterations < maxIter);
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in)) {
X[i][j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.getInputMissingValues(in)) X[i][j] = inst.getInputNominalValues(in);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
X[i][j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) X[i][j] = inst.getOutputNominalValues(out);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
out++;
}
}
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_train_name);
/** ************************************************************************************ */
// does a test file associated exist?
if (input_train_name.compareTo(input_test_name) != 0) {
try {
// Load in memory a dataset that contains a classification problem
IStest.readSet(input_test_name, false);
int in = 0;
int out = 0;
ndatos = IStest.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
for (int i = 0; i < ndatos; i++) {
Instance inst = IStest.getInstance(i);
in = 0;
out = 0;
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in)) {
X[i][j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.getInputMissingValues(in)) X[i][j] = inst.getInputNominalValues(in);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
X[i][j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) X[i][j] = inst.getOutputNominalValues(out);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
out++;
}
}
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_test_name);
}
}
/** Process the training and test files provided in the parameters file to the constructor. */
public void process() {
double[] outputs;
double[] outputs2;
try {
FileWriter file_write = new FileWriter(output_train_name);
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_train_name, true);
int in = 0;
int out = 0;
int in2 = 0;
int out2 = 0;
int lastMissing = -1;
boolean fin = false;
boolean stepNext = false;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
String[] row = null;
X = new Vector[ndatos]; // matrix with transformed data
for (int i = 0; i < ndatos; i++) X[i] = new Vector();
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
file_write.write(IS.getHeader());
// now, print the normalized data
file_write.write("@data\n");
// now, search for missed data, and replace them with
// the most common value
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
row = new String[nvariables];
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.existsAnyMissingValue()) {
row[j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.existsAnyMissingValue()) row[j] = inst.getInputNominalValues(in);
else {
// missing data
outputs = inst.getAllOutputValues();
in2 = 0;
out2 = 0;
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in2)) {
row[attr] = new String(String.valueOf(inst.getInputRealValues(in2)));
} else {
if (!inst.getInputMissingValues(in2))
row[attr] = inst.getInputNominalValues(in2);
}
in2++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out2)) {
row[attr] = new String(String.valueOf(inst.getOutputRealValues(out2)));
} else {
if (!inst.getOutputMissingValues(out2))
row[attr] = inst.getOutputNominalValues(out2);
}
out2++;
}
}
}
// make frecuencies for each attribute
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
lastMissing = attr;
timesSeen[attr] = new FreqList();
for (int m = 0; m < ndatos; m++) {
Instance inst2 = IS.getInstance(m);
outputs2 = inst2.getAllOutputValues();
boolean sameClass = true;
// are they same concept instances??
for (int k = 0; k < nsalidas && sameClass; k++)
if (outputs[k] != outputs2[k]) sameClass = false;
if (sameClass) {
if (tipo != Attribute.NOMINAL && !inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(
new String(String.valueOf(inst2.getInputRealValues(attr))));
} else {
if (!inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(inst2.getInputNominalValues(attr));
}
}
}
}
}
}
for (int attr = 0; attr < nvariables; attr++) {
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
timesSeen[attr].reset();
}
}
fin = false;
stepNext = false;
while (!fin) {
in2 = 0;
for (int attr = 0; attr < nvariables && !fin; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(in2)) {
if (stepNext) {
timesSeen[attr].iterate();
stepNext = false;
}
if (timesSeen[attr].outOfBounds()) {
stepNext = true;
if (attr == lastMissing) fin = true;
timesSeen[attr].reset();
}
if (!fin)
row[attr] =
((ValueFreq) timesSeen[attr].getCurrent())
.getValue(); // replace missing data
}
in2++;
}
if (!fin) {
stepNext = true;
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
// X[i].addElement(row);
// row = (String[])row.clone();
}
}
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
row[j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) row[j] = inst.getOutputNominalValues(out);
else row[j] = new String("?");
}
out++;
}
}
}
if (!inst.existsAnyMissingValue()) {
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
file_write.close();
} catch (IOException e) {
System.out.println("IO exception = " + e);
e.printStackTrace();
System.exit(-1);
}
/** ************************************************************************************ */
// does a test file associated exist?
if (input_train_name.compareTo(input_test_name) != 0) {
try {
FileWriter file_write = new FileWriter(output_test_name);
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_test_name, false);
int in = 0;
int out = 0;
int in2 = 0;
int out2 = 0;
int lastMissing = -1;
boolean fin = false;
boolean stepNext = false;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
String[] row = null;
X = new Vector[ndatos]; // matrix with transformed data
for (int i = 0; i < ndatos; i++) X[i] = new Vector();
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
file_write.write(IS.getHeader());
// now, print the normalized data
file_write.write("@data\n");
// now, search for missed data, and replace them with
// the most common value
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
row = new String[nvariables];
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.existsAnyMissingValue()) {
row[j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.existsAnyMissingValue()) row[j] = inst.getInputNominalValues(in);
else {
// missing data
outputs = inst.getAllOutputValues();
in2 = 0;
out2 = 0;
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in2)) {
row[attr] = new String(String.valueOf(inst.getInputRealValues(in2)));
} else {
if (!inst.getInputMissingValues(in2))
row[attr] = inst.getInputNominalValues(in2);
}
in2++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out2)) {
row[attr] = new String(String.valueOf(inst.getOutputRealValues(out2)));
} else {
if (!inst.getOutputMissingValues(out2))
row[attr] = inst.getOutputNominalValues(out2);
}
out2++;
}
}
}
// make frecuencies for each attribute
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
lastMissing = attr;
timesSeen[attr] = new FreqList();
for (int m = 0; m < ndatos; m++) {
Instance inst2 = IS.getInstance(m);
outputs2 = inst2.getAllOutputValues();
boolean sameClass = true;
// are they same concept instances??
for (int k = 0; k < nsalidas && sameClass; k++)
if (outputs[k] != outputs2[k]) sameClass = false;
if (sameClass) {
if (tipo != Attribute.NOMINAL && !inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(
new String(String.valueOf(inst2.getInputRealValues(attr))));
} else {
if (!inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(inst2.getInputNominalValues(attr));
}
}
}
}
}
}
for (int attr = 0; attr < nvariables; attr++) {
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
timesSeen[attr].reset();
}
}
fin = false;
stepNext = false;
while (!fin) {
in2 = 0;
for (int attr = 0; attr < nvariables && !fin; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(in2)) {
if (stepNext) {
timesSeen[attr].iterate();
stepNext = false;
}
if (timesSeen[attr].outOfBounds()) {
stepNext = true;
if (attr == lastMissing) fin = true;
timesSeen[attr].reset();
}
if (!fin)
row[attr] =
((ValueFreq) timesSeen[attr].getCurrent())
.getValue(); // replace missing data
}
in2++;
}
if (!fin) {
stepNext = true;
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
// X[i].addElement(row);
// row = (String[])row.clone();
}
}
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
row[j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out))
row[j] = inst.getOutputNominalValues(out);
else row[j] = new String("?");
}
out++;
}
}
}
if (!inst.existsAnyMissingValue()) {
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
file_write.close();
} catch (IOException e) {
System.out.println("IO exception = " + e);
e.printStackTrace();
System.exit(-1);
}
}
}