Example usage for weka.core Instance setClassValue

List of usage examples for weka.core Instance setClassValue

Introduction

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

Prototype

public void setClassValue(String value);

Source Link

Document

Sets the class value of an instance to the given value.

Usage

From source file:moa.streams.generators.LEDGeneratorDrift.java

License:Open Source License

@Override
public Instance nextInstance() {
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    inst.setDataset(header);//  w  ww.  j a  va2  s  .  c o m
    int selected = this.instanceRandom.nextInt(10);
    for (int i = 0; i < 7; i++) {
        if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
            inst.setValue(this.numberAttribute[i], originalInstances[selected][i] == 0 ? 1 : 0);
        } else {
            inst.setValue(this.numberAttribute[i], originalInstances[selected][i]);
        }
    }
    if (!this.suppressIrrelevantAttributesOption.isSet()) {
        for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
            inst.setValue(this.numberAttribute[i + 7], this.instanceRandom.nextInt(2));
        }
    }
    inst.setClassValue(selected);
    return inst;
}

From source file:moa.streams.generators.MySEAGenerator.java

License:Open Source License

@Override
public Instance nextInstance() {
    double attrib1 = 0, attrib2 = 0, attrib3 = 0;
    int group = 0;
    boolean desiredClassFound = false;
    while (!desiredClassFound) {
        // generate attributes
        attrib1 = 10 * this.instanceRandom.nextDouble();
        attrib2 = 10 * this.instanceRandom.nextDouble();
        attrib3 = 10 * this.instanceRandom.nextDouble();

        // determine class
        group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(attrib1, attrib2,
                attrib3);/*  www. j  av a2  s .  c  o m*/
        if (!this.balanceClassesOption.isSet()) {
            desiredClassFound = true;
        } else {
            // balance the classes
            if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
                desiredClassFound = true;
                this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
            } // else keep searching
        }
    }
    //Add Noise
    if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
        group = (group == 0 ? 1 : 0);
    }

    // construct instance
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    inst.setValue(0, attrib1);
    inst.setValue(1, attrib2);
    inst.setValue(2, attrib3);
    inst.setDataset(header);
    inst.setClassValue(group);
    return inst;
}

From source file:moa.streams.generators.RandomRBFGenerator.java

License:Open Source License

@Override
public Instance nextInstance() {
    Centroid centroid = this.centroids[MiscUtils.chooseRandomIndexBasedOnWeights(this.centroidWeights,
            this.instanceRandom)];
    int numAtts = this.numAttsOption.getValue();
    double[] attVals = new double[numAtts + 1];
    for (int i = 0; i < numAtts; i++) {
        attVals[i] = (this.instanceRandom.nextDouble() * 2.0) - 1.0;
    }//from   ww  w .j a va 2 s  .c om
    double magnitude = 0.0;
    for (int i = 0; i < numAtts; i++) {
        magnitude += attVals[i] * attVals[i];
    }
    magnitude = Math.sqrt(magnitude);
    double desiredMag = this.instanceRandom.nextGaussian() * centroid.stdDev;
    double scale = desiredMag / magnitude;
    for (int i = 0; i < numAtts; i++) {
        attVals[i] = centroid.centre[i] + attVals[i] * scale;
    }
    Instance inst = new DenseInstance(1.0, attVals);
    inst.setDataset(getHeader());
    inst.setClassValue(centroid.classLabel);
    return inst;
}

From source file:moa.streams.generators.RandomTreeGenerator.java

License:Open Source License

@Override
public Instance nextInstance() {
    double[] attVals = new double[this.numNominalsOption.getValue() + this.numNumericsOption.getValue()];
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    for (int i = 0; i < attVals.length; i++) {
        attVals[i] = i < this.numNominalsOption.getValue()
                ? this.instanceRandom.nextInt(this.numValsPerNominalOption.getValue())
                : this.instanceRandom.nextDouble();
        inst.setValue(i, attVals[i]);/*from w  w  w . ja v  a 2s  .  c o m*/
    }
    inst.setDataset(header);
    inst.setClassValue(classifyInstance(this.treeRoot, attVals));
    return inst;
}

From source file:moa.streams.generators.STAGGERGenerator.java

