"use client";

// Load the Inkeep script
const inkeepScript = document.createElement("script");
inkeepScript.type = "module";
inkeepScript.src =
  "https://unpkg.com/@inkeep/widgets-embed@0.2.263/dist/embed.js";

document.body.appendChild(inkeepScript);

// find the Mintlify search container
const buttons = Array.from(document.getElementsByTagName("button"));
const searchButtonContainerEl = buttons.find((button) =>
  button.textContent.includes("Search or ask...")
);

const clonedSearchButtonContainerEl = searchButtonContainerEl.cloneNode(true);

// replace with dummy div, required to remove event listeners on it
searchButtonContainerEl.parentNode.replaceChild(
  clonedSearchButtonContainerEl,
  searchButtonContainerEl
);

// Once the script has loaded, load the Inkeep chat components
inkeepScript.addEventListener("load", function () {
  // Settings for the components
  const sharedConfig = {
    baseSettings: {
      apiKey: "c99c3754a78cf9f7d3d389ef9fa7c3d49cdeb18b95050d10",
      integrationId: "cltexfnd9000iy0ufy9oqo6h6",
      organizationId: "org_VKqv6JAjdI85T7aJ",
      primaryBrandColor: "#0c0c0c",
    },
    aiChatSettings: {
      chatSubjectName: "Nixtla",
      botAvatarSrcUrl:
        "https://storage.googleapis.com/organization-image-assets/nixtla-botAvatarSrcUrl-1709853122420.png",
      botAvatarDarkSrcUrl:
        "https://storage.googleapis.com/organization-image-assets/nixtla-botAvatarDarkSrcUrl-1709853121631.png",
      getHelpCallToActions: [
        {
          name: "Ask on Slack",
          url: "https://join.slack.com/t/nixtlaworkspace/shared_invite/zt-135dssye9-fWTzMpv2WBthq8NK0Yvu6A",
          icon: {
            builtIn: "FaSlack",
          },
        },
        {
          name: "View Repositories",
          url: "https://github.com/Nixtla",
          icon: {
            builtIn: "FaGithub",
          },
        },
      ],
      quickQuestions: [
        "How do I train my own model using mlforecast?",
        "How was TimeGPT trained and what's it best for?",
        "How do I make multivariate scoring for hierarchical forecasting?",
      ],
    },
  };

  // for syncing with dark mode
  const colorModeSettings = {
    observedElement: document.documentElement,
    isDarkModeCallback: (el) => {
      return el.classList.contains("dark");
    },
    colorModeAttribute: "class",
  };

  // add the chat button
  const chatButton = Inkeep().embed({
    componentType: "ChatButton",
    colorModeSync: colorModeSettings,
    properties: sharedConfig,
  });

  // insantiate Inkeep modal
  const searchButtonWithCustomTrigger = Inkeep({
    ...sharedConfig.baseSettings,
  }).embed({
    componentType: "CustomTrigger",
    colorModeSync: colorModeSettings,
    properties: {
      ...sharedConfig,
      isOpen: false,
      onClose: () => {
        searchButtonWithCustomTrigger.render({
          isOpen: false,
        });
      },
    },
  });

  // When the Mintlify search bar clone is clicked, open the Inkeep search modal
  clonedSearchButtonContainerEl.addEventListener("click", function () {
    searchButtonWithCustomTrigger.render({
      isOpen: true,
    });
  });
});


!(function (t) {
  if (window.oneloop) return;
  window.oneloop = {key: "cus_b57d16380d7240e4a47c9f4a6f0893c6"};
  var n = document.createElement("script");
  (n.async = !0),
    n.setAttribute(
      "src",
      "https://oneloop-website-script.s3.us-west-1.amazonaws.com/oneloop-main.js"
    ),
    (document.body || document.head).appendChild(n);
})();


module coreforecast.differences

function num_diffs

function num_seas_diffs

function diff

Nixtla

About TimeGPT

TimeGPT is a production ready, generative pretrained transformer for time series. It's capable of accurately predicting various domains such as retail, electricity, finance, and IoT with just a few lines of code 🚀.

TimeGPT Quickstart

TimeGPT Quickstart (Polars)

TimeGEN-1 is TimeGPT optimized for the Azure infrastructure. It is a production ready, generative pretrained transformer for time series. It's capable of accurately predicting various domains such as retail, electricity, finance, and IoT with just a few lines of code 🚀.

