Example usage for weka.core Instance classAttribute

Introduction

In this page you can find the example usage for weka.core Instance classAttribute.

Prototype

public Attribute classAttribute();

Source Link

Document

Returns class attribute.

Usage

From source file:Bilbo.java

License:Open Source License

/**
 * Calculates the class membership probabilities for the given test
 * instance.// w w w .j ava  2s.  com
 *
 * @param instance the instance to be classified
 * @return preedicted class probability distribution
 * @throws Exception if distribution can't be computed successfully 
 */
@Override
public double[] distributionForInstance(Instance instance) throws Exception {

    double[] sums = new double[instance.numClasses()], newProbs;

    double numPreds = 0;
    for (int i = 0; i < m_NumIterations; i++) {
        if (instance.classAttribute().isNumeric() == true) {
            double pred = ((NewTree) m_Classifiers[i]).classifyInstance(instance);
            if (!Utils.isMissingValue(pred)) {
                sums[0] += pred;
                numPreds++;
            }
        } else {
            newProbs = ((NewTree) m_Classifiers[i]).distributionForInstance(instance);
            for (int j = 0; j < newProbs.length; j++)
                sums[j] += newProbs[j];
        }
    }
    if (instance.classAttribute().isNumeric() == true) {
        if (numPreds == 0) {
            sums[0] = Utils.missingValue();
        } else {
            sums[0] /= numPreds;
        }
        return sums;
    } else if (Utils.eq(Utils.sum(sums), 0)) {
        return sums;
    } else {
        Utils.normalize(sums);
        return sums;
    }
}

---

From source file:DocClassifier.java

public Evaluation classify(Classifier classifier) throws Exception {
    docPredList.clear();/*from   ww  w  .  ja va 2s  .  com*/
    Instances testInstances = createInstances(testFiles);
    Instances trainInstances = createInstances(trainFiles);
    classifier.buildClassifier(trainInstances);
    Evaluation ev = new Evaluation(trainInstances);
    for (int i = 0; i < testInstances.numInstances(); ++i) {
        Instance inst = testInstances.instance(i);
        double pred = ev.evaluateModelOnceAndRecordPrediction(classifier, inst);
        docPredList.add(testFiles[i].getName() + "\t=>\t" + inst.classAttribute().value((int) pred));
    }
    return ev;
}

---

From source file:BaggingImprove.java

/**
 * Calculates the class membership probabilities for the given test
 * instance.//from   w w w.j  av  a 2 s  . c o  m
 *
 * @param instance the instance to be classified
 * @return predicted class probability distribution
 * @throws Exception if distribution can't be computed successfully
 */
@Override
public double[] distributionForInstance(Instance instance) throws Exception {

    double[] sums = new double[instance.numClasses()], newProbs;
    //-
    //System.out.println("\nDistribution For Instance\n");
    for (int i = 0; i < m_NumIterations; i++) {
        if (instance.classAttribute().isNumeric() == true) {
            //System.out.println(m_Classifiers[i].classifyInstance(instance));
            sums[0] += m_Classifiers[i].classifyInstance(instance);
        } else {
            //System.out.println(m_Classifiers[i].distributionForInstance(instance));
            newProbs = m_Classifiers[i].distributionForInstance(instance);
            //-
            //                for (int j = 0; j < newProbs.length; j++) {
            //                    sums[j] += newProbs[j];
            //                    System.out.println("Sums "+sums[j]);
            //                }
            //+

        }
    }
    if (instance.classAttribute().isNumeric() == true) {
        sums[0] /= m_NumIterations;
        return sums;
    } else if (Utils.eq(Utils.sum(sums), 0)) {
        return sums;
    } else {
        Utils.normalize(sums);
        return sums;
    }
}

---

From source file:MPCKMeans.java

License:Open Source License

/** Outputs the current clustering
 *
 * @exception Exception if something goes wrong
 *///from   ww  w .j  a v  a2  s.c  o m
public void printIndexClusters() throws Exception {
    if (m_IndexClusters == null)
        throw new Exception("Clusters were not created");

    for (int i = 0; i < m_NumClusters; i++) {
        HashSet cluster = m_IndexClusters[i];
        if (cluster == null) {
            System.out.println("Cluster " + i + " is null");
        } else {
            System.out.println("Cluster " + i + " consists of " + cluster.size() + " elements");
            Iterator iter = cluster.iterator();
            while (iter.hasNext()) {
                int idx = ((Integer) iter.next()).intValue();
                Instance inst = m_TotalTrainWithLabels.instance(idx);
                if (m_TotalTrainWithLabels.classIndex() >= 0) {
                    System.out
                            .println("\t\t" + idx + ":" + inst.classAttribute().value((int) inst.classValue()));
                }
            }
        }
    }
}

---

From source file:adams.data.conversion.WekaPredictionContainerToSpreadSheet.java

License:Open Source License

/**
 * Performs the actual conversion./*from  w w  w  .  ja  va2 s  .c  om*/
 *
 * @return      the converted data
 * @throws Exception   if something goes wrong with the conversion
 */
