Introduction

Forecasting the future of a business metric is often a struggle between simple linear models and overly complex neural networks that lack interpretability. For data scientists facing this gap, Uber Orbit is a professional-grade Python package for Bayesian time series forecasting and inference. With over 2,000 GitHub stars, it bridges the gap between rigorous statistical methodologies and challenging real-world business problems by providing a probabilistic approach to time series analysis.

What Is Uber Orbit?

Uber Orbit is a Python package for Bayesian time series modeling and inference that utilizes probabilistic programming languages (PPL) under the hood to produce accurate forecasts. It is maintained by Uber and released under the Apache License 2.0, providing an object-oriented design that makes complex Bayesian structural time series models accessible to any developer familiar with the Scikit-learn API.

The library is designed to handle the inherent uncertainty of time series data, allowing users to generate credible probabilistic forecasts with confidence intervals rather than single-point estimates. By leveraging backends like Stan and Pyro, Orbit transforms complex posterior approximations into a familiar initialize-fit-predict workflow.

Why Uber Orbit Matters

Traditional forecasting tools often fail when faced with the volatility of real-world data, such as sudden trend shifts or complex seasonality. Orbit fills this gap by implementing a fully Bayesian framework, which allows for the integration of prior knowledge and the quantification of uncertainty—something that is critical for high-stakes business decisions.

The project has gained significant traction because it provides an end-to-end solution. Unlike raw PPLs like Pyro or PyMC, which require deep expertise in probabilistic programming, Orbit provides pre-built, high-performance models that are optimized for time series tasks. This allows data scientists to move from data exploration to production-ready forecasts without writing custom Stan code.

Furthermore, Orbit is specifically engineered for scalability and interpretability. It enables the decomposition of a KPI time series into trend, seasonality, and the effects of exogenous variables (marketing channels, holidays, etc.), making it an essential tool for Marketing Mix Modeling (MMM) and causal inference.

Key Features

• Multiple Model Implementations: Orbit provides concrete implementations for Exponential Smoothing (ETS), Local Global Trend (LGT), Damped Local Trend (DLT), and Kernel Time-based Regression (KTR), covering a wide range of forecasting scenarios.
• Flexible Posterior Estimation: Users can choose between Markov-Chain Monte Carlo (MCMC) for full sampling, Maximum a Posteriori (MAP) for fast point estimates, and Variational Inference (VI) as a hybrid approach for approximate distributions.
• Scikit-learn Style API: The library uses a familiar .fit() and .predict() interface, drastically reducing the learning curve for Python developers.
• Uncertainty Quantification: By producing probabilistic forecasts, Orbit provides confidence intervals (credible intervals) that help stakeholders understand the risk associated with a prediction.
• Trend and Seasonality Decomposition: Orbit allows for the clear separation of the underlying trend and seasonal patterns from the noise and exogenous effects in a time series.
• Exogenous Variable Support: The models support the inclusion of external regressors, allowing users to model the impact of specific events or marketing levers on the target metric.
• High-Performance Backends: By utilizing Stan and Pyro, Orbit ensures that the heavy mathematical lifting of Bayesian inference is handled by optimized C++ and Python libraries.
• Built-in Diagnostics: The package includes tools for model validation, backtesting, and visualization of predicted components, ensuring the model is statistically sound.

How Uber Orbit Compares

When comparing Uber Orbit to Meta Prophet, the primary differentiator is the Bayesian framework. While Prophet is designed for analysts to quickly generate forecasts with a focus on additive components, Orbit provides a more rigorous statistical foundation. Orbit allows for a wider variety of model types (like DLT and LGT) and more precise uncertainty quantification through MCMC sampling, which Prophet lacks in its default configuration.

Compared to traditional ARIMA models, Orbit removes the tedious requirement for manual stationarity checks and differencing. By using a structural time series approach, it handles trends and seasonality as components of the model rather than as transformations of the data. This makes Orbit significantly more intuitive for developers who are not PhD-level econometricians.

