### Setup ForecastingPipeline Environment

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingcomposeforecastingpipeline

Initializes the necessary datasets, forecasters, and transformers required for pipeline examples.

```python
>>> from sktime.datasets import load_longley
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.forecasting.compose import ForecastingPipeline
>>> from sktime.transformations.impute import Imputer
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.split import temporal_train_test_split
>>> from sklearn.preprocessing import MinMaxScaler
>>> y, X = load_longley()
>>> y_train, _, X_train, X_test = temporal_train_test_split(y, X)
>>> fh = ForecastingHorizon(X_test.index, is_relative=False)
```

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

### Setup ForecastingHorizon Environment

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingbaseforecastinghorizon

Initial imports and data preparation required for using ForecastingHorizon examples.

```python
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.datasets import load_airline
>>> from sktime.split import temporal_train_test_split
>>> import numpy as np
>>> y = load_airline()
>>> y_train, y_test = temporal_train_test_split(y, test_size=6)
```

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

### Installation

Source: https://www.sktime.net/docs/examples/transformation/fracdiff/example-howto

Install the necessary dependencies for data manipulation and fractional differentiation.

```bash
# !pip install matplotlib pandas pandas_datareader seaborn
# !pip install fracdiff
```

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

### Install documentation dependencies

Source: https://www.sktime.net/docs/developer-guide/documentation

Installs the necessary packages for building documentation from the project root.

```bash
pip install --editable .[docs]
```

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

### Install sktime and dependencies

Source: https://www.sktime.net/docs/examples/blog-posts/overview-of-sktime-functionalities-for-forecasting

Use this command to install sktime along with all optional dependencies.

```bash
# %%capture
# !pip install numpy
# !pip install pandas
# !pip install seaborn
# !pip install 'sktime[all_extras]'
```

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

### Install dependencies

Source: https://www.sktime.net/docs/examples/transformation/fracdiff/example-exercise

Install the necessary libraries for cointegration analysis, data manipulation, and fractional differentiation.

```bash
# !pip install cointanalysis matplotlib numpy pandas pandas_datareader scipy seaborn sklearn statsmodels  # noqa: E501
# !pip install fracdiff
```

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

### Environment Setup

Source: https://www.sktime.net/docs/examples/transformation/fracdiff/example-howto

Import required libraries and configure plotting styles.

```python
import matplotlib.pyplot as plt
import pandas as pd
import pandas_datareader
import seaborn

seaborn.set_style("white")
```

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

### Install sphinx-autobuild

Source: https://www.sktime.net/docs/developer-guide/documentation

Installs the tool required for live-reloading documentation during development.

```bash
pip install sphinx-autobuild
```

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

### Import ExpandingGreedySplitter

Source: https://www.sktime.net/docs/api-reference/sktimesplitexpandinggreedyexpandinggreedysplitter

Initial setup required to use the splitter.

```python
>>> import numpy as np
>>> from sktime.split import ExpandingGreedySplitter
```

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

### Basic Deployment Workflow

Source: https://www.sktime.net/docs/examples/forecasting

A complete workflow example using the NaiveForecaster to predict values.

```python
from sktime.datasets import load_airline
from sktime.forecasting.base import ForecastingHorizon
from sktime.forecasting.naive import NaiveForecaster
```

```python
# step 1: data specification
y = load_airline()

# step 2: specifying forecasting horizon
fh = np.arange(1, 37)

# step 3: specifying the forecasting algorithm
forecaster = NaiveForecaster(strategy="last", sp=12)

# step 4: fitting the forecaster
forecaster.fit(y)

# step 5: querying predictions
y_pred = forecaster.predict(fh)
```

```python
# optional: plotting predictions and past data
plot_series(y, y_pred, labels=["y", "y_pred"])
```

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

### Install latest sktime from GitHub

Source: https://www.sktime.net/docs/installation

Installs the latest static snapshot of the sktime repository directly from GitHub.

```bash
pip install git+https://github.com/sktime/sktime.git
```

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

### Install sktime from a local clone

Source: https://www.sktime.net/docs/installation

Installs sktime from the current directory, typically used after cloning the repository.

```bash
pip install .
```

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

### Setup and Imports

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingcomposetransformedtargetforecaster

Initial imports and data loading required for using TransformedTargetForecaster.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.forecasting.compose import TransformedTargetForecaster
>>> from sktime.transformations.impute import Imputer
>>> from sktime.transformations.detrend import Detrender
>>> from sktime.transformations.exponent import ExponentTransformer
>>> y = load_airline()
```

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

### Run live-reloading documentation server

Source: https://www.sktime.net/docs/developer-guide/documentation

Starts a local server that automatically rebuilds documentation upon file changes.

```bash
make autobuild
```

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

### Initialize Pairwise Series Data

Source: https://www.sktime.net/docs/examples/transformers

Setup univariate series and panel data for pairwise transformer examples.

```python
from sktime.datatypes import get_examples

# unviariate series used in the examples
X_series = get_examples("pd.Series", "Series")[0]
X2_series = get_examples("pd.Series", "Series")[1]
# panel used in the examples
X_panel = get_examples("pd-multiindex", "Panel")[0]
```

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

### Import SAX Transformer

Source: https://www.sktime.net/docs/api-reference/sktimetransformationssaxsax

Initial setup required to use the SAX transformer.

```python
>>> from numpy import arange
>>> from sktime.transformations.sax import SAX
```

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

### Setup input data for HolidayFeatures

Source: https://www.sktime.net/docs/api-reference/sktimetransformationsholidayholidayfeatures

Prepare a pandas DataFrame with a daily datetime index for use with holiday transformation examples.

```python
>>> import numpy as np
>>> import pandas as pd
>>> from datetime import date
>>> from holidays import country_holidays, financial_holidays
>>> values = np.random.normal(size=365)
>>> index = pd.date_range("2000-01-01", periods=365, freq="D")
>>> X = pd.DataFrame(values, index=index)
```

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

### Initialize TimeSince with Airline Dataset

Source: https://www.sktime.net/docs/api-reference/sktimetransformationstime-sincetimesince

Setup the environment and load the airline dataset for time series transformation.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.transformations.time_since import TimeSince
>>> X = load_airline()
```

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

