functime 0.4.3

The easiest way to run and scale time-series machine learning in the Cloud.

Time-series machine learning and embeddings at scale

---

functime is a powerful Python library for production-ready forecasting and temporal embeddings.

functime also comes with time-series preprocessing (box-cox, differencing etc), cross-validation splitters (expanding and sliding window), and forecast metrics (MASE, SMAPE etc). All optimized as lazy Polars transforms.

Want to use functime for seamless time-series predictive analytics across your data team? Looking for production-grade time-series machine learning in a serverless Cloud deployment? Shoot Chris a message on LinkedIn to learn more about functime Cloud.

Highlights

• Fast: Forecast 100,000 time series in seconds on your laptop
• Efficient: Embarrassingly parallel feature engineering for time-series using Polars
• Battle-tested: Machine learning algorithms that deliver real business impact and win competitions
• Exogenous features: supported by every forecaster
• Backtesting with expanding window and sliding window splitters
• Automated lags and hyperparameter tuning using FLAML
• Censored forecaster: for zero-inflated and thresholding forecasts

Getting Started

Install functime via the pip package manager.

pip install functime

Forecasting

import polars as pl
from functime.cross_validation import train_test_split
from functime.feature_extraction import add_fourier_terms
from functime.forecasting import linear_model
from functime.preprocessing import scale
from functime.metrics import mase

# Load commodities price data
y = pl.read_parquet("https://github.com/descendant-ai/functime/raw/main/data/commodities.parquet")
entity_col, time_col = y.columns[:2]

# Time series split
y_train, y_test = y.pipe(train_test_split(test_size=3))

# Fit-predict
forecaster = linear_model(freq="1mo", lags=24)
forecaster.fit(y=y_train)
y_pred = forecaster.predict(fh=3)

# functime ❤️ functional design
# fit-predict in a single line
y_pred = linear_model(freq="1mo", lags=24)(y=y_train, fh=3)

# Score forecasts in parallel
scores = mase(y_true=y_test, y_pred=y_pred, y_train=y_train)

# Forecast with target transforms and feature transforms
forecaster = linear_model(
    freq="1mo",
    lags=24,
    target_transform=scale(),
    feature_transform=add_fourier_terms(sp=12, K=6)
)

View the full walkthrough on forecasting with functime.

Embeddings

Currently in closed-beta for functime Cloud. Have an interesting use-case? Contact us at Calendly.

Temporal embeddings measure the relatedness of time-series. Embeddings are more accurate and efficient compared to statistical methods (e.g. Catch22) for characteristing time-series.[^1] Embeddings have applications across many domains from finance to IoT monitoring. They are commonly used for the following tasks:

• Matching: Where time-series are ranked by similarity to a given time-series
• Classification: Where time-series are grouped together by matching patterns
• Clustering: Where time-series are assigned labels (e.g. normal vs irregular heart rate)
• Anomaly detection: Where outliers with unexpected regime / trend changes are identified

View the full walkthrough on temporal embeddings with functime.

Serverless Deployment

Currently in closed-beta for functime Cloud. Contact us for a demo via Calendly.

Deploy and train forecasters the moment you call any .fit method. Run the functime list CLI command to list all deployed models. Finally, track data and forecasts usage using functime usage CLI command.

You can reuse a deployed model for predictions anywhere using the stub_id variable. Note: the .from_deployed model class must be the same as during .fit.

forecaster = LightGBM.from_deployed(stub_id)
y_pred = forecaster.predict(fh=3)

License

functime is distributed under AGPL-3.0-only. For Apache-2.0 exceptions, see LICENSING.md.