The main tradeoff is computational intensity. Because Orbit performs posterior sampling, it will generally take longer to fit a model than a frequentist ARIMA model or a simple additive Prophet model. However, for most business use cases, the gain in accuracy and the ability to quantify risk (uncertainty) far outweighs the additional compute time.

Getting Started: Installation

Installing Uber Orbit requires a Python environment. Because it relies on cmdstanpy for Bayesian sampling, ensure you have a C++ compiler installed on your system.

Installing Stable Release

The most reliable way to install the stable version is via PyPI:

pip install orbit-ml

Installing from Source

If you wish to contribute or use the latest development features, you can install directly from the GitHub repository:

git clone https://github.com/uber/orbit.git
cd orbit
pip install -r requirements.txt
pip install .

Installing via Conda

For users preferring the Anaconda distribution, Orbit is available through the conda-forge channel:

conda install -c conda-forge orbit-ml

Installing the Development Branch

To use the experimental features on the dev branch, use the following command:

pip install git+https://github.com/uber/orbit.git@dev

How to Use Uber Orbit

The workflow in Uber Orbit follows the standard machine learning pipeline: initialize the model, fit it to training data, and predict the future values.

First, you must prepare your data in a pandas DataFrame. Your dataset should include a date column and a response column (the metric you want to forecast). If you are using exogenous variables, they should be included as additional columns in the same DataFrame.

Once the model is initialized, you call the .fit() method. Depending on the estimation method chosen (MAP, MCMC, or VI), Orbit will estimate the posterior distribution of the parameters. Finally, the .predict() method generates the forecast, including the mean prediction and the credible intervals.

Code Examples

Below is a basic implementation using the Damped Local Trend (DLT) model, which is ideal for forecasts where the trend is expected to flatten over time.

from orbit.utils.dataset import load_iclaims
from orbit.models import DLT
from orbit.diagnostics.plot import plot_predicted_data

# Load sample dataset
df = load_iclaims()

# Split into train and test sets
test_size = 52
train_df = df[:-test_size]
test_df = df[-test_size:]

# Initialize the DLT model
dlt = DLT(
    response_col='claims',
    date_col='week',
    regressor_col=['trend.unemploy', 'trend.filling', 'trend.job'],
    seasonality=52,
)

# Fit the model to the training data
dlt.fit(df=train_df)

# Predict the future values
predicted_df = dlt.predict(df=test_df)

# Visualize the results
plot_predicted_data(
    training_actual_df=train_df, 
    predicted_df=predicted_df, 
    date_col=dlt.date_col, 
    actual_col=dlt.response_col, 
    test_actual_df=test_df
)

In this example, we use the load_iclaims utility to load a dataset of unemployment claims. We specify the regressor_col to include external factors that influence the number of claims, and set the seasonality to 52 for weekly data. The plot_predicted_data function provides a visual confirmation of how well the model captured the trend and the uncertainty intervals.

Real-World Use Cases

Uber Orbit shines in scenarios where understanding the why behind a forecast is just as important as the what. Because it decomposes the time series, it is highly effective for the following:

• Marketing Mix Modeling (MMM): Marketing scientists use Orbit to measure the incrementality of different advertising channels. By treating marketing spend as exogenous variables, they can isolate the effect of each channel on a KPI (like app installs) while controlling for seasonality and baseline trend.
• Demand Forecasting for Logistics: Logistics planners use Orbit to predict driver demand in specific city zones. By incorporating local events and holidays as regressors, they can quantify the uncertainty of demand spikes, allowing for better resource allocation.
• Infrastructure Capacity Planning: DevOps engineers use Orbit to forecast server load and hardware requirements. The Bayesian approach allows them to plan for the “worst-case” scenario (the upper bound of the credible interval) rather than just the average expected load.
• Financial Budgeting and Planning: Finance teams use Orbit to perform what-if scenario analysis. By adjusting the exogenous regressors in the future prediction DataFrame, they can simulate how different budget allocations would impact future revenue.