Example usage for weka.core Instances add

List of usage examples for weka.core Instances add

  1. HOME
  2. Java
  3. weka
  4. weka.core.*
  5. Instances
  6. add

Introduction

In this page you can find the example usage for weka.core Instances add.

Prototype

@Override
public boolean add(Instance instance)

Source Link

Document

Adds one instance to the end of the set.

Usage

From source file:moa.clusterers.AmidstClusteringAlgorithm.java

License:Apache License

/**
 * {@inheritDoc}/*w  w w  .  j a v  a 2s .c om*/
 */
@Override
public Clustering getClusteringResult() {
    //sourceClustering = new Clustering();

    Instances dataset = getDataset(attributes_.getNumberOfAttributes(), getNumClusters());
    Instances newInstances = new Instances(dataset);

    if (bnModel_ == null) {
        //parameterLearningAlgorithm_.setParallelMode(isParallelMode_());
        parameterLearningAlgorithm_.setDAG(dag);
        ((SVB) parameterLearningAlgorithm_).setWindowsSize(timeWindowOption.getValue());
        parameterLearningAlgorithm_.initLearning();
        parameterLearningAlgorithm_.updateModel(batch_);
    } else {
        parameterLearningAlgorithm_.updateModel(batch_);
    }

    bnModel_ = parameterLearningAlgorithm_.getLearntBayesianNetwork();
    predictions_.setModel(bnModel_);

    for (DataInstance dataInstance : batch_) {
        this.predictions_.setEvidence(dataInstance);
        this.predictions_.runInference();
        Multinomial multinomial = this.predictions_.getPosterior(clusterVar_);

        double[] results = multinomial.getProbabilities();

        int cnum = IntStream.rangeClosed(0, getNumClusters() - 1)
                .reduce((a, b) -> (results[a] > results[b]) ? a : b).getAsInt();

        double[] attValues = dataInstance.toArray();
        Instance newInst = new DenseInstance(1.0, attValues);
        newInst.insertAttributeAt(attributes_.getNumberOfAttributes());
        newInst.setDataset(dataset);
        newInst.setClassValue(cnum);
        newInstances.add(newInst);
    }
    clustering = new Clustering(newInstances);

    return clustering;
}

From source file:moa.reduction.bayes.IncrInfoThAttributeEval.java

License:Open Source License

/**
 * Updates an information gain attribute evaluator. Discretizes all
 * attributes that are numeric.//  w w  w  . j  a  v a 2 s  .  co m
 * 
 * @param data set of instances serving as training data
 * @throws Exception if the evaluator has not been generated successfully
 */
public void updateEvaluator(Instance inst) throws Exception {

    if (counts == null) {
        // can evaluator handle data?
        weka.core.Instance winst = new weka.core.DenseInstance(inst.weight(), inst.toDoubleArray());
        ArrayList<Attribute> list = new ArrayList<Attribute>();
        //ArrayList<Attribute> list = Collections.list(winst.enumerateAttributes());
        //list.add(winst.classAttribute());
        for (int i = 0; i < inst.numAttributes(); i++)
            list.add(new Attribute(inst.attribute(i).name(), i));
        weka.core.Instances data = new weka.core.Instances("single", list, 1);
        data.setClassIndex(inst.classIndex());
        data.add(winst);
        //getCapabilities().testWithFail(data);
        classIndex = inst.classIndex();
        counts = (HashMap<Key, Float>[]) new HashMap[inst.numAttributes()];
        for (int i = 0; i < counts.length; i++)
            counts[i] = new HashMap<Key, Float>();
    }
    for (int i = 0; i < inst.numValues(); i++) {
        if (inst.index(i) != classIndex) {
            Key key = new Key((float) inst.valueSparse(i), (float) inst.classValue());
            Float cval = (float) (counts[inst.index(i)].getOrDefault(key, 0.0f) + inst.weight());
            counts[inst.index(i)].put(key, cval);
        }
    }

    updated = true;
}

From source file:moa.reduction.core.ReductionClassifier.java

License:Open Source License

