Example usage for weka.filters.unsupervised.instance RemoveWithValues setInvertSelection

List of usage examples for weka.filters.unsupervised.instance RemoveWithValues setInvertSelection

Introduction

In this page you can find the example usage for weka.filters.unsupervised.instance RemoveWithValues setInvertSelection.

Prototype

public void setInvertSelection(boolean invert) 

Source Link

Document

Set whether selected values should be removed or kept.

Usage

From source file:MultiClassClassifier.java

License:Open Source License

/**
 * Builds the classifiers.//from w  w w .j  a  v a2s .c  o  m
 *
 * @param insts the training data.
 * @throws Exception if a classifier can't be built
 */
public void buildClassifier(Instances insts) throws Exception {

    Instances newInsts;

    // can classifier handle the data?
    getCapabilities().testWithFail(insts);

    // remove instances with missing class
    insts = new Instances(insts);
    insts.deleteWithMissingClass();

    if (m_Classifier == null) {
        throw new Exception("No base classifier has been set!");
    }
    m_ZeroR = new ZeroR();
    m_ZeroR.buildClassifier(insts);

    m_TwoClassDataset = null;

    int numClassifiers = insts.numClasses();
    if (numClassifiers <= 2) {

        m_Classifiers = Classifier.makeCopies(m_Classifier, 1);
        m_Classifiers[0].buildClassifier(insts);

        m_ClassFilters = null;

    } else if (m_Method == METHOD_1_AGAINST_1) {
        // generate fastvector of pairs
        FastVector pairs = new FastVector();
        for (int i = 0; i < insts.numClasses(); i++) {
            for (int j = 0; j < insts.numClasses(); j++) {
                if (j <= i)
                    continue;
                int[] pair = new int[2];
                pair[0] = i;
                pair[1] = j;
                pairs.addElement(pair);
            }
        }

        numClassifiers = pairs.size();
        m_Classifiers = Classifier.makeCopies(m_Classifier, numClassifiers);
        m_ClassFilters = new Filter[numClassifiers];
        m_SumOfWeights = new double[numClassifiers];

        // generate the classifiers
        for (int i = 0; i < numClassifiers; i++) {
            RemoveWithValues classFilter = new RemoveWithValues();
            classFilter.setAttributeIndex("" + (insts.classIndex() + 1));
            classFilter.setModifyHeader(true);
            classFilter.setInvertSelection(true);
            classFilter.setNominalIndicesArr((int[]) pairs.elementAt(i));
            Instances tempInstances = new Instances(insts, 0);
            tempInstances.setClassIndex(-1);
            classFilter.setInputFormat(tempInstances);
            newInsts = Filter.useFilter(insts, classFilter);
            if (newInsts.numInstances() > 0) {
                newInsts.setClassIndex(insts.classIndex());
                m_Classifiers[i].buildClassifier(newInsts);
                m_ClassFilters[i] = classFilter;
                m_SumOfWeights[i] = newInsts.sumOfWeights();
            } else {
                m_Classifiers[i] = null;
                m_ClassFilters[i] = null;
            }
        }

        // construct a two-class header version of the dataset
        m_TwoClassDataset = new Instances(insts, 0);
        int classIndex = m_TwoClassDataset.classIndex();
        m_TwoClassDataset.setClassIndex(-1);
        m_TwoClassDataset.deleteAttributeAt(classIndex);
        FastVector classLabels = new FastVector();
        classLabels.addElement("class0");
        classLabels.addElement("class1");
        m_TwoClassDataset.insertAttributeAt(new Attribute("class", classLabels), classIndex);
        m_TwoClassDataset.setClassIndex(classIndex);

    } else {
        // use error correcting code style methods
        Code code = null;
        switch (m_Method) {
        case METHOD_ERROR_EXHAUSTIVE:
            code = new ExhaustiveCode(numClassifiers);
            break;
        case METHOD_ERROR_RANDOM:
            code = new RandomCode(numClassifiers, (int) (numClassifiers * m_RandomWidthFactor), insts);
            break;
        case METHOD_1_AGAINST_ALL:
            code = new StandardCode(numClassifiers);
            break;
        default:
            throw new Exception("Unrecognized correction code type");
        }
        numClassifiers = code.size();
        m_Classifiers = Classifier.makeCopies(m_Classifier, numClassifiers);
        m_ClassFilters = new MakeIndicator[numClassifiers];
        for (int i = 0; i < m_Classifiers.length; i++) {
            m_ClassFilters[i] = new MakeIndicator();
            MakeIndicator classFilter = (MakeIndicator) m_ClassFilters[i];
            classFilter.setAttributeIndex("" + (insts.classIndex() + 1));
            classFilter.setValueIndices(code.getIndices(i));
            classFilter.setNumeric(false);
            classFilter.setInputFormat(insts);
            newInsts = Filter.useFilter(insts, m_ClassFilters[i]);
            m_Classifiers[i].buildClassifier(newInsts);
        }
    }
    m_ClassAttribute = insts.classAttribute();
}

