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

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

Introduction

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

Prototype

public RemoveWithValues() 

Source Link

Document

Default constructor

Usage

From source file:MultiClassClassifier.java

License:Open Source License

/**
 * Builds the classifiers.// www. j a  v  a2s  . co 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//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  . jav a2s  .  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:soccer.core.classifiers.BookKeeperConsistencyClassifier.java

public static void main(String[] args) throws Exception {
    BookKeeperConsistency bkc = new BookKeeperConsistency();
    Instances data = bkc.getInstances();

    RemoveWithValues rwv = new RemoveWithValues();
    rwv.setOptions(new String[] { "-C", "4", "-S", "6", "-V" });
    rwv.setInputFormat(data);//from  w ww . j av a  2 s. com
    data = Filter.useFilter(data, rwv);
    RemoveWithValues rwv1 = new RemoveWithValues();
    rwv1.setOptions(new String[] { "-C", "6", "-S", "6", "-V" });
    rwv1.setInputFormat(data);
    data = Filter.useFilter(data, rwv1);

    //        Normalize nm = new Normalize();
    //        nm.setOptions(new String[]{
    //            "-S", "100"
    //        });
    //        nm.setInputFormat(data);
    //        data = Filter.useFilter(data, nm);

    Remove rm = new Remove();
    rm.setOptions(new String[] { "-R", "2-last" });
    rm.setInputFormat(data);
    Instances newData = Filter.useFilter(data, rm);

    SimpleKMeans cluster = new SimpleKMeans();
    cluster.setOptions(new String[] { "-N", "2", "-A", "weka.core.ManhattanDistance" });

    cluster.buildClusterer(newData);
    ClusterEvaluation eval = new ClusterEvaluation();
    eval.setClusterer(cluster);
    eval.evaluateClusterer(newData);
    System.out.println(eval.clusterResultsToString());
    //        for (int i = 0; i < newData.size(); i++) {
    //            Instance instance = newData.get(i);
    //            if (cluster.clusterInstance(instance) == 0) {
    //                System.out.println(data.get(i).toString());
    //            }
    //        }
}

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 ww  w .  jav  a  2  s. c  om
    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;
}