private Instance performFS(Instance rinst) {
    // Feature selection process performed before
    weka.core.Instance winst = new weka.core.DenseInstance(rinst.weight(), rinst.toDoubleArray());

    if (fselector != null) {
        if (fselector.isUpdated() && totalCount % winSizeOption.getValue() == 0) {
            fselector.applySelection();//ww w  . ja  v a  2 s.  c o  m
            selector = new AttributeSelection();
            Ranker ranker = new Ranker();
            ranker.setNumToSelect(Math.min(numFeaturesOption.getValue(), winst.numAttributes() - 1));
            selector.setEvaluator((ASEvaluation) fselector);
            selector.setSearch(ranker);

            ArrayList<Attribute> list = new ArrayList<Attribute>();
            //ArrayList<Attribute> list = Collections.list(winst.enumerateAttributes());
            //list.add(winst.classAttribute());
            for (int i = 0; i < rinst.numAttributes(); i++)
                list.add(new Attribute(rinst.attribute(i).name(), i));
            //ArrayList<Attribute> list = Collections.list(winst.enumerateAttributes());
            //list.add(winst.classAttribute());
            weka.core.Instances single = new weka.core.Instances("single", list, 1);
            single.setClassIndex(rinst.classIndex());
            single.add(winst);
            try {
                selector.SelectAttributes(single);
                System.out.println("Selected features: " + selector.toResultsString());
                selectedFeatures.clear();
                for (int att : selector.selectedAttributes())
                    selectedFeatures.add(att);
                WekaToSamoaInstanceConverter convWS = new WekaToSamoaInstanceConverter();
                return convWS.samoaInstance(selector.reduceDimensionality(winst));
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    return rinst;
}

From source file:moa.tasks.CacheShuffledStream.java

License:Open Source License

@Override
protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
    InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
    Instances cache = new Instances(stream.getHeader(), 0);
    monitor.setCurrentActivity("Caching instances...", -1.0);
    while ((cache.numInstances() < this.maximumCacheSizeOption.getValue()) && stream.hasMoreInstances()) {
        cache.add(stream.nextInstance());
        if (cache.numInstances() % MainTask.INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
            if (monitor.taskShouldAbort()) {
                return null;
            }//from   w ww  . j  a va  2 s.  co  m
            long estimatedRemainingInstances = stream.estimatedRemainingInstances();
            long maxRemaining = this.maximumCacheSizeOption.getValue() - cache.numInstances();
            if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
                estimatedRemainingInstances = maxRemaining;
            }
            monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
                    : (double) cache.numInstances()
                            / (double) (cache.numInstances() + estimatedRemainingInstances));
        }
    }
    monitor.setCurrentActivity("Shuffling instances...", -1.0);
    cache.randomize(new Random(this.shuffleRandomSeedOption.getValue()));
    return new CachedInstancesStream(cache);
}