From source file:etc.aloe.data.ExampleSet.java

License:Open Source License

/**
 * Returns a new example set containing only those examples with labels.
 *
 * @return//from  w  w w .  ja  va2 s  . c o  m
 */
public ExampleSet onlyLabeled() {
    RemoveWithValues filter = new RemoveWithValues();
    filter.setAttributeIndex("" + (instances.classIndex() + 1));
    filter.setMatchMissingValues(true);
    filter.setInvertSelection(true);

    try {
        filter.setInputFormat(instances);
        Instances result = Filter.useFilter(instances, filter);
        ExampleSet resultSet = new ExampleSet(result);
        return resultSet;
    } catch (Exception ex) {
        System.err.println("Unable to apply filter!");
        return null;
    }
}

From source file:gov.va.chir.tagline.TagLineEvaluator.java

License:Open Source License

public void evaluate(final ClassifierType type, final String... options) throws Exception {
    Classifier model = null;/* ww  w  .j  a  v a 2s.c o  m*/

    if (type == null) {
        throw new IllegalArgumentException("Classifier type must be specified");
    }

    if (type.equals(ClassifierType.J48)) {
        model = new J48();
    } else if (type.equals(ClassifierType.LMT)) {
        model = new LMT();
    } else if (type.equals(ClassifierType.RandomForest)) {
        model = new RandomForest();
    } else if (type.equals(ClassifierType.SVM)) {
        model = new LibSVM();
    } else {
        throw new IllegalArgumentException(String.format("Classifier type not supported (%s)", type));
    }

    if (model != null) {
        // Set classifier options
        if (options != null && options.length > 0) {
            if (model instanceof AbstractClassifier) {
                ((AbstractClassifier) model).setOptions(options);
            }
        }

        fc.setClassifier(model);

        final Attribute attrDocId = instances.attribute(DatasetUtil.DOC_ID);

        if (attrDocId == null) {
            throw new IllegalStateException(String.format("%s attribute must exist", DatasetUtil.DOC_ID));
        }
        final List<Set<Object>> foldDocIds = getFoldDocIds(attrDocId);

        final RemoveWithValues rmv = new RemoveWithValues();

        // RemoveWithValues filter is not zero-based!
        rmv.setAttributeIndex(String.valueOf(attrDocId.index() + 1));
        rmv.setModifyHeader(false);

        final Evaluation eval = new Evaluation(instances);

        // Perform cross-validation
        for (int i = 0; i < numFolds; i++) {
            rmv.setNominalIndicesArr(getAttributeIndexValues(attrDocId, foldDocIds.get(i)));

            rmv.setInvertSelection(false);
            rmv.setInputFormat(instances); // Must be called AFTER all options
            final Instances train = Filter.useFilter(instances, rmv);

            rmv.setInvertSelection(true);
            rmv.setInputFormat(instances); // Must be called AFTER all options
            final Instances test = Filter.useFilter(instances, rmv);

            fc.buildClassifier(train);
            eval.evaluateModel(fc, test);
        }

        evaluationSummary = String.format("%s%s%s%s%s", eval.toSummaryString(),
                System.getProperty("line.separator"), eval.toMatrixString(),
                System.getProperty("line.separator"), eval.toClassDetailsString());
    }
}

From source file:wekimini.DataManager.java

private void updateInstancesForNewLowerMaxClass(int index, int newNumClasses) {
    //Change allInstances, dummyInstances
    // dummyInstances.attribute(numMetaData + numInputs + index).

    RemoveWithValues r = new RemoveWithValues();
    String rangeList = "1-" + (newNumClasses + 1); //String indices start at 1 in weka

    Instances newAll;//from   w w w . j a  va  2 s. co m
    try {
        r.setAttributeIndex(Integer.toString(numMetaData + numInputs + index + 1)); //Weka indexing stupidity
        r.setNominalIndices(rangeList);
        r.setInvertSelection(true); //Keep all classes from 0 to newNumClasses
        r.setMatchMissingValues(false);
        r.setModifyHeader(true);
        r.setInputFormat(allInstances);

        newAll = Filter.useFilter(allInstances, r);
    } catch (Exception ex) {
        Logger.getLogger(DataManager.class.getName()).log(Level.SEVERE, null, ex);
        return;
    }
    if (newAll.numInstances() != allInstances.numInstances()) {
        logger.log(Level.SEVERE, "Problem: deleted instances when removing class attribute");
    }
    allInstances = newAll;

    Instances newD;
    try {
        newD = Filter.useFilter(dummyInstances, r);
    } catch (Exception ex) {
        Logger.getLogger(DataManager.class.getName()).log(Level.SEVERE, null, ex);
        return;
    }

    dummyInstances = newD;
}