/**
* Calculates the class membership probabilities for the given test instance.
*
* @param instance the instance to be classified
* @return predicted class probability distribution
* @exception Exception if distribution can't be computed
*/
@Override
public double[] distributionForInstance(Instance instance) throws Exception {
double[] probs = new double[instance.numClasses()];
int attIndex;
for (int j = 0; j < instance.numClasses(); j++) {
probs[j] = 1;
Enumeration<Attribute> enumAtts = instance.enumerateAttributes();
attIndex = 0;
while (enumAtts.hasMoreElements()) {
Attribute attribute = enumAtts.nextElement();
if (!instance.isMissing(attribute)) {
if (attribute.isNominal()) {
probs[j] *= m_Counts[j][attIndex][(int) instance.value(attribute)];
} else {
probs[j] *=
normalDens(instance.value(attribute), m_Means[j][attIndex], m_Devs[j][attIndex]);
}
}
attIndex++;
}
probs[j] *= m_Priors[j];
}
// Normalize probabilities
Utils.normalize(probs);
return probs;
}
public double[] getVotesForInstance(Instance inst) {
DoubleVector combinedVote = new DoubleVector();
DoubleVector confidenceVec = new DoubleVector();
int success = 0;
double[] ensembleVotes = new double[inst.numClasses()];
double[] ensMemberWeights = new double[this.ensemble.length];
boolean[] ensMemberFlags = new boolean[this.ensemble.length];
double confidence = 0.0;
for (int i = 0; i < this.ensemble.length; i++) {
if (!ensMemberFlags[i]) {
ensMemberWeights[i] = getEnsembleMemberWeight(i);
}
if (ensMemberWeights[i] > 0.0) {
DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(inst));
if (vote.sumOfValues() > 0.0) {
vote.normalize();
vote.scaleValues(ensMemberWeights[i]);
combinedVote.addValues(vote);
if (getEnsembleMemberError(i) < errorRatio) {
//
// these are the votes of the ensembles for the classes
//
success++;
// successFlag = true;
confidenceVec.addValues(vote);
ensembleVotes[confidenceVec.maxIndex()] +=
confidenceVec.getValue(confidenceVec.maxIndex());
}
}
} else {
break;
}
}
confidenceVec = (DoubleVector) combinedVote.copy();
confidenceVec.normalize();
confidence = confidenceVec.getValue(confidenceVec.maxIndex());
// Reconfigure the activeLearningRatio
// For confidence measure add to the pool and in order to fit the confidence value between 0
// and 1 divide by success val
if (confidence > confidenceThreshold) {
double qbcEntropy =
QBC.queryByCommitee(ensembleVotes, inst.numClasses(), success, ensemble.length);
Math.pow(qbcEntropy, 2);
System.out.println("QBC Entropy: " + qbcEntropy);
double activeLearningRatio = getActiveLearningRatio(qbcEntropy, combinedVote);
inst.setClassValue(combinedVote.maxIndex()); // Set the class value of the instance
instConfPool.addVotedInstance(
inst, combinedVote.getValue(combinedVote.maxIndex()), activeLearningRatio);
instConfCount++;
}
return combinedVote.getArrayRef();
}
/**
* Use <code> classifyInstance </code> from <code> OSDLCore </code> and assign probability one to
* the chosen label. The implementation is heavily based on the same method in the <code>
* Classifier </code> class.
*
* @param instance the instance to be classified
* @return an array containing a single '1' on the index that <code> classifyInstance </code>
* returns.
*/
public double[] distributionForInstance(Instance instance) {
// based on the code from the Classifier class
double[] dist = new double[instance.numClasses()];
int classification = 0;
switch (instance.classAttribute().type()) {
case Attribute.NOMINAL:
try {
classification = (int) Math.round(classifyInstance(instance));
} catch (Exception e) {
System.out.println("There was a problem with classifyIntance");
System.out.println(e.getMessage());
e.printStackTrace();
}
if (Utils.isMissingValue(classification)) {
return dist;
}
dist[classification] = 1.0;
return dist;
case Attribute.NUMERIC:
try {
dist[0] = classifyInstance(instance);
} catch (Exception e) {
System.out.println("There was a problem with classifyIntance");
System.out.println(e.getMessage());
e.printStackTrace();
}
return dist;
default:
return dist;
}
}
public double classifyInstance(Instance instance) throws Exception {
double maxProb = -1;
double currentProb;
int maxIndex = 0;
int j;
for (j = 0; j < instance.numClasses(); j++) {
currentProb = getProbs(j, instance, 1);
if (Utils.gr(currentProb, maxProb)) {
maxIndex = j;
maxProb = currentProb;
}
}
return (double) maxIndex;
}
/**
* Classifies an instance.
*
* @param instance the instance to classify
* @return the classification
* @throws Exception if instance can't be classified successfully
*/
public double classifyInstance(Instance instance) throws Exception {
double maxProb = -1;
int maxIndex = 0;
// classify by maximum probability
double[] probs = distributionForInstance(instance);
for (int j = 0; j < instance.numClasses(); j++) {
if (Utils.gr(probs[j], maxProb)) {
maxIndex = j;
maxProb = probs[j];
}
}
return (double) maxIndex;
}
@Override
public double[] distributionForInstance(Instance instance) throws Exception {
double[] distribution = getClassifier().distributionForInstance(instance);
int maxIndex = 0;
for (int i = 0; i < distribution.length; i++) {
if (distribution[maxIndex] < distribution[i]) maxIndex = i;
}
final String maxLabel = instance.classAttribute().value(maxIndex);
if (sureClasses.contains(maxLabel)) {
Arrays.fill(distribution, 0.0);
distribution[maxIndex] = 1.0;
System.err.println("INFO: Hacked confidence of '" + maxLabel + "'.");
} else {
Arrays.fill(distribution, 1.0d / instance.numClasses());
}
return distribution;
}
/**
* Calculates the class membership probabilities for the given test instance.
*
* @param instance the instance to be classified
* @return predicted class probability distribution
* @exception Exception if distribution can't be computed successfully
*/
public double[] distributionForInstance(Instance instance) throws Exception {
if (instance.classAttribute().isNumeric()) {
throw new UnsupportedClassTypeException("Decorate can't handle a numeric class!");
}
double[] sums = new double[instance.numClasses()], newProbs;
Classifier curr;
for (int i = 0; i < m_Committee.size(); i++) {
curr = (Classifier) m_Committee.get(i);
newProbs = curr.distributionForInstance(instance);
for (int j = 0; j < newProbs.length; j++) sums[j] += newProbs[j];
}
if (Utils.eq(Utils.sum(sums), 0)) {
return sums;
} else {
Utils.normalize(sums);
return sums;
}
}
/**
* Calculates the class membership probabilities for the given test instance.
*
* @param instance the instance to be classified
* @return predicted class probability distribution
* @throws Exception if instance could not be classified successfully
*/
public double[] distributionForInstance(Instance instance) throws Exception {
double[] sums = new double[instance.numClasses()];
for (int i = -1; i < m_NumIterationsPerformed; i++) {
double prob = 1, shrinkage = m_Shrinkage;
if (i == -1) {
prob = m_ZeroR.distributionForInstance(instance)[0];
shrinkage = 1.0;
} else {
prob = m_Classifiers[i].distributionForInstance(instance)[0];
// Make sure that probabilities are never 0 or 1 using ad-hoc smoothing
prob = (m_SumOfWeights * prob + 1) / (m_SumOfWeights + 2);
}
sums[0] += shrinkage * 0.5 * (Math.log(prob) - Math.log(1 - prob));
}
sums[1] = -sums[0];
return Utils.logs2probs(sums);
}
/**
* Predicts the class memberships for a given instance. If an instance is unclassified, the
* returned array elements must be all zero. If the class is numeric, the array must consist of
* only one element, which contains the predicted value. Note that a classifier MUST implement
* either this or classifyInstance().
*
* @param instance the instance to be classified
* @return an array containing the estimated membership probabilities of the test instance in each
* class or the numeric prediction
* @exception Exception if distribution could not be computed successfully
*/
@Override
public double[] distributionForInstance(Instance instance) throws Exception {
double[] dist = new double[instance.numClasses()];
switch (instance.classAttribute().type()) {
case Attribute.NOMINAL:
double classification = classifyInstance(instance);
if (Utils.isMissingValue(classification)) {
return dist;
} else {
dist[(int) classification] = 1.0;
}
return dist;
case Attribute.NUMERIC:
case Attribute.DATE:
dist[0] = classifyInstance(instance);
return dist;
default:
return dist;
}
}
/**
* internal function for determining the class distribution for an instance, will be overridden by
* derived classes. <br>
* Here we just retrieve the class value for the given instance that was calculated during
* building our classifier. It just returns "1" for the class that was predicted, no real
* distribution. Note: the ReplaceMissingValues filter is applied to a copy of the given instance.
*
* @param instance the instance to get the distribution for
* @return the distribution for the given instance
* @see Classifier#distributionForInstance(Instance)
* @see ReplaceMissingValues
* @throws Exception if something goes wrong
*/
protected double[] getDistribution(Instance instance) throws Exception {
double[] result;
int i;
result = new double[instance.numClasses()];
for (i = 0; i < result.length; i++) result[i] = 0.0;
i = Arrays.binarySearch(m_LabeledTestset, instance, new InstanceComparator(false));
if (i >= 0) {
result[(int) m_LabeledTestset[i].classValue()] = 1.0;
} else {
CollectiveHelper.writeToTempFile("train.txt", m_TrainsetNew.toString());
CollectiveHelper.writeToTempFile("test.txt", m_TestsetNew.toString());
throw new Exception(
"Cannot find test instance: "
+ instance
+ "\n -> pos="
+ i
+ " = "
+ m_LabeledTestset[StrictMath.abs(i)]);
}
return result;
}
/**
* Calculates the class membership probabilities for the given test instance.
*
* @param instance the instance to be classified
* @return predicted class probability distribution
* @throws Exception if class is numeric
*/
public double[] distributionForInstance(Instance instance) throws Exception {
if (m_GroovyObject != null) return m_GroovyObject.distributionForInstance(instance);
else return new double[instance.numClasses()];
}