Example usage for weka.core Instance value

Introduction

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

Prototype

public double value(Attribute att);

Source Link

Document

Returns an instance's attribute value in internal format.

Usage

From source file:mulan.classifier.transformation.CalibratedLabelRanking.java

License:Open Source License

@Override
protected void buildInternal(MultiLabelInstances trainingSet) throws Exception {
    // Virtual label models
    debug("Building calibration label models");
    System.out.println("Building calibration label models");
    virtualLabelModels = new BinaryRelevance(getBaseClassifier());
    virtualLabelModels.setDebug(getDebug());
    virtualLabelModels.build(trainingSet);

    // One-vs-one models
    numModels = ((numLabels) * (numLabels - 1)) / 2;
    oneVsOneModels = AbstractClassifier.makeCopies(getBaseClassifier(), numModels);
    nodata = new boolean[numModels];
    metaDataTest = new Instances[numModels];

    Instances trainingData = trainingSet.getDataSet();

    int counter = 0;
    // Creation of one-vs-one models
    for (int label1 = 0; label1 < numLabels - 1; label1++) {
        // Attribute of label 1
        Attribute attrLabel1 = trainingData.attribute(labelIndices[label1]);
        for (int label2 = label1 + 1; label2 < numLabels; label2++) {
            debug("Building one-vs-one model " + (counter + 1) + "/" + numModels);
            System.out.println("Building one-vs-one model " + (counter + 1) + "/" + numModels);
            // Attribute of label 2
            Attribute attrLabel2 = trainingData.attribute(labelIndices[label2]);

            // initialize training set
            Instances dataOneVsOne = new Instances(trainingData, 0);
            // filter out examples with no preference
            for (int i = 0; i < trainingData.numInstances(); i++) {
                Instance tempInstance;
                if (trainingData.instance(i) instanceof SparseInstance) {
                    tempInstance = new SparseInstance(trainingData.instance(i));
                } else {
                    tempInstance = new DenseInstance(trainingData.instance(i));
                }/*from  w  w  w. j a  va 2  s  .  c  om*/

                int nominalValueIndex;
                nominalValueIndex = (int) tempInstance.value(labelIndices[label1]);
                String value1 = attrLabel1.value(nominalValueIndex);
                nominalValueIndex = (int) tempInstance.value(labelIndices[label2]);
                String value2 = attrLabel2.value(nominalValueIndex);

                if (!value1.equals(value2)) {
                    tempInstance.setValue(attrLabel1, value1);
                    dataOneVsOne.add(tempInstance);
                }
            }

            // remove all labels apart from label1 and place it at the end
            Reorder filter = new Reorder();
            int numPredictors = trainingData.numAttributes() - numLabels;
            int[] reorderedIndices = new int[numPredictors + 1];
            for (int i = 0; i < numPredictors; i++) {
                reorderedIndices[i] = featureIndices[i];
            }
            reorderedIndices[numPredictors] = labelIndices[label1];
            filter.setAttributeIndicesArray(reorderedIndices);
            filter.setInputFormat(dataOneVsOne);
            dataOneVsOne = Filter.useFilter(dataOneVsOne, filter);
            //System.out.println(dataOneVsOne.toString());
            dataOneVsOne.setClassIndex(numPredictors);

            // build model label1 vs label2
            if (dataOneVsOne.size() > 0) {
                oneVsOneModels[counter].buildClassifier(dataOneVsOne);
            } else {
                nodata[counter] = true;
            }
            dataOneVsOne.delete();
            metaDataTest[counter] = dataOneVsOne;
            counter++;
        }
    }
}

From source file:mulan.classifier.transformation.MultiLabelStacking.java

License:Open Source License

