/**
* Returns an array with the bevavior of the classifier with test dataset
*
* @param classifier Classifier to obtain the error
* @return double[] Behavior array
*/
public double[] getTestClassificationBehaviorArray(IClassifier classifier) {
// Dataset to be used
DoubleTransposedDataSet dataset;
if (dataNormalized) dataset = scaledTestData;
else dataset = unscaledTestData;
// Resulting array
double[] result = new double[dataset.getNofobservations()];
// Obtained outputs with this dataSet
byte obtained[][] = classifier.classify(dataset.getAllInputs());
// Expected outputs
double expected[][] = dataset.getAllOutputs();
// Init result
for (int j = 0; j < dataset.getNofobservations(); j++) result[j] = 1;
// Put a 0 in observations where the expected is not
// the same than the observed
for (int o = 0; o < obtained.length; o++) // For each output (o)
for (int e = 0; e < obtained[o].length; e++) // For each example (e)
if (obtained[o][e] != expected[o][e]) if (result[e] == 1) result[e] = 0;
return result;
}
/**
* Configuration parameters for NeuralNetEvaluator are:
*
* <ul>
* <li><code>train-data: complex</code> Train data set used in individuals evaluation.
* <ul>
* <li><code>train-data[@file-name] String </code> File name of train data
* </ul>
* <li><code>test-data: complex</code> Test data set used in individuals evaluation.
* <ul>
* <li><code>test-data[@file-name] String </code> File name of test data
* </ul>
* <li><code>[@normalize-data]: boolean (default = false)</code> If this parameter is set to
* <code>true</code> data sets values are normalizated after reading their contents
* <li><code>[input-interval] (complex)</code> Input interval of normalization.
* <li><code>[output-interval] (complex)</code> Output interval of normalization.
* </ul>
*
* <p>
*
* @param settings Configuration object from which the properties are read
*/
public void configure(Configuration settings) {
// Set trainData
unscaledTrainData = new DoubleTransposedDataSet();
unscaledTrainData.configure(settings.subset("train-data"));
// Set testData
unscaledTestData = new DoubleTransposedDataSet();
unscaledTestData.configure(settings.subset("test-data"));
// Set normalizer
normalizer = new Normalizer();
// Set dataNormalized
dataNormalized = settings.getBoolean("[@normalize-data]", false);
// Set dataNormalized
logTransformation = settings.getBoolean("[@log-input-data]", false);
if (dataNormalized) {
// Normalization Input Interval
Interval interval = new Interval();
// Configure interval
interval.configure(settings.subset("input-interval"));
// Set interval
setInputInterval(interval);
// Normalization Output Interval
interval = new Interval();
// Configure range
interval.configure(settings.subset("output-interval"));
// Set interval
setOutputInterval(interval);
}
}
/**
* Read and normalize evaluator datasets
*
* @param schema Schema of the dataset
* @param traindata IDataset with the training data
* @param testdata IDataset with the test data
*/
public void readData(byte[] schema, IDataset traindata, IDataset testdata) {
// Read trainData
try {
unscaledTrainData.read(schema, traindata);
} catch (DatasetException e1) {
e1.printStackTrace();
}
// Read testData
try {
unscaledTestData.read(schema, testdata);
} catch (DatasetException e1) {
e1.printStackTrace();
}
normalizeData();
}
/**
* Read and normalize evaluator datasets
*
* @throws IOException Data not correct
* @throws NumberFormatException Format of data not correct
*/
public void readData() throws IOException, NumberFormatException {
// Read trainData
try {
unscaledTrainData.read();
} catch (IOException e) {
throw new IOException("trainData IOException: " + e.getLocalizedMessage());
} catch (NumberFormatException e) {
throw new NumberFormatException(
"trainData NumberFormatException: " + e.getLocalizedMessage());
}
// Read testData
try {
unscaledTestData.read();
} catch (IOException e) {
throw new IOException("testData IOException: " + e.getLocalizedMessage());
} catch (NumberFormatException e) {
throw new NumberFormatException("testData NumberFormatException: " + e.getLocalizedMessage());
}
normalizeData();
}
/**
* Returns the train error value of a neural net with an specified error function
*
* @param nnind Neural net to obtain the error
* @param errorFunction Error function to obtain the error
* @return double Train error value
*/
public double getTrainClassificationError(
IClassifier classifier, IErrorFunction<byte[][]> errorFunction) {
// Dataset to be used
DoubleTransposedDataSet dataset;
if (dataNormalized) dataset = scaledTrainData;
else dataset = unscaledTrainData;
// Obtained outputs with this dataSet
byte obtained[][] = classifier.classify(dataset.getAllInputs());
// Casting the outputs
double doubleExpected[][] = dataset.getAllOutputs();
byte expected[][] = new byte[doubleExpected.length][doubleExpected[0].length];
for (int i = 0; i < doubleExpected.length; i++)
for (int j = 0; j < doubleExpected[i].length; j++)
expected[i][j] = (byte) doubleExpected[i][j];
// Obtain error
double error = errorFunction.calculateError(obtained, expected);
// Return train error value
return error;
}
/** Normalize data */
private void normalizeData() {
if (dataNormalized) {
// Obtain maximum and minimum values
unscaledMin = new double[unscaledTrainData.getNofvariables()];
unscaledMax = new double[unscaledTrainData.getNofvariables()];
double temp;
for (int i = 0; i < unscaledTrainData.getNofvariables(); i++) {
unscaledMax[i] = unscaledTrainData.getMaxValueOf(i);
temp = unscaledTestData.getMaxValueOf(i);
if (temp > unscaledMax[i]) unscaledMax[i] = temp;
unscaledMin[i] = unscaledTrainData.getMinValueOf(i);
temp = unscaledTestData.getMinValueOf(i);
if (temp < unscaledMin[i]) unscaledMin[i] = temp;
}
// Obtain maximum and minimum desired values
double[] scaledMin = new double[unscaledTrainData.getNofvariables()];
double[] scaledMax = new double[unscaledTrainData.getNofvariables()];
for (int i = 0; i < unscaledTrainData.getNofvariables(); i++) {
if (i < unscaledTrainData.getNofinputs()) {
scaledMin[i] = inputInterval.getLeft();
scaledMax[i] = inputInterval.getRight();
} else {
scaledMin[i] = outputInterval.getLeft();
scaledMax[i] = outputInterval.getRight();
}
}
// Normalize trainData
scaledTrainData = unscaledTrainData.copy();
normalizer.scaleDS(scaledTrainData, scaledMax, scaledMin, unscaledMax, unscaledMin);
// Normalize trainData
scaledTestData = unscaledTestData.copy();
normalizer.scaleDS(scaledTestData, scaledMax, scaledMin, unscaledMax, unscaledMin);
}
// Remove constant inputs
int newNofinputs = 0;
boolean[] toRemove = unscaledTrainData.obtainConstantsInputs();
for (int i = 0; i < toRemove.length; i++) if (!toRemove[i]) newNofinputs++;
unscaledTrainData.removeInputs(toRemove, newNofinputs);
unscaledTestData.removeInputs(toRemove, newNofinputs);
if (dataNormalized) {
scaledTrainData.removeInputs(toRemove, newNofinputs);
scaledTestData.removeInputs(toRemove, newNofinputs);
// Log transformation
if (logTransformation) {
double[][] inputs = scaledTrainData.getAllInputs();
for (int i = 0; i < inputs.length; i++)
for (int j = 0; j < inputs[i].length; j++) inputs[i][j] = Math.log(inputs[i][j]);
inputs = scaledTestData.getAllInputs();
for (int i = 0; i < inputs.length; i++)
for (int j = 0; j < inputs[i].length; j++) inputs[i][j] = Math.log(inputs[i][j]);
}
}
// Log transformation
else if (logTransformation) {
double[][] inputs = unscaledTrainData.getAllInputs();
for (int i = 0; i < inputs.length; i++)
for (int j = 0; j < inputs[i].length; j++) inputs[i][j] = Math.log(inputs[i][j]);
inputs = unscaledTestData.getAllInputs();
for (int i = 0; i < inputs.length; i++)
for (int j = 0; j < inputs[i].length; j++) inputs[i][j] = Math.log(inputs[i][j]);
}
}