TimeGEN-1 Quickstart (Azure)

Setting up your API key

Subscription Plans

This section explains the data requirements for `TimeGPT`.

Data Requirements

Glossary

Why TimeGPT?

The foundational models for time series by Nixtla can be deployed on your Azure subscription. This page explains how to easily get started with TimeGEN-1 deployed as an Azure AI endpoint. If you use the `nixtla` library, it should be a drop-in replacement where you only need to change the client parameters (endpoint URL, API key, model name).

AzureAI

Anomaly detection

Forecasting web traffic

Learn how to use TimeGPT for financial time series forecasting

Bitcoin price prediction

Forecasting Energy Demand

Forecasting Intermittent Demand

What if? Forecasting price effects in retail

SDK Reference

Date Features

TimeGPT Excel Add-in (Beta)

TimeGPT in R

StatsForecast offers a collection of popular univariate time series forecasting models optimized for high performance and scalability.

StatsForecast ⚡️

Install

Quick Start

Model training, evaluation and selection for multiple time series

End to End Walkthrough

End to End Walkthrough with Polars

In this notebook, we'll implement anomaly detection in time series data

Anomaly Detection

In this example, we'll implement conformal prediction

Conformal Prediction

In this example, we'll implement time series cross-validation to evaluate model's performance.

Cross validation

In this example we will show how to perform electricity load forecasting considering a model capable of handling multiple seasonalities (MSTL).

Electricity Load Forecast

In this example we will show how to perform electricity load forecasting on the ERCOT (Texas) market for detecting daily peaks.

Detect Demand Peaks

In this example, we'll forecast the volatility of the S&P 500 and several publicly traded companies using GARCH and ARCH models

Volatility forecasting (GARCH & ARCH)

In this notebook, we'll implement models for intermittent or sparse data

Intermittent or Sparse Data

MLFlow

In this example we will show how to forecast data with multiple seasonalities using an MSTL.

Multiple seasonalities

In this notebook, you will make forecasts for the M5 dataset choosing the best model for each time series using cross validation.

Statistical, Machine Learning and Neural Forecasting methods

In this example, we'll implement prediction intervals

Probabilistic Forecasting

How to do automatic forecasting using `AutoARIMA`, `AutoETS`, `AutoCES` and `AutoTheta`.

Automatic Time Series Forecasting

In this notebook, we'll incorporate exogenous regressors to a StatsForecast model.

Exogenous Regressors

Leverage StatsForecast models to create features

Generating features

Use any scikit-learn model for forecasting

Sklearn models

Migrating from R

Enabling caching for numba functions to reduce cold-starts

Numba caching

Run StatsForecast distributedly on top of Dask.

Dask

Run StatsForecast distributedly on top of Ray.

Run StatsForecast distributedly on top of Spark.

Spark

Amazon's AutoML vs open source statistical methods

Amazon Forecast vs StatsForecast

AutoARIMA Comparison (Prophet and pmdarima)

Forecasting at Scale using ETS and ray (M5)

This notebook was originally executed using DataBricks

StatsForecast ETS and Facebook Prophet on Spark (M5)

Step-by-step guide on using the `ADIDA Model` with `Statsforecast`.

ADIDA Model

Step-by-step guide on using the `ARCH Model` with `Statsforecast`.

ARCH Model

Step-by-step guide on using the `ARIMA Model` with `Statsforecast`.

ARIMA Model

Step-by-step guide on using the `AutoARIMA Model` with `Statsforecast`.

AutoARIMA Model

Step-by-step guide on using the `AutoCES Model` with `Statsforecast`.

AutoCES Model

Step-by-step guide on using the `AutoETS Model` with `Statsforecast`.

AutoETS Model

Step-by-step guide on using the `AutoRegressive Model` with `Statsforecast`.

AutoRegressive Model

Step-by-step guide on using the `AutoTheta Model` with `Statsforecast`.

AutoTheta Model

Step-by-step guide on using the `CrostonClassic Model` with `Statsforecast`.

CrostonClassic Model

Step-by-step guide on using the `CrostonOptimized Model` with `Statsforecast`.

CrostonOptimized Model

Step-by-step guide on using the `CrostonSBA Model` with `Statsforecast`.

CrostonSBA Model

Step-by-step guide on using the `DynamicOptimizedTheta Model` with `Statsforecast`.

Dynamic Optimized Theta Model

