Maschinelles Lernen ist nicht länger auf statische Datensätze beschränkt. Viele moderne Problemstellungen — von Energieprognosen und Betrugserkennung bis hin zu Sensoranalytik und Cybersicherheit — basieren auf kontinuierlichen Datenströmen. Diese Daten treffen instanzweise ein, verändern sich im Zeitverlauf und unterliegen häufig einer Konzeptdrift, wodurch klassische Batch-Lernverfahren ungeeignet werden.
Dieser Beitrag richtet sich an ML-Praktiker*innen und angewandt Forschende, die mit dynamischen Datenströmen arbeiten und hochdurchsatzfähige, adaptive Lernverfahren benötigen – und dabei MOA-Performance in Python nutzen möchten, ohne Abstriche bei der Benutzerfreundlichkeit zu machen.
Es handelt sich um den abschließenden Beitrag unserer Stream-Mining-Reihe und baut auf den Grundlagen der vorherigen Artikel „Lernen aus Datenströmen: Grundlagen des Stream Learning“, „Grünes Online-Lernen mit Heterogenen Ensembles“ und „Streaming Gradient Boosting: Online Learning neu gedacht“ auf, mit dem Fokus darauf, wie diese Konzepte in der Praxis zusammenwirken.
Zur Bewältigung dieser und weiterer Herausforderungen wurde CapyMOA entwickelt. CapyMOA ist eine Open-Source-Python-Bibliothek für Datenstromlernen und Online Continual Learning (OCL). Die erste öffentliche Version wurde im Mai 2024 veröffentlicht. CapyMOA verfolgt das Ziel, die Effizienz von MOA, die Zugänglichkeit von Python sowie die für moderne Streaming-Anwendungen erforderliche Flexibilität zu vereinen.
MOA war die erste breit etablierte Open-Source-Bibliothek für Datenstromlernen. Ursprünglich um 2007 in Java implementiert, wird sie bis heute aktiv genutzt und weiterentwickelt.
Warum CapyMOA?
Bestehende Werkzeuge gehen unterschiedliche Kompromisse ein:
• MOA (Java) ist äußerst effizient, jedoch weniger zugänglich für Python-zentrierte Workflows.
• River ist benutzerfreundlich, vollständig in Python implementiert, stößt jedoch bei hochdurchsatzfähigen Datenströmen an Performancegrenzen.
• Scikit-Multiflow schloss einige dieser Lücken, wird jedoch nicht mehr aktiv weiterentwickelt.
Für Anwender*innen resultiert daraus häufig ein Zielkonflikt zwischen Performance, Usability und langfristiger Wartbarkeit. CapyMOA überbrückt diese Welten durch drei zentrale Säulen:
1. Effizienz
CapyMOA kombiniert native Python-Implementierungen mit dem Zugriff auf optimierte Java-Algorithmen aus MOA über eine moderne Python-API. Wo sinnvoll, werden ausgereifte MOA-Implementierungen mittels JPype mit minimalem Overhead eingebunden, während zugleich ein eigenes, wachsendes Ökosystem an Methoden für das Datenstromlernen bereitgestellt wird.
Dies ermöglicht MOA-Performance, ohne eine einzige Zeile Java-Code schreiben zu müssen.
Warum das in der Praxis relevant ist:
Effizienz ist beim Data Stream Lerning von entscheidender Bedeutung, da Modelle unter Zeit- und Ressourcenbeschränkungen kontinuierlich eintreffende Daten verarbeiten müssen. Schnellere Implementierungen ermöglichen es Forschenden und Praktiker*innen, mit längeren und realistischeren Datenströmen zu arbeiten, eine größere Anzahl von Experimenten durchzuführen und die Rechenkosten zu senken. Dies macht eine groß angelegte Bewertung und Bereitstellung insbesondere in ressourcenbeschränkten Umgebungen besser realisierbar. CapyMOA bietet diese Effizienz und bleibt dabei vollständig in Python-basierte Workflows integriert.
2. Interoperabilität
CapyMOA lässt sich nahtlos integrieren mit:
- MOA-Algorithmen (automatisch eingebunden)
- scikit-learn-Modellen
- PyTorch-Komponenten
Dies ermöglicht hybride Ansätze, die traditionelle Online-Modelle mit Deep Learning kombinieren – besonders nützlich für Online Continual Learning. Diese Interoperabilität ist entscheidend für angewandte ML-Teams, die bereits auf scikit-learn oder PyTorch setzen und bestehende Pipelines auf Streaming-Szenarien ausweiten möchten, anstatt alles von Grund auf neu aufzubauen.
3. Zugänglichkeit
Die API ist so konzipiert, dass sie für normale Benutzerinnen intuitiv zu bedienen ist und gleichzeitig die Flexibilität bietet, die fortgeschrittene Benutzerinnen wie Forschende und Entwickler*innen benötigen. Dies spiegelt sich in Funktionen wie den folgenden wider:
- Einfache, hochentwickelte Auswertungsfunktionen
- Integrierte Stream-Generatoren und Benchmark-Datensätze
- Driftbezogene Funktionen, einschließlich Simulation, Erkennung und Auswertung
- Automatische Verarbeitung von Datenschemata und Instanzen
- Visualisierungstools zur Überwachung von Metriken
- Eine modulare Pipelines-API zum Erstellen von Streaming-Workflows
- Ein End-to-End-Framework für kontinuierliches Online-Lernen (OCL), einschließlich Experimentkonfiguration, Auswertung und Algorithmen
Zugänglichkeit bedeutet hier nicht übermäßige Vereinfachung. Es bedeutet vielmehr, Boilerplate-Code für einfache Aufgaben – wie das schnelle Benchmarking von Driftdetektoren – zu reduzieren und gleichzeitig die volle Kontrolle über fortgeschrittene Workflows zu behalten, wie z. B. die Erstellung von Pipelines mit Online-Vorverarbeitung, mehreren Driftdetektoren und benutzerdefinierten Metriken.
Lernen aus Datenströmen mit CapyMOA
Die meisten Stream-Learning-Pipelines folgen dem Test-dann-Trainieren-Zyklus:
- Die nächste Instanz abrufen
- Eine Vorhersage treffen
- Den Lerner trainieren
- Metriken aktualisieren
CapyMOA abstrahiert dies in präsequenzielle Bewertungsfunktionen, wodurch Boilerplate-Code reduziert und die Bewertung über Algorithmen hinweg standardisiert wird. Diese Abstraktion gewährleistet eine konsistente Bewertung über Modelle und Experimente hinweg.
Beispiel: Hoeffding-Baum auf dem Strom-Datensatz
from capymoa.datasets import Electricity
from capymoa.classifier import HoeffdingTree
from capymoa.evaluation import prequential_evaluation
stream = Electricity()
ht = HoeffdingTree(schema=stream.get_schema(), grace_period=50)
results = prequential_evaluation(stream=stream, learner=ht, window_size=4500)
print(results.cumulative.accuracy())
Metric-Fenster werden automatisch in einem Pandas DataFrame gespeichert und können mit folgendem Befehl visualisiert werden:
from capymoa.evaluation.visualization import plot_windowed_results
plot_windowed_results(results, metric="accuracy")Beispiel: Online-Bagging für den Stromdatensatz
Natürlich ist es weiterhin möglich, die Schleife zu steuern und explizit zu bewerten, wie im folgenden Beispiel gezeigt.
from capymoa.datasets import Electricity
from capymoa.evaluation import ClassificationEvaluator
from capymoa.classifier import OnlineBagging
elec_stream = Electricity()
ob_learner = OnlineBagging(schema=elec_stream.get_schema(), ensemble_size=5)
ob_evaluator = ClassificationEvaluator(schema=elec_stream.get_schema())
for instance in elec_stream:
prediction = ob_learner.predict(instance)
ob_learner.train(instance)
ob_evaluator.update(instance.y_index, prediction)
print(ob_evaluator.accuracy())Diese Flexibilität ermöglicht es Benutzer*innen, bei Bedarf Abstraktion gegen detaillierte Kontrolle einzutauschen. Weitere Informationen hierzu im CapyMOA-Notizbuch.
Schemas und Instanzen: Datenkonsistenz durch Design
Im Gegensatz zu Frameworks, die auf Python-Dictionaries basieren, erzwingt CapyMOA ein Schema für jeden Stream. Dies vermeidet stille Fehler, gewährleistet stabile Langzeitexperimente und sorgt für Kompatibilität zwischen Python- und Java-Komponenten. Unabhängig davon, ob eine CSV- oder ARFF-Datei geladen oder auf synthetische Generatoren zurückgegriffen wird, enthält jede Instanz strukturierte Metadaten, wodurch die Interoperabilität über die gesamte Pipeline hinweg zuverlässig und automatisch gewährleistet ist.
Bei lang andauernden Stream-Experimenten können kleine Inkonsistenzen die Ergebnisse unbemerkt ungültig machen. In einer auf Dictionaries basierenden Instanzdarstellung kann beispielsweise das Fehlen eines Merkmals mehrdeutig sein: Es kann auf einen fehlenden Wert hinweisen oder darauf, dass das Merkmal nicht mehr existiert. Mit expliziter Schema-Verfolgung wird diese Unterscheidung klar – das System kann erkennen, ob sich der Merkmalsatz selbst geändert hat oder ob einfach ein Wert fehlt. Dadurch kann sich der Lerner (oder andere Komponenten in der Pipeline) entsprechend an die Schemaentwicklung anpassen. Die Schema-Durchsetzung macht solche Änderungen daher explizit und reproduzierbar, was sowohl in der Forschung als auch in der Produktion ein entscheidender Vorteil ist.
Concept Drift: Ein First-Class Citizen
CapyMOA bietet ein komplettes System für die Arbeit mit Drift:
- Drift-Simulation mit DriftStream, AbruptDrift und GradualDrift
- Integration mit Bewertungs- und Visualisierungstools
- Native Unterstützung für klassische und moderne Drift-Detektoren
Beispiel: Aufbau eines Streams mit einer abrupten und einer allmählichen Drift
from capymoa.stream.drift import DriftStream, AbruptDrift, GradualDrift
from capymoa.stream.generator import SEA
from capymoa.evaluation.visualization import plot_windowed_results
stream_sea2drift = DriftStream(
stream=[
SEA(function=1),
AbruptDrift(position=5000),
SEA(function=3),
GradualDrift(position=10000, width=2000),
# GradualDrift(start=9000, end=12000),
SEA(function=1),
]
)
OB = OnlineBagging(schema=stream_sea2drift.get_schema(), ensemble_size=10)
results_sea2drift_OB = prequential_evaluation(
stream=stream_sea2drift, learner=OB, window_size=100, max_instances=15000
)
print(
f"The definition of the DriftStream is accessible through the object:\n {stream_sea2drift}"
)
plot_windowed_results(results_sea2drift_OB, metric="accuracy")Die Plots zeigen automatisch die Driftpositionen an und helfen Forschenden dabei, zu diagnostizieren, wann und warum Modelle Probleme haben. Dadurch wird Drift nicht nur erkennbar, sondern auch interpretierbar – ein entscheidender Schritt hin zu vertrauenswürdigen adaptiven Systemen.
Weitere Informationen hierzu im CapyMOA-Notizbuch.
Pipelines: Modular, flexibel und bereit für AutoML
Streaming-Pipelines sind bekanntermaßen schwierig, da Transformationen den Zustand über die Zeit hinweg beibehalten müssen. CapyMOA führt ein flexibles Pipeline-System ein, das Folgendes unterstützt:
- Feature-Scaler
- Drift-Detektoren
- Inkrementelle Lerner
- Benutzerdefinierte Komponenten über PipelineElement
- Multi-Detektor-Pipelines (z. B. ABCD + ADWIN)
Dieses Design ermöglicht Experimente mit komplexen adaptiven Pipelines unter Beibehaltung der Korrektheit über einen längeren Zeitraum. Es legt auch den Grundstein für AutoML für Datenströme, indem es Pipelines dynamisch auswählt und anpasst, wenn sich die Daten ändern.
Beispiel: Normalisierung anwenden und Rauschen hinzufügen
from capymoa.stream.preprocessing import MOATransformer
from capymoa.stream.preprocessing import ClassifierPipeline
from moa.streams.filters import AddNoiseFilter, NormalisationFilter
elec_stream = Electricity()
# Creating the transformers
normalisation_transformer = MOATransformer(
schema=elec_stream.get_schema(), moa_filter=NormalisationFilter()
)
add_noise_transformer = MOATransformer(
schema=normalisation_transformer.get_schema(), moa_filter=AddNoiseFilter()
)
# Creating a learner
ob_learner = OnlineBagging(schema=add_noise_transformer.get_schema(), ensemble_size=5)
# Creating and populating the pipeline
pipeline = (
ClassifierPipeline()
.add_transformer(normalisation_transformer)
.add_transformer(add_noise_transformer)
.add_classifier(ob_learner)
)
# Creating the evaluator
ob_evaluator = ClassificationEvaluator(schema=elec_stream.get_schema())
while elec_stream.has_more_instances():
instance = elec_stream.next_instance()
prediction = pipeline.predict(instance)
ob_evaluator.update(instance.y_index, prediction)
pipeline.train(instance)
ob_evaluator.accuracy()Weitere Informationen hierzu im CapyMOA-Notizbuch hier und hier.
Online Continual Learning (OCL): Über das klassische Stream Learning hinaus
Das traditionelle Stream Learning behandelt Konzeptdrift, geht jedoch in der Regel davon aus, dass überwachte Labels zeitnah eintreffen. OCL hingegen befasst sich mit:
- Inkrementellen Aufgaben
- Domänenverschiebungen
- Spärlichen oder verzögerten Labels
- Speicherbeschränkungen
CapyMOA integriert OCL nativ und ermöglicht es sowohl klassischen Online-Modellen als auch neuronalen kontinuierlichen Lernern, auf demselben Bewertungsrahmen zu arbeiten.
Diese einheitliche Behandlung von Stream Learning und kontinuierlichem Lernen ist noch selten und positioniert CapyMOA an der Schnittstelle zweier schnell wachsender Forschungsbereiche – als eines der ersten vollständig integrierten Frameworks, das Stream Learning und Online Continual Learning miteinander verbindet.
Beispiel: Ausführung von Experience Replay
from capymoa.ann import Perceptron
from capymoa.classifier import Finetune
from capymoa.ocl.strategy import ExperienceReplay
from capymoa.ocl.datasets import TinySplitMNIST
from capymoa.ocl.evaluation import ocl_train_eval_loop
import torch
_ = torch.manual_seed(0)
scenario = TinySplitMNIST()
model = Perceptron(scenario.schema)
learner = ExperienceReplay(Finetune(scenario.schema, model))
results = ocl_train_eval_loop(
learner,
scenario.train_loaders(32),
scenario.test_loaders(32),
)
print(f"{results.accuracy_final*100:.1f}%")Weitere Informationen hierzu im CapyMOA-Notizbuch.
Zusammenfassung
CapyMOA versteht sich als moderne Grundlage für Forschung und Praxis im Bereich des adaptiven maschinellen Lernens. Durch die ausgewogene Kombination von Effizienz, Interoperabilität und Benutzerfreundlichkeit bietet es eine Plattform, auf der:
- Forschende schnell neue Algorithmen entwickeln und testen können.
- Praktiker*innen robuste, leistungsstarke Tools für Echtzeitdaten nutzen können.
- Studierende anhand klarer, einfacher Beispiele Konzepte des Stream Learning erlernen können.
Im Zuge der Weiterentwicklung von CapyMOA sind unter anderem eine tiefere OCL-Integration, verbesserte Drift-Diagnosen, erweiterte Deep-Learning-Pipelines und eine erweiterte Unterstützung für Clustering und Anomalieerkennung geplant.
- CapyMOA ist Open Source und freut sich über Beiträge:
- Website: https://capymoa.org
- GitHub: https://github.com/adaptive-machine-learning/CapyMOA
- Tutorials: https://capymoa.org/tutorials.html
- Discord: https://discord.gg/spd2gQJGAb