@Override
protected MultiLabelOutput makePredictionInternal(Instance instance) throws Exception {
    boolean[] bipartition = new boolean[numLabels];
    // the confidences given as final output
    double[] metaconfidences = new double[numLabels];
    // the confidences produced by the first level ensemble of classfiers
    double[] confidences = new double[numLabels];

    if (!(baseClassifier instanceof IBk)) {
        // getting the confidences for each label
        for (int labelIndex = 0; labelIndex < numLabels; labelIndex++) {
            Instance newInstance = BinaryRelevanceTransformation.transformInstance(instance, labelIndices,
                    labelIndices[labelIndex]);
            newInstance.setDataset(baseLevelData[labelIndex]);

            double distribution[] = new double[2];
            distribution = baseLevelEnsemble[labelIndex].distributionForInstance(newInstance);

            // Ensure correct predictions both for class values {0,1} and
            // {1,0}
            Attribute classAttribute = baseLevelData[labelIndex].classAttribute();
            // The confidence of the label being equal to 1
            confidences[labelIndex] = distribution[classAttribute.indexOfValue("1")];
        }//w  w  w  . ja v a 2 s  . co  m
    } else {
        // old way using brknn
        // MultiLabelOutput prediction = brknn.makePrediction(instance);
        // confidences = prediction.getConfidences();

        // new way
        int numOfNeighbors = ((IBk) baseClassifier).getKNN();
        Instances knn = new Instances(lnn.kNearestNeighbours(instance, numOfNeighbors));

        /*
         * Get the label confidence vector.
         */
        for (int i = 0; i < numLabels; i++) {
            // compute sum of counts for each label in KNN
            double count_for_label_i = 0;
            for (int k = 0; k < numOfNeighbors; k++) {
                double value = Double.parseDouble(
                        train.attribute(labelIndices[i]).value((int) knn.instance(k).value(labelIndices[i])));
                if (Utils.eq(value, 1.0)) {
                    count_for_label_i++;
                }
            }

            confidences[i] = count_for_label_i / numOfNeighbors;

        }
    }
    // System.out.println(Utils.arrayToString(confidences));
    /* creation of the meta-instance with the appropriate values */
    double[] values = new double[numLabels + 1];

    if (includeAttrs) {
        values = new double[instance.numAttributes() + 1];
        // Copy the original features
        for (int m = 0; m < featureIndices.length; m++) {
            values[m] = instance.value(featureIndices[m]);
        }
        // Copy the label confidences as additional features
        for (int m = 0; m < confidences.length; m++) {
            values[instance.numAttributes() - numLabels + m] = confidences[m];
        }
    } else {
        for (int m = 0; m < confidences.length; m++) {
            values[m] = confidences[m];
        }
    }

    /* application of the meta-level ensemble to the metaInstance */
    for (int labelIndex = 0; labelIndex < numLabels; labelIndex++) {
        // values[values.length - 1] =
        // instance.value(instance.numAttributes() - numLabels +
        // labelIndex);
        values[values.length - 1] = 0;
        Instance newmetaInstance = DataUtils.createInstance(instance, 1, values);

        double distribution[] = new double[2];
        try {
            distribution = metaLevelFilteredEnsemble[labelIndex].distributionForInstance(newmetaInstance);
        } catch (Exception e) {
            System.out.println(e);
            return null;
        }
        int maxIndex = (distribution[0] > distribution[1]) ? 0 : 1;

        // Ensure correct predictions both for class values {0,1} and {1,0}
        Attribute classAttribute = metaLevelData[labelIndex].classAttribute();
        bipartition[labelIndex] = (classAttribute.value(maxIndex).equals("1")) ? true : false;

        // The confidence of the label being equal to 1
        metaconfidences[labelIndex] = distribution[classAttribute.indexOfValue("1")];
    }

    MultiLabelOutput mlo = new MultiLabelOutput(bipartition, metaconfidences);
    return mlo;
}

From source file:mulan.classifier.transformation.TwoStageClassifierChainArchitecture.java

License:Open Source License

