AdvancedEvaluatePrequentialDelayed.ipynb

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": ["This IPYNB file was generated automatically by MOA GUI.<br>\n",
"Task name: moa.tasks.EvaluatePrequentialDelayed<br>\n",
"## Libraries importing\n"]
},

{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": ["%maven nz.ac.waikato.cms.moa:moa:2019.05.0\n",
"%classpath \"moa-flow-core.jar\"\n",
"import moa.classifiers.meta.AdaptiveRandomForest;\n",
"import moa.streams.generators.RandomTreeGenerator;\n",
"import moa.evaluation.WindowClassificationPerformanceEvaluator;\n",
"import moa.evaluation.LearningEvaluation;\n",
"import moa.evaluation.preview.LearningCurve;\n",
"import moa.core.TimingUtils;\n",
"import moa.tasks.MainTask;\n",
"import com.yahoo.labs.samoa.instances.Instance;\n",
"import moa.core.Example;\n",
"import moa.core.Measurement;\n",
"import java.util.LinkedList;\n",
"import moaflow.sink.DrawTable;\n",
"import moa.core.Utils;\n",
"import moa.core.InstanceExample;\n"]
},

{
"cell_type": "markdown",
"metadata": {},
"source": ["## Configuring learner, stream and evaluator\n"]
},

{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": ["String learnerString = \"meta.AdaptiveRandomForest -l (ARFHoeffdingTree -e 2000000 -g 75 -s GiniSplitCriterion -c 0.01 -l MC) -o (Percentage (M * (m / 100))) -m 80\";\n",
"AdaptiveRandomForest adap = new AdaptiveRandomForest();adap.getOptions().setViaCLIString(\"-l (ARFHoeffdingTree -e 2000000 -g 75 -s GiniSplitCriterion -c 0.01 -l MC) -o (Percentage (M * (m / 100))) -m 80\");\n",
"adap.prepareForUse();\n",
"\n",
"String streamString = \"generators.RandomTreeGenerator\";\n",
"RandomTreeGenerator rand = new RandomTreeGenerator();\n",
"rand.prepareForUse();\n",
"adap.setModelContext(rand.getHeader());\n",
"\n",
"String evaluatorString = \"WindowClassificationPerformanceEvaluator\";\n",
"WindowClassificationPerformanceEvaluator wind = new WindowClassificationPerformanceEvaluator();\n"]
},

{
"cell_type": "markdown",
"metadata": {},
"source": ["## Setting environmental parameters\n"]
},

{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": ["int maxInstances = 100000;\n",
"long instancesProcessed = 0;\n",
"int maxSeconds = -1;\n",
"int secondsElapsed = 0;\n",
"LearningCurve learningCurve = new LearningCurve(\"learning evaluation instances\");\n",
"File dumpFile = new File(\"null\");\n",
"PrintStream immediateResultStream = null;\n",
"if (dumpFile != null) {\n",
"    try {\n",
"        if (dumpFile.exists()) {\n",
"            immediateResultStream = new PrintStream(\n",
"                    new FileOutputStream(dumpFile, true), true);\n",
"        } else {\n",
"            immediateResultStream = new PrintStream(\n",
"                    new FileOutputStream(dumpFile), true);\n",
"        }\n",
"    } catch (Exception ex) {\n",
"        throw new RuntimeException(\n",
"                \"Unable to open immediate result file: \"  + dumpFile, ex);\n",
"    }\n",
"}\n",
"File outputPredictionFile = null;\n",
"PrintStream outputPredictionResultStream = null;\n",
"if (outputPredictionFile != null) {\n",
"    try {\n",
"        if (outputPredictionFile.exists()) {\n",
"            outputPredictionResultStream = new PrintStream(\n",
"                    new FileOutputStream(outputPredictionFile, true), true);\n",
"        } else {\n",
"            outputPredictionResultStream = new PrintStream(\n",
"                    new FileOutputStream(outputPredictionFile), true);\n",
"        }\n",
"    } catch (Exception ex) {\n",
"        throw new RuntimeException(\n",
"                 \"Unable to open prediction result file: \" + outputPredictionFile, ex);\n",
"    }\n",
"}\n",
"LinkedList<Example> trainInstances = new LinkedList<Example>();\n",
"boolean firstDump = true;\n",
"boolean firstPrint = true;\n",
"boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();\n",
"long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();\n",
"long lastEvaluateStartTime = evaluateStartTime;\n",
"double RAMHours = 0.0;\n"]
},

{
"cell_type": "markdown",
"metadata": {},
"source": ["## Testing & training, exporting result\n"]
},