From source file:moa.tasks.EvaluateInterleavedChunks.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());
    int maxInstances = this.instanceLimitOption.getValue();
    int chunkSize = this.chunkSizeOption.getValue();
    long instancesProcessed = 0;
    int maxSeconds = this.timeLimitOption.getValue();
    int secondsElapsed = 0;

    monitor.setCurrentActivity("Evaluating learner...", -1.0);
    LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
    File dumpFile = this.dumpFileOption.getFile();
    PrintStream immediateResultStream = null;
    if (dumpFile != null) {
        try {//from ww  w  .ja v 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;
    boolean firstChunk = true;
    boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
    long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
    long sampleTestTime = 0, sampleTrainTime = 0;
    double RAMHours = 0.0;

    while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
            && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {

        Instances chunkInstances = new Instances(stream.getHeader(), chunkSize);

        while (stream.hasMoreInstances() && chunkInstances.numInstances() < chunkSize) {
            chunkInstances.add(stream.nextInstance());
            if (chunkInstances.numInstances() % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
                if (monitor.taskShouldAbort()) {
                    return null;
                }

                long estimatedRemainingInstances = stream.estimatedRemainingInstances();

                if (maxInstances > 0) {
                    long maxRemaining = maxInstances - instancesProcessed;
                    if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
                        estimatedRemainingInstances = maxRemaining;
                    }
                }

                monitor.setCurrentActivityFractionComplete((double) instancesProcessed
                        / (double) (instancesProcessed + estimatedRemainingInstances));
            }
        }

        ////Testing
        long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
        if (!firstChunk) {
            for (int i = 0; i < chunkInstances.numInstances(); i++) {
                Instance testInst = (Instance) chunkInstances.instance(i).copy();
                //testInst.setClassMissing();
                double[] prediction = learner.getVotesForInstance(testInst);
                evaluator.addResult(testInst, prediction);
            }
        } else {
            firstChunk = false;
        }

        sampleTestTime += TimingUtils.getNanoCPUTimeOfCurrentThread() - testStartTime;

        ////Training
        long trainStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();

        for (int i = 0; i < chunkInstances.numInstances(); i++) {
            learner.trainOnInstance(chunkInstances.instance(i));
            instancesProcessed++;
        }

        sampleTrainTime += TimingUtils.getNanoCPUTimeOfCurrentThread() - trainStartTime;

        ////Result output
        if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0) {

            double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
            RAMHoursIncrement *= (TimingUtils.nanoTimeToSeconds(sampleTrainTime + sampleTestTime) / 3600.0); //Hours
            RAMHours += RAMHoursIncrement;

            double avgTrainTime = TimingUtils.nanoTimeToSeconds(sampleTrainTime)
                    / ((double) this.sampleFrequencyOption.getValue() / chunkInstances.numInstances());
            double avgTestTime = TimingUtils.nanoTimeToSeconds(sampleTestTime)
                    / ((double) this.sampleFrequencyOption.getValue() / chunkInstances.numInstances());

            sampleTestTime = 0;
            sampleTrainTime = 0;

            learningCurve.insertEntry(new LearningEvaluation(new Measurement[] {
                    new Measurement("learning evaluation instances", instancesProcessed),
                    new Measurement(("evaluation time (" + (preciseCPUTiming ? "cpu " : "") + "seconds)"),
                            TimingUtils.nanoTimeToSeconds(
                                    TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime)),
                    new Measurement("average chunk train time", avgTrainTime),
                    new Measurement("average chunk train speed", chunkInstances.numInstances() / avgTrainTime),
                    new Measurement("average chunk test time", avgTestTime),
                    new Measurement("average chunk test speed", chunkInstances.numInstances() / avgTestTime),
                    new Measurement("model cost (RAM-Hours)", RAMHours) }, evaluator, learner));

            if (immediateResultStream != null) {
                if (firstDump) {
                    immediateResultStream.println(learningCurve.headerToString());
                    firstDump = false;
                }
                immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
                immediateResultStream.flush();
            }
        }

        ////Memory testing
        if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
            if (monitor.taskShouldAbort()) {
                return null;
            }
            long estimatedRemainingInstances = stream.estimatedRemainingInstances();
            if (maxInstances > 0) {
                long maxRemaining = maxInstances - instancesProcessed;
                if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
                    estimatedRemainingInstances = maxRemaining;
                }
            }
            monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
                    : (double) instancesProcessed
                            / (double) (instancesProcessed + estimatedRemainingInstances));
            if (monitor.resultPreviewRequested()) {
                monitor.setLatestResultPreview(learningCurve.copy());
            }
            secondsElapsed = (int) TimingUtils
                    .nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
        }
    }
    if (immediateResultStream != null) {
        immediateResultStream.close();
    }
    return learningCurve;
}

From source file:moa.tasks.EvaluateNonStationaryDynamicStream.java

License:Open Source License

/**
 *
 *
 * @return instances retrieved from stream
 *//*  w w  w.java 2 s .c  o m*/