### Deseasonalizer usage example

Source: https://www.sktime.net/docs/api-reference/sktimetransformationsdetrenddeseasonalizer

Demonstrates how to initialize the Deseasonalizer and apply it to a time series dataset.

```python
>>> from sktime.transformations.detrend import Deseasonalizer
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> transformer = Deseasonalizer()
>>> y_hat = transformer.fit_transform(y)
```

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

### StackingForecaster Usage Example

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingcomposestackingforecaster

Demonstrates how to initialize a StackingForecaster with multiple base models and fit it to a time series dataset.

```python
>>> from sktime.forecasting.compose import StackingForecaster
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.forecasting.trend import PolynomialTrendForecaster
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> forecasters = [
...     ("trend", PolynomialTrendForecaster()),
...     ("naive", NaiveForecaster()),
... ]
>>> forecaster = StackingForecaster(forecasters=forecasters)
>>> forecaster.fit(y=y, fh=[1,2,3])
StackingForecaster(...)
>>> y_pred = forecaster.predict()
```

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

### Setup and Basic Transformation

Source: https://www.sktime.net/docs/api-reference/sktimetransformationsadaptpandastransformadaptor

Initialize the transformer with a pandas method name and apply it to a time series dataset.

```python
>>> from sktime.transformations.adapt import PandasTransformAdaptor
>>> from sktime.datasets import load_airline
>>> y = load_airline()
```

```python
>>> transformer = PandasTransformAdaptor("diff")
>>> y_hat = transformer.fit_transform(y)
```

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

### Load example data

Source: https://www.sktime.net/docs/examples/transformers

Retrieve univariate series and panel data examples using the sktime datatypes utility.

```python
from sktime.datatypes import get_examples

# univariate series used in the examples
X_series = get_examples("pd.Series", "Series")[3]
# panel used in the examples
X_panel = get_examples("pd-multiindex", "Panel")[2]
```

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

### Initialize pre-commit hooks

Source: https://www.sktime.net/docs/developer-guide/coding-standards

Install the pre-commit hooks in the local repository to automate code quality checks on commit.

```bash
pre-commit install
```

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

### Importing necessary modules

Source: https://www.sktime.net/docs/api-reference/sktimetransformationscomposecolumnensembletransformer

Initial setup for using ColumnEnsembleTransformer with sktime components.

```python
>>> import pandas as pd
>>> from sktime.transformations.compose import ColumnEnsembleTransformer
>>> from sktime.transformations.detrend import Detrender
>>> from sktime.transformations.difference import Differencer
>>> from sktime.datasets import load_longley
```

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

### Install sktime from a specific branch

Source: https://www.sktime.net/docs/installation

Installs a specific branch of the sktime repository by appending the branch name to the URL.

```bash
pip install git+https://github.com/sktime/sktime.git@<branch_name>
```

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

### Retrieve sktime data examples

Source: https://www.sktime.net/docs/examples/hierarchical-forecasting

Imports the utility function to fetch example datasets for different data types.

```python
from sktime.datatypes import get_examples
```

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

### Initialize and fit ForecastX

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingcomposeforecastx

Imports and basic setup for using ForecastX with VAR and ARIMA models.

```python
>>> from sktime.datasets import load_longley
>>> from sktime.forecasting.arima import ARIMA
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.forecasting.compose import ForecastX
>>> from sktime.forecasting.var import VAR
```

```python
>>> y, X = load_longley()
>>> fh = ForecastingHorizon([1, 2, 3])
>>> pipe = ForecastX(
...     forecaster_X=VAR(),
...     forecaster_y=ARIMA(),
... )
>>> pipe = pipe.fit(y, X=X, fh=fh)
>>> # this now works without X from the future of y!
>>> y_pred = pipe.predict(fh=fh)
```

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

### Get bivariate pd.DataFrame example

Source: https://www.sktime.net/docs/examples/hierarchical-forecasting

Retrieves the second example of a bivariate series in the pd.DataFrame format.

```python
get_examples(mtype="pd.DataFrame")[1]
```

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

### Initialize TransformerPipeline

Source: https://www.sktime.net/docs/api-reference/sktimetransformationscomposetransformerpipeline

Setup required for creating a pipeline with ExponentTransformer instances.

```python
>>> from sktime.transformations.compose import TransformerPipeline
>>> from sktime.transformations.exponent import ExponentTransformer
>>> t1 = ExponentTransformer(power=2)
>>> t2 = ExponentTransformer(power=0.5)
```

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

### Get univariate pd.DataFrame example

Source: https://www.sktime.net/docs/examples/hierarchical-forecasting

Retrieves the first example of a univariate series in the pd.DataFrame format.

```python
get_examples(mtype="pd.DataFrame")[0]
```

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

### Get pd-multiindex panel example

Source: https://www.sktime.net/docs/examples/hierarchical-forecasting

Retrieves the first example of a panel of multivariate series in the pd-multiindex format.

```python
get_examples(mtype="pd-multiindex")[0]
```

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

### Import PAA Transformer

Source: https://www.sktime.net/docs/api-reference/sktimetransformationspaapaa

Initial setup required to use the PAA transformer.

```python
>>> from numpy import arange
>>> from sktime.transformations.paa import PAA
```

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

### Example .ts File Structure

Source: https://www.sktime.net/docs/api-reference/file-specifications/ts

A sample extract from a BasicMotion.ts file demonstrating the description, metadata, and data blocks.

