Advanced Topics

This tutorial covers advanced OpenMOA capabilities: semi-supervised stream learning, online continual learning, integration with MOA's Java ecosystem, prediction intervals for regression, and techniques for high-performance evaluation.

1. Semi-Supervised Learning

Semi-supervised stream learning handles the realistic case where labels arrive infrequently. OpenMOA's ClassifierSSL wraps any classifier to work with partially-labeled streams.

ClassifierSSL Interface

All SSL classifiers implement ClassifierSSL, which extends the standard Classifier interface with an is_labeled flag in learn_one.

from openmoa.classifier import ClassifierSSL

ssl_clf = SomeSSLClassifier()

# Labeled instance
ssl_clf.learn_one(x, y, is_labeled=True)

# Unlabeled instance — only unsupervised update
ssl_clf.learn_one(x, y=None, is_labeled=False)

# Prediction is unchanged
y_pred = ssl_clf.predict_one(x)

prequential_ssl_evaluation

The dedicated SSL evaluator generates a variable labeling rate, measures accuracy only on labeled instances, and tracks unlabeled instance usage.

from openmoa.evaluation import prequential_ssl_evaluation

results = prequential_ssl_evaluation(
    stream=stream,
    model=ssl_clf,
    labeling_rate=0.1,    # 10 % of instances are labeled
    n_samples=10000,
    window_size=1000,
)

OSNN — Online Semi-supervised Nearest Neighbor

OSNN maintains an online prototype graph. Labeled nodes propagate labels to nearby unlabeled neighbors via graph-based label propagation, enabling effective learning even at very low labeling rates.

from openmoa.classifier import OSNN

model = OSNN(
    n_neighbors=5,
    window_size=500,
)

results = prequential_ssl_evaluation(
    stream=stream,
    model=model,
    labeling_rate=0.05,   # only 5 % labeled
    n_samples=10000,
)

2. Online Continual Learning

Online Continual Learning (OCL) addresses the challenge of learning new tasks sequentially without forgetting previous knowledge. OpenMOA provides a complete OCL pipeline for both classic benchmarks and vision tasks.

Supported Datasets

Task Interface

Each OCL dataset exposes a task-based iteration interface. Tasks arrive sequentially; each task contains a stream of instances from that task's classes only.

from openmoa.datasets import SplitMNIST

dataset = SplitMNIST()

for task_id, task_stream in dataset.tasks():
    print(f"Task {task_id}: classes = {task_stream.classes}")
    for x, y in task_stream:
        ...

ocl_train_eval_loop

The unified OCL training loop handles task boundaries, calls the strategy's before_task / after_task hooks, and accumulates the accuracy matrix.

from openmoa.evaluation import ocl_train_eval_loop
from openmoa.ocl import ExperienceReplay

strategy = ExperienceReplay(mem_size=200)
metrics = ocl_train_eval_loop(
    dataset=SplitMNIST(),
    strategy=strategy,
)

OCLMetrics

The OCLMetrics object returned by ocl_train_eval_loop provides the standard continual learning metrics derived from the accuracy matrix R, where R[i][j] is accuracy on task j after training on task i.

Strategies

from openmoa.ocl import ExperienceReplay, SLDA, NCM

er   = ExperienceReplay(mem_size=200)
slda = SLDA(shrinkage=1e-4)
ncm  = NCM(n_neighbors=1)

for name, strategy in [("ER", er), ("SLDA", slda), ("NCM", ncm)]:
    m = ocl_train_eval_loop(SplitMNIST(), strategy)
    print(f"{name}: avg_acc={m.avg_accuracy:.3f}, forgetting={m.forgetting:.3f}")

3. MOA Integration

OpenMOA bridges the rich Java-based MOA (Massive Online Analysis) ecosystem through JPype. This gives access to hundreds of MOA classifiers and detectors without leaving Python.

MOAClassifier

MOAClassifier wraps any MOA learner using its CLI string syntax. It implements the standard OpenMOA Classifier interface so it drops into any evaluation loop.

from openmoa.classifier import MOAClassifier
from openmoa.evaluation import prequential_evaluation