License:Open Source License

@Override
public Instance nextInstance() {

    int size = 0, color = 0, shape = 0, group = 0;
    boolean desiredClassFound = false;
    while (!desiredClassFound) {
        // generate attributes
        size = this.instanceRandom.nextInt(3);
        color = this.instanceRandom.nextInt(3);
        shape = this.instanceRandom.nextInt(3);

        // determine class
        group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(size, color, shape);
        if (!this.balanceClassesOption.isSet()) {
            desiredClassFound = true;/*from  w  ww.j ava 2s  .c  om*/
        } else {
            // balance the classes
            if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
                desiredClassFound = true;
                this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
            } // else keep searching
        }
    }

    // construct instance
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    inst.setValue(0, size);
    inst.setValue(1, color);
    inst.setValue(2, shape);
    inst.setDataset(header);
    inst.setClassValue(group);
    return inst;
}

From source file:moa.streams.generators.STAGGERGenerator2.java

License:Open Source License

@Override
public Instance nextInstance() {

    int size = 0, color = 0, shape = 0, group = 0;
    boolean desiredClassFound = false;
    while (!desiredClassFound) {
        // generate attributes
        size = this.instanceRandom.nextInt(3);
        color = this.instanceRandom.nextInt(3);
        shape = this.instanceRandom.nextInt(3);

        // determine class
        group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(size, color, shape);
        if (!this.balanceClassesOption.isSet()) {
            desiredClassFound = true;//from  w ww . j  av a 2s . c  om
        } else {
            // balance the classes
            if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
                desiredClassFound = true;
                this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
            } // else keep searching
        }
    }

    //TODO refactor
    //sudden drift
    flag = flag + 1;
    if (flag > this.changeIntervalOption.getValue()) {
        this.functionOption.setValue(3);
    }
    if (flag > 2 * this.changeIntervalOption.getValue()) {
        this.functionOption.setValue(2);
    }

    if (flag > 3 * this.changeIntervalOption.getValue()) {
        this.functionOption.setValue(2);
    }

    // construct instance
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    inst.setValue(0, size);
    inst.setValue(1, color);
    inst.setValue(2, shape);
    inst.setDataset(header);
    inst.setClassValue(group);
    return inst;
}

From source file:moa.streams.generators.WaveformGenerator.java

License:Open Source License

@Override
public Instance nextInstance() {
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    inst.setDataset(header);/*  w ww  .j av a 2  s. c  o m*/
    int waveform = this.instanceRandom.nextInt(NUM_CLASSES);
    int choiceA = 0, choiceB = 0;
    switch (waveform) {
    case 0:
        choiceA = 0;
        choiceB = 1;
        break;
    case 1:
        choiceA = 0;
        choiceB = 2;
        break;
    case 2:
        choiceA = 1;
        choiceB = 2;
        break;

    }
    double multiplierA = this.instanceRandom.nextDouble();
    double multiplierB = 1.0 - multiplierA;
    for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) {
        inst.setValue(i, (multiplierA * hFunctions[choiceA][i]) + (multiplierB * hFunctions[choiceB][i])
                + this.instanceRandom.nextGaussian());
    }
    if (this.addNoiseOption.isSet()) {
        for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) {
            inst.setValue(i, this.instanceRandom.nextGaussian());
        }
    }
    inst.setClassValue(waveform);
    return inst;
}

From source file:moa.streams.generators.WaveformGeneratorDrift.java

License:Open Source License

@Override
public Instance nextInstance() {
    InstancesHeader header = getHeader();
    Instance inst = new DenseInstance(header.numAttributes());
    inst.setDataset(header);//from w ww  .j a  v  a 2 s. c  om
    int waveform = this.instanceRandom.nextInt(NUM_CLASSES);
    int choiceA = 0, choiceB = 0;
    switch (waveform) {
    case 0:
        choiceA = 0;
        choiceB = 1;
        break;
    case 1:
        choiceA = 0;
        choiceB = 2;
        break;
    case 2:
        choiceA = 1;
        choiceB = 2;
        break;

    }
    double multiplierA = this.instanceRandom.nextDouble();
    double multiplierB = 1.0 - multiplierA;
    for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) {
        inst.setValue(this.numberAttribute[i], (multiplierA * hFunctions[choiceA][i])
                + (multiplierB * hFunctions[choiceB][i]) + this.instanceRandom.nextGaussian());
    }
    if (this.addNoiseOption.isSet()) {
        for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) {
            inst.setValue(this.numberAttribute[i], this.instanceRandom.nextGaussian());
        }
    }
    inst.setClassValue(waveform);
    return inst;
}

