TODS: Automated Outlier Detection for Multivariate Time Series – No ML Expertise Required

In modern data-driven operations—whether monitoring industrial sensors, analyzing financial transactions, or securing IT infrastructure—unexpected anomalies can signal critical failures, fraud, or security breaches. Yet building reliable anomaly detection systems for time-series data often demands deep machine learning expertise, extensive tuning, and significant development time.

Enter TODS (Time-series Outlier Detection System): an open-source, full-stack automated machine learning framework designed specifically for detecting outliers in multivariate time-series data. Developed by the DATA Lab at Rice University and released under the permissive Apache 2.0 license, TODS removes the barrier to entry by offering a modular, extensible, and automation-ready platform that works out of the box—without requiring users to become experts in anomaly detection algorithms.

Why TODS Stands Out

A Truly Modular, Full-Stack System

TODS is built around the concept of primitives—reusable, configurable components that implement specific functions such as data smoothing, feature extraction, or outlier scoring. With over 70 primitives spanning five categories—data processing, time-series processing, feature analysis, detection algorithms, and reinforcement—users can assemble custom detection pipelines like building blocks.

This modularity enables both flexibility and reproducibility: you can start with a default pipeline or design a tailored one for your domain, all while maintaining end-to-end traceability of each transformation and decision step.

Three Detection Modes for Real-World Scenarios

Not all anomalies look the same. TODS supports three common detection paradigms:

• Point-wise detection: Identifies individual time points that deviate from expected behavior (e.g., a sudden spike in CPU usage).
• Pattern-wise (collective) detection: Flags anomalous subsequences or behaviors over time (e.g., an unusual sequence of database queries).
• System-wise detection: Treats entire sets of time series as units to detect systemic anomalies (e.g., coordinated failures across multiple servers).

For each mode, TODS integrates a wide range of algorithms—including all point-wise methods from the popular PyOD library, state-of-the-art models like DeepLog and Telemanom, and ensemble strategies for robust system-level analysis.

Automation Meets Human Oversight

TODS isn’t just a toolkit—it’s an intelligent system. Its built-in AutoML pipeline searcher automatically explores combinations of primitives to discover high-performing pipelines for your specific dataset, all within a user-defined time budget.

At the same time, it embraces human-in-the-loop principles: the optional Graphical User Interface (GUI) allows domain experts to visually construct, inspect, and refine pipelines via drag-and-drop, making collaboration between data scientists and subject-matter experts seamless.

Real Problems, Solved Out of the Box

TODS excels in operational environments where timely, accurate anomaly detection is critical:

• Fraud detection in payment or transaction logs, where subtle behavioral shifts precede malicious activity.
• Predictive maintenance in manufacturing or energy sectors, where sensor drift or equipment faults manifest as time-series outliers.
• IT/DevOps monitoring, where abnormal resource usage across server clusters can indicate cyberattacks or misconfigurations.

In each case, TODS transforms raw, multivariate streams into actionable insights—often with minimal configuration—by leveraging its rich library of time-tested and cutting-edge detection methods.

When to Use (and When Not to Use) TODS

Ideal Use Cases

• You have structured, multivariate time-series data (e.g., CSV files with timestamped sensor readings).
• Your goal is to detect temporal anomalies, whether labeled or unlabeled.
• You want to prototype quickly or automate pipeline selection without hand-tuning models.
• Your stack supports Python 3.7+ and you can install standard system dependencies (e.g., libssl-dev, ffmpeg).

Limitations to Consider

• TODS is not designed for non-temporal data such as images, text, or static tabular records without time ordering.
• While it supports unlabeled anomaly detection, performance on completely unsupervised tasks may vary depending on data characteristics.
• The GUI and AutoML features require additional setup beyond the core library.

Getting Started in Under Five Minutes

You don’t need to be an ML expert to try TODS. Here’s how to run a basic evaluation on a sample dataset:

import pandas as pd
from tods import schemas as schemas_utils
from tods import generate_dataset, evaluate_pipeline

# Load sample data (e.g., Yahoo anomaly benchmark)
table_path = 'datasets/anomaly/raw_data/yahoo_sub_5.csv'
target_index = 6  # column containing anomaly labels
metric = 'F1_MACRO'

df = pd.read_csv(table_path)
dataset = generate_dataset(df, target_index)
pipeline = schemas_utils.load_default_pipeline()
result = evaluate_pipeline(dataset, pipeline, metric)
print(result)

Want to let TODS find the best pipeline for you? Use the built-in BruteForceSearch (or more advanced searchers) to auto-optimize within a time limit:

from tods.searcher import BruteForceSearch
from axolotl.backend.simple import SimpleRunner
from tods import generate_problem

problem = generate_problem(dataset, metric)
backend = SimpleRunner(random_seed=0)
search = BruteForceSearch(problem_description=problem, backend=backend)
best_runtime, _ = search.search_fit(input_data=[dataset], time_limit=30)

This low-code approach lets technical teams validate TODS on their own data within minutes—not weeks.

Integration and Ecosystem

TODS integrates cleanly into existing Python-based data science workflows. Its API is consistent, well-documented, and compatible with standard data formats like Pandas DataFrames.

Backed by academic research (published at AAAI 2021) and actively maintained by a reputable university lab, TODS offers both innovation and stability. The Apache 2.0 license ensures freedom to use, modify, and deploy in commercial products without legal concerns.

Moreover, TODS is part of a broader vision for data-centric AI, with connections to related projects like AutoVideo, reflecting a commitment to automated, domain-agnostic machine learning systems.

Summary

TODS delivers a rare combination: the depth of a research-grade anomaly detection framework and the accessibility of an automated, user-friendly tool. For engineers, data scientists, and technical leaders facing time-series monitoring challenges, it offers a fast, reliable, and extensible path to production-ready outlier detection—without requiring mastery of the underlying algorithms.

Whether you’re validating a proof of concept, augmenting an existing monitoring stack, or exploring new detection strategies, TODS lowers the entry barrier while maintaining the flexibility to scale with your needs.