```text
 1#The data was generated as part of a student project where four students performed four activities whilst wearing a smart watch.
 2#The watch collects 3D accelerometer and a 3D gyroscope It consists of four classes, which are walking, resting, running and
 3#badminton.
 4...
 5@problemName BasicMotions
 6@timeStamps false
 7@missing false
 8...
 9@data
10-0.740653,-0.740653,10.208449,2.867009,-0.194301,-0.194301,-0.249618,0.516079,-0.255552:Standing
11-0.247409,-0.247409,-0.77129,-0.576154,-0.368484,-0.020851,-0.020851,-0.465607,-0.382975,-0.382975:Walking
12...
```

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

### Initialize and fit a ThetaForecaster

Source: https://www.sktime.net/docs/examples/probabilistic-forecasting

Setup a ThetaForecaster and fit it to the airline dataset.

```python
import numpy as np

from sktime.datasets import load_airline
from sktime.forecasting.theta import ThetaForecaster

# until fit, identical with the simple workflow
y = load_airline()

fh = np.arange(1, 13)

forecaster = ThetaForecaster(sp=12)
forecaster.fit(y, fh=fh)
```

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

### Retrieve tabular data examples

Source: https://www.sktime.net/docs/examples/distances-kernels

Use get_examples to fetch sample pandas DataFrames for testing.

```python
from sktime.datatypes import get_examples

# we retrieve some DataFrame examples
X_tabular = get_examples("pd.DataFrame", "Series")[1]
X2_tabular = get_examples("pd.DataFrame", "Series")[1][0:3]
```

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

### Initialize PluginParamsTransformer with Seasonality Estimation

Source: https://www.sktime.net/docs/api-reference/sktimeparam-estpluginpluginparamstransformer

Setup a pipeline using a seasonality estimator to determine parameters for a Deseasonalizer.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.param_est.plugin import PluginParamsTransformer
>>> from sktime.param_est.seasonality import SeasonalityACF
>>> from sktime.transformations.detrend import Deseasonalizer
>>> from sktime.transformations.difference import Differencer
>>>
>>> X = load_airline()
>>>
>>> # sp_est is a seasonality estimator
>>> # ACF assumes stationarity so we concat with differencing first
>>> sp_est = Differencer() * SeasonalityACF()
```

```python
>>> # trafo is a forecaster with a "sp" parameter which we want to tune
>>> trafo = Deseasonalizer()
>>> sp_auto = PluginParamsTransformer(sp_est, trafo)
>>>
>>> # fit sp_auto to data, transform, and inspect the tuned sp parameter
>>> sp_auto.fit(X)
PluginParamsTransformer(...)
>>> Xt = sp_auto.transform(X)
>>> sp_auto.transformer_.get_params()["sp"]
12
>>> # shorthand ways to specify sp_auto, via dunder, does the same
>>> sp_auto = sp_est * trafo
>>> # or entire pipeline in one go
>>> sp_auto = Differencer() * SeasonalityACF() * Deseasonalizer()
```

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

### Initialize and use EnbPIForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingenbpienbpiforecaster

Demonstrates setting up an EnbPIForecaster with a base NaiveForecaster and a MovingBlockBootstrap transformer, followed by fitting and prediction.

```python
>>> import numpy as np
>>> from tsbootstrap import MovingBlockBootstrap
>>> from sktime.forecasting.enbpi import EnbPIForecaster
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.datasets import load_airline
>>> from sktime.transformations.difference import Differencer
>>> from sktime.transformations.detrend import Deseasonalizer
>>> from sktime.forecasting.base import ForecastingHorizon
>>> y = load_airline()
>>> forecaster = Differencer(lags=[1]) * Deseasonalizer(sp=12) * EnbPIForecaster(
...    forecaster=NaiveForecaster(sp=12),
...    bootstrap_transformer=MovingBlockBootstrap(n_bootstraps=10))
>>> fh = ForecastingHorizon(np.arange(1, 13))
>>> forecaster.fit(y, fh=fh)
TransformedTargetForecaster(...)
>>> res = forecaster.predict()
>>> res_int = forecaster.predict_interval(coverage=[0.5])
```

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

### Importing check_estimator

Source: https://www.sktime.net/docs/api-reference/sktimeutilsestimator-checkscheck-estimator

Initial setup required to use the estimator checking utility.

```python
>>> from sktime.transformations.exponent import ExponentTransformer
>>> from sktime.utils.estimator_checks import check_estimator
```

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

### Initialize PeakTimeFeature Data

Source: https://www.sktime.net/docs/api-reference/sktimetransformationspeakpeaktimefeature

Setup the environment and load the solar dataset for use with the transformer.

```python
>>> from sktime.transformations.peak import PeakTimeFeature
>>> from sktime.datasets import
>>> y = load_solar()
>>> y = y.tz_localize(None)
>>> y = y.asfreq("H")
```

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

### Full Classification Workflow

Source: https://www.sktime.net/docs/examples/classification-clustering

A complete example combining data loading, model initialization, training, and prediction.

```python
# steps 1, 2 - prepare osuleaf dataset (train and new)
from sktime.datasets import load_italy_power_demand

X_train, y_train = load_italy_power_demand(split="train", return_type="numpy3D")
X_new, _ = load_italy_power_demand(split="test", return_type="numpy3D")

# step 3 - specify the classifier
from sktime.classification.distance_based import KNeighborsTimeSeriesClassifier
from sktime.dists_kernels import FlatDist, ScipyDist

eucl_dist = FlatDist(ScipyDist())
clf = KNeighborsTimeSeriesClassifier(n_neighbors=3, distance=eucl_dist)

# step 4 - fit/train the classifier
clf.fit(X_train, y_train)

# step 5 - predict labels on new data
y_pred = clf.predict(X_new)
```

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

### Fit and Transform with IntervalSegmenter

Source: https://www.sktime.net/docs/api-reference/sktimetransformationssegmentintervalsegmenter

Example demonstrating the initialization of the segmenter and the application of fit_transform on panel data.

```python
>>> X = _make_panel()
>>> t = IntervalSegmenter()
>>> Xt = t.fit_transform(X)
```

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

### Install Numba

Source: https://www.sktime.net/docs/examples/transformation/minirocket

Install or upgrade the Numba library required for MiniRocket compilation.

```bash
# !pip install --upgrade numba
```

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

### Importing sktime splitters and dependencies

Source: https://www.sktime.net/docs/examples/forecasting/window-splitters

Initial setup for using window splitters and plotting utilities in sktime.

```python
from warnings import simplefilter

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from matplotlib.ticker import MaxNLocator

from sktime.datasets import load_airline
from sktime.forecasting.base import ForecastingHorizon
from sktime.split import (
    CutoffSplitter,
    ExpandingWindowSplitter,
    SingleWindowSplitter,
    SlidingWindowSplitter,
    temporal_train_test_split,
)
from sktime.utils.plotting import plot_series
```

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

### Initialize and use TimerForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingtimertimerforecaster

Demonstrates the basic workflow of importing, initializing, fitting, and predicting with the TimerForecaster model.

```python
>>> from sktime.forecasting.timer import TimerForecaster
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> forecaster = TimerForecaster(
...     model_name="thuml/timer-base-84m",
... )
>>> forecaster.fit(y)
>>> y_pred = forecaster.predict(fh=[1, 2, 3])
```

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

### Install tsfresh

Source: https://www.sktime.net/docs/examples/transformation/feature-extraction-with-tsfresh

Command to install the tsfresh library if it is not already present in the environment.

```bash
# !pip install --upgrade tsfresh
```

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

### Initialize fABBA Transformer

Source: https://www.sktime.net/docs/examples/transformation/fabba

Setup the FABBA transformer with specific clustering methods and approximation tolerances.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from sktime.datasets import load_airline
from sktime.transformations.fabba import FABBA

# Load example dataset
y = load_airline()

# Load fABBA transformer
transformer = FABBA(
    n_jobs=1,
    # k=50, # doesn't matter for agg, since it determines k automatically
    random_state=42,
    return_start_values=True,  # neccessary for inverse transform
    method="agg",  # method for clustering
    tolerance=0.001,  # determines no of pieces formed, tolerance for approximation
    alpha=0.05,  # determines no of symbols formed, tolerance for clustering
)
```

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

### Batch Forecast Evaluation Workflow (Class Interface)

Source: https://www.sktime.net/docs/examples/forecasting

A complete workflow example demonstrating data splitting, forecasting, and evaluation using the class interface.

```python
from sktime.datasets import load_airline
from sktime.forecasting.base import ForecastingHorizon
from sktime.forecasting.naive import NaiveForecaster
from sktime.performance_metrics.forecasting import MeanAbsolutePercentageError
from sktime.split import temporal_train_test_split
```

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

### Detecting Changepoints with PELT

Source: https://www.sktime.net/docs/api-reference/sktimedetectionpeltpelt

Example demonstrating how to initialize the PELT detector with an L2 cost function and a penalty, then fit it to synthetic data.

```python
>>> from sktime.detection.pelt import PELT
>>> from sktime.detection.costs._l2_cost import L2Cost
>>> import numpy as np
>>> X = np.concatenate([np.zeros(50), 10 * np.ones(50)])
>>> detector = PELT(cost=L2Cost(), penalty=15)
>>> detector.fit(X).predict(X)
```

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

### EnsembleForecaster usage example

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingcomposeensembleforecaster

Demonstrates initializing an EnsembleForecaster with multiple models and custom weights, then fitting and predicting on airline data.

```python
>>> from sktime.forecasting.compose import EnsembleForecaster
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.forecasting.trend import PolynomialTrendForecaster
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> forecasters = [
...     ("trend", PolynomialTrendForecaster()),
...     ("naive", NaiveForecaster()),
... ]
>>> forecaster = EnsembleForecaster(forecasters=forecasters, weights=[4, 10])
>>> forecaster.fit(y=y, fh=[1,2,3])
EnsembleForecaster(...)
>>> y_pred = forecaster.predict()
```

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

### Install editable development version

Source: https://www.sktime.net/docs/developer-guide/continuous-integration

Installs the package in editable mode with development dependencies.

```bash
pip install -e ".[dev]"
```

```bash
pip install -e ".[dev,dependencies_lower]"
```

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

### Generate Splits with ExpandingGreedySplitter

Source: https://www.sktime.net/docs/api-reference/sktimesplitexpandinggreedyexpandinggreedysplitter

Example demonstrating how to initialize the splitter and generate train/test indices for a numpy array.

```python
>>> ts = np.arange(10)
>>> splitter = ExpandingGreedySplitter(test_size=3, folds=2)
>>> list(splitter.split(ts))
[
    (array([0, 1, 2, 3]), array([4, 5, 6])),
    (array([0, 1, 2, 3, 4, 5, 6]), array([7, 8, 9]))
]
```

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

### Retrieve pd_multiindex_hier example

Source: https://www.sktime.net/docs/examples/data-formats

Fetches an example of a hierarchical time series in the pd_multiindex_hier mtype.

```python
get_examples(mtype="pd_multiindex_hier", as_scitype="Hierarchical")[0]
```

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

### Build documentation locally

Source: https://www.sktime.net/docs/developer-guide/documentation

Generates the HTML documentation files from the source directory.

```bash
make html
```

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

### Retrieve df-list example

Source: https://www.sktime.net/docs/examples/data-formats

Fetches an example of a panel of multivariate series in the df-list mtype.

```python
get_examples(mtype="df-list", as_scitype="Panel")[0]
```

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

### Forecasting with KronosForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingkronoskronosforecaster

Demonstrates initializing the KronosForecaster with a pre-trained model path and performing a forecast on time series data.

```python
>>> import pandas as pd
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.forecasting.kronos import KronosForecaster
>>> url = (
...     "https://raw.githubusercontent.com/shiyu-coder/Kronos/"
...     "refs/heads/master/tests/data/regression_input.csv"
... )
>>> df = pd.read_csv(
...     url,
...     parse_dates=["timestamps"],
...     index_col="timestamps",
... )
>>> lookback, pred_len = 400, 120
>>> y = df.iloc[:lookback]
>>> fh = ForecastingHorizon(
...     df.index[lookback : lookback + pred_len],
...     is_relative=False,
... )
>>> forecaster = KronosForecaster(
...     model_path="NeoQuasar/Kronos-small",
...     tokenizer_path="NeoQuasar/Kronos-Tokenizer-base",
...     device="cpu",
...     deterministic=True,
...     predict_kwargs={
...         "T": 1.0,
...         "top_p": 0.9,
...         "sample_count": 1,
...         "verbose": True,
...     },
... )
>>> y_pred = forecaster.fit(y).predict(fh=fh)
```

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

### Retrieve pd.Series example

Source: https://www.sktime.net/docs/examples/data-formats

Fetches an example of a univariate time series in the pd.Series format.

```python
get_examples(mtype="pd.Series", as_scitype="Series")[0]
```

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

### Initialize and use DummyRegularChangePoints

Source: https://www.sktime.net/docs/api-reference/sktimedetectiondummydummyregularchangepoints

Demonstrates how to import the class, initialize it with a specific step size, and apply it to a pandas Series using fit_transform.

```python
>>> import pandas as pd
>>> from sktime.detection.dummy import DummyRegularChangePoints
>>> y = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> d = DummyRegularChangePoints(step_size=3)
>>> yt = d.fit_transform(y)
```

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

### Install editable sktime with dependencies

Source: https://www.sktime.net/docs/installation

Installs sktime in editable mode with developer or all extra dependencies.

```bash
pip install -e ".[dev]"
```

```bash
pip install -e ".[all_extras,dev]"
```

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

### Load Panel Data Example

Source: https://www.sktime.net/docs/examples/data-formats

Prepares a panel dataset by resetting the index to mimic a standard CSV import.

```python
# mimicking a scenario where we already have a csv file in the right format
from sktime.datasets import load_arrow_head

df_panel = load_arrow_head(split="TRAIN", return_type="pd-multiindex")[0].reset_index()
# imagine this is the result of df_panel = pd.read_csv
```

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

### Fit and Predict with StatsForecastMSTL

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingstatsforecaststatsforecastmstl

Example demonstrating how to initialize the model with multiple seasonalities, fit it to the airline dataset, and generate forecasts.

```python
>>> y = load_airline()
>>> model = StatsForecastMSTL(season_length=[3,12])
>>> fitted_model = model.fit(y=y)
>>> y_pred = fitted_model.predict(fh=[1,2,3])
```

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

### Retrieve numpy3D panel example

Source: https://www.sktime.net/docs/examples/data-formats

Fetches an example of a panel of multivariate series in the numpy3D format.

```python
get_examples(mtype="numpy3D", as_scitype="Panel")[0]
```

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

### Initialize Environment for Time Series Analysis

Source: https://www.sktime.net/docs/examples/classification-clustering

Sets up the environment by importing necessary libraries and configuring pandas display options.

```python
import numpy as np
import pandas as pd

# Increase display width
pd.set_option("display.width", 1000)
```

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

### Forecasting with Chronos2Forecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingchronos2chronos2forecaster

Demonstrates the basic workflow of loading data, initializing the forecaster, fitting the model, and generating predictions.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.chronos2 import Chronos2Forecaster
>>> from sktime.split import temporal_train_test_split
>>> y = load_airline()
>>> y_train, y_test = temporal_train_test_split(y)
>>> forecaster = Chronos2Forecaster("amazon/chronos-2")
>>> forecaster.fit(y_train)
>>> y_pred = forecaster.predict(fh=[1, 2, 3])
```

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

### Retrieve np.ndarray bivariate example

Source: https://www.sktime.net/docs/examples/data-formats

Fetches an example of a bivariate time series in the np.ndarray format.

```python
get_examples(mtype="np.ndarray", as_scitype="Series")[1]
```

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

### Configuring and fitting ForecastingOptunaSearchCV

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingmodel-selectionforecastingoptunasearchcv

Example demonstrating how to define a search space, configure cross-validation, and fit the model.

```python
>>> y = load_shampoo_sales()
>>> y_train, y_test = temporal_train_test_split(y=y, test_size=6)
>>> fh = ForecastingHorizon(y_test.index, is_relative=False).to_relative(
...         cutoff=y_train.index[-1]
...     )
>>> cv = ExpandingWindowSplitter(fh=fh, initial_window=24, step_length=1)
>>> forecaster = TransformedTargetForecaster(
...     steps=[
...             ("detrender", Detrender()),
...             ("scaler", RobustScaler()),
...             ("minmax2", MinMaxScaler((1, 10))),
...             ("forecaster", NaiveForecaster()),
...         ]
...     )
>>> param_grid = {
...     "scaler__with_scaling": CategoricalDistribution(
...             (True, False)
...         ),
...     "forecaster": CategoricalDistribution(
...             (NaiveForecaster(), TrendForecaster())
...         ),
...     }
>>> gscv = ForecastingOptunaSearchCV(
...         forecaster=forecaster,
...         param_grid=param_grid,
...         cv=cv,
...         n_evals=10,
...     )
>>> gscv.fit(y)
ForecastingOptunaSearchCV(...)
>>> print(f"{gscv.best_params_=}")
```

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

### cBOSS Classification Example

Source: https://www.sktime.net/docs/examples/classification/dictionary-based-classification

Demonstrates fitting and predicting with the Contractable BOSS classifier using non-contract parameters.

```python
# Recommended non-contract cBOSS parameters
cboss = ContractableBOSS(n_parameter_samples=250, max_ensemble_size=50, random_state=47)

# cBOSS with a 1 minute build time contract
# cboss = ContractableBOSS(time_limit_in_minutes=1,
#                         max_ensemble_size=50,
#                         random_state=47)

cboss.fit(X_train, y_train)

cboss_preds = cboss.predict(X_test)
print("cBOSS Accuracy: " + str(metrics.accuracy_score(y_test, cboss_preds)))
```

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

### Retrieve np.ndarray univariate example

Source: https://www.sktime.net/docs/examples/data-formats

Fetches an example of a univariate time series in the np.ndarray format.

```python
get_examples(mtype="np.ndarray", as_scitype="Series")[0]
```

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

### Initialize and Fit Prophetverse

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingprophetverseprophetverse

Demonstrates how to configure a Prophetverse model with Fourier seasonality and fit it to the airline dataset.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.prophetverse import Prophetverse
>>> from prophetverse.effects.fourier import LinearFourierSeasonality
>>> from prophetverse.utils.regex import no_input_columns
>>> y = load_airline()
>>> model = Prophetverse(
...     exogenous_effects=[
...         (
...             "seasonality",
...             LinearFourierSeasonality(
...                 sp_list=[12],
...                 fourier_terms_list=[3],
...                 freq="M",
...                 effect_mode="multiplicative",
...             ),
...             no_input_columns,
...         )
...     ],
... )
>>> model.fit(y)
>>> model.predict(fh=[1, 2, 3])
```

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

### Initialize Environment

Source: https://www.sktime.net/docs/examples/pipelines-tuning

Imports necessary libraries and suppresses warnings for cleaner output.

```python
import warnings

import numpy as np

warnings.filterwarnings("ignore")
```

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

### Retrieve panel data example (pd-multiindex)

Source: https://www.sktime.net/docs/examples/transformers

Fetch an example of a panel dataset using the pd-multiindex mtype.

```python
# example of a panel with mtype pd-multiindex
get_examples("pd-multiindex", "Panel")[0]
```

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

### Retrieve multivariate series example

Source: https://www.sktime.net/docs/examples/transformers

Fetch an example of a multivariate time series represented as a pandas DataFrame.

```python
# example of a multivariate series
get_examples("pd.DataFrame", "Series")[1]
```

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

### WindFMForecaster(model_path, tokenizer_path, device, columns, freq, start, clip, predict_kwargs, deterministic)

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingwindfmwindfmforecaster

Initializes the WindFMForecaster for zero-shot wind power forecasting.

```APIDOC
## class WindFMForecaster

### Description
Initializes a WindFM zero-shot forecaster for wind power data. This class wraps the WindFM foundation model through the sktime forecasting interface for inference-only tasks.

### Parameters
- **model_path** (str) - Optional - Hugging Face repository identifier or local path for the WindFM model. Default: "NeoQuasar/WindFM".
- **tokenizer_path** (str) - Optional - Hugging Face repository identifier or local path for the WindFM tokenizer. Default: "NeoQuasar/WindFM-Tokenizer".
- **device** (str) - Optional - Device used for model and tokenizer inference. Default: "cpu".
- **columns** (list of str or None) - Optional - Mapping from columns in X to WindFM weather covariates (wind_speed, wind_direction, density, temperature, pressure).
- **freq** (str or pandas offset) - Optional - Frequency used to synthesize timestamps. Default: "1h".
- **start** (str or pd.Timestamp) - Optional - Start timestamp used to synthesize timestamps. Default: "2000-01-01".
- **clip** (float) - Optional - Input normalization clipping value. Default: 5.0.
- **predict_kwargs** (dict or None) - Optional - Additional keyword arguments passed to WindFMPredictor.predict.
- **deterministic** (bool) - Optional - Whether predictions should reset the PyTorch random seed. Default: False.
```

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

### Forecasting with MIRAForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingmiramiraforecaster

Demonstrates initializing the forecaster, fitting it to training data, and generating predictions for a specified horizon.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.mira import MIRAForecaster
>>> from sktime.split import temporal_train_test_split
>>> y = load_airline()
>>> y_train, _ = temporal_train_test_split(y)
>>> f = MIRAForecaster()
>>> f.fit(y_train)
>>> y_pred = f.predict(fh=[1, 2, 3])
```

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

### Load Hierarchical Data Example

Source: https://www.sktime.net/docs/examples/hierarchical-forecasting

Retrieves a hierarchical time series example using the sktime datatypes utility.

```python
from sktime.datatypes import get_examples

y_hier = get_examples("pd_multiindex_hier")[1]
y_hier
```

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

### Initialize and use ClustererPipeline

Source: https://www.sktime.net/docs/api-reference/sktimeclusteringcomposeclustererpipeline

Demonstrates creating a pipeline with a transformer and a clusterer, fitting it to training data, and generating predictions.

```python
>>> from sktime.transformations.pca import PCATransformer
>>> from sktime.clustering.k_means import TimeSeriesKMeans
>>> from sktime.datasets import load_unit_test
>>> from sktime.clustering.compose import ClustererPipeline
>>> X_train, y_train = load_unit_test(split="train")
>>> X_test, y_test = load_unit_test(split="test")
>>> pipeline = ClustererPipeline(
...     TimeSeriesKMeans(), [PCATransformer()]
... )
>>> pipeline.fit(X_train, y_train)
ClustererPipeline(...)
>>> y_pred = pipeline.predict(X_test)
```

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

### Install sktime via pip

Source: https://www.sktime.net/docs/installation

Install the core sktime package or the version including all soft dependencies using pip.

```bash
pip install sktime
```

```bash
pip install sktime[all_extras]
```

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

### Forecasting with WindFMForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingwindfmwindfmforecaster

Demonstrates initializing, fitting, and generating point and quantile forecasts using the WindFMForecaster.

```python
>>> import pandas as pd
>>> import torch
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.forecasting.windfm import WindFMForecaster
>>> df = pd.read_csv(
...     "https://raw.githubusercontent.com/shiyu-coder/WindFM/"
...     "refs/heads/master/examples/data/121522.csv",
...     parse_dates=["time"],
...     index_col="time",
... )
>>> lookback, pred_len = 240, 80
>>> covariate_cols = [
...     "wind_speed",
...     "wind_direction",
...     "density",
...     "temperature",
...     "pressure",
... ]
>>> y_train = df["power"].iloc[:lookback]
>>> X_train = df[covariate_cols].iloc[:lookback]
>>> fh = ForecastingHorizon(
...     df.index[lookback : lookback + pred_len],
...     is_relative=False,
... )
>>> device = "cuda:0" if torch.cuda.is_available() else "cpu"
>>> forecaster = WindFMForecaster(
...     model_path="NeoQuasar/WindFM",
...     tokenizer_path="NeoQuasar/WindFM-Tokenizer",
...     # robust variants:
...     # model_path="NeoQuasar/WindFM-robust",
...     # tokenizer_path="NeoQuasar/WindFM-Tokenizer-robust",
...     device=device,
...     deterministic=True,
...     predict_kwargs={
...         "T": 1.0,
...         "top_k": 0,
...         "top_p": 0.9,
...         "sample_count": 100,
...         "verbose": True,
...     },
... )
>>> forecaster.fit(y_train, X=X_train)
WindFMForecaster(...)
>>> y_pred = forecaster.predict(fh=fh)
>>> y_quantiles = forecaster.predict_quantiles(
...     fh=fh,
...     alpha=[0.1, 0.5, 0.9],
... )
```

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

### Install sktime development dependencies

Source: https://www.sktime.net/docs/developer-guide/coding-standards

Install the package in editable mode with development dependencies to enable local quality checks.

```bash
pip install -e .[dev]
```

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

### Initializing and fitting TEASER

Source: https://www.sktime.net/docs/examples/classification/early-classification

Configure the TEASER classifier with specific classification points and a base estimator, then fit it to the training data.

```python
teaser = TEASER(
    random_state=0,
    classification_points=[25, 50, 75, 100, 125, 150, 175, 200, 251],
    estimator=TimeSeriesForestClassifier(n_estimators=10, random_state=0),
)
teaser.fit(arrow_train_X, arrow_train_y)
```

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

### Batch Forecast Evaluation Workflow (Function Interface)

Source: https://www.sktime.net/docs/examples/forecasting

A complete workflow example demonstrating data splitting, forecasting, and evaluation using the function interface.

```python
from sktime.datasets import load_airline
from sktime.forecasting.base import ForecastingHorizon
from sktime.forecasting.naive import NaiveForecaster
from sktime.performance_metrics.forecasting import mean_absolute_percentage_error
from sktime.split import temporal_train_test_split
```

```python
# step 1: splitting historical data
y = load_airline()
y_train, y_test = temporal_train_test_split(y, test_size=36)

# step 2: running the basic forecasting workflow
fh = ForecastingHorizon(y_test.index, is_relative=False)
forecaster = NaiveForecaster(strategy="last", sp=12)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)

# step 3: specifying the evaluation metric and
# step 4: computing the forecast performance
mean_absolute_percentage_error(y_test, y_pred, symmetric=False)

# step 5: testing forecast performance against baseline
# under development
```

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

### Initialize and use ZeroChangePoints

Source: https://www.sktime.net/docs/api-reference/sktimedetectiondummyzerochangepoints

Demonstrates how to import, instantiate, and apply the ZeroChangePoints detector to a pandas Series.

```python
>>> import pandas as pd
>>> from sktime.detection.dummy import ZeroChangePoints
>>> X = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> d = ZeroChangePoints()
>>> Xt = d.fit_transform(X)
```

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

### .ts file data instance example

Source: https://www.sktime.net/docs/examples/data/loading-data

Example of three instances with two dimensions and four observations per dimension.

```text
2,3,2,4:4,3,2,2
13,12,32,12:22,23,12,32
4,4,5,4:3,2,3,2

```

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

### Install sktime via conda

Source: https://www.sktime.net/docs/installation

Install the core sktime package or the version including available soft dependencies using conda-forge.

```bash
conda install -c conda-forge sktime
```

```bash
conda install -c conda-forge sktime-all-extras
```

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

### Initialize and use MOIRAIForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingmoiraimoiraiforecaster

Demonstrates initializing the forecaster with a checkpoint path, fitting it to training data, and generating a forecast.

```python
>>> from sktime.forecasting.moirai import MOIRAIForecaster
>>> import pandas as pd
>>> import numpy as np
>>> morai_forecaster = MOIRAIForecaster(
...     checkpoint_path="sktime/moirai-1.0-R-small"
... )
>>> y = np.random.normal(0, 1, (30, 2))
>>> X = y * 2 + np.random.normal(0, 1, (30,1))
>>> index = pd.date_range("2020-01-01", periods=30, freq="D")
>>> y = pd.DataFrame(y, index=index)
>>> X = pd.DataFrame(X, columns=["x1", "x2"], index=index)
>>> morai_forecaster.fit(y, X=X)
MOIRAIForecaster(checkpoint_path='sktime/moirai-1.0-R-small')
>>> X_test = pd.DataFrame(
...     np.random.normal(0, 1, (10, 2)),
...     columns=["x1", "x2"],
...     index=pd.date_range("2020-01-31", periods=10, freq="D"),
... )
>>> forecast = morai_forecaster.predict(fh=range(1, 11), X=X_test)
```

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

### Transform with Multiple Start Times

Source: https://www.sktime.net/docs/api-reference/sktimetransformationstime-sincetimesince

Create multiple columns representing time elapsed since different specified start dates.

```python
>>> transformer = TimeSince(["2000-01", "2000-02"])
>>> Xt = transformer.fit_transform(X)
```

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

### Forecasting with FlowStateForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingflowstateflowstateforecaster

Demonstrates initializing the forecaster, fitting it to training data, and generating predictions.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.flowstate import FlowStateForecaster
>>> from sktime.split import temporal_train_test_split
>>> y = load_airline()
>>> y_train, _ = temporal_train_test_split(y)
>>> f = FlowStateForecaster()
>>> f.fit(y_train)
>>> y_pred = f.predict(fh=[1, 2, 3])
```

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

### split_loc(y)

Source: https://www.sktime.net/docs/api-reference/sktimesplittemporal-train-test-splittemporaltraintestsplitter

Get loc references to train/test splits of y.

```APIDOC
## split_loc(y)

### Description
Get loc references to train/test splits of y.

### Parameters
- **y** (array-like) - The time series data to be split.
```

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

### Initialize Probabilistic Forecasting Workflow

Source: https://www.sktime.net/docs/examples/forecasting

Sets up a forecaster for probabilistic predictions using the ThetaForecaster.

```python
import numpy as np

from sktime.datasets import load_airline
from sktime.forecasting.theta import ThetaForecaster

# until fit, identical with the simple workflow
y = load_airline()

fh = np.arange(1, 13)

forecaster = ThetaForecaster(sp=12)
forecaster.fit(y, fh=fh)
```

```python
ThetaForecaster(sp=12)
```

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

### split(y)

Source: https://www.sktime.net/docs/api-reference/sktimesplittemporal-train-test-splittemporaltraintestsplitter

Get iloc references to train/test splits of y.

```APIDOC
## split(y)

### Description
Get iloc references to train/test splits of y.

### Parameters
- **y** (array-like) - The time series data to be split.
```

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

### Import all_estimators utility

Source: https://www.sktime.net/docs/examples/distances-kernels

Import the registry utility required to list available sktime estimators.

```python
from sktime.registry import all_estimators
```

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

### Forecasting with CiscoTSMForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingcisco-tsmciscotsmforecaster

Demonstrates initializing the forecaster, fitting it to airline data, and generating predictions and intervals.

```python
>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.cisco_tsm import CiscoTSMForecaster
>>> y = load_airline()
>>> forecaster = CiscoTSMForecaster()
>>> forecaster.fit(y)
CiscoTSMForecaster(...)
>>> y_pred = forecaster.predict(fh=[1, 2, 3])
>>> pred_int = forecaster.predict_interval(fh=[1, 2, 3],coverage=0.9)
```

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

### get_params([deep])

Source: https://www.sktime.net/docs/api-reference/sktimeclassificationdictionary-basedindividualtde

Get a dictionary of parameter values for this object.

```APIDOC
### get_params([deep])

Get a dict of parameters values for this object.
```

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

### Forecasting with MomentFMForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingmomentfmmomentfmforecaster

Demonstrates initializing the forecaster, fitting it to the airline dataset, and generating predictions.

```python
>>> from sktime.forecasting.momentfm import MomentFMForecaster
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> forecaster = MomentFMForecaster(seq_len = 2)
>>> forecaster.fit(y, fh=[1, 2, 3])
>>> y_pred = forecaster.predict()
```

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

### Check sktime version

Source: https://www.sktime.net/docs/examples/blog-posts/overview-of-sktime-functionalities-for-forecasting

Verify the installed version of the sktime library.

```python
import sktime
sktime.__version__
```

```python
'0.24.1'
```

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

### Forecasting with LTSFLinearForecaster

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingltsfltsflinearforecaster

Demonstrates initializing the forecaster, fitting it to the airline dataset, and generating predictions.

```python
>>> from sktime.forecasting.ltsf import LTSFLinearForecaster
>>> from sktime.datasets import load_airline
>>> model = LTSFLinearForecaster(10, 3)
>>> y = load_airline()
>>> model.fit(y, fh=[1,2,3])
LTSFLinearForecaster(pred_len=3, seq_len=10)
>>> y_pred = model.predict()
>>> y_pred
1961-01    515.456726
1961-02    576.704712
1961-03    559.859680
Freq: M, Name: Number of airline passengers, dtype: float32
```

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

### Individual Forecaster Definitions

Source: https://www.sktime.net/docs/examples/blog-posts/overview-of-sktime-functionalities-for-forecasting

Examples of initializing specific forecaster classes.

```python
ThetaForecaster(sp=4)
```

```python
ExponentialSmoothing(sp=4, trend='add')
```

```python
AutoARIMA(sp=4)
```

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

### Pipeline Chaining Examples

Source: https://www.sktime.net/docs/api-reference/sktimetransformationscomposetransformerpipeline

Various configurations for chaining StandardScaler and SummaryTransformer.

```python
>>> pipe = StandardScaler() * SummaryTransformer()
```

```python
>>> pipe = SummaryTransformer() * StandardScaler()
```

```python
>>> pipe = StandardScaler() * SummaryTransformer() * StandardScaler()
```

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

### Using DummyGlobalForecaster for Global Forecasting

Source: https://www.sktime.net/docs/api-reference/sktimeforecastingdummy-globaldummyglobalforecaster

Demonstrates initializing the forecaster, pretraining on hierarchical panel data, fitting to a specific series, and generating predictions.

```python
>>> from sktime.forecasting.dummy_global import DummyGlobalForecaster
>>> from sktime.utils._testing.hierarchical import _make_hierarchical
>>> # Create panel of training data
>>> y_panel = _make_hierarchical(
...     hierarchy_levels=(2,), min_timepoints=10, max_timepoints=10
... )
>>> forecaster = DummyGlobalForecaster()
>>> forecaster.pretrain(y_panel)  # Learn global mean
DummyGlobalForecaster()
>>> # Now fit to a specific series
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> forecaster.fit(y)  # Set context
DummyGlobalForecaster()
>>> y_pred = forecaster.predict(fh=[1, 2, 3])  # Predict global mean
>>> y_pred.shape
(3,)
```

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

### Calculate RMSEnormalizedByIQR

Source: https://www.sktime.net/docs/api-reference/sktimeperformance-metricsforecastingrmsenormalizedbyiqr

Example usage of the RMSEnormalizedByIQR metric with numpy arrays.

```python
>>> import numpy as np
>>> from sktime.performance_metrics.forecasting import RMSEnormalizedByIQR
>>> y_true = np.array([3, -0.5, 2, 7, 2])
>>> y_pred = np.array([2.5, 0.0, 2, 8, 1.25])
>>> iqre = RMSEnormalizedByIQR()
>>> iqre(y_true, y_pred)
np.float64(0.6422616289332564)
```