@Override
protected Object doConvert() throws Exception {
    SpreadSheet result;
    WekaPredictionContainer cont;
    Row row;
    double[] dist;
    double[] distSorted;
    int[] distIndex;
    int i;
    String entry;
    Instance inst;
    String label;
    List<SortContainer> dists;

    result = new DefaultSpreadSheet();
    cont = (WekaPredictionContainer) m_Input;

    // header
    row = result.getHeaderRow();
    row.addCell(COLUMN_NAME).setContent(m_TitleNameColumn);
    row.addCell(COLUMN_VALUE).setContent(m_TitleValueColumn);

    // data
    if (m_AddClassification && cont.hasValue(WekaPredictionContainer.VALUE_CLASSIFICATION)) {
        row = result.addRow("" + result.getRowCount());
        row.addCell(COLUMN_NAME).setContent(m_ClassificationEntry);
        row.addCell(COLUMN_VALUE)
                .setContent((Double) cont.getValue(WekaPredictionContainer.VALUE_CLASSIFICATION));
    }
    if (m_AddClassificationLabel && cont.hasValue(WekaPredictionContainer.VALUE_CLASSIFICATION_LABEL)) {
        row = result.addRow("" + result.getRowCount());
        row.addCell(COLUMN_NAME).setContent(m_ClassificationLabelEntry);
        row.addCell(COLUMN_VALUE)
                .setContent((String) cont.getValue(WekaPredictionContainer.VALUE_CLASSIFICATION_LABEL));
    }
    if (m_AddDistribution && cont.hasValue(WekaPredictionContainer.VALUE_DISTRIBUTION)) {
        dist = (double[]) cont.getValue(WekaPredictionContainer.VALUE_DISTRIBUTION);
        distIndex = new int[dist.length];
        for (i = 0; i < dist.length; i++)
            distIndex[i] = i;
        // sort?
        if (m_DistributionSorting != Sorting.NONE) {
            dists = new ArrayList<SortContainer>();
            for (i = 0; i < dist.length; i++) {
                if (m_DistributionSorting == Sorting.DESCENDING)
                    dists.add(new SortContainer(distIndex[i], 1.0 - dist[i]));
                else
                    dists.add(new SortContainer(distIndex[i], dist[i]));
            }
            Collections.sort(dists);
            distSorted = new double[dist.length];
            for (i = 0; i < dists.size(); i++) {
                distSorted[i] = dist[dists.get(i).getIndex()];
                distIndex[i] = dists.get(i).getIndex();
            }
            dist = distSorted;
        }

        inst = (Instance) cont.getValue(WekaPredictionContainer.VALUE_INSTANCE);
        for (i = 0; i < dist.length; i++) {
            entry = m_DistributionFormat;
            entry = entry.replace(PLACEHOLDER_INDEX, "" + (distIndex[i] + 1));
            if (inst == null)
                label = "" + (distIndex[i] + 1);
            else
                label = inst.classAttribute().value(distIndex[i]);
            entry = entry.replace(PLACEHOLDER_LABEL, label);
            row = result.addRow("" + result.getRowCount());
            row.addCell(COLUMN_NAME).setContent(entry);
            row.addCell(COLUMN_VALUE).setContent(dist[i]);
        }
    }

    return result;
}

---

From source file:adams.flow.condition.bool.WekaClassification.java

License:Open Source License

/**
 * Returns the index of the case that should get executed.
 * // w w  w. j ava  2 s.  co  m
 * @param owner   the owning actor
 * @param token   the current token passing through the actor
 * @return      the index, -1 if not available
 */
public int getCaseIndex(Actor owner, Token token) {
    int result;
    double classification;
    String msg;
    Instance inst;

    result = -1;

    if (m_OnTheFly && (m_Model == null)) {
        msg = setUpModel(owner);
        if (msg != null) {
            getLogger().severe(msg);
            return result;
        }
    }

    if ((token != null) && (token.getPayload() != null)) {
        inst = ((Instance) token.getPayload());
        if (inst.classIndex() == -1) {
            getLogger().severe("No class set!");
            return result;
        }
        if (!inst.classAttribute().isNominal()) {
            getLogger().severe("Class attribute is not nominal!");
            return result;
        }

        try {
            classification = m_Model.classifyInstance(inst);
            if (Utils.isMissingValue(classification))
                result = -1;
            else
                result = (int) classification;
        } catch (Exception e) {
            getLogger().log(Level.SEVERE, "Failed to obtain classification: ", e);
        }
    }

    return result;
}

---

From source file:adams.flow.condition.bool.WekaClassification.java

License:Open Source License

/**
 * Returns the index of the default case.
 * //from  w  w  w.  j  a  va  2 s  .co m
 * @param owner   the owning actor
 * @param token   the current token passing through the actor
 * @return      the index, -1 if not available
 */