@Override
protected void buildInternal(MultiLabelInstances trainingSet) throws Exception {
    // Virtual label models
    debug("Building calibration label models");
    virtualLabelModels = new BinaryRelevance(getBaseClassifier());
    virtualLabelModels.setDebug(getDebug());
    virtualLabelModels.build(trainingSet);

    //Generate the chain: Test the same dataset
    MultiLabelInstances tempTrainingSet = GenerateChain(trainingSet);

    labelIndices = tempTrainingSet.getLabelIndices();
    featureIndices = tempTrainingSet.getFeatureIndices();

    // One-vs-one models
    numModels = ((numLabels) * (numLabels - 1)) / 2;
    oneVsOneModels = AbstractClassifier.makeCopies(getBaseClassifier(), numModels);
    nodata = new boolean[numModels];
    metaDataTest = new Instances[numModels];

    Instances trainingData = tempTrainingSet.getDataSet();

    int counter = 0;
    // Creation of one-vs-one models
    for (int label1 = 0; label1 < numLabels - 1; label1++) {
        // Attribute of label 1
        Attribute attrLabel1 = trainingData.attribute(labelIndices[label1]);
        for (int label2 = label1 + 1; label2 < numLabels; label2++) {
            debug("Building one-vs-one model " + (counter + 1) + "/" + numModels);
            // Attribute of label 2
            Attribute attrLabel2 = trainingData.attribute(labelIndices[label2]);

            // initialize training set
            Instances dataOneVsOne = new Instances(trainingData, 0);
            // filter out examples with no preference
            for (int i = 0; i < trainingData.numInstances(); i++) {
                Instance tempInstance;
                if (trainingData.instance(i) instanceof SparseInstance) {
                    tempInstance = new SparseInstance(trainingData.instance(i));
                } else {
                    tempInstance = new DenseInstance(trainingData.instance(i));
                }/*from   w w w. j  a  va  2  s . c om*/

                int nominalValueIndex;
                nominalValueIndex = (int) tempInstance.value(labelIndices[label1]);
                String value1 = attrLabel1.value(nominalValueIndex);
                nominalValueIndex = (int) tempInstance.value(labelIndices[label2]);
                String value2 = attrLabel2.value(nominalValueIndex);

                if (!value1.equals(value2)) {
                    tempInstance.setValue(attrLabel1, value1);
                    dataOneVsOne.add(tempInstance);
                }
            }

            // remove all labels apart from label1 and place it at the end
            Reorder filter = new Reorder();
            int numPredictors = trainingData.numAttributes() - numLabels;
            int[] reorderedIndices = new int[numPredictors + 1];

            System.arraycopy(featureIndices, 0, reorderedIndices, 0, numPredictors);
            reorderedIndices[numPredictors] = labelIndices[label1];
            filter.setAttributeIndicesArray(reorderedIndices);
            filter.setInputFormat(dataOneVsOne);
            dataOneVsOne = Filter.useFilter(dataOneVsOne, filter);
            //System.out.println(dataOneVsOne.toString());
            dataOneVsOne.setClassIndex(numPredictors);

            // build model label1 vs label2
            if (dataOneVsOne.size() > 0) {
                oneVsOneModels[counter].buildClassifier(dataOneVsOne);
            } else {
                nodata[counter] = true;
            }
            dataOneVsOne.delete();
            metaDataTest[counter] = dataOneVsOne;
            counter++;
        }
    }
}

From source file:mulan.classifier.transformation.TwoStagePrunedClassifierChainArchitecture.java

License:Open Source License

@Override
protected void buildInternal(MultiLabelInstances trainingSet) throws Exception {
    // Virtual label models
    debug("Building calibration label models");
    virtualLabelModels = new BinaryRelevance(getBaseClassifier());
    virtualLabelModels.setDebug(getDebug());
    virtualLabelModels.build(trainingSet);

    // One-vs-one models
    numModels = ((numLabels) * (numLabels - 1)) / 2;
    oneVsOneModels = AbstractClassifier.makeCopies(getBaseClassifier(), numModels);
    nodata = new boolean[numModels];
    metaDataTest = new Instances[numModels];

    ArrayList<MultiLabelOutput> predictions;
    predictions = predictLabels(trainingSet);

    int counter = 0;
    // Creation of one-vs-one models
    for (int label1 = 0; label1 < numLabels - 1; label1++) {
        for (int label2 = label1 + 1; label2 < numLabels; label2++) {
            //Generate the chain: Test the same dataset
            MultiLabelInstances tempTrainingSet = GenerateChain(trainingSet, label1, label2, predictions);

            Instances trainingData = tempTrainingSet.getDataSet();

            labelIndices = tempTrainingSet.getLabelIndices();
            featureIndices = tempTrainingSet.getFeatureIndices();

            // Attribute of label 1
            Attribute attrLabel1 = trainingData.attribute(labelIndices[label1]);

            debug("Building one-vs-one model " + (counter + 1) + "/" + numModels);
            // Attribute of label 2
            Attribute attrLabel2 = trainingData.attribute(labelIndices[label2]);

            // initialize training set
            Instances dataOneVsOne = new Instances(trainingData, 0);
            // filter out examples with no preference
            for (int i = 0; i < trainingData.numInstances(); i++) {
                Instance tempInstance;
                if (trainingData.instance(i) instanceof SparseInstance) {
                    tempInstance = new SparseInstance(trainingData.instance(i));
                } else {
                    tempInstance = new DenseInstance(trainingData.instance(i));
                }//w  ww .  j  a  v a 2  s . c om

                int nominalValueIndex;
                nominalValueIndex = (int) tempInstance.value(labelIndices[label1]);
                String value1 = attrLabel1.value(nominalValueIndex);
                nominalValueIndex = (int) tempInstance.value(labelIndices[label2]);
                String value2 = attrLabel2.value(nominalValueIndex);

                if (!value1.equals(value2)) {
                    tempInstance.setValue(attrLabel1, value1);
                    dataOneVsOne.add(tempInstance);
                }
            }

            // remove all labels apart from label1 and place it at the end
            Reorder filter = new Reorder();
            int numPredictors = trainingData.numAttributes() - numLabels;
            int[] reorderedIndices = new int[numPredictors + 1];
            System.arraycopy(featureIndices, 0, reorderedIndices, 0, numPredictors);
            reorderedIndices[numPredictors] = labelIndices[label1];
            filter.setAttributeIndicesArray(reorderedIndices);
            filter.setInputFormat(dataOneVsOne);
            dataOneVsOne = Filter.useFilter(dataOneVsOne, filter);
            //System.out.println(dataOneVsOne.toString());
            dataOneVsOne.setClassIndex(numPredictors);

            // build model label1 vs label2
            if (dataOneVsOne.size() > 0) {
                oneVsOneModels[counter].buildClassifier(dataOneVsOne);
            } else {
                nodata[counter] = true;
            }
            dataOneVsOne.delete();
            metaDataTest[counter] = dataOneVsOne;
            counter++;
        }
    }
}