From source file:moa.tasks.EvaluatePeriodicHeldOutTestLA.java

License:Open Source License

@Override
protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
    int numberOfCheckCalls = 0;
    double modelTime = 0;
    Classifier learner = (Classifier) getPreparedClassOption(this.learnerOption);
    InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
    ClassificationPerformanceEvaluator evaluator = (ClassificationPerformanceEvaluator) getPreparedClassOption(
            this.evaluatorOption);
    learner.setModelContext(stream.getHeader());
    long instancesProcessed = 0;
    LearningCurve learningCurve = new LearningCurve("evaluation instances") {

        @Override//from w  w w. j  a v  a  2s.  com
        public String entryToString(int entryIndex) {
            // TODO Auto-generated method stub
            return super.entryToString(entryIndex).replace(',', '\t');
        }

    };
    File dumpFile = this.dumpFileOption.getFile();
    PrintStream immediateResultStream = null;
    if (dumpFile != null) {
        try {
            if (dumpFile.exists()) {
                immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
            } else {
                immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
            }
        } catch (Exception ex) {
            throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
        }
    }
    boolean firstDump = true;
    InstanceStream testStream = null;
    int testSize = this.testSizeOption.getValue();
    if (this.cacheTestOption.isSet()) {
        monitor.setCurrentActivity("Caching test examples...", -1.0);
        Instances testInstances = new Instances(stream.getHeader(), this.testSizeOption.getValue());
        while (testInstances.numInstances() < testSize) {
            testInstances.add(stream.nextInstance());
            if (testInstances.numInstances() % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }
                monitor.setCurrentActivityFractionComplete(
                        (double) testInstances.numInstances() / (double) (this.testSizeOption.getValue()));
            }
        }
        testStream = new CachedInstancesStream(testInstances);
    } else {
        //testStream = (InstanceStream) stream.copy();
        testStream = stream;
        /*monitor.setCurrentActivity("Skipping test examples...", -1.0);
        for (int i = 0; i < testSize; i++) {
        stream.nextInstance();
        }*/
    }
    instancesProcessed = 0;
    TimingUtils.enablePreciseTiming();
    double totalTrainTime = 0.0;
    while ((this.trainSizeOption.getValue() < 1 || instancesProcessed < this.trainSizeOption.getValue())
            && stream.hasMoreInstances() == true) {
        monitor.setCurrentActivityDescription("Training...");
        long instancesTarget = instancesProcessed + this.sampleFrequencyOption.getValue();
        long fixup = 0;
        long trainStartTime = System.nanoTime();
        while (instancesProcessed < instancesTarget && stream.hasMoreInstances() == true) {
            long start = System.nanoTime();
            Instance i = stream.nextInstance();
            fixup += System.nanoTime() - start;
            learner.trainOnInstance(i);
            instancesProcessed++;
            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }
                monitor.setCurrentActivityFractionComplete(
                        (double) (instancesProcessed) / (double) (this.trainSizeOption.getValue()));
            }
        }
        double lastTrainTime = TimingUtils.nanoTimeToSeconds(System.nanoTime() - trainStartTime);
        totalTrainTime += lastTrainTime;
        if (totalTrainTime > this.trainTimeOption.getValue()) {
            break;
        }
        if (this.cacheTestOption.isSet()) {
            testStream.restart();
        }
        evaluator.reset();
        long testInstancesProcessed = 0;
        monitor.setCurrentActivityDescription("Testing (after "
                + StringUtils.doubleToString(
                        ((double) (instancesProcessed) / (double) (this.trainSizeOption.getValue()) * 100.0), 2)
                + "% training)...");
        long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
        int instCount = 0;
        long count = 0;
        long period = 0;

        for (instCount = 0; instCount < testSize; instCount++) {
            if (stream.hasMoreInstances() == false) {
                break;
            }
            Instance testInst = (Instance) testStream.nextInstance().copy();
            if (instCount == 0) {
                long modelBuildStart = System.nanoTime();
                learner.getVotesForInstance(testInst);
                long modelBuildEnd = System.nanoTime();
                modelTime = (modelBuildEnd - modelBuildStart) / 1000000.0;
            }
            double trueClass = testInst.classValue();
            testInst.setClassMissing();

            double[] prediction = learner.getVotesForInstance(testInst);

            do // tune to get more or less stable data
            {
                long start = System.nanoTime();
                for (int i = 0; i < numberOfCheckCalls; ++i)
                    prediction = learner.getVotesForInstance(testInst);
                long end = System.nanoTime();

                if ((end - start) / 1000000.0 < 30) {
                    numberOfCheckCalls += 10;
                } else {
                    count += numberOfCheckCalls;
                    period += (end - start);
                    break;
                }
            } while (true);

            testInst.setClassValue(trueClass);
            evaluator.addResult(testInst, prediction);
            testInstancesProcessed++;
            if (testInstancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }
                monitor.setCurrentActivityFractionComplete(
                        (double) testInstancesProcessed / (double) (testSize));
            }
        }
        if (instCount != testSize) {
            break;
        }
        double final_period = ((double) period / count) / 1000000.0; // msec
        double testTime = TimingUtils
                .nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - testStartTime);
        List<Measurement> measurements = new ArrayList<Measurement>();
        measurements.add(new Measurement("number of attributes", testStream.getHeader().numAttributes() - 1));
        measurements.add(new Measurement("evaluation instances", instancesProcessed));
        measurements.add(new Measurement("test latency", final_period));
        measurements.add(new Measurement("model build time", modelTime));
        measurements.add(new Measurement("trainTime", (totalTrainTime / instancesProcessed)));
        Measurement[] performanceMeasurements = evaluator.getPerformanceMeasurements();
        for (Measurement measurement : performanceMeasurements) {
            measurements.add(measurement);
        }
        Measurement[] modelMeasurements = learner.getModelMeasurements();
        for (Measurement measurement : modelMeasurements) {
            measurements.add(measurement);
        }
        learningCurve.insertEntry(
                new LearningEvaluation(measurements.toArray(new Measurement[measurements.size()])));
        if (immediateResultStream != null) {
            if (firstDump) {
                immediateResultStream.println(learningCurve.headerToString());
                firstDump = false;
            }
            immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
            immediateResultStream.flush();
        }
        //if (monitor.resultPreviewRequested()) {
        //   monitor.setLatestResultPreview(learningCurve.copy());
        //}

    }
    if (immediateResultStream != null) {
        immediateResultStream.close();
    }
    return learningCurve;
}

