/** 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;
}
/** It does return the original header definiton but without @input and @output in there */
public String getOriginalHeaderWithoutInOut() {
String line = "";
Attribute[] attrs = null;
// Getting the relation name and the attributes
if (storeAttributesAsNonStatic && attributes != null) {
line = "@relation " + attributes.getRelationName() + "\n";
attrs = attributes.getAttributes();
} else {
line = "@relation " + Attributes.getRelationName() + "\n";
attrs = Attributes.getAttributes();
}
for (int i = 0; i < attrs.length; i++) {
line += attrs[i].toString() + "\n";
}
return line;
} // end getOriginalHeaderWithoutInOut
/**
* It reads the whole input data-set and it stores each example and its associated output value in
* local arrays to ease their use.
*
* @param datasetFile String name of the file containing the dataset
* @param train boolean It must have the value "true" if we are reading the training data-set
* @throws IOException If there ocurs any problem with the reading of the data-set
*/
public void readClassificationSet(String datasetFile, boolean train) throws IOException {
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(datasetFile, train);
nData = IS.getNumInstances();
nInputs = Attributes.getInputNumAttributes();
nVars = nInputs + Attributes.getOutputNumAttributes();
// outputIntegerheck that there is only one output variable
if (Attributes.getOutputNumAttributes() > 1) {
System.out.println("This algorithm can not process MIMO datasets");
System.out.println("All outputs but the first one will be removed");
System.exit(1);
}
boolean noOutputs = false;
if (Attributes.getOutputNumAttributes() < 1) {
System.out.println("This algorithm can not process datasets without outputs");
System.out.println("Zero-valued output generated");
noOutputs = true;
System.exit(1);
}
// Initialice and fill our own tables
X = new double[nData][nInputs];
Nominal = new String[nData][nVars];
missing = new boolean[nData][nVars];
outputInteger = new int[nData];
outputReal = new double[nData];
output = new String[nData];
// Maximum and minimum of inputs
emax = new double[nInputs];
emin = new double[nInputs];
for (int i = 0; i < nInputs; i++) {
emax[i] = Attributes.getAttribute(i).getMaxAttribute();
emin[i] = Attributes.getAttribute(i).getMinAttribute();
}
// All values are casted into double/integer
nClasses = 0;
for (int i = 0; i < nData; i++) {
Instance inst = IS.getInstance(i);
for (int j = 0; j < nInputs; j++) {
X[i][j] = IS.getInputNumericValue(i, j); // inst.getInputRealValues(j);
Nominal[i][j] = "" + IS.getInputNumericValue(i, j);
missing[i][j] = inst.getInputMissingValues(j);
if (missing[i][j]) {
X[i][j] = emin[j] - 1;
}
}
if (noOutputs) {
outputInteger[i] = 0;
output[i] = "";
} else {
outputInteger[i] = (int) IS.getOutputNumericValue(i, 0);
output[i] = IS.getOutputNominalValue(i, 0);
Nominal[i][nInputs] = output[i];
missing[i][nInputs] = false;
}
if (outputInteger[i] > nClasses) {
nClasses = outputInteger[i];
}
}
nClasses++;
System.out.println("Number of classes=" + nClasses);
} catch (Exception e) {
System.out.println("DBG: Exception in readSet");
e.printStackTrace();
}
computeStatistics();
this.computeInstancesPerClass();
Attribute[] atts = Attributes.getAttributes();
for (indexClass = 0;
(indexClass < atts.length)
&& (!(Attributes.getOutputAttribute(0)
.getName()
.equalsIgnoreCase(atts[indexClass].getName())));
indexClass++) {;
}
}