From source file:mulan.data.IterativeStratification.java

License:Open Source License

private boolean[] getTrueLabels(Instance instance, int numLabels, int[] labelIndices) {

    boolean[] trueLabels = new boolean[numLabels];
    for (int counter = 0; counter < numLabels; counter++) {
        int classIdx = labelIndices[counter];
        String classValue = instance.attribute(classIdx).value((int) instance.value(classIdx));
        trueLabels[counter] = classValue.equals("1");
    }/*w  w  w .j av  a2  s.c  o m*/

    return trueLabels;
}

From source file:mulan.transformations.BinaryRelevanceTransformation.java

License:Open Source License

/**
 * Remove all label attributes except label at position indexToKeep
 * @param instance /*from  w  ww  .  ja va  2s  .  com*/
 * @param labelIndices 
 * @param indexToKeep 
 * @return transformed Instance
 */
public static Instance transformInstance(Instance instance, int[] labelIndices, int indexToKeep) {
    double[] values = instance.toDoubleArray();
    double[] transformedValues = new double[values.length - labelIndices.length + 1];

    int counterTransformed = 0;
    boolean isLabel = false;

    for (int i = 0; i < values.length; i++) {
        for (int j = 0; j < labelIndices.length; j++) {
            if (i == labelIndices[j] && i != indexToKeep) {
                isLabel = true;
                break;
            }
        }

        if (!isLabel) {
            transformedValues[counterTransformed] = instance.value(i);
            counterTransformed++;
        }
        isLabel = false;
    }

    Instance transformedInstance = DataUtils.createInstance(instance, 1, transformedValues);
    return transformedInstance;
}

From source file:mulan.transformations.multiclass.Copy.java

License:Open Source License

/**
 * Transforms a multi-label instance to a list of single-label instances,
 * one for each of the labels that annotate the instance, by copying the
 * feature vector/*from w  ww .jav a 2 s. c o  m*/
 *
 * @param instance a multi-label instance
 * @return a list with the transformed single-label instances
 */
List<Instance> transformInstance(Instance instance) {
    List<Instance> result = new ArrayList<Instance>();
    for (int counter = 0; counter < numOfLabels; counter++) {
        if (instance.attribute(labelIndices[counter]).value((int) instance.value(labelIndices[counter]))
                .equals("1")) {
            Instance transformed = null;
            try {
                transformed = RemoveAllLabels.transformInstance(instance, labelIndices);
                transformed.setDataset(null);
                transformed.insertAttributeAt(transformed.numAttributes());
                transformed.setValue(transformed.numAttributes() - 1, counter);
            } catch (Exception ex) {
                Logger.getLogger(Copy.class.getName()).log(Level.SEVERE, null, ex);
            }
            result.add(transformed);
        }
    }
    return result;
}

From source file:mulan.transformations.multiclass.Ignore.java

License:Open Source License

/**
 * Transforms a multi-label example with a single annotation to a
 * single-label example and ignores multi-label example with more
 * annotations/*w  w  w .j  a  va2 s.  com*/
 *
 * @param instance a multi-label example
 * @return a list that is either empty or contains the transformed
 * single-label example
 */
List<Instance> transformInstance(Instance instance) {
    List<Instance> result = new ArrayList<Instance>();
    int indexOfSingleLabel = -1;
    int counter = 0;
    for (int labelCounter = 0; labelCounter < numOfLabels; labelCounter++) {
        int index = labelIndices[labelCounter];
        if (instance.attribute(index).value((int) instance.value(index)).equals("1")) {
            counter++;
            indexOfSingleLabel = labelCounter;
        }
        if (counter > 1) {
            break;
        }
    }
    if (counter > 1 || counter == 0) {
        return result;
    }

    Instance transformedInstance;
    try {
        transformedInstance = RemoveAllLabels.transformInstance(instance, labelIndices);
        transformedInstance.setDataset(null);
        transformedInstance.insertAttributeAt(transformedInstance.numAttributes());
        transformedInstance.setValue(transformedInstance.numAttributes() - 1, indexOfSingleLabel);
        result.add(transformedInstance);
    } catch (Exception ex) {
        Logger.getLogger(Ignore.class.getName()).log(Level.SEVERE, null, ex);
    }
    return result;
}

From source file:mulan.transformations.multiclass.SelectBasedOnFrequency.java

License:Open Source License

/**
 * Transforms a multi-label example to a list containing a single-label
 * multi-class example by selecting the most/least frequent label in the 
 * training set//from w  w w.ja v  a 2 s  .c  o m
 *
 * @param instance
 * @return
 */
List<Instance> transformInstance(Instance instance) {
    int value = labelOccurance[0];
    int labelSelected = 0;
    for (int counter = 1; counter < numOfLabels; counter++) {
        if (instance.attribute(labelIndices[counter]).value((int) instance.value(labelIndices[counter]))
                .equals("1")) {
            boolean test = false;
            switch (type) {
            case MIN:
                test = labelOccurance[counter] < value ? true : false;
                break;
            case MAX:
                test = labelOccurance[counter] > value ? true : false;
                break;
            }

            if (test) {
                value = labelOccurance[counter];
                labelSelected = counter;
            }
        }
    }

    Instance transformed = null;
    try {
        transformed = RemoveAllLabels.transformInstance(instance, labelIndices);
        transformed.setDataset(null);
        transformed.insertAttributeAt(transformed.numAttributes());
        transformed.setValue(transformed.numAttributes() - 1, labelSelected);
    } catch (Exception ex) {
        Logger.getLogger(Copy.class.getName()).log(Level.SEVERE, null, ex);
    }

    List<Instance> result = new ArrayList<Instance>();
    result.add(transformed);
    return result;
}

From source file:mulan.transformations.multiclass.SelectRandom.java

License:Open Source License

/**
 * Transforms a multi-label example to a list containing a single-label
 * multi-class example by randomly selecting one of the labels
 * // w  ww .  j  a  v  a 2s  . co m
 * @param instance the multi-label example
 * @return the list with the single-label multi-class example
 */
List<Instance> transformInstance(Instance instance) {
    ArrayList<Integer> labels = new ArrayList<Integer>();
    for (int counter = 0; counter < numOfLabels; counter++) {
        if (instance.attribute(labelIndices[counter]).value((int) instance.value(labelIndices[counter]))
                .equals("1")) {
            labels.add(counter);
        }
    }

    int randomLabel = labels.get((int) (Math.random() * labels.size()));

    Instance transformed = null;
    try {
        transformed = RemoveAllLabels.transformInstance(instance, labelIndices);
        transformed.setDataset(null);
        transformed.insertAttributeAt(transformed.numAttributes());
        transformed.setValue(transformed.numAttributes() - 1, randomLabel);
    } catch (Exception ex) {
        Logger.getLogger(Copy.class.getName()).log(Level.SEVERE, null, ex);
    }

    List<Instance> result = new ArrayList<Instance>();
    result.add(transformed);
    return result;
}