{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": ["DrawTable table = new DrawTable();\n",
"System.out.println( \"Evaluating learner...\");\n",
"while (rand.hasMoreInstances()\n",
"        && ((maxInstances < 0) || (instancesProcessed < maxInstances))\n",
"        && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {\n",
"    instancesProcessed++;\n",
"    Example currentInst = rand.nextInstance();\n",
"    boolean trainOnInitialWindow = false;\n",
"    boolean trainInBatches = false;\n",
"    int initialWindowSize = 1000;\n",
"    int delayLength = 1000;\n",
"    if (instancesProcessed <= initialWindowSize) {\n",
"        if (trainOnInitialWindow) {\n",
"            adap.trainOnInstance(currentInst);\n",
"        } else if ((initialWindowSize - instancesProcessed) < delayLength) {\n",
"            trainInstances.addLast(currentInst);\n",
"        }\n",
"    } else {\n",
"        trainInstances.addLast(currentInst);\n",
"        if (delayLength < trainInstances.size()) {\n",
"            if (trainInBatches) {\n",
"                // Do not train on the latest instance, otherwise\n",
"                // it would train on k+1 instances\n",
"                while (trainInstances.size() > 1) {\n",
"                    Example trainInst = trainInstances.removeFirst();\n",
"                    adap.trainOnInstance(trainInst);\n",
"                }\n",
"            } else {\n",
"                Example trainInst = trainInstances.removeFirst();\n",
"                adap.trainOnInstance(trainInst);\n",
"            }\n",
"        }\n",
"        // Remove class label from test instances.\n",
"        Instance testInstance = ((Instance) currentInst.getData()).copy();\n",
"        testInstance.setMissing(testInstance.classAttribute());\n",
"        testInstance.setClassValue(0.0);\n",
"        Example testInst = new InstanceExample(testInstance);\n",
"        double[] prediction = adap.getVotesForInstance(testInst);\n",
"        testInstance = ((Instance) currentInst.getData()).copy();\n",
"        testInst = new InstanceExample(testInstance);\n",
"        // Output prediction\n",
"        if (outputPredictionFile != null) {\n",
"            int trueClass = (int) ((Instance) currentInst.getData()).classValue();\n",
"            outputPredictionResultStream.println(Utils.maxIndex(prediction) + \",\"  + ( \n",
"                    ((Instance) testInst.getData()).classIsMissing() == true ? \" ? \" : trueClass));\n",
"        }\n",
"        wind.addResult(testInst, prediction);\n",
"    if (instancesProcessed % 10000 == 0\n",
"            ||  rand.hasMoreInstances() == false) {\n",
"        long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();\n",
"        double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);\n",
"        double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);\n",
"        double RAMHoursIncrement = adap.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs\n",
"        RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours\n",
"        RAMHours += RAMHoursIncrement;\n",
"        lastEvaluateStartTime = evaluateTime;\n",
"        learningCurve.insertEntry(new LearningEvaluation(\n",
"                new Measurement[]{\n",
"                        new Measurement(\n",
"                                \"learning evaluation instances\",\n",
"                                instancesProcessed),\n",
"                        new Measurement(\n",
"                                \"evaluation time (\"\n",
"                                        + (preciseCPUTiming ? \"cpu \"\n",
"                                        : \"\") + \"seconds)\",\n",
"                                time),\n",
"                        new Measurement(\n",
"                                \"model cost (RAM-Hours)\",\n",
"                                RAMHours)\n",
"                },\n",
"                wind, adap));\n",
"        if (immediateResultStream != null) {\n",
"            if (firstDump) {\n",
"                immediateResultStream.println(learningCurve.headerToString());\n",
"                firstDump = false;\n",
"            }\n",
"            immediateResultStream.print(learnerString + \",\" + streamString);\n",
"            immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));\n",
"            immediateResultStream.flush();\n",
"        }\n",
"        if (firstPrint) {\n",
"           System.out.println(learnerString + \",\" + streamString);\n",
"           System.out.print(table.headerLine(learningCurve.headerToString()));\n",
"           firstPrint = false;\n",
"        }\n",
"        System.out.print(table.bodyLine(learningCurve.entryToString(learningCurve.numEntries() - 1)));\n",
"        System.out.flush();\n",
"    }\n",
"}\n",
"}\n",
"double time = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()- evaluateStartTime);\n",
"System.out.println(instancesProcessed + \" instances processed in \" + time + \" seconds.\");\n",
"if (immediateResultStream != null) {\n",
"    immediateResultStream.close();\n",
"}\n"]
}
],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 0
}