/**
* Process a classifier's prediction for an instance and update a set of plotting instances and
* additional plotting info. m_PlotShape for nominal class datasets holds shape types (actual data
* points have automatic shape type assignment; classifier error data points have box shape type).
* For numeric class datasets, the actual data points are stored in m_PlotInstances and m_PlotSize
* stores the error (which is later converted to shape size values).
*
* @param toPredict the actual data point
* @param classifier the classifier
* @param eval the evaluation object to use for evaluating the classifier on the instance to
* predict
* @see #m_PlotShapes
* @see #m_PlotSizes
* @see #m_PlotInstances
*/
public void process(Instance toPredict, Classifier classifier, Evaluation eval) {
double pred;
double[] values;
int i;
try {
pred = eval.evaluateModelOnceAndRecordPrediction(classifier, toPredict);
if (classifier instanceof weka.classifiers.misc.InputMappedClassifier) {
toPredict =
((weka.classifiers.misc.InputMappedClassifier) classifier)
.constructMappedInstance(toPredict);
}
if (!m_SaveForVisualization) return;
if (m_PlotInstances != null) {
values = new double[m_PlotInstances.numAttributes()];
for (i = 0; i < m_PlotInstances.numAttributes(); i++) {
if (i < toPredict.classIndex()) {
values[i] = toPredict.value(i);
} else if (i == toPredict.classIndex()) {
values[i] = pred;
values[i + 1] = toPredict.value(i);
i++;
} else {
values[i] = toPredict.value(i - 1);
}
}
m_PlotInstances.add(new DenseInstance(1.0, values));
if (toPredict.classAttribute().isNominal()) {
if (toPredict.isMissing(toPredict.classIndex()) || Utils.isMissingValue(pred)) {
m_PlotShapes.addElement(new Integer(Plot2D.MISSING_SHAPE));
} else if (pred != toPredict.classValue()) {
// set to default error point shape
m_PlotShapes.addElement(new Integer(Plot2D.ERROR_SHAPE));
} else {
// otherwise set to constant (automatically assigned) point shape
m_PlotShapes.addElement(new Integer(Plot2D.CONST_AUTOMATIC_SHAPE));
}
m_PlotSizes.addElement(new Integer(Plot2D.DEFAULT_SHAPE_SIZE));
} else {
// store the error (to be converted to a point size later)
Double errd = null;
if (!toPredict.isMissing(toPredict.classIndex()) && !Utils.isMissingValue(pred)) {
errd = new Double(pred - toPredict.classValue());
m_PlotShapes.addElement(new Integer(Plot2D.CONST_AUTOMATIC_SHAPE));
} else {
// missing shape if actual class not present or prediction is missing
m_PlotShapes.addElement(new Integer(Plot2D.MISSING_SHAPE));
}
m_PlotSizes.addElement(errd);
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Convert an input instance
*
* @param current the input instance to convert
* @return a transformed instance
* @throws Exception if a problem occurs
*/
protected Instance convertInstance(Instance current) throws Exception {
double[] vals = new double[getOutputFormat().numAttributes()];
int index = 0;
for (int j = 0; j < current.numAttributes(); j++) {
if (j != current.classIndex()) {
if (m_unchanged != null && m_unchanged.attribute(current.attribute(j).name()) != null) {
vals[index++] = current.value(j);
} else {
Estimator[] estForAtt = m_estimatorLookup.get(current.attribute(j).name());
for (int k = 0; k < current.classAttribute().numValues(); k++) {
if (current.isMissing(j)) {
vals[index++] = Utils.missingValue();
} else {
double e = estForAtt[k].getProbability(current.value(j));
vals[index++] = e;
}
}
}
}
}
vals[vals.length - 1] = current.classValue();
DenseInstance instNew = new DenseInstance(current.weight(), vals);
return instNew;
}
@Override
public double[] distributionForInstance(Instance xy) throws Exception {
int L = xy.classIndex();
double y[] = new double[L];
double w = 0.0;
/*
* e.g. K = [3,3,5]
* we push y_[] from [0,0,0] to [2,2,4] over all necessary iterations.
*/
int K[] = getKs(xy.dataset());
if (getDebug()) System.out.println("K[] = " + Arrays.toString(K));
double y_[] = new double[L];
for (int i = 0; i < 1000000; i++) { // limit to 1m
// System.out.println(""+i+" "+Arrays.toString(y_));
double w_ = A.product(super.probabilityForInstance(xy, y_));
if (w_ > w) {
if (getDebug()) System.out.println("y' = " + Arrays.toString(y_) + ", :" + w_);
y = Arrays.copyOf(y_, y_.length);
w = w_;
}
if (push(y_, K, 0)) {
// Done !
if (getDebug()) System.out.println("Tried all " + (i + 1) + " combinations.");
break;
}
}
return y;
}
@Override
public void buildClassifier(Instances data) throws Exception {
trainingData = data;
Attribute classAttribute = data.classAttribute();
prototypes = new ArrayList<>();
classedData = new HashMap<String, ArrayList<Sequence>>();
indexClassedDataInFullData = new HashMap<String, ArrayList<Integer>>();
for (int c = 0; c < data.numClasses(); c++) {
classedData.put(data.classAttribute().value(c), new ArrayList<Sequence>());
indexClassedDataInFullData.put(data.classAttribute().value(c), new ArrayList<Integer>());
}
sequences = new Sequence[data.numInstances()];
classMap = new String[sequences.length];
for (int i = 0; i < sequences.length; i++) {
Instance sample = data.instance(i);
MonoDoubleItemSet[] sequence = new MonoDoubleItemSet[sample.numAttributes() - 1];
int shift = (sample.classIndex() == 0) ? 1 : 0;
for (int t = 0; t < sequence.length; t++) {
sequence[t] = new MonoDoubleItemSet(sample.value(t + shift));
}
sequences[i] = new Sequence(sequence);
String clas = sample.stringValue(classAttribute);
classMap[i] = clas;
classedData.get(clas).add(sequences[i]);
indexClassedDataInFullData.get(clas).add(i);
// System.out.println("Element "+i+" of train is classed "+clas+" and went to element
// "+(indexClassedDataInFullData.get(clas).size()-1));
}
buildSpecificClassifier(data);
}
public String classifyInstance(Instance wekaInstance) {
String label = null;
try {
double labelIndex = bayesNet.classifyInstance(wekaInstance);
wekaInstance.setClassValue(labelIndex);
label = wekaInstance.toString(wekaInstance.classIndex());
} catch (Exception e) {
System.err.println(e.getMessage());
e.printStackTrace();
System.exit(-1);
}
return label;
}
/**
* turns the instance into a libsvm row
*
* @param inst the instance to transform
* @return the generated libsvm row
*/
protected String instanceToLibsvm(Instance inst) {
StringBuffer result;
int i;
// class
result = new StringBuffer("" + inst.classValue());
// attributes
for (i = 0; i < inst.numAttributes(); i++) {
if (i == inst.classIndex()) continue;
if (inst.value(i) == 0) continue;
result.append(" " + (i + 1) + ":" + inst.value(i));
}
return result.toString();
}
/**
* Transform - turn [y1,y2,y3,x1,x2] into [y1,y2,x1,x2].
*
* @return transformed Instance
*/
public Instance transform(Instance x, double ypred[]) throws Exception {
x = (Instance) x.copy();
int L = x.classIndex();
int L_c = (paY.length + 1);
x.setDataset(null);
for (int j = 0; j < (L - L_c); j++) {
x.deleteAttributeAt(0);
}
for (int pa : paY) {
// System.out.println("x_["+map[pa]+"] <- "+ypred[pa]);
x.setValue(map[pa], ypred[pa]);
}
x.setDataset(T);
x.setClassMissing();
return x;
}
/**
* log(N!) + (for all the words)(log(Pi^ni) - log(ni!))
*
* <p>where N is the total number of words Pi is the probability of obtaining word i ni is the
* number of times the word at index i occurs in the document
*
* @param inst The instance to be classified
* @param classIndex The index of the class we are calculating the probability with respect to
* @return The log of the probability of the document occuring given the class
*/
private double probOfDocGivenClass(Instance inst, int classIndex) {
double answer = 0;
// double totalWords = 0; //no need as we are not calculating the factorial at all.
double freqOfWordInDoc; // should be double
for (int i = 0; i < inst.numValues(); i++)
if (inst.index(i) != inst.classIndex()) {
freqOfWordInDoc = inst.valueSparse(i);
// totalWords += freqOfWordInDoc;
answer +=
(freqOfWordInDoc
* m_probOfWordGivenClass[classIndex][
inst.index(i)]); // - lnFactorial(freqOfWordInDoc));
}
// answer += lnFactorial(totalWords);//The factorial terms don't make
// any difference to the classifier's
// accuracy, so not needed.
return answer;
}
public double classifyInstance(Instance sample) throws Exception {
// transform instance to sequence
MonoDoubleItemSet[] sequence = new MonoDoubleItemSet[sample.numAttributes() - 1];
int shift = (sample.classIndex() == 0) ? 1 : 0;
for (int t = 0; t < sequence.length; t++) {
sequence[t] = new MonoDoubleItemSet(sample.value(t + shift));
}
Sequence seq = new Sequence(sequence);
double minD = Double.MAX_VALUE;
String classValue = null;
for (ClassedSequence s : prototypes) {
double tmpD = seq.distance(s.sequence);
if (tmpD < minD) {
minD = tmpD;
classValue = s.classValue;
}
}
// System.out.println(prototypes.size());
return sample.classAttribute().indexOfValue(classValue);
}
/**
* test on one sample
*
* @param sample
* @return p(y|sample) forall y
* @throws Exception
*/
public double classifyInstance(Instance sample) throws Exception {
// transform instance to sequence
MonoDoubleItemSet[] sequence = new MonoDoubleItemSet[sample.numAttributes() - 1];
int shift = (sample.classIndex() == 0) ? 1 : 0;
for (int t = 0; t < sequence.length; t++) {
sequence[t] = new MonoDoubleItemSet(sample.value(t + shift));
}
Sequence seq = new Sequence(sequence);
// for each class
String classValue = null;
double maxProb = 0.0;
double[] pr = new double[classedData.keySet().size()];
for (String clas : classedData.keySet()) {
int c = trainingData.classAttribute().indexOfValue(clas);
double prob = 0.0;
for (int k = 0; k < centroidsPerClass[c].length; k++) {
// compute P(Q|k_c)
if (sigmasPerClass[c][k] == Double.NaN || sigmasPerClass[c][k] == 0) {
System.err.println("sigma=NAN||sigma=0");
continue;
}
double dist = seq.distanceEuc(centroidsPerClass[c][k]);
double p = computeProbaForQueryAndCluster(sigmasPerClass[c][k], dist);
prob += p / centroidsPerClass[c].length;
// prob += p*prior[c][k];
if (p > maxProb) {
maxProb = p;
classValue = clas;
}
}
// if (prob > maxProb) {
// maxProb = prob;
// classValue = clas;
// }
}
// System.out.println(Arrays.toString(pr));
// System.out.println(classValue);
return sample.classAttribute().indexOfValue(classValue);
}
@Override
public void updateNode(Instance inst) throws Exception {
super.updateDistribution(inst);
for (int i = 0; i < inst.numAttributes(); i++) {
Attribute a = inst.attribute(i);
if (i != inst.classIndex()) {
ConditionalSufficientStats stats = m_nodeStats.get(a.name());
if (stats == null) {
if (a.isNumeric()) {
stats = new GaussianConditionalSufficientStats();
} else {
stats = new NominalConditionalSufficientStats();
}
m_nodeStats.put(a.name(), stats);
}
stats.update(
inst.value(a), inst.classAttribute().value((int) inst.classValue()), inst.weight());
}
}
}
/**
* Call this function to predict the class of an instance once a classification model has been
* built with the buildClassifier call.
*
* @param i The instance to classify.
* @return A double array filled with the probabilities of each class type.
* @throws Exception if can't classify instance.
*/
public double[] distributionForInstance(Instance i) throws Exception {
// Make a copy of the instance so that it isn't modified
m_currentInstance = (Instance) i.copy();
if (m_normalizeAttributes) {
for (int noa = 0; noa < m_currentInstance.dataset().numAttributes(); noa++) {
if (noa != m_currentInstance.classIndex()) {
if (m_attributeRanges[noa] != 0) {
m_currentInstance.setValue(
noa,
(m_currentInstance.value(noa) - m_attributeBases[noa]) / m_attributeRanges[noa]);
} else {
m_currentInstance.setValue(noa, m_currentInstance.value(noa) - m_attributeBases[noa]);
}
}
}
}
resetNetwork();
// since all the output values are needed.
// They are calculated manually here and the values collected.
double[] theArray = new double[m_numClasses];
double count = 0;
for (int noa = 0; noa < m_numClasses; noa++) {
theArray[noa] = m_outputs[noa].outputValue(true);
count += theArray[noa];
}
if (count <= 0) {
return m_ZeroR.m_Counts;
}
return theArray;
}
protected static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
return inst.classIndex() > index ? index : index + 1;
}
/**
* processes the given instance (may change the provided instance) and returns the modified
* version.
*
* @param instance the instance to process
* @return the modified data
* @throws Exception in case the processing goes wrong
*/
@Override
protected Instance process(Instance instance) throws Exception {
Instance result;
int i;
double val;
double factor;
result = (Instance) instance.copy();
if (m_Decimals > -1) {
factor = StrictMath.pow(10, m_Decimals);
} else {
factor = 1;
}
for (i = 0; i < result.numAttributes(); i++) {
// only numeric attributes
if (!result.attribute(i).isNumeric()) {
continue;
}
// out of range?
if (!m_Cols.isInRange(i)) {
continue;
}
// skip class?
if ((result.classIndex() == i) && (!m_IncludeClass)) {
continue;
}
// too small?
if (result.value(i) < m_MinThreshold) {
if (getDebug()) {
System.out.println("Too small: " + result.value(i) + " -> " + m_MinDefault);
}
result.setValue(i, m_MinDefault);
}
// too big?
else if (result.value(i) > m_MaxThreshold) {
if (getDebug()) {
System.out.println("Too big: " + result.value(i) + " -> " + m_MaxDefault);
}
result.setValue(i, m_MaxDefault);
}
// too close?
else if ((result.value(i) - m_CloseTo < m_CloseToTolerance)
&& (m_CloseTo - result.value(i) < m_CloseToTolerance)
&& (result.value(i) != m_CloseTo)) {
if (getDebug()) {
System.out.println("Too close: " + result.value(i) + " -> " + m_CloseToDefault);
}
result.setValue(i, m_CloseToDefault);
}
// decimals?
if (m_Decimals > -1 && !result.isMissing(i)) {
val = result.value(i);
val = StrictMath.round(val * factor) / factor;
result.setValue(i, val);
}
}
return result;
}
/**
* train from dataset
*
* @param data
*/
public void buildClassifier(Instances data) {
trainingData = data;
Attribute classAttribute = data.classAttribute();
prototypes = new ArrayList<>();
classedData = new HashMap<String, ArrayList<Sequence>>();
indexClassedDataInFullData = new HashMap<String, ArrayList<Integer>>();
for (int c = 0; c < data.numClasses(); c++) {
classedData.put(data.classAttribute().value(c), new ArrayList<Sequence>());
indexClassedDataInFullData.put(data.classAttribute().value(c), new ArrayList<Integer>());
}
sequences = new Sequence[data.numInstances()];
classMap = new String[sequences.length];
for (int i = 0; i < sequences.length; i++) {
Instance sample = data.instance(i);
MonoDoubleItemSet[] sequence = new MonoDoubleItemSet[sample.numAttributes() - 1];
int shift = (sample.classIndex() == 0) ? 1 : 0;
for (int t = 0; t < sequence.length; t++) {
sequence[t] = new MonoDoubleItemSet(sample.value(t + shift));
}
sequences[i] = new Sequence(sequence);
String clas = sample.stringValue(classAttribute);
classMap[i] = clas;
classedData.get(clas).add(sequences[i]);
indexClassedDataInFullData.get(clas).add(i);
// System.out.println("Element "+i+" of train is classed "+clas+"
// and went to element
// "+(indexClassedDataInFullData.get(clas).size()-1));
}
ArrayList<String> classes = new ArrayList<String>(classedData.keySet());
centroidsPerClass = new Sequence[classes.size()][nClustersPerClass];
sigmasPerClass = new double[classes.size()][nClustersPerClass];
prior = new double[classes.size()][nClustersPerClass];
nck = new double[nClustersPerClass];
int dataAttributes = data.numAttributes() - 1;
for (String clas : classes) {
int c = trainingData.classAttribute().indexOfValue(clas);
EUCFUZZYCMEANSSymbolicSequence gmmclusterer =
new EUCFUZZYCMEANSSymbolicSequence(
nClustersPerClass, classedData.get(clas), dataAttributes);
gmmclusterer.cluster();
centroidsPerClass[c] = gmmclusterer.getMus();
sigmasPerClass[c] = gmmclusterer.getSigmas();
for (int k = 0; k < centroidsPerClass[c].length; k++) {
if (sigmasPerClass[c][k] == Double.NaN) continue;
ClassedSequence s = new ClassedSequence(centroidsPerClass[c][k], clas);
prototypes.add(s);
prior[c][k] = gmmclusterer.getNck()[k] / data.numInstances();
System.out.println(
gmmclusterer.getNck()[k]
+ " objects,priors is "
+ prior[c][k]
+ " Gaussian "
+ clas
+ " #"
+ k
+ ":mu="
+ centroidsPerClass[c][k]
+ "\tsigma="
+ sigmasPerClass[c][k]);
// System.out.println(clas+","+k+","+centroidsPerClass[c][k]+","+sigmasPerClass[c][k]);
}
}
}
/**
* Generates the classifier.
*
* @param instances set of instances serving as training data
* @throws Exception if the classifier has not been generated successfully
*/
public void buildClassifier(Instances instances) throws Exception {
// can classifier handle the data?
getCapabilities().testWithFail(instances);
// remove instances with missing class
instances = new Instances(instances);
instances.deleteWithMissingClass();
m_headerInfo = new Instances(instances, 0);
m_numClasses = instances.numClasses();
m_numAttributes = instances.numAttributes();
m_probOfWordGivenClass = new double[m_numClasses][];
/*
initialising the matrix of word counts
NOTE: Laplace estimator introduced in case a word that does not appear for a class in the
training set does so for the test set
*/
for (int c = 0; c < m_numClasses; c++) {
m_probOfWordGivenClass[c] = new double[m_numAttributes];
for (int att = 0; att < m_numAttributes; att++) {
m_probOfWordGivenClass[c][att] = 1;
}
}
// enumerate through the instances
Instance instance;
int classIndex;
double numOccurences;
double[] docsPerClass = new double[m_numClasses];
double[] wordsPerClass = new double[m_numClasses];
java.util.Enumeration enumInsts = instances.enumerateInstances();
while (enumInsts.hasMoreElements()) {
instance = (Instance) enumInsts.nextElement();
classIndex = (int) instance.value(instance.classIndex());
docsPerClass[classIndex] += instance.weight();
for (int a = 0; a < instance.numValues(); a++)
if (instance.index(a) != instance.classIndex()) {
if (!instance.isMissing(a)) {
numOccurences = instance.valueSparse(a) * instance.weight();
if (numOccurences < 0)
throw new Exception("Numeric attribute values must all be greater or equal to zero.");
wordsPerClass[classIndex] += numOccurences;
m_probOfWordGivenClass[classIndex][instance.index(a)] += numOccurences;
}
}
}
/*
normalising probOfWordGivenClass values
and saving each value as the log of each value
*/
for (int c = 0; c < m_numClasses; c++)
for (int v = 0; v < m_numAttributes; v++)
m_probOfWordGivenClass[c][v] =
Math.log(m_probOfWordGivenClass[c][v] / (wordsPerClass[c] + m_numAttributes - 1));
/*
calculating Pr(H)
NOTE: Laplace estimator introduced in case a class does not get mentioned in the set of
training instances
*/
final double numDocs = instances.sumOfWeights() + m_numClasses;
m_probOfClass = new double[m_numClasses];
for (int h = 0; h < m_numClasses; h++)
m_probOfClass[h] = (double) (docsPerClass[h] + 1) / numDocs;
}
/**
* Accepts and processes a classifier encapsulated in an incremental classifier event
*
* @param ce an <code>IncrementalClassifierEvent</code> value
*/
@Override
public void acceptClassifier(final IncrementalClassifierEvent ce) {
try {
if (ce.getStatus() == IncrementalClassifierEvent.NEW_BATCH) {
m_throughput = new StreamThroughput(statusMessagePrefix());
m_throughput.setSamplePeriod(m_statusFrequency);
// m_eval = new Evaluation(ce.getCurrentInstance().dataset());
m_eval = new Evaluation(ce.getStructure());
m_eval.useNoPriors();
m_dataLegend = new Vector();
m_reset = true;
m_dataPoint = new double[0];
Instances inst = ce.getStructure();
System.err.println("NEW BATCH");
m_instanceCount = 0;
if (m_windowSize > 0) {
m_window = new LinkedList<Instance>();
m_windowEval = new Evaluation(ce.getStructure());
m_windowEval.useNoPriors();
m_windowedPreds = new LinkedList<double[]>();
if (m_logger != null) {
m_logger.logMessage(
statusMessagePrefix()
+ "[IncrementalClassifierEvaluator] Chart output using windowed "
+ "evaluation over "
+ m_windowSize
+ " instances");
}
}
/*
* if (m_logger != null) { m_logger.statusMessage(statusMessagePrefix()
* + "IncrementalClassifierEvaluator: started processing...");
* m_logger.logMessage(statusMessagePrefix() +
* " [IncrementalClassifierEvaluator]" + statusMessagePrefix() +
* " started processing..."); }
*/
} else {
Instance inst = ce.getCurrentInstance();
if (inst != null) {
m_throughput.updateStart();
m_instanceCount++;
// if (inst.attribute(inst.classIndex()).isNominal()) {
double[] dist = ce.getClassifier().distributionForInstance(inst);
double pred = 0;
if (!inst.isMissing(inst.classIndex())) {
if (m_outputInfoRetrievalStats) {
// store predictions so AUC etc can be output.
m_eval.evaluateModelOnceAndRecordPrediction(dist, inst);
} else {
m_eval.evaluateModelOnce(dist, inst);
}
if (m_windowSize > 0) {
m_windowEval.evaluateModelOnce(dist, inst);
m_window.addFirst(inst);
m_windowedPreds.addFirst(dist);
if (m_instanceCount > m_windowSize) {
// "forget" the oldest prediction
Instance oldest = m_window.removeLast();
double[] oldDist = m_windowedPreds.removeLast();
oldest.setWeight(-oldest.weight());
m_windowEval.evaluateModelOnce(oldDist, oldest);
oldest.setWeight(-oldest.weight());
}
}
} else {
pred = ce.getClassifier().classifyInstance(inst);
}
if (inst.classIndex() >= 0) {
// need to check that the class is not missing
if (inst.attribute(inst.classIndex()).isNominal()) {
if (!inst.isMissing(inst.classIndex())) {
if (m_dataPoint.length < 2) {
m_dataPoint = new double[3];
m_dataLegend.addElement("Accuracy");
m_dataLegend.addElement("RMSE (prob)");
m_dataLegend.addElement("Kappa");
}
// int classV = (int) inst.value(inst.classIndex());
if (m_windowSize > 0) {
m_dataPoint[1] = m_windowEval.rootMeanSquaredError();
m_dataPoint[2] = m_windowEval.kappa();
} else {
m_dataPoint[1] = m_eval.rootMeanSquaredError();
m_dataPoint[2] = m_eval.kappa();
}
// int maxO = Utils.maxIndex(dist);
// if (maxO == classV) {
// dist[classV] = -1;
// maxO = Utils.maxIndex(dist);
// }
// m_dataPoint[1] -= dist[maxO];
} else {
if (m_dataPoint.length < 1) {
m_dataPoint = new double[1];
m_dataLegend.addElement("Confidence");
}
}
double primaryMeasure = 0;
if (!inst.isMissing(inst.classIndex())) {
if (m_windowSize > 0) {
primaryMeasure = 1.0 - m_windowEval.errorRate();
} else {
primaryMeasure = 1.0 - m_eval.errorRate();
}
} else {
// record confidence as the primary measure
// (another possibility would be entropy of
// the distribution, or perhaps average
// confidence)
primaryMeasure = dist[Utils.maxIndex(dist)];
}
// double [] dataPoint = new double[1];
m_dataPoint[0] = primaryMeasure;
// double min = 0; double max = 100;
/*
* ChartEvent e = new
* ChartEvent(IncrementalClassifierEvaluator.this, m_dataLegend,
* min, max, dataPoint);
*/
m_ce.setLegendText(m_dataLegend);
m_ce.setMin(0);
m_ce.setMax(1);
m_ce.setDataPoint(m_dataPoint);
m_ce.setReset(m_reset);
m_reset = false;
} else {
// numeric class
if (m_dataPoint.length < 1) {
m_dataPoint = new double[1];
if (inst.isMissing(inst.classIndex())) {
m_dataLegend.addElement("Prediction");
} else {
m_dataLegend.addElement("RMSE");
}
}
if (!inst.isMissing(inst.classIndex())) {
double update;
if (!inst.isMissing(inst.classIndex())) {
if (m_windowSize > 0) {
update = m_windowEval.rootMeanSquaredError();
} else {
update = m_eval.rootMeanSquaredError();
}
} else {
update = pred;
}
m_dataPoint[0] = update;
if (update > m_max) {
m_max = update;
}
if (update < m_min) {
m_min = update;
}
}
m_ce.setLegendText(m_dataLegend);
m_ce.setMin((inst.isMissing(inst.classIndex()) ? m_min : 0));
m_ce.setMax(m_max);
m_ce.setDataPoint(m_dataPoint);
m_ce.setReset(m_reset);
m_reset = false;
}
notifyChartListeners(m_ce);
}
m_throughput.updateEnd(m_logger);
}
if (ce.getStatus() == IncrementalClassifierEvent.BATCH_FINISHED || inst == null) {
if (m_logger != null) {
m_logger.logMessage(
"[IncrementalClassifierEvaluator]"
+ statusMessagePrefix()
+ " Finished processing.");
}
m_throughput.finished(m_logger);
// save memory if using windowed evaluation for charting
m_windowEval = null;
m_window = null;
m_windowedPreds = null;
if (m_textListeners.size() > 0) {
String textTitle = ce.getClassifier().getClass().getName();
textTitle = textTitle.substring(textTitle.lastIndexOf('.') + 1, textTitle.length());
String results =
"=== Performance information ===\n\n"
+ "Scheme: "
+ textTitle
+ "\n"
+ "Relation: "
+ m_eval.getHeader().relationName()
+ "\n\n"
+ m_eval.toSummaryString();
if (m_eval.getHeader().classIndex() >= 0
&& m_eval.getHeader().classAttribute().isNominal()
&& (m_outputInfoRetrievalStats)) {
results += "\n" + m_eval.toClassDetailsString();
}
if (m_eval.getHeader().classIndex() >= 0
&& m_eval.getHeader().classAttribute().isNominal()) {
results += "\n" + m_eval.toMatrixString();
}
textTitle = "Results: " + textTitle;
TextEvent te = new TextEvent(this, results, textTitle);
notifyTextListeners(te);
}
}
}
} catch (Exception ex) {
if (m_logger != null) {
m_logger.logMessage(
"[IncrementalClassifierEvaluator]"
+ statusMessagePrefix()
+ " Error processing prediction "
+ ex.getMessage());
m_logger.statusMessage(
statusMessagePrefix() + "ERROR: problem processing prediction (see log for details)");
}
ex.printStackTrace();
stop();
}
}
