Example usage for weka.filters.unsupervised.attribute Reorder setAttributeIndicesArray

List of usage examples for weka.filters.unsupervised.attribute Reorder setAttributeIndicesArray

  1. HOME
  2. Java
  3. weka
  4. weka.filters.unsupervised.attribute.*
  5. Reorder
  6. setAttributeIndicesArray

Introduction

In this page you can find the example usage for weka.filters.unsupervised.attribute Reorder setAttributeIndicesArray.

Prototype

public void setAttributeIndicesArray(int[] attributes) throws Exception

Source Link

Document

Set which attributes are to be copied (or kept if invert is true)

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;/*w w  w . j av  a2 s. co  m*/
                if (trainingData.instance(i) instanceof SparseInstance) {
                    tempInstance = new SparseInstance(trainingData.instance(i));
                } else {
                    tempInstance = new DenseInstance(trainingData.instance(i));
                }

                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.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;//w  ww.  j  a v a2s.  co m
                if (trainingData.instance(i) instanceof SparseInstance) {
                    tempInstance = new SparseInstance(trainingData.instance(i));
                } else {
                    tempInstance = new DenseInstance(trainingData.instance(i));
                }

                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;/*from w ww.  ja  v a 2s.  co m*/
                if (trainingData.instance(i) instanceof SparseInstance) {
                    tempInstance = new SparseInstance(trainingData.instance(i));
                } else {
                    tempInstance = new DenseInstance(trainingData.instance(i));
                }

                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:wekimini.DataManager.java

private void updateFiltersForOutput(int output) throws Exception {
    Reorder r = new Reorder();
    Reorder s = new Reorder();

    int[] inputList = inputListsForOutputs.get(output); //includes only "selected" inputs
    int[] reordering = new int[inputList.length + 1];
    int[] saving = new int[numMetaData + inputList.length + 1];

    //Metadata/*from w  w w  .  j ava  2 s.c  o m*/
    for (int f = 0; f < numMetaData; f++) {
        saving[f] = f;
    }

    //Features
    for (int f = 0; f < inputList.length; f++) {
        reordering[f] = inputList[f] + numMetaData;
        saving[f + numMetaData] = inputList[f] + numMetaData;
    }

    //The actual "class" output
    reordering[reordering.length - 1] = numMetaData + numInputs + output;
    saving[saving.length - 1] = numMetaData + numInputs + output;

    r.setAttributeIndicesArray(reordering);
    r.setInputFormat(dummyInstances);

    s.setAttributeIndicesArray(saving);
    s.setInputFormat(dummyInstances);

    outputFilters[output] = r;
    savingFilters[output] = s;
}

From source file:wekimini.DataManager.java

private void setupFilters() throws Exception {
    outputFilters = new Reorder[numOutputs];
    savingFilters = new Reorder[numOutputs];

    for (int i = 0; i < numOutputs; i++) {
        Reorder r = new Reorder();
        Reorder s = new Reorder();

        int[] inputList = inputListsForOutputs.get(i);
        int[] reordering = new int[inputList.length + 1];
        int[] saving = new int[numMetaData + inputList.length + 1];

        //Metadata
        for (int f = 0; f < numMetaData; f++) {
            saving[f] = f;/*from  www . j a v  a 2s .co  m*/
        }

        //Features
        for (int f = 0; f < inputList.length; f++) {
            reordering[f] = inputList[f] + numMetaData;
            saving[f + numMetaData] = inputList[f] + numMetaData;
        }

        //The actual "class" output
        reordering[reordering.length - 1] = numMetaData + numInputs + i;
        saving[saving.length - 1] = numMetaData + numInputs + i;

        r.setAttributeIndicesArray(reordering);
        r.setInputFormat(dummyInstances);

        s.setAttributeIndicesArray(saving);
        s.setInputFormat(dummyInstances);

        outputFilters[i] = r;
        savingFilters[i] = s;
    }
}

From source file:wekimini.InputGenerator.java

public void buildDataset() throws Exception {
    int storedNumAttributes = storedInputs.numAttributes();
    String storedString = Integer.toString(storedNumAttributes);
    logger.log(Level.SEVERE, "storedInputs number attributes:{0}", storedString);

    int storedNumInstances = storedInputs.numInstances();
    String storedString2 = Integer.toString(storedNumInstances);
    logger.log(Level.SEVERE, "storedInputs number instances:{0}", storedString2);

    Reorder r = new Reorder();
    int[] reordering = new int[numInputs];

    for (int i = 0; i < numInputs; i++) {
        reordering[i] = i + numMetaData;
    }/*from ww  w  .  j  a  v  a2 s . c  om*/

    r.setAttributeIndicesArray(reordering);
    r.setInputFormat(storedInputs);

    dataset = Filter.useFilter(storedInputs, r);

    int datasetNumAttributes = dataset.numAttributes();
    String datasetString = Integer.toString(datasetNumAttributes);
    logger.log(Level.SEVERE, "Dataset number attributes:{0}", datasetString);

    int datasetNumInstances = dataset.numInstances();
    String datasetString2 = Integer.toString(datasetNumInstances);
    logger.log(Level.SEVERE, "Dataset number instances:{0}", datasetString2);

}