public int getDefaultCaseIndex(Actor owner, Token token) {
    Instance inst;

    inst = ((Instance) token.getPayload());

    return inst.classAttribute().numValues();
}

---

From source file:adams.flow.container.WekaPredictionContainer.java

License:Open Source License

/**
 * Initializes the container./*www.ja v  a 2  s.co m*/
 *
 * @param inst   the instance that was used for prediction
 * @param cls      the classification
 * @param dist   the class distribution
 * @param rangeCheck   the range check, null if not available
 */
public WekaPredictionContainer(Instance inst, double cls, double[] dist, String rangeCheck) {
    super();

    if (inst != null)
        store(VALUE_INSTANCE, inst.copy());
    store(VALUE_CLASSIFICATION, cls);
    store(VALUE_DISTRIBUTION, dist.clone());
    if ((inst != null) && inst.classAttribute().isNominal())
        store(VALUE_CLASSIFICATION_LABEL, inst.classAttribute().value((int) cls));
    if (rangeCheck != null)
        store(VALUE_RANGECHECK, rangeCheck);
}

---

From source file:adams.flow.transformer.WekaClassifying.java

License:Open Source License

/**
 * Processes the instance and generates the output token.
 *
 * @param inst   the instance to process
 * @return      the generated output token (e.g., container)
 * @throws Exception   if processing fails
 *///from   w w w . j  av a 2  s .c om
@Override
protected Token processInstance(Instance inst) throws Exception {
    Token result;
    WekaPredictionContainer cont;
    List<String> rangeChecks;
    String rangeCheck;
    AbstainingClassifier abstain;
    double classification;
    double[] distribution;

    synchronized (m_Model) {
        // does the classifier support range checks?
        rangeCheck = null;
        if (m_Model instanceof RangeCheckClassifier) {
            rangeChecks = ((RangeCheckClassifier) m_Model).checkRangeForInstance(inst);
            if (rangeChecks.size() > 0)
                rangeCheck = Utils.flatten(rangeChecks, "\n");
        }

        if (inst.classAttribute().isNumeric()) {
            classification = m_Model.classifyInstance(inst);
            distribution = new double[] { classification };
        } else {
            distribution = m_Model.distributionForInstance(inst);
            classification = StatUtils.maxIndex(distribution);
            if (distribution[(int) Math.round(classification)] == 0)
                classification = weka.core.Utils.missingValue();
        }
        cont = new WekaPredictionContainer(inst, classification, distribution, rangeCheck);

        // abstaining classifier?
        if (m_Model instanceof AbstainingClassifier) {
            abstain = (AbstainingClassifier) m_Model;
            if (abstain.canAbstain()) {
                if (inst.classAttribute().isNumeric()) {
                    classification = abstain.getAbstentionClassification(inst);
                    distribution = new double[] { classification };
                } else {
                    distribution = abstain.getAbstentionDistribution(inst);
                    classification = StatUtils.maxIndex(distribution);
                    if (distribution[(int) Math.round(classification)] == 0)
                        classification = weka.core.Utils.missingValue();
                }
                cont.setValue(WekaPredictionContainer.VALUE_ABSTENTION_CLASSIFICATION, classification);
                if (inst.classAttribute().isNominal() && !weka.core.Utils.isMissingValue(classification))
                    cont.setValue(WekaPredictionContainer.VALUE_ABSTENTION_CLASSIFICATION_LABEL,
                            inst.classAttribute().value((int) Math.round(classification)));
                cont.setValue(WekaPredictionContainer.VALUE_ABSTENTION_DISTRIBUTION, distribution);
            }
        }
    }

    if (m_OutputInstance) {
        inst = (Instance) ((Instance) cont.getValue(WekaPredictionContainer.VALUE_INSTANCE)).copy();
        inst.setClassValue((Double) cont.getValue(WekaPredictionContainer.VALUE_CLASSIFICATION));
        result = new Token(inst);
    } else {
        result = new Token((WekaPredictionContainer) cont);
    }

    return result;
}

---

From source file:ann.MyANN.java

/**
 * mengubah Instance menjadi Data//from w w  w . j ava 2  s . c o m
 * @param instance Instance yang akan diubah menjadi kelas Data
 * @return kelas Data dari input
 */
private Data instanceToData(Instance instance) {
    ArrayList<Double> input = new ArrayList<>();
    ArrayList<Double> target = new ArrayList<>();
    for (int j = 0; j < instance.numAttributes() - 1; j++) {
        input.add(0.0);
    }
    if (instance.classAttribute().isNominal()) {
        for (int j = 0; j < instance.classAttribute().numValues(); j++) {
            target.add(0.0);
        }
    } else {
        target.add(0.0);
    }
    for (int j = 0; j < instance.numAttributes(); j++) {
        if (j == instance.classIndex()) {
            if (instance.attribute(j).isNominal())
                target.set((int) instance.value(j), 1.0);
            else
                target.add(instance.value(j));
        } else {
            input.set(j, instance.value(j));
        }
    }
    return new Data(input, target);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »