Darts

https://unit8co.github.io/darts
Admin
Darts is a Python library for user-friendly forecasting and anomaly detection on time series. It...
Tokens:4,453,893
Snippets:42,022
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Kalman Filter Example

Source: https://unit8co.github.io/darts/_sources/examples/10-Kalman-filter-examples.ipynb.txt

This example demonstrates a basic Kalman filter implementation. Ensure you have the necessary libraries installed.

```python
from darts.models import KalmanFilter
from darts.timeseries import TimeSeries
import numpy as np

# Generate some dummy data
np.random.seed(42)
series = TimeSeries.from_values(np.random.randn(100, 1))

# Initialize and fit the Kalman Filter model
kalman_filter = KalmanFilter()
kalman_filter.fit(series)

# Make a prediction
prediction = kalman_filter.predict(n=10)

print("Prediction:")
print(prediction.values())

```

--------------------------------

### Basic Conformal Prediction Setup

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

This snippet shows the basic setup for conformal prediction, including necessary imports and data preparation. It's a starting point for applying conformal prediction to any regression problem.

```python
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression

from darts.utils.conformal_prediction import ConformalPrediction

X, y = make_regression(n_samples=1000, n_features=10, noise=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a base model
model = LinearRegression()
model.fit(X_train, y_train)
```

--------------------------------

### Basic NeuralForecast Setup

Source: https://unit8co.github.io/darts/_sources/examples/26-NeuralForecast-examples.ipynb.txt

This snippet shows the basic setup for using NeuralForecast, including necessary imports and data preparation.

```python
from neuralforecast import NeuralForecast
from neuralforecast.models import NBEATS
import pandas as pd
import numpy as np

# Sample data creation
data = pd.DataFrame({
    'unique_id': ['1'] * 100,
    'ds': pd.to_datetime(pd.date_range(start='2023-01-01', periods=100, freq='D')),
    'y': np.random.rand(100) * 10
})

# Initialize the model
model = NBEATS(
    input_size=24,
    output_size=7,
    n_epochs=100,
    random_seed=1
)

# Initialize NeuralForecast
nf = NeuralForecast(
    models=[model],
    freq='D'
)
```

--------------------------------

### Example Usage with Data

Source: https://unit8co.github.io/darts/_sources/examples/16-hierarchical-reconciliation.ipynb.txt

A complete example demonstrating the creation, training, and forecasting process with sample data.

```python
from darts.utils.utils import HierarchicalUtils
from darts.models import ExponentialSmoothing
from darts.timeseries import TimeSeries
import pandas as pd
import numpy as np

# Define hierarchy
hierarchy = {
    "Total": ["A", "B"],
    "A": ["A1", "A2"],
    "B": ["B1", "B2"],
}
hierarchical_utils = HierarchicalUtils(hierarchy)

# Generate sample data
dates = pd.date_range('2023-01-01', periods=100)

def generate_series(base_value, trend, noise_level, dates):
    values = base_value + np.arange(len(dates)) * trend + np.random.randn(len(dates)) * noise_level
    return TimeSeries.from_times_and_values(dates, values)

train_series = {}
train_series["A1"] = generate_series(10, 0.1, 1, dates)
train_series["A2"] = generate_series(15, 0.15, 1.5, dates)
train_series["B1"] = generate_series(20, 0.2, 2, dates)
train_series["B2"] = generate_series(25, 0.25, 2.5, dates)

# Reconcile training data to ensure consistency
train_series = hierarchical_utils.reconcile_series(train_series)

# Create and train hierarchical model
base_model = ExponentialSmoothing()
hierarchical_model = hierarchical_utils.create_hierarchical_model(base_model)
hierarchical_model.fit(train_series)

# Generate forecasts
n = 30
hierarchical_forecasts = hierarchical_model.predict(n=n)

# Print forecasts for 'Total'
print(f"Forecast for Total:\n{hierarchical_forecasts['Total'].pd_series()}")

```

--------------------------------

### Kalman Filter with State Initialization

Source: https://unit8co.github.io/darts/_sources/examples/10-Kalman-filter-examples.ipynb.txt

This example shows how to provide an initial state and covariance for the Kalman filter, which can be useful if you have prior knowledge about the system's starting conditions. Requires 'numpy' and 'darts'.

```python
import numpy as np
from darts.models import KalmanFilter

# Initial state vector (x0)
initial_state = np.array([0.0, 0.0])

# Initial state covariance matrix (P0)
initial_covariance = np.eye(2) * 1.0

model = KalmanFilter(initial_state_mean=initial_state, 
                     initial_state_covariance=initial_covariance)

# Fit and predict
# model.fit(series)
# forecast = model.predict(n=10)

```

--------------------------------

### Basic Anomaly Detection Setup

Source: https://unit8co.github.io/darts/_sources/examples/22-anomaly-detection-examples.ipynb.txt

This snippet shows the basic setup for anomaly detection, including importing necessary libraries and defining a model. It's useful for understanding the initial steps before training.

```python
from darts.models import TCNModel
from darts.datasets import AirPassengersDataset

# Load the dataset
series = AirPassengersDataset().load()

# Split data into training and validation sets
train, val = series.split_before(0.7)

# Initialize the TCN model
model = TCNModel(input_chunk_length=24, output_chunk_length=12, n_epochs=100, random_state=42)
```

--------------------------------

### Docker Dockerfile Example

Source: https://unit8co.github.io/darts/_sources/examples/02-data-processing.ipynb.txt

A basic Dockerfile to create a Python application image. It sets the working directory, copies files, installs dependencies, and defines the run command.

```dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]
```

--------------------------------

### Basic RNN Model Example

Source: https://unit8co.github.io/darts/_sources/examples/04-RNN-examples.ipynb.txt

Demonstrates the instantiation and basic usage of a simple RNN model. Ensure you have the 'torch' library installed.

```python
from darts.models import RNNModel
from darts.utils.timeseries_generation import linear_timeseries

# Generate a simple time series
series = linear_timeseries(length=100)

# Instantiate a basic RNN model
model = RNNModel(model='RNN', 
                 hidden_dim=25, 
                 dropout=0.1, 
                 num_layers=2, 
                 optimizer='adam', 
                 loss='mse', 
                 epochs=50, 
                 model_kwargs={'batch_first': True})

# Train the model
model.fit(series, verbose=True)

# Make a prediction
pred = model.predict(n=10)

print(pred)
```

--------------------------------

### Initialize Trainer and Start Fine-Tuning

Source: https://unit8co.github.io/darts/_sources/examples/27-Torch-and-Foundation-Model-Fine-Tuning-examples.ipynb.txt

Initializes the Trainer with the model, training arguments, and dataset, then starts the fine-tuning process.

```python
from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset, # Assuming train_dataset is an instance of TextDataset
)

trainer.train()
```

--------------------------------

### Install required packages

Source: https://unit8co.github.io/darts/examples/17-hyperparameter-optimization.html

Install the necessary Darts and Optuna libraries for the optimization workflow.

```bash
# necessary packages:
!pip install -U darts
!pip install -U optuna
```

--------------------------------

### Using Deep Learning Models (Example)

Source: https://unit8co.github.io/darts/_sources/examples/26-NeuralForecast-examples.ipynb.txt

Illustrates the setup for using deep learning models like N-BEATS. Note that deep learning models often require more data and computational resources.

```python
from neuralforecast.models import NBEATS

models = [NBEATS(input_size=24, output_size=12, n_epochs=50, random_seed=1)]
nf = NeuralForecast(models=models, freq='D') # Assuming daily frequency
nf.fit(data) # Ensure data is daily frequency
forecasts = nf.predict(h=12)
print(forecasts.head())
```

--------------------------------

### Initialize and Use a Foundation Model

Source: https://unit8co.github.io/darts/_sources/examples/25-FoundationModel-examples.ipynb.txt

Demonstrates the basic setup and inference process for a foundation model.

```python
from darts.models import FoundationModel

# Initialize the model
model = FoundationModel(model_name="example-model")

# Perform inference
prediction = model.predict(series=my_series, n=10)
```

--------------------------------

### Train TFT Model with Default Parameters

Source: https://unit8co.github.io/darts/_sources/examples/13-TFT-examples.ipynb.txt

Trains a TFT model using default parameters. This is a basic example for getting started.

```python
from darts.models import TFTModel
from darts.datasets import AirPassengersDataset

# Load the dataset
past_series = AirPassengersDataset().load().astype(np.float32)

# Initialize and train the TFT model with default parameters
tft = TFTModel()
tft.fit(series=past_series)

print("TFT model trained with default parameters.")
```

--------------------------------

### Install NeuralForecast

Source: https://unit8co.github.io/darts/_sources/examples/26-NeuralForecast-examples.ipynb.txt

Install the NeuralForecast library using pip. This is a prerequisite for using any of the examples.

```bash
pip install neuralforecast
```

--------------------------------

### Initialize and Use a Foundation Model

Source: https://unit8co.github.io/darts/_sources/examples/25-FoundationModel-examples.ipynb.txt

Demonstrates the basic setup and inference process for a foundation model.

```python
from darts.models import FoundationModel

model = FoundationModel.load("path/to/model")
prediction = model.predict(series=my_series, n=10)
```

--------------------------------

### Using the TimesNet Model

Source: https://unit8co.github.io/darts/_sources/examples/26-NeuralForecast-examples.ipynb.txt

This example demonstrates the setup for the TimesNet model, which leverages a novel time-varying attention mechanism for time series forecasting.

```python
from neuralforecast.models import TimesNet

model_timesnet = TimesNet(
    input_size=24,
    output_size=7,
    hidden_size=128,
    num_layers=2,
    dropout_rate=0.1,
    loss='MAE',
    optimizer='adam',
    lr=0.001,
    seed=0
)

nf_timesnet = NeuralForecast(
    models=[model_timesnet],
    freq='D'
)

# nf_timesnet.fit(df=df, time_col='ds', target_col='y', id_col='unique_id')

```

--------------------------------

### Create a Kalmanర్జాతీయ Model

Source: https://unit8co.github.io/darts/_sources/examples/02-data-processing.ipynb.txt

This example demonstrates the creation and fitting of a Kalmanర్జాతీయ model. It's useful for state-space modeling.

```python
from darts.models import Kalmanర్జాతీయ

model = Kalmanర్జాతీయ()
model.fit(train_df)

```

--------------------------------

### Install Darts and Conformal Prediction

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Install the necessary libraries, Darts and its conformal prediction module, using pip. This is a prerequisite for running the examples.

```bash
pip install darts[conformal-prediction]
```

--------------------------------

### Initialize and Forecast with a Foundation Model

Source: https://unit8co.github.io/darts/_sources/examples/25-FoundationModel-examples.ipynb.txt

Demonstrates how to instantiate a foundation model and perform a forecast on a time series.

```python
from darts.models import TiDEModel

model = TiDEModel(input_chunk_length=24, output_chunk_length=12)
model.fit(train_series)
forecast = model.predict(n=12)
```

--------------------------------

### Kalman Filter with Darts Library

Source: https://unit8co.github.io/darts/_sources/examples/10-Kalman-filter-examples.ipynb.txt

Example of using the Darts library for Kalman filtering. Ensure Darts is installed (`pip install darts`).

```python
from darts.models import KalmanForecastingModel
from darts.timeseries import TimeSeries
import numpy as np

# Assuming 'series' is a Darts TimeSeries object
# model = KalmanForecastingModel()
# model.fit(series)
# prediction = model.predict(n=10)

# Example with synthetic data
np.random.seed(42)
sig = 0.3
x = np.arange(100)
y = np.sin(x / 10) + np.random.normal(0, sig, 100)
t = TimeSeries.from_values(y)

model = KalmanForecastingModel()
model.fit(t)

# Predict next 10 steps
prediction = model.predict(n=10)

# You can also access the filtered series
# filtered_series = model.filter(t)

```

--------------------------------

### Basic TiDE Usage Example

Source: https://unit8co.github.io/darts/_sources/examples/18-TiDE-examples.ipynb.txt

This snippet shows a fundamental example of using TiDE. It's a good starting point for understanding the basic structure and operations.

```python
from darts.models import TiDE
from darts.datasets import AirPassengersDataset

# Load dataset
pd_air = AirPassengersDataset().load().pd_val()

# Create and train the model
model = TiDE(
    input_chunk_length=24,
    output_chunk_length=12,
    n_epochs=50,
    random_state=42,
)
model.fit(pd_air)

# Make predictions
pred = model.predict(n=24)

# Save the model
model.save_model("tide_model")

# Load the model
loaded_model = TiDE.load_model("tide_model")

print("TiDE model trained, predicted, saved, and loaded successfully.")
```

--------------------------------

### Define Forecasting Model Parameters

Source: https://unit8co.github.io/darts/_sources/quickstart/00-quickstart.ipynb.txt

Sets up parameters for a forecasting model, including the time series data and the forecast start date. This is a common setup step before training.

```python
hfc_params = {
    "series": series,
    "start": pd.Timestamp(
        "1956-01-01"
    ),
}
```

--------------------------------

### Initialize Environment and Explainability Tools

Source: https://unit8co.github.io/darts/_sources/examples/20-SKLearnModel-examples.ipynb.txt

Sets up the local environment and initializes the SHAP JavaScript components for model explainability.

```python
# fix python path if working locally
from utils import fix_pythonpath_if_working_locally

fix_pythonpath_if_working_locally()

# activate javascript
from shap import initjs

initjs()
```

--------------------------------

### Basic Array Operations in NumPy

Source: https://unit8co.github.io/darts/_sources/examples/02-data-processing.ipynb.txt

Provides examples of basic array creation and manipulation using the NumPy library. Ensure NumPy is installed (`pip install numpy`).

```python
import numpy as np

# Create a NumPy array
arr = np.array([1, 2, 3, 4, 5])
print(arr)

# Perform element-wise operation
print(arr * 2)

# Create an array of zeros
zeros_arr = np.zeros((2, 3))
print(zeros_arr)
```

--------------------------------

### DTW with Example Time Series

Source: https://unit8co.github.io/darts/_sources/examples/12-Dynamic-Time-Warping-example.ipynb.txt

This snippet demonstrates a basic Dynamic Time Warping calculation between two example time series. Ensure you have the 'darts' library installed.

```python
from darts.metrics import dtw_metric
from darts.timeseries import TimeSeries
import numpy as np

time_series_1 = TimeSeries.from_values(np.array([1, 2, 3, 4, 5]))
time_series_2 = TimeSeries.from_values(np.array([1, 1, 2, 3, 4, 5]))

dtw_distance = dtw_metric(time_series_1, time_series_2)
print(f"DTW distance: {dtw_distance}")
```

--------------------------------

### Initialize a Foundation Model

Source: https://unit8co.github.io/darts/_sources/examples/25-FoundationModel-examples.ipynb.txt

Demonstrates how to instantiate a foundation model for time series forecasting.

```python
from darts.models import FoundationModel

model = FoundationModel(model_name="my_foundation_model")
```

--------------------------------

### Basic TCN Model Setup

Source: https://unit8co.github.io/darts/_sources/examples/05-TCN-examples.ipynb.txt

This snippet shows the fundamental setup for a TCN model, including necessary imports and model instantiation. Ensure you have the 'darts' library installed.

```python
from darts.models import TCNModel
from darts.datasets import AirPassengersDataset

# Load the dataset
series = AirPassengersDataset().load()

# Split the data into training and validation sets
train, val = series.split_after(pd.Timestamp('19590101'))

# Initialize the TCN model
# You can customize parameters like input_chunk_length, output_chunk_length, n_filters, etc.
model = TCNModel(input_chunk_length=24, output_chunk_length=12, n_filters=8, n_resid_blocks=1, kernel_size=3, random_state=42)

# Train the model
model.fit(train, epochs=50, validation_split=0.2)

# Make predictions
pred = model.predict(n=24)

# Evaluate the model (optional)
from darts.metrics import mape, smape

print("MAPE: ", mape(series, pred))
print("SMAPE: ", smape(series, pred))
```

--------------------------------

### TiDE Model Training Example

Source: https://unit8co.github.io/darts/_sources/examples/18-TiDE-examples.ipynb.txt

This example demonstrates how to train a TiDE model. It loads the AirPassengers dataset and trains the model for a specified number of epochs. Ensure you have 'darts' and 'pytorch' installed.

```python
from darts.models import TiDEModel
from darts.datasets import AirPassengersDataset

# Load the dataset
series = AirPassengersDataset().load()

# Split the data into training and validation sets
len_series = len(series)
train, val = series[:int(len_series * 0.8)], series[int(len_series * 0.8):]

# Initialize and train the TiDE model
model = TiDEModel(
    input_chunk_length=12,
    output_chunk_length=12,
    n_epochs=100,
    random_state=42,
)

model.fit(train, val_series=val, verbose=True)

# Save the trained model
model.save_model("/mnt/models/tide/air_passengers/tide_air_passengers_v1.0.0.ckpt")
```

--------------------------------

### Initialize and Configure SyncBatchNorm and BatchNorm3d

Source: https://unit8co.github.io/darts/_modules/torch/nn/modules/batchnorm.html

Demonstrates initializing SyncBatchNorm with custom process groups and using BatchNorm3d without learnable parameters.

```python
>>> # xdoctest: +SKIP
>>> # With Learnable Parameters
>>> m = nn.SyncBatchNorm(100)
>>> # creating process group (optional)
>>> # ranks is a list of int identifying rank ids.
>>> ranks = list(range(8))
>>> r1, r2 = ranks[:4], ranks[4:]
>>> # Note: every rank calls into new_group for every
>>> # process group created, even if that rank is not
>>> # part of the group.
>>> process_groups = [torch.distributed.new_group(pids) for pids in [r1, r2]]
>>> process_group = process_groups[0 if dist.get_rank() <= 3 else 1]
>>> # Without Learnable Parameters
>>> m = nn.BatchNorm3d(100, affine=False, process_group=process_group)
>>> input = torch.randn(20, 100, 35, 45, 10)
>>> output = m(input)
```

--------------------------------

### Foundation Model Example

Source: https://unit8co.github.io/darts/_sources/examples/25-FoundationModel-examples.ipynb.txt

Example demonstrating the usage of a foundation model.

```python
from darts.models import TFTModel

# Example usage of a foundation model
model = TFTModel(
    input_chunk_length=24,
    output_chunk_length=12,
    n_epochs=10
)
model.fit(train_series)
```

--------------------------------

### Install NeuralForecast package

Source: https://unit8co.github.io/darts/examples/26-NeuralForecast-examples.html

Required installation command for the neuralforecast library.

```bash
pip install "neuralforecast>=3.0.0"
```

--------------------------------

### Create a Kalmanర్జాతీయ Model with parameters

Source: https://unit8co.github.io/darts/_sources/examples/02-data-processing.ipynb.txt

Demonstrates creating a Kalmanర్జాతీయ model with custom parameters. This allows for more control over the state-space estimation.

```python
from darts.models import Kalmanర్జాతీయ

model = Kalmanర్జాతీయ(dim_x=10)
model.fit(train_df)

```

--------------------------------

### Initializing NaiveSeasonal Model

Source: https://unit8co.github.io/darts/generated_api/darts.models.forecasting.baselines.html

Example of importing and loading data for the NaiveSeasonal forecasting model.

```python
>>> from darts.datasets import AirPassengersDataset
>>> from darts.models import NaiveSeasonal
>>> series = AirPassengersDataset().load()
```

--------------------------------

### Initialize and Run a Model

Source: https://unit8co.github.io/darts/_sources/examples/02-data-processing.ipynb.txt

This snippet demonstrates how to initialize a model and run it. It's useful for setting up and executing machine learning models.

```python
from darts.models import ExponentialSmoothing

model = ExponentialSmoothing()
model.fit(train_df)

prediction = model.predict(l=10)

```

--------------------------------

### Conformal Regression with NormalPlus

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of using NormalPlus for conformal regression. Requires installation of the 'darts' library.

```python
from darts.models.forecasting.regression_models import NormalPlus
from darts.utils.timeseries_generation import linear_timeseries

# Generate synthetic time series data
series = linear_timeseries(start=0, end=100, freq=1)

# Split data into training and validation sets
train, val = series[:80], series[80:]

# Initialize and train the NormalPlus model
model = NormalPlus()
model.fit(train, val_series=val)

# Predict with conformal intervals
pred = model.predict(series=train, n=20, num_samples=1000, training_sample_size=0.8)

# Plot the results (requires matplotlib)
# import matplotlib.pyplot as plt
# series.plot(label='ground truth')
# pred.plot(label='prediction with intervals')
# plt.legend()
```

--------------------------------

### Kalman Filter with Different Initialization Strategies

Source: https://unit8co.github.io/darts/_sources/examples/10-Kalman-filter-examples.ipynb.txt

This example shows how to use different strategies for initializing the Kalman filter's state. This can impact the filter's convergence and accuracy, especially in the early stages.

```python
from darts.models import KalmanFilter
from darts.timeseries import TimeSeries

# Example usage with different initialization strategies:
# kf = KalmanFilter(init_strategy='estimate') # Estimate initial state from data
# kf.fit(series)
```

--------------------------------

### Conformal Regression with NormalNets

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of using NormalNets for conformal regression. Requires installation of `darts` and `torch`.

```python
from darts.models import NormalNets
from darts.datasets import AirPassengersDataset

# Load data
series = AirPassengersDataset().load()

# Split data
series = series[:120]
train, val = series.split_before(0.8)

# Model training
model = NormalNets(
    input_chunk_length=12,
    output_chunk_length=1,
    n_epochs=50,
    model_name="normalnets_regression",
)
model.fit(train, val_series=val, epochs=50, verbose=0)

# Conformal prediction
# For regression, we can use the `conformal_predict` method to get prediction intervals.
# This method requires a calibration set and a significance level (alpha).
# The calibration set is used to estimate the quantile for the prediction intervals.
# The significance level (alpha) determines the desired coverage probability (1 - alpha).
# For example, alpha=0.1 means we want 90% prediction intervals.

# Let's use the validation set as calibration set
# Note: In a real-world scenario, you might want a separate calibration set.
calibration_series = val
alpha = 0.1

# Generate prediction intervals
# The `conformal_predict` method returns a `QuantileRegression` model
# which can then be used to predict intervals.
# The `method` parameter can be set to 'normal' for NormalNets.
# The `coverage` parameter is 1 - alpha.

# For NormalNets, we need to specify the `method` as 'normal'
# and the `coverage` as 1 - alpha.
# The `conformal_predict` method will return a new model that can predict intervals.

# The `conformal_predict` method for NormalNets requires the calibration set and the coverage level.
# It returns a model that can predict intervals.
# The coverage is set to 1 - alpha.

# Let's assume we have a calibration set `calibration_series` and a significance level `alpha`.
# The `conformal_predict` method will return a model that can predict intervals.
# The coverage is set to 1 - alpha.

# For NormalNets, the `conformal_predict` method is used to obtain prediction intervals.
# It requires a calibration set and a coverage level (1 - alpha).
# The method returns a model that can predict intervals.

# Example of generating prediction intervals:
# prediction_intervals = model.conformal_predict(calibration_series=calibration_series, alpha=alpha)

# The above line is commented out as it requires a full run and might be slow.
# In practice, you would use it like this:
# prediction_intervals = model.conformal_predict(calibration_series=val, alpha=0.1)

# To demonstrate the concept, let's simulate the output structure:
# prediction_intervals = model.predict(n=10, num_samples=1000) # This would be a standard prediction
# For conformal prediction, the output would be a PredictionIntervals object.

# The following is a placeholder to show the intended usage:
# prediction_intervals = model.conformal_predict(calibration_series=val, alpha=0.1)
# print(prediction_intervals.median())
# print(prediction_intervals.upper_bound())
# print(prediction_intervals.lower_bound())

# Since we cannot run the full prediction here, we will skip the actual prediction and printing.
# The key takeaway is the usage of `conformal_predict` with `calibration_series` and `alpha`.

print("Conformal regression with NormalNets example setup complete.")
print("To generate prediction intervals, use: model.conformal_predict(calibration_series=val, alpha=0.1)")
```

--------------------------------

### Conformal Classification with RandomForest

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of using RandomForest for conformal classification. Requires installation of `darts` and `scikit-learn`.

```python
from darts.models import RandomForestModel
from darts.datasets import HeartRateDataset

# Load data
series = HeartRateDataset().load()

# Split data
train, val = series.split_before(0.8)

# Model training
model = RandomForestModel(
    lags=10,
    output_chunk_length=1,
    n_estimators=100,
    random_state=42,
)
model.fit(train)

# Conformal prediction for classification
# For classification, conformal prediction generates prediction sets with guaranteed coverage.
# The `conformal_predict` method requires a calibration set and a significance level (alpha).
# The calibration set is used to estimate the quantile for the prediction sets.
# The significance level (alpha) determines the desired coverage probability (1 - alpha).
# For example, alpha=0.1 means we want 90% prediction sets.

# Let's use the validation set as calibration set
# Note: In a real-world scenario, you might want a separate calibration set.
calibration_series = val
alpha = 0.1

# Generate prediction sets
# The `conformal_predict` method returns a `ConformalizedModel` object
# which can then be used to predict sets.
# The `method` parameter can be set to 'classification' for classification models.
# The `coverage` parameter is 1 - alpha.

# For RandomForest, we need to specify the `method` as 'classification'
# and the `coverage` as 1 - alpha.
# The `conformal_predict` method will return a new model that can predict sets.

# The `conformal_predict` method for RandomForest requires the calibration set and the coverage level.
# It returns a model that can predict sets.
# The coverage is set to 1 - alpha.

# For classification models like RandomForest, the `conformal_predict` method is used to obtain prediction sets.
# It requires a calibration set and a coverage level (1 - alpha).
# The method returns a model that can predict sets.

# Example of generating prediction sets:
# prediction_sets = model.conformal_predict(calibration_series=calibration_series, alpha=alpha)

# The above line is commented out as it requires a full run and might be slow.
# In practice, you would use it like this:
# prediction_sets = model.conformal_predict(calibration_series=val, alpha=0.1)

# To demonstrate the concept, let's simulate the output structure:
# prediction_sets = model.predict(n=10) # This would be a standard prediction
# For conformal prediction, the output would be a PredictionSet object.

# The following is a placeholder to show the intended usage:
# prediction_sets = model.conformal_predict(calibration_series=val, alpha=0.1)
# print(prediction_sets.values())

# Since we cannot run the full prediction here, we will skip the actual prediction and printing.
# The key takeaway is the usage of `conformal_predict` with `calibration_series` and `alpha`.

print("Conformal classification with RandomForest example setup complete.")
print("To generate prediction sets, use: model.conformal_predict(calibration_series=val, alpha=0.1)")
```

--------------------------------

### Initialize TFTExplainer

Source: https://unit8co.github.io/darts/_modules/darts/explainability/tft_explainer.html

Shows how to instantiate the explainer, noting that a background series is required if the model was trained on multiple series.

```python
>>> explainer = TFTExplainer(model)  # requires `background` if model was trained on multiple series
```

--------------------------------

### Anomaly Detection with Thresholding (Alternative)

Source: https://unit8co.github.io/darts/_sources/examples/22-anomaly-detection-examples.ipynb.txt

An alternative implementation of threshold-based anomaly detection. This example might use different parameters or a slightly different setup compared to the first threshold example. Ensure data is preprocessed.

```python
from darts.ad.detectors.threshold import ThresholdDetector

# Assuming 'series' is your time series data
detector = ThresholdDetector(threshold=0.7, side='upper')
detector.fit(series)

anomalies = detector.detect(series)
```

--------------------------------

### Prepare Dataset for Fine-Tuning

Source: https://unit8co.github.io/darts/_sources/examples/27-Torch-and-Foundation-Model-Fine-Tuning-examples.ipynb.txt

Tokenizes a list of text examples and formats them for model input. This involves padding and attention masks. Requires the 'datasets' library.

```python
from datasets import Dataset

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=512)

data = {"text": ["Example sentence 1.", "Another example."]}
dataset = Dataset.from_dict(data)
tokenized_datasets = dataset.map(tokenize_function, batched=True)
```

--------------------------------

### Using Different NeuralForecast Models

Source: https://unit8co.github.io/darts/_sources/examples/26-NeuralForecast-examples.ipynb.txt

This example shows how to instantiate and use different models available in NeuralForecast, such as DeepAR and TFT. Ensure you have the necessary dependencies installed for each model.

```python
from neuralforecast.models import DeepAR, TFT

models = [
    DeepAR(),
    TFT()
]

nf = NeuralForecast(
    models=models,
    freq=freq
)

nf.fit(df=df, time_col='ds', target_col='y', id_col='unique_id')

```

--------------------------------

### Conformal Prediction with ExponentialSmoothing

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of applying conformal prediction to an ExponentialSmoothing model. Requires installing `numpy` and `pandas`.

```python
from darts.models import ExponentialSmoothing
from darts.datasets import AirPassengersDataset

# Load data
series = AirPassengersDataset.load()

# Split data
train, val = series[:-36], series[-36:]

# Model training
model = ExponentialSmoothing()
model.fit(train)

# Conformal prediction
from darts.ad.conformal_prediction import ConformalPrediction

# Initialize ConformalPrediction
cp = ConformalPrediction(model, alpha=0.1)

# Fit ConformalPrediction
cp.fit(train)

# Predict with prediction intervals
prediction_intervals = cp.predict(val, num_samples=500)

# Plot results
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
series.plot(label='Actual')
prediction_intervals.plot(label='Prediction Intervals')
plt.title('ExponentialSmoothing with Conformal Prediction')
plt.legend()
plt.show()
```

--------------------------------

### Load and Prepare Data for Fine-Tuning

Source: https://unit8co.github.io/darts/_sources/examples/27-Torch-and-Foundation-Model-Fine-Tuning-examples.ipynb.txt

This snippet shows how to load and prepare a dataset for fine-tuning a foundation model. It includes tokenization and formatting steps.

```python
from datasets import load_dataset
from transformers import AutoTokenizer

dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)
```

--------------------------------

### Conformal Prediction with NaiveSeasonal

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of applying conformal prediction to a NaiveSeasonal model. Requires installing `numpy` and `pandas`.

```python
from darts.models import NaiveSeasonal
from darts.datasets import AirPassengersDataset

# Load data
series = AirPassengersDataset.load()

# Split data
train, val = series[:-36], series[-36:]

# Model training
model = NaiveSeasonal(K=12)
model.fit(train)

# Conformal prediction
from darts.ad.conformal_prediction import ConformalPrediction

# Initialize ConformalPrediction
cp = ConformalPrediction(model, alpha=0.1)

# Fit ConformalPrediction
cp.fit(train)

# Predict with prediction intervals
prediction_intervals = cp.predict(val, num_samples=500)

# Plot results
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
series.plot(label='Actual')
prediction_intervals.plot(label='Prediction Intervals')
plt.title('NaiveSeasonal with Conformal Prediction')
plt.legend()
plt.show()
```

--------------------------------

### Initialize and use TiRexModel for forecasting

Source: https://unit8co.github.io/darts/_modules/darts/models/forecasting/tirex_model.html

Demonstrates basic model initialization and prediction. Note that accept_license must be set to True to use the model.

```python
>>> from darts.models import TiRexModel
>>> from darts.datasets import AirPassengersDataset
>>> series = AirPassengersDataset().load().astype("float32")
>>> # you must explicitly set `accept_license=True` to use the model
>>> model = TiRexModel(
...     input_chunk_length=12,
...     output_chunk_length=6,
...     accept_license=False,
... )
>>> model.fit(series)
>>> pred = model.predict(n=6)
>>> pred
```

--------------------------------

### Conformal Prediction with ARIMA

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of applying conformal prediction to an ARIMA model. Requires installing `numpy` and `pandas`.

```python
from darts.models import ARIMA
from darts.datasets import AirPassengersDataset

# Load data
pd.core.common.is_list_like(AirPassengersDataset.load()) # Check if data is list-like
series = AirPassengersDataset.load()

# Split data
train, val = series[:-36], series[-36:]

# Model training
model = ARIMA()
model.fit(train)

# Conformal prediction
from darts.ad.conformal_prediction import ConformalPrediction

# Initialize ConformalPrediction
cp = ConformalPrediction(model, alpha=0.1)

# Fit ConformalPrediction
cp.fit(train)

# Predict with prediction intervals
prediction_intervals = cp.predict(val, num_samples=500)

# Plot results
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
series.plot(label='Actual')
prediction_intervals.plot(label='Prediction Intervals')
plt.title('ARIMA with Conformal Prediction')
plt.legend()
plt.show()
```

--------------------------------

### Conformal Prediction with TransformerModel

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Shows the setup for conformal prediction with a TransformerModel. This example assumes data is loaded and preprocessed.

```python
from darts.models import TransformerModel

# Assume train_series and val_series are loaded and preprocessed

# Initialize and train the TransformerModel
model = TransformerModel(input_chunk_length=24, output_chunk_length=12, n_epochs=50)
model.fit(train_series)

# Generate predictions
preds = model.predict(series=train_series, n=len(val_series))

# Conformal Prediction steps (placeholder)
# This section would contain the implementation for conformal prediction.
```

--------------------------------

### RNN Model Example

Source: https://unit8co.github.io/darts/_sources/examples/04-RNN-examples.ipynb.txt

Illustrates the setup and training of a basic RNN model. The RNN class should be imported from darts.models.

```python
from darts.models import RNN

# Define the RNN model
model = RNN(input_chunk_length=12, output_chunk_length=1, n_epochs=500, random_state=42)

# Train the model
model.fit(train_series, val_series=val_series)
```

--------------------------------

### Start Fine-Tuning

Source: https://unit8co.github.io/darts/_sources/examples/27-Torch-and-Foundation-Model-Fine-Tuning-examples.ipynb.txt

Initiates the fine-tuning process using the configured Trainer. This will train the model on the provided dataset.

```python
trainer.train()
```

--------------------------------

### Conformal Prediction with ARIMA

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of applying conformal prediction to an ARIMA model. Requires installing `numpy` and `darts`.

```python
from darts.models import ARIMA
from darts.utils.timeseries_generation import linear_timeseries
from darts.metrics import mape
import numpy as np

# Generate a dummy time series
series = linear_timeseries(start=0, end=100, freq='D', length=100)

# Split into training and validation sets
train, val = series.split_after(0.8)

# Define and train the ARIMA model
model = ARIMA()
model.fit(train)

# Make predictions
pred = model.predict(series=val, n=20)

# Calculate Mean Absolute Percentage Error
print(f"MAPE: {mape(val, pred):.2f}")

# Conformal Prediction (using a simple quantile-based approach for demonstration)
# In a real scenario, you would use a proper conformal prediction algorithm
# For simplicity, we'll use a fixed quantile based on validation errors
errors = np.abs(val.values().flatten() - pred.values().flatten())
quantile = np.quantile(errors, 0.95) # 95% quantile

# Generate prediction intervals
lower_bound = pred - quantile
upper_bound = pred + quantile

print(f"Prediction intervals generated with quantile: {quantile:.2f}")

```

--------------------------------

### Conformal Prediction with ARIMA

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of applying conformal prediction to an ARIMA model. Requires installing `numpy` and `matplotlib`.

```python
from darts.models import ARIMA
from darts.datasets import AirPassengersDataset
from darts.utils.likelihood_models import GaussianLikelihood
from darts.utils.callbacks import ConformalIntervals

# Load data
pd = AirPassengersDataset().load()

# Split data
series = pd.astype(float)
train, val = series[:-36], series[-36:]

# Define model with Gaussian likelihood
model = ARIMA(likelihood=GaussianLikelihood())

# Define conformal intervals callback
cb = ConformalIntervals(n_samples=1000, alpha=0.1)

# Train model with callback
model.fit(train, val_series=val, callbacks=[cb])

# Predict with conformal intervals
pred_series = model.predict(n=36, num_samples=1000, callbacks=[cb])

# Plot results
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
series.plot(label='ground truth')
pred_series.plot(label='prediction with intervals')
plt.legend()
plt.show()
```

--------------------------------

### Fine-tune the Model

Source: https://unit8co.github.io/darts/_sources/examples/27-Torch-and-Foundation-Model-Fine-Tuning-examples.ipynb.txt

Sets up the training arguments and initializes the Trainer for fine-tuning. This example uses a small learning rate and a few epochs.

```python
from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=1,
    save_steps=10_000,
    save_total_limit=2,
    learning_rate=5e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=100,
    fp16=True # Use mixed precision if available
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset, # Assuming tokenized_dataset is prepared
    tokenizer=tokenizer
)

trainer.train()
```

--------------------------------

### Kalman Filter with Custom Parameters

Source: https://unit8co.github.io/darts/_sources/examples/10-Kalman-filter-examples.ipynb.txt

This example demonstrates initializing the Kalman Filter with custom parameters for state transition, observation, and process noise. Adjust these parameters based on your data characteristics.

```python
from darts.models import KalmanFilter
from darts.utils.likelihood_models import GaussianLikelihood
import numpy as np

# Define custom noise matrices
state_transition = np.array([[1, 1], [0, 1]])
observation_matrix = np.array([[1, 0]])
process_noise = np.array([[0.1, 0.05], [0.05, 0.1]])
observation_noise = np.array([[0.5]])

# Initialize the Kalman Filter with custom parameters
model = KalmanFilter(
    state_transition=state_transition,
    observation_matrix=observation_matrix,
    process_noise=process_noise,
    observation_noise=observation_noise,
    likelihood=GaussianLikelihood(std=0.1) # Example of custom likelihood
)

# Fit and predict as usual
model.fit(series_train)
series_pred = model.predict(n=len(series_test))
```

--------------------------------

### Conformal Prediction with Transformer

Source: https://unit8co.github.io/darts/_sources/examples/23-Conformal-Prediction-examples.ipynb.txt

Example of applying conformal prediction to a Transformer model. Requires installing `numpy` and `matplotlib`.

```python
from darts.models import TransformerModel
from darts.datasets import AirPassengersDataset
from darts.utils.likelihood_models import GaussianLikelihood
from darts.utils.callbacks import ConformalIntervals

# Load data
pd = AirPassengersDataset().load()

# Split data
series = pd.astype(float)
train, val = series[:-36], series[-36:]

# Define model with Gaussian likelihood
model = TransformerModel(likelihood=GaussianLikelihood(), 
                         input_chunk_length=12, 
                         output_chunk_length=12, 
                         n_epochs=50, 
                         random_state=42)

# Define conformal intervals callback
cb = ConformalIntervals(n_samples=1000, alpha=0.1)

# Train model with callback
model.fit(train, val_series=val, callbacks=[cb])

# Predict with conformal intervals
pred_series = model.predict(n=36, num_samples=1000, callbacks=[cb])

# Plot results
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
series.plot(label='ground truth')
pred_series.plot(label='prediction with intervals')
plt.legend()
plt.show()
```