private Instances getChunk() {
    Instances chunk = new Instances(stream.getHeader(), this.chunkSizeOption.getValue());
    // Add "chunk size" number of instances to test directly from the stream (first time we see each instance):
    while (stream.hasMoreInstances() && chunk.numInstances() < this.chunkSizeOption.getValue()) {
        Instance inst = stream.nextInstance();
        this.instancesProcessed++;
        chunk.add(inst);

        if (this.inWarmupPhase) { // For warmup phase, use full and immediate training
            inst.setWeight(1.0);
            latentTrainingInstQueue.addFirst(new TimeBoxedInstance(inst, this.instancesProcessed, 0, null));
        } else if (rng.nextFloat() > this.trainingFractionOption.getValue()) { // Select a portion for latent training set by setting non-training instance weight to zero.
            // place at beginning of the queue/list and record intended activation 'time' for immediate unsupervised 'training'
            inst.setWeight(0.0);
            latentTrainingInstQueue.addFirst(new TimeBoxedInstance(inst, this.instancesProcessed, 0, null));
        } else {
            if (this.sendZeroWeightsOption.isSet()) {
                Instance unsupervisedInstance = (Instance) inst.copy();
                unsupervisedInstance.setWeight(0.0);
                //unsupervisedInstance.setClassValue(0);
                latentTrainingInstQueue.addFirst(
                        new TimeBoxedInstance(unsupervisedInstance, this.instancesProcessed, 0, null));
            }
            // place at end of the queue/list and record intended activation 'time' for latent supervised training
            latentTrainingInstQueue.addLast(new TimeBoxedInstance(inst, this.instancesProcessed,
                    this.trainingTimeDelayOption.getValue(), null));
        }

        // MOA framework housekeeping and reporting...
        if ((instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES) == 0) {
            this.monitor.setCurrentActivityDescription("Updating Metrics");
            if (monitor.taskShouldAbort()) {
                chunk.clear();
                return chunk;
            }
            long estimatedRemainingInstances = stream.estimatedRemainingInstances();

            if (this.instanceLimitOption.getValue() > 0) {
                long maxRemaining = this.instanceLimitOption.getValue() - instancesProcessed;
                if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
                    estimatedRemainingInstances = maxRemaining;
                }
            }
            monitor.setCurrentActivityFractionComplete(
                    (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
        }
    } // end while
    return chunk;
}

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//  w w  w.ja va2  s.co m
        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  .  ja v a 2s.  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;
}

From source file:moa.tud.ke.patching.AdaptivePatchingAdwin.java

/**
 * Merges two sets of instances/* w  ww . j  a va  2  s  .  c o m*/
 *
 * @param a
 * @param b
 * @return
 */
private Instances mergeInstances(Instances a, Instances b) {
    Instances merged = a;
    Iterator it = b.iterator();
    while (it.hasNext()) {
        weka.core.Instance i = (weka.core.Instance) it.next();
        merged.add(i);
    }
    return merged;
}

From source file:moa.tud.ke.patching.AdaptivePatchingAdwin.java

public double classifyInstance(weka.core.Instance inst) throws Exception {

    int region = -1;
    int defaultDecider = -1;
    int amountDeciders = -1;
    double label;

    weka.core.Instance origInst = inst;/*from w ww .j av  a2s. c  o  m*/

    try {
        if (this.regionDecider != null) {

            // Handling of optional usage of the base class as an additional attribute.
            if (this.useBaseClassAsAttribute.isSet()) {
                Instances tmp = new Instances(this.prototypeData); // deep copy of our empty prototypeData
                tmp.add(inst);
                tmp = addBaseClassToInstances(tmp);
                weka.core.Instance inst2 = tmp.get(0);
                inst = inst2;
                inst2 = null;
            }

            // Pre-classify instance and retrieve the used Decider
            double regClass = this.regionDecider.classifyInstance(inst);

            if (regClass == 0) { // only if its in a "wrong" region

                Boolean isMultiDecider = false;
                if (this.regionDecider.getAmountOfDeciders() > 1) {
                    isMultiDecider = true;
                }

                Classifier patch;

                if (isMultiDecider) {
                    region = this.regionDecider.getLastUsedDecider();

                    //                        System.out.println("using patch region decider: "+region);

                    patch = (Classifier) regionPatches.elementAt(region);
                    if (patch != null) {
                        return patch.classifyInstance(inst);
                    }
                } else { // case b: we only have a 0/1 information about if its in the error region or not.
                    patch = (Classifier) regionPatches.elementAt(0);
                    if (patch != null) {
                        return patch.classifyInstance(inst);
                    }

                }
            } else { // if its not in a "wrong" region, return the class from the base classifier
                if (this.useBaseClassAsAttribute.isSet()) {
                    return inst.value(0); // this has maybe already been calculated into the first attribute.
                }
            }
        }
    } catch (Exception e) {
        System.err.println("AdaptivePatching : Error in classifyInstance while using regionDecider.");
        System.out.println("Region: " + region + " DefaultDecider:" + defaultDecider + " amountDeciders:"
                + amountDeciders + " regionPatches#:" + regionPatches.size());
        e.printStackTrace();
        System.exit(234545345);
    }

    return baseClassifier.classifyInstance(origInst);
}