Skip to content

OpenReservoirComputing (ORC)

ORC Logo

OpenReservoirComputing (ORC) provides GPU-accelerated implementations of reservoir computing architectures for time series forecasting and temporal data analysis. Built on JAX, ORC delivers high-performance computing capabilities with a modular design that supports both research experimentation and practical applications.

Overview

Reservoir Computing (RC) is a computational framework for processing temporal and sequential data. The approach trains only the output layer (readout) while keeping the reservoir dynamics fixed, making it computationally efficient and particularly effective for chaotic system forecasting, time series prediction, and nonlinear system identification.

Key Features

Modular Architecture: Composable embedding layers, reservoir drivers, and readout functions that can be mixed, matched, or extended with custom implementations.

Multiple Paradigms: Support for discrete- and continuous-time Echo State Networks (ESNs) and parallel reservoir architectures.

Comprehensive Tooling: Built-in chaotic dynamical systems, visualization utilities, regression solvers, and performance evaluation metrics.

Architecture

ORC decomposes reservoir computing models into three core components:

  • Embedding Layer: Maps input signals to reservoir dimension through linear or nonlinear transformations
  • Driver Layer: Implements reservoir dynamics (ESN, continuous-time ESN, custom)
  • Readout Layer: Learns mappings from reservoir states to desired outputs

This modular design enables systematic exploration of different architectural choices while maintaining consistent interfaces across implementations.

Quick Example

import orc

# Generate Lorenz system data
U, t = orc.data.lorenz63(tN=100, dt=0.01)

# Train-test split
test_perc = 0.2
split_idx = int((1 - test_perc) * U.shape[0])
U_train = U[:split_idx, :]
U_test = U[split_idx:, :]

# Create and train Echo State Network
esn = orc.forecaster.ESNForecaster(data_dim=3, res_dim=500, seed=42)
esn, res_states = orc.forecaster.train_ESNForecaster(esn, U_train)

# Generate forecast
U_pred = esn.forecast(fcast_len=U_test.shape[0], res_state=res_states[-1])

# Visualize results
orc.utils.visualization.plot_time_series(
    [U_test, U_pred],
    t[split_idx:] - t[split_idx],
    state_var_names=["x", "y", "z"],
    time_series_labels=["Ground Truth", "Forecast"]
)

Documentation

Getting Started

  • Installation: System requirements and installation procedures for CPU and GPU configurations
  • Quick Start: Step-by-step tutorial for training your first reservoir computer

User Guide

  • Overview: Comprehensive guide to ORC's capabilities and design principles
  • Models: Available reservoir computing implementations and training procedures
  • Architecture Components: Detailed documentation of embedding, driver, and readout layers

API Reference

Complete technical documentation of all classes, functions, and interfaces:

  • Forecaster: Time series forecasting models (ESN, continuous ESN, ensemble)

  • Classifier: Time series classification models

  • Control: Dynamical system control models

  • Drivers: Reservoir driver implementations

  • Embeddings: Input embedding implementations

  • Readouts: Output readout implementations

  • Data: Built-in dynamical systems for benchmarking

  • Utils: Regression, visualization, and numerical utilities

Examples

Practical demonstrations using Jupyter notebooks:

Applications

Scientific Computing: Forecasting chaotic dynamical systems, analyzing spatiotemporal phenomena, and modeling complex temporal dependencies.

Time Series Analysis: Financial forecasting, climate modeling, sensor data processing, and anomaly detection in sequential data.

Control Systems: State estimation, system identification, and real-time prediction for feedback control applications.

Machine Learning Research: Investigating novel reservoir architectures, hyperparameter optimization strategies, and performance benchmarking.

Technical Specifications

Dependencies: JAX ecosystem with Equinox for functional programming, Diffrax for ODE integration, and standard scientific Python libraries.

Performance: Optimized for both CPU and GPU execution with support for parallel reservoirs and efficient memory management.

Precision: x64 floating-point arithmetic enabled by default for numerical stability in chaotic system forecasting.

Compatibility: Python 3.10-3.12 on Linux, macOS, and Windows platforms.

Contributing

ORC welcomes contributions from the reservoir computing community. See the Contributing Guide for development procedures, coding standards, and submission guidelines.

Citation

When using ORC in research publications, please cite:

@software{orc2025,
  title={OpenReservoirComputing: GPU-accelerated reservoir computing in JAX},
  author={Williams, Jan P. and Tretiak, Dima and Kutz, Nathan and Manohar, Krithika},
  year={2025},
  url={https://github.com/Jan-Williams/OpenReservoirComputing}
}

License

This project is distributed under the Apache License. See the LICENSE file for complete terms and conditions.