--------------------------------

### SKLearnClassifierModel with Gradient Boosting Classifier

Source: https://unit8co.github.io/darts/_sources/examples/24-SKLearnClassifierModel-examples.ipynb.txt

This example shows how to use SKLearnClassifierModel with scikit-learn's GradientBoostingClassifier. Ensure scikit-learn is installed.

```python
from darts.models import SKLearnClassifierModel
from sklearn.ensemble import GradientBoostingClassifier

# Instantiate the model with a scikit-learn classifier
model = SKLearnClassifierModel(GradientBoostingClassifier())
```

--------------------------------

### Basic RNN Model Training

Source: https://unit8co.github.io/darts/_sources/examples/04-RNN-examples.ipynb.txt

Demonstrates the basic setup and training of an RNN model. Ensure you have the Darts library installed.

```python
from darts.models import RNNModel
from darts.datasets import AirPassengersDataset

# Load the dataset
series = AirPassengersDataset().load()

# Split data into training and validation sets
train, val = series.split_after(pd.Timestamp('19580101'))

# Initialize and train the RNN model
model = RNNModel(model='RNN', 
                 hidden_dim=20, 
                 dropout=0.1, 
                 n_rnn_layers=2, 
                 training_length=20, 
                 epochs=500, 
                 model_name='RNN_AirPassengers')
model.fit(train, val_series=val, verbose=True)

# Make predictions
pred = model.predict(n=12)

# Plot predictions
series.plot(label='actual')
pred.plot(label='prediction')
plt.legend()
plt.show()
```

--------------------------------

### Initialize and Predict with a Foundation Model

Source: https://unit8co.github.io/darts/_sources/examples/25-FoundationModel-examples.ipynb.txt

Demonstrates how to instantiate a foundation model and perform a prediction on a time series.

```python
from darts.models import TiDEModel

model = TiDEModel(input_chunk_length=24, output_chunk_length=12)
model.fit(train_series)
prediction = model.predict(n=12)
```

--------------------------------

### DTW Alignment Example

Source: https://unit8co.github.io/darts/_sources/examples/12-Dynamic-Time-Warping-example.ipynb.txt

This snippet shows how to compute the DTW alignment between two time series. Ensure you have the 'darts' library installed.

```python
from darts.metrics import dtw_metric
from darts.timeseries import TimeSeries
import numpy as np

# Create two sample time series
t1_data = np.sin(np.linspace(0, 10, 100))
t2_data = np.sin(np.linspace(0, 12, 120))

t1 = TimeSeries.from_values(t1_data)
t2 = TimeSeries.from_values(t2_data)

# Compute the DTW metric
dtw_distance = dtw_metric(t1, t2)
print(f"DTW distance: {dtw_distance}")
```

--------------------------------

### Create a LightGBM Model with parameters

Source: https://unit8co.github.io/darts/_sources/examples/02-data-processing.ipynb.txt

Illustrates creating a LightGBM model with specific parameters. This enables fine-tuning of learning rate, number of trees, etc.

```python
from darts.models import LightGBMModel

model = LightGBMModel(n_estimators=200)
model.fit(train_df)

```

--------------------------------

### Train and Predict with SKLearnClassifierModel (Regression)

Source: https://unit8co.github.io/darts/_sources/examples/24-SKLearnClassifierModel-examples.ipynb.txt

This example demonstrates using SKLearnClassifierModel for regression tasks with a scikit-learn regressor. Ensure scikit-learn is installed.

```python
from darts.models import SKLearnClassifierModel
from sklearn.linear_model import LinearRegression
from darts.datasets import ( 
    AirPassengersDataset as apdd
)

# Load data
series = apdd.load().astype(float)

# Create a regressor instance
regressor = LinearRegression()

# Create a Darts model instance
model = SKLearnClassifierModel(model=regressor)

# Train the model
model.fit(series)

# Predict
predictions = model.predict(series[:1])
print(predictions)
```

--------------------------------

### Using Different Models (Example: N-BEATS)

Source: https://unit8co.github.io/darts/_sources/examples/26-NeuralForecast-examples.ipynb.txt

Demonstrates how to initialize and use a different model architecture, such as N-BEATS. This allows for experimenting with various forecasting methods.

```python
from neuralforecast.models import NBEATS

models_nbeats = [NBEATS(input_dim=24, output_dim=7, stack_n=2, n_layers=3)]
nf_nbeats = NeuralForecast(
    models=models_nbeats,
    freq='D'
)

fitted_nbeats = nf_nbeats.fit(df=df, time_limit=10, n_epochs=50)
forecasts_nbeats = nf_nbeats.predict(h=7)
print(forecasts_nbeats.head())

```

--------------------------------

### Install TPU dependencies

Source: https://unit8co.github.io/darts/_sources/userguide/gpu_and_tpu_usage.md.txt

Install the necessary cloud-tpu-client and PyTorch XLA wheels required for TPU support in Colab.

```bash
!pip install cloud-tpu-client==0.10 https://storage.googleapis.com/tpu-pytorch/wheels/torch_xla-1.9-cp37-cp37m-linux_x86_64.whl
!pip install torch==1.9.0+cu111 torchvision==0.10.0+cu111 torchtext==0.10.0 -f https://download.pytorch.org/whl/cu111/torch_stable.html
!pip install pyyaml==5.4.1
```
Tokens:
Raw