From source file:moa.tasks.EvaluatePeriodicHeldOutTestLatency.java

License:Open Source License

@Override
protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
    Classifier learner = (Classifier) getPreparedClassOption(this.learnerOption);
    InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
    ClassificationPerformanceEvaluator evaluator = (ClassificationPerformanceEvaluator) getPreparedClassOption(
            this.evaluatorOption);
    learner.setModelContext(stream.getHeader());
    long instancesProcessed = 0;
    LearningCurve learningCurve = new LearningCurve("evaluation instances");
    File dumpFile = this.dumpFileOption.getFile();
    PrintStream immediateResultStream = null;
    if (dumpFile != null) {
        try {/* w w w. j  av a  2 s. c o  m*/
            if (dumpFile.exists()) {
                immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
            } else {
                immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
            }
        } catch (Exception ex) {
            throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
        }
    }
    boolean firstDump = true;
    InstanceStream testStream = null;
    int testSize = this.testSizeOption.getValue();
    if (this.cacheTestOption.isSet()) {
        monitor.setCurrentActivity("Caching test examples...", -1.0);
        Instances testInstances = new Instances(stream.getHeader(), this.testSizeOption.getValue());
        while (testInstances.numInstances() < testSize) {
            testInstances.add(stream.nextInstance());
            if (testInstances.numInstances() % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }
                monitor.setCurrentActivityFractionComplete(
                        (double) testInstances.numInstances() / (double) (this.testSizeOption.getValue()));
            }
        }
        testStream = new CachedInstancesStream(testInstances);
    } else {
        //testStream = (InstanceStream) stream.copy();
        testStream = stream;
        /*monitor.setCurrentActivity("Skipping test examples...", -1.0);
        for (int i = 0; i < testSize; i++) {
        stream.nextInstance();
        }*/
    }
    instancesProcessed = 0;
    TimingUtils.enablePreciseTiming();
    double totalTrainTime = 0.0;
    while ((this.trainSizeOption.getValue() < 1 || instancesProcessed < this.trainSizeOption.getValue())
            && stream.hasMoreInstances() == true) {
        monitor.setCurrentActivityDescription("Training...");
        long instancesTarget = instancesProcessed + this.sampleFrequencyOption.getValue();
        long trainStartTime = System.nanoTime();
        while (instancesProcessed < instancesTarget && stream.hasMoreInstances() == true) {
            learner.trainOnInstance(stream.nextInstance());
            instancesProcessed++;
            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }
                monitor.setCurrentActivityFractionComplete(
                        (double) (instancesProcessed) / (double) (this.trainSizeOption.getValue()));
            }
        }
        double lastTrainTime = TimingUtils.nanoTimeToSeconds(System.nanoTime() - trainStartTime);
        totalTrainTime += lastTrainTime;
        if (totalTrainTime > this.trainTimeOption.getValue()) {
            break;
        }
        if (this.cacheTestOption.isSet()) {
            testStream.restart();
        }
        evaluator.reset();
        long testInstancesProcessed = 0;
        monitor.setCurrentActivityDescription("Testing (after "
                + StringUtils.doubleToString(
                        ((double) (instancesProcessed) / (double) (this.trainSizeOption.getValue()) * 100.0), 2)
                + "% training)...");
        long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
        int instCount = 0;
        long count = 0;
        long period = 0;

        for (instCount = 0; instCount < testSize; instCount++) {
            if (stream.hasMoreInstances() == false) {
                break;
            }
            Instance testInst = (Instance) testStream.nextInstance().copy();
            if (instCount == 0)
                learner.getVotesForInstance(testInst);
            double trueClass = testInst.classValue();
            testInst.setClassMissing();

            double[] prediction = learner.getVotesForInstance(testInst);

            long start = System.nanoTime();
            long end = System.nanoTime();
            count += 10;
            period += (end - start);

            testInst.setClassValue(trueClass);
            evaluator.addResult(testInst, prediction);
            testInstancesProcessed++;
            if (testInstancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }
                monitor.setCurrentActivityFractionComplete(
                        (double) testInstancesProcessed / (double) (testSize));
            }
        }
        if (instCount != testSize) {
            break;
        }
        double final_period = ((double) period / count) / 1000000.0; // msec
        double testTime = TimingUtils
                .nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - testStartTime);
        List<Measurement> measurements = new ArrayList<Measurement>();
        measurements.add(new Measurement("evaluation instances", instancesProcessed));
        measurements.add(new Measurement("total train speed", instancesProcessed / totalTrainTime));
        measurements.add(
                new Measurement("last train speed", this.sampleFrequencyOption.getValue() / lastTrainTime));

        Measurement[] performanceMeasurements = evaluator.getPerformanceMeasurements();
        for (Measurement measurement : performanceMeasurements) {
            measurements.add(measurement);
        }
        Measurement[] modelMeasurements = learner.getModelMeasurements();
        for (Measurement measurement : modelMeasurements) {
            measurements.add(measurement);
        }
        learningCurve.insertEntry(
                new LearningEvaluation(measurements.toArray(new Measurement[measurements.size()])));
        if (immediateResultStream != null) {
            if (firstDump) {
                immediateResultStream.println(learningCurve.headerToString());
                firstDump = false;
            }
            immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
            immediateResultStream.flush();
        }
        if (monitor.resultPreviewRequested()) {
            monitor.setLatestResultPreview(learningCurve.copy());
        }

    }
    if (immediateResultStream != null) {
        immediateResultStream.close();
    }
    return learningCurve;
}