clf = MOAClassifier(moa_learner="trees.HoeffdingTree -g 200 -c 0.0")

results = prequential_evaluation(stream, clf, n_samples=10000)

MOADriftDetector

MOADriftDetector wraps MOA drift detectors, bridging them into OpenMOA's DriftDetector interface.

from openmoa.drift import MOADriftDetector

detector = MOADriftDetector(moa_detector="drift.ADWIN -d 0.002")

for x, y in stream:
    y_pred = clf.predict_one(x)
    detector.add_element(int(y_pred != y))
    if detector.detected_change():
        print("Drift detected!")

OpenFeatureStream

OpenFeatureStream simulates evolving feature spaces — a key characteristic of open-world streams where new sensors, modalities, or measurement types appear over time.

Evolution patterns

Feature selection modes

from openmoa.stream import OpenFeatureStream

stream = OpenFeatureStream(
    base_stream="generators.SEAGenerator",
    evolution_pattern="pyramid",
    feature_selection="union",
    n_features_start=5,
    n_features_max=20,
    evolution_speed=500,   # features change every 500 instances
)

Lazy Java Loading

JPype and the MOA JVM are loaded on first use — not at import time. Importing OpenMOA is instant even without a JVM; Java initializes only when a MOAClassifier, MOADriftDetector, or OpenFeatureStream is first instantiated.

import openmoa                          # instant — no JVM started

from openmoa.classifier import MOAClassifier
clf = MOAClassifier("trees.HoeffdingTree")  # JVM starts here

4. Prediction Intervals

For regression tasks, OpenMOA supports prediction intervals alongside point estimates. Regressors that implement interval prediction return a 3-tuple instead of a scalar.

Output Format

An interval-capable regressor's predict_one returns (lower, point, upper):

lower, point, upper = regressor.predict_one(x)
# lower  — lower confidence bound
# point  — point estimate (same as a standard regressor)
# upper  — upper confidence bound

Evaluators

Two evaluators handle interval predictions; both accept the 3-tuple output directly.

from openmoa.evaluation import PredictionIntervalWindowedEvaluator

evaluator = PredictionIntervalWindowedEvaluator(window_size=1000)

for x, y in stream:
    lower, point, upper = regressor.predict_one(x)
    evaluator.update(y, lower, point, upper)
    regressor.learn_one(x, y)

metrics = evaluator.get_metrics()

Interval Metrics

5. Performance Optimization

OpenMOA provides several mechanisms to accelerate evaluation and training on large-scale streams.

Fast Evaluation Mode

Fast mode uses MOA's native EfficientEvaluationLoops — the entire prequential loop runs in Java, avoiding Python overhead per instance. It activates automatically when both conditions are met:

from openmoa.classifier import MOAClassifier
from openmoa.stream import MOAStream
from openmoa.evaluation import prequential_evaluation

clf    = MOAClassifier("trees.HoeffdingTree")
stream = MOAStream("generators.SEAGenerator -f 2")

# Both MOA — fast mode activates automatically
results = prequential_evaluation(
    stream=stream,
    model=clf,
    n_samples=1_000_000,
)

Batch Learning

BatchClassifier wraps any scikit-learn compatible classifier for stream evaluation. It collects instances into mini-batches before calling the underlying learner's partial_fit.

from openmoa.classifier import BatchClassifier
from sklearn.linear_model import SGDClassifier

clf = BatchClassifier(
    classifier=SGDClassifier(),
    batch_size=256,
)

results = prequential_evaluation(stream, clf, n_samples=50000)

Multi-Learner Single-Pass

When benchmarking multiple classifiers, pass a list of models to prequential_evaluation. The stream is iterated only once and all models are updated simultaneously — cutting total evaluation time roughly by the number of models.

from openmoa.classifier import HoeffdingTree, NaiveBayes, KNN

models = [HoeffdingTree(), NaiveBayes(), KNN(n_neighbors=5)]

# Single pass — all models evaluated in one stream iteration
results = prequential_evaluation(
    stream=stream,
    model=models,
    n_samples=100000,
    window_size=1000,
)

Performance Summary