Step-by-step guide on using the `DynamicStandardTheta Model` with `Statsforecast`.

Dynamic Standard Theta Model

Step-by-step guide on using the `GARCH Model` with `Statsforecast`.

GARCH Model

Step-by-step guide on using the `Holt Model` with `Statsforecast`.

Holt Model

Step-by-step guide on using the `Holt Winters Model` with `Statsforecast`.

Holt Winters Model

Step-by-step guide on using the `IMAPA Model` with `Statsforecast`.

IMAPA Model

MFLES is a simple time series method based on gradient boosting time series decomposition.

MFLES

Step-by-step guide on using the `MSTL Model` with `Statsforecast`.

Multiple Seasonal Trend (MSTL)

Step-by-step guide on using the `OptimizedTheta Model` with `Statsforecast`.

Optimized Theta Model

Step-by-step guide on using the `SeasonalExponentialSmoothing Model` with `Statsforecast`.

Seasonal Exponential Smoothing Model

Step-by-step guide on using the `SeasonalExponentialSmoothingOptimized Model` with `Statsforecast`.

Seasonal Exponential Smoothing Optimized Model

Step-by-step guide on using the `SimpleExponentialSmoothingOptimized Model` with `Statsforecast`.

Simple Exponential Smoothing Optimized Model

Step-by-step guide on using the `SimpleExponentialSmoothing Model` with `Statsforecast`.

Simple Exponential Smoothing Model

Step-by-step guide on using the `Standard Theta Model` with `Statsforecast`.

Standard Theta Model

Step-by-step guide on using the `TSB Model` with `Statsforecast`.

TSB Model

Methods for Fit, Predict, Forecast (fast), Cross Validation and plotting

Core Methods

FugueBackend

Models currently supported by StatsForecast

Models

StatsForecast's Models

Feature engineering

How to Contribute

Contribute to Nixtla

Writing Documentation

Nixtla Documentation

Interpreting Issue Labels

Understanding Issue Labels

Submit an Issue

Submit an Issue 📢

mlforecast

Instructions to install the package from different sources.

Quick start (local)

Minimal example of distributed training with MLForecast

Quick start (distributed)

Detailed description of all the functionalities that MLForecast provides.

End to end walkthrough

Use exogenous regressors for training and predicting

Exogenous features

Lag transformations

Hyperparameter optimization

Leverage scikit-learn's composability to define pipelines as models

Using scikit-learn pipelines

Provide a column to pass through to the underlying models as sample weights

Sample weights

Probabilistic forecasting

Target transformations

Access and interpret the models after fitting

Analyzing the trained models

MLflow

Compute transformations on your exogenous features for MLForecast

Transforming exogenous features

Customize the training procedure for your models

Custom training

Convert your dataframes to arrays to use less memory and train faster

Training with numpy arrays

Train one model to predict each step of the forecasting horizon

One model per step

Define your own functions to be used as date features

Custom date features

Get access to the input features and predictions in each forecasting horizon

Predict callbacks

Compute predictions for only a subset of the training ids

Predicting a subset of ids

Transfer Learning

In this example we will show how to perform electricity load forecasting using MLForecast alongside many models. We also compare them against the prophet library.

Prediction intervals

**NeuralForecast** offers a large collection of neural forecasting models focused on their usability, and robustness. The models range from classic networks like `MLP`, `RNN`s to novel proven contributions like `NBEATS`, `NHITS`, `TFT` and other architectures.

About NeuralForecast

Quickstart

Installation

Forecasting Models

Optimization Objectives

Exogenous Variables

Cross-validation

Hyperparameter Optimization

Tutorial on how to produce insample predictions.

Predict Insample

Save and Load Models

Time Series Scaling

Predictive Maintenance

Neuralforecasting map.html

NeuralForecast contains two main components, PyTorch implementations deep learning predictive models, as well as parallelization and distributed computation utilities. The first component comprises low-level PyTorch model estimator classes like `models.NBEATS` and `models.RNN`. The second component is a high-level `core.NeuralForecast` wrapper class that operates with sets of time series data stored in pandas DataFrames.

API Reference

Differences

`module` `coreforecast.differences`

`function` `num_diffs`

`function` `num_seas_diffs`

`function` `diff`

API Reference

​module coreforecast.differences

​function num_diffs

​function num_seas_diffs

​function diff

`module` `coreforecast.differences`

`function` `num_diffs`

`function` `num_seas_diffs`

`function` `diff`