GluonTS

https://ts.gluon.ai/
Admin
GluonTS is a Python package for probabilistic time series modeling with deep learning-based models...
Tokens:1,120,255
Snippets:8,528
Trust Score:8.3
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Setup Git Hooks

Source: https://ts.gluon.ai/stable/community/devsetup.html

Run this script to install all required packages and set up Git hooks for automated checks. If using zsh, you may need to quote the package name.

```bash
./dev_setup.sh
pip install -e .

# if you use zsh you might need to escape `[` and `]`
pip install -e ".[dev]"

```

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

### Install GluonTS

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install the latest version of GluonTS from PyPI.

```bash
pip install gluonts

```

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

### Install Prophet for GluonTS

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.ext.prophet.html

Instructions for installing the Prophet library, either directly or via GluonTS extras. This is a prerequisite for using the ProphetPredictor.

```bash
pip install prophet
```

```bash
pip install gluonts[Prophet]
```

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

### R Package Installation Instructions

Source: https://ts.gluon.ai/stable/_modules/gluonts/ext/r_forecast/_predictor.html

Provides command-line instructions for installing required R packages ('forecast', 'nnfor' for univariate, and 'hts' for hierarchical methods) using the R console.

```text
R -e 'install.packages(c("forecast", "nnfor"),\repos="https://cloud.r-project.org")'

R -e 'install.packages(c("hts"), repos="https://cloud.r-project.org")'
```

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

### Install with Shell Extra

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install GluonTS with the 'shell' extra to enable integration with Amazon SageMaker.

```bash
pip install "gluonts[shell]"

```

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

### Installer Class

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.shell.sagemaker.dyn.html

The Installer class handles the process of installing packages and managing code archives within the SageMaker environment. It provides methods for cleanup, copying installations, handling archives, and performing pip installations.

```APIDOC
## class gluonts.shell.sagemaker.dyn.Installer

### Description
Manages dynamic code installation for SageMaker environments.

### Methods
- **cleanup()**: Cleans up any temporary installation files.
- **copy_install(path: pathlib.Path)**: Copies an existing installation to a specified path.
- **handle_archive(open_fn, extractall_fn, path)**: Handles the extraction of code archives.
- **install(path)**: Installs code from a given path.
- **install_requirement(path: pathlib.Path)**: Installs a specific requirement from a path.
- **pip_install(path: pathlib.Path)**: Performs a pip installation from a specified path.
```

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

### Install and Restart Function

Source: https://ts.gluon.ai/stable/_modules/gluonts/shell/sagemaker/dyn.html

Installs code from a specified channel and restarts the Python process to apply changes. This is useful for dynamically updating code in a running environment like SageMaker.

```python
def install_and_restart(code_channel: Optional[Path], packages: Path):
    # skip if there is no code, and if we already done our work
    if code_channel is None or "__SHELL_RELOADED__" in os.environ:
        return

    packages.mkdir(exist_ok=True)

    inst = Installer(packages)
    inst.install(code_channel)
    inst.cleanup()

    python_path = os.environ.get("PYTHONPATH", "")
    python_path = f"{packages}:{python_path}"

    os.environ.update(__SHELL_RELOADED__="1", PYTHONPATH=python_path)

    # restart
    os.execve(
        sys.executable,
        [sys.executable, "-m", "gluonts.shell"] + sys.argv[1:],
        os.environ,
    )
```

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

### Install with Prophet Extra

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install GluonTS with the 'prophet' extra to enable the use of the Prophet forecasting library.

```bash
pip install "gluonts[prophet]"

```

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

### Dynamic Code Installation

Source: https://ts.gluon.ai/stable/_modules/gluonts/shell/sagemaker/train.html

Installs dynamic code dependencies and restarts the environment if a 'code' channel is specified. This is useful for updating or installing custom code during a SageMaker training job.

```python
    def install_dynamic(self):
        install_and_restart(self.channels.get("code"), self.path.base / "code")
```

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

### Translator Usage Example

Source: https://ts.gluon.ai/stable/_modules/gluonts/dataset/schema/translate.html

Demonstrates how to instantiate and use the Translator class with a simple parsing example.

```APIDOC
## Translator Usage Example

### Description
This example shows how to parse a string to create a Translator instance, specifying target fields and dynamic real features.

### Method
`Translator.parse(target: str, feat_dynamic_real: str)`

### Parameters
#### Keyword Arguments
- **target** (str) - The name of the target field.
- **feat_dynamic_real** (str) - A string defining dynamic real features, potentially a list of names.

### Request Example
```python
tl = Translator.parse(target="demand", feat_dynamic_real="[price]")
```

### Response
#### Success Response (Translator Instance)
- The method returns an instance of the `Translator` class configured with the provided parameters.
```

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

### Install with Arrow Extra

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install GluonTS with the 'arrow' extra to enable support for reading and writing Arrow and Parquet based datasets using Apache Arrow.

```bash
pip install "gluonts[arrow]"

```

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

### Initialize ServePaths for SageMaker

Source: https://ts.gluon.ai/stable/_modules/gluonts/shell/sagemaker/serve.html

Sets up base directories for SageMaker model artifacts and output. Ensures these directories exist, creating them if necessary.

```python
from pathlib import Path

class ServePaths:
    def __init__(self, base: Path = Path("/opt/ml")) -> None:
        self.base = base.expanduser().resolve()
        self.model = self.base / "model"
        self.output = self.base / "output"

        self.model.mkdir(parents=True, exist_ok=True)
        self.output.mkdir(parents=True, exist_ok=True)
```

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

### Get Previous 5 Periods

Source: https://ts.gluon.ai/stable/_modules/gluonts/zebras/_period.html

Retrieves the 5 periods preceding the start of the current Periods object. Asserts that the result matches a newly created Periods object starting from a calculated past date.

```python
>>> p = periods("2021", "D", 365)
>>> assert p.past(5) == periods("2020-12-27", "D", 5)
```

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

### Get Seasonality for a Frequency

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.time_feature.seasonality.html

Use `get_seasonality` to find the seasonal period for a given frequency string. For example, '2h' (2 hours) corresponds to a seasonality of 12.

```python
>>> get_seasonality("2h")
12

```

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

### Build Project Documentation

Source: https://ts.gluon.ai/stable/community/devsetup.html

Generate the project's documentation. The output will be in `docs/_build/html`.

```bash
python setup.py docs

```

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

### Live Preview Documentation with Sphinx Autobuild

Source: https://ts.gluon.ai/stable/community/devsetup.html

Start a local web server with automatic rebuilding for Sphinx documentation. This allows for live previewing of changes to .rst files.

```bash
cd docs                          # go to the docs folder
make livehtml                    # run the autobuild watchdog, ensure that
                                 # there are no syntax errors and warnings
open http://127.0.0.1:8000       # open the autobuild preview

```

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

### Get Pre-defined Dummy Dataset (Python)

Source: https://ts.gluon.ai/stable/_modules/gluonts/testutil/dummy_datasets.html

Returns a ListDataset with a fixed set of multi-dimensional time series. Useful for quick testing or examples where specific data structure is needed.

```python
def get_dataset():
    return ListDataset(
        [
            {
                "target": np.c_[
                    np.array([0.2, 0.7, 0.2, 0.5, 0.3, 0.3, 0.2, 0.1]),
                    np.array([0, 1, 2, 0, 1, 2, 2, 2]),
                ].T,
                "start": "2011-01-01 00:00:00",
                "end": pd.Timestamp("2011-01-01 03:00:00"),
            },
            {
                "target": np.c_[
                    np.array([0.2, 0.1, 0.2, 0.5, 0.4]),
                    np.array([0, 1, 2, 1, 1]),
                ].T,
                "start": "2011-01-01 00:00:00",
                "end": pd.Timestamp("2011-01-01 03:00:00"),
            },
            {
                "target": np.c_[
                    np.array([0.2, 0.7, 0.2, 0.5, 0.1, 0.2, 0.1]),
                    np.array([0, 1, 0, 2]),
                ].T,
                "start": "2011-01-01 00:00:00",
                "end": pd.Timestamp("2011-01-01 03:00:00"),
            },
        ],
        freq="H",
        one_dim_target=False,
        use_timestamp=True,
    )
```

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

### Get Last 5 Periods

Source: https://ts.gluon.ai/stable/_modules/gluonts/zebras/_period.html

Retrieves the last 5 periods from a given Periods object. Asserts that the result matches a newly created Periods object with a specified start date and count.

```python
>>> p = periods("2021", "D", 365)
>>> assert p.tail(5) == periods("2021-12-27", "D", 5)
```

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

### Initialize and Run PyTorch Lightning Trainer

Source: https://ts.gluon.ai/stable/tutorials/advanced_topics/howto_pytorch_lightning.ipynb

Sets up a PyTorch Lightning Trainer and starts the model training process.

```python
trainer = pl.Trainer(max_epochs=10)
trainer.fit(net, data_loader)
```

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

### Get First 5 Periods

Source: https://ts.gluon.ai/stable/_modules/gluonts/zebras/_period.html

Retrieves the first 5 periods from a given Periods object. Asserts that the result matches a newly created Periods object with a specified start date and count.

```python
>>> p = periods("2021", "D", 365)
>>> assert p.head(5) == periods("2021-01-01", "D", 5)
```

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

### Using Settings for Global Context Management

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.core.settings.html

Demonstrates how to define custom settings, instantiate them, and use the `_let` context manager to temporarily override settings for a specific block of code. This is useful for managing global configurations or debugging flags.

```python
from gluonts.core.settings import Settings

class MySettings(Settings):
    debug: bool = False

settings = MySettings()

def fn():
    if settings.debug:
        print("In debug mode.")

with settings._let(debug=True):
    # this will print the message
    fn()

# no message will be printed
fn()

```

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

### Create Default Synthetic Dataset

Source: https://ts.gluon.ai/stable/_modules/gluonts/dataset/artificial/_base.html

Creates a default synthetic dataset with a linear trend and random Gaussian noise, including static and dynamic features. This is a convenient way to get started with artificial data.

```python
def default_synthetic() -> Tuple[DatasetInfo, Dataset, Dataset]:
    recipe = [
        (FieldName.TARGET, LinearTrend() + RandomGaussian()),
        (FieldName.FEAT_STATIC_CAT, RandomCat([10])),
        (
            FieldName.FEAT_STATIC_REAL,
            ForEachCat(RandomGaussian(1, (10,)), FieldName.FEAT_STATIC_CAT) 
            + RandomGaussian(0.1, (10,)),
        ),
    ]

    data = RecipeDataset(
        recipe=recipe,
        metadata=MetaData(
            freq="D",
            feat_static_real=[
                BasicFeatureInfo(name=FieldName.FEAT_STATIC_REAL)
            ],
            feat_static_cat=[
                CategoricalFeatureInfo(
                    name=FieldName.FEAT_STATIC_CAT, cardinality="10"
                )
            ],
            feat_dynamic_real=[
                BasicFeatureInfo(name=FieldName.FEAT_DYNAMIC_REAL)
            ],
        ),
        max_train_length=20,
        prediction_length=10,
        num_timeseries=10,
        trim_length_fun=lambda x, **kwargs: np.minimum(
            int(np.random.geometric(1 / (kwargs["train_length"] / 2))),
            kwargs["train_length"],
        ),
    )

    generated = data.generate()
    assert generated.test is not None
    info = data.dataset_info(generated.train, generated.test)

    return info, generated.train, generated.test
```

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

### Generate and Preview Documentation

Source: https://ts.gluon.ai/stable/community/devsetup.html

Commands to generate the documentation locally and open it in a browser. Ensure there are no syntax errors or warnings before committing.

```bash
make -C docs html                # generate the docs
open docs/_build/html/index.html # open the generated docs in a browser

```

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

### Get Next 5 Periods

Source: https://ts.gluon.ai/stable/_modules/gluonts/zebras/_period.html

Retrieves the next 5 periods following the end of the current Periods object. Asserts that the result matches a newly created Periods object starting from the day after the current end date.

```python
>>> p = periods("2021", "D", 365)
>>> assert p.future(5) == periods("2022-01-01", "D", 5)
```

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

### Use Multiple Callbacks with WarmStart

Source: https://ts.gluon.ai/stable/tutorials/advanced_topics/trainer_callbacks.ipynb

Demonstrates using multiple callbacks, including WarmStart for continuing training from a previous predictor, alongside TrainingHistory.

```python
from gluonts.mx.trainer.callback import WarmStart

warm_start = WarmStart(predictor=predictor)

trainer = Trainer(epochs=3, callbacks=[history, warm_start])

estimator = SimpleFeedForwardEstimator(
    prediction_length=prediction_length, trainer=trainer
)

predictor = estimator.train(dataset.train, num_workers=None)
```

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

### Install with MXNet Extra

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install GluonTS with the 'mxnet' extra. This installs a CPU-only version of MXNet, suitable for development or environments without GPU support.

```bash
pip install "gluonts[mxnet]"

```

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

### install_and_restart

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.shell.sagemaker.dyn.html

Installs specified packages and restarts the environment if necessary. This function is useful for applying updates or new dependencies.

```APIDOC
## gluonts.shell.sagemaker.dyn.install_and_restart

### Description
Installs packages from a code channel and restarts the environment.

### Parameters
- **code_channel** (Optional[pathlib.Path]): Path to the code channel directory.
- **packages** (pathlib.Path): Path to the packages to be installed.
```

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

### Calculate Forecast Start Time

Source: https://ts.gluon.ai/stable/_modules/gluonts/dataset/util.html

Calculates the start time of a forecast based on the entry's start field and the shape of the target time series.

```python
def forecast_start(entry, time_axis: int = -1):
    return entry[FieldName.START] + entry[FieldName.TARGET].shape[time_axis]
```

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

### Install orjson

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install the 'orjson' package for faster JSON parsing. GluonTS will emit a warning if neither 'orjson' nor 'ujson' are installed, impacting performance with large datasets.

```bash
pip install orjson

```

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

### sample

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.mx.distribution.html

Draw samples from the distribution.

```APIDOC
## sample

### Description
Draw samples from the distribution. If num_samples is given the first dimension of the output will be num_samples.

### Parameters
- **num_samples** (Optional[int]): Number of samples to to be drawn.
- **dtype** (type): Data-type of the samples.

### Returns
A tensor containing samples. This has shape (*batch_shape, *eval_shape) if num_samples = None and (num_samples, *batch_shape, *eval_shape) otherwise.

### Return type
Tensor
```

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

### Install GluonTS with PyTorch or MXNet Support

Source: https://ts.gluon.ai/stable/index.html

Install GluonTS using pip, choosing between support for PyTorch or MXNet models. Ensure Python 3.7 or newer is installed.

```bash
pip install "gluonts[torch]"
```

```bash
pip install "gluonts[mxnet]"
```

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

### Initialize DistributionForecast

Source: https://ts.gluon.ai/stable/_modules/gluonts/torch/model/forecast.html

Instantiate a `DistributionForecast` with a PyTorch distribution, start date, and optional item ID or info. The distribution should be capable of producing samples with a shape corresponding to (num_samples, prediction_length).

```python
from typing import Dict, Optional, Union

import numpy as np
import pandas as pd
import torch
from torch.distributions import Distribution

from gluonts.model.forecast import Forecast, Quantile, SampleForecast



class DistributionForecast(Forecast):
    """
    A `Forecast` object that uses a distribution directly.

    This can for instance be used to represent marginal probability
    distributions for each time point -- although joint distributions are
    also possible, e.g. when using MultiVariateGaussian).

    Parameters
    ----------
    distribution
        Distribution object. This should represent the entire prediction
        length, i.e., if we draw `num_samples` samples from the distribution,
        the sample shape should be

            samples = trans_dist.sample(num_samples)
            samples.shape -> (num_samples, prediction_length)

    start_date
        start of the forecast
    info
        additional information that the forecaster may provide e.g. estimated
        parameters, number of iterations ran etc.
    """

    def __init__(
        self,
        distribution: Distribution,
        start_date: pd.Period,
        item_id: Optional[str] = None,
        info: Optional[Dict] = None,
    ) -> None:
        self.distribution = distribution
        self.shape = distribution.batch_shape + distribution.event_shape
        self.prediction_length = self.shape[0]
        self.item_id = item_id
        self.info = info

        assert isinstance(
            start_date, pd.Period
        ), "start_date should be a pandas Period object"
        self.start_date = start_date

        self._mean = None

```

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

### Initialize WaveNetLightningModule

Source: https://ts.gluon.ai/stable/_modules/gluonts/torch/model/wavenet/lightning_module.html

Initializes the WaveNetLightningModule with model arguments, learning rate, and weight decay. It saves hyperparameters and instantiates the WaveNet model.

```python
from gluonts.torch.model.wavenet.lightning_module import WaveNetLightningModule

model_kwargs = {
    "input_dim": 10,
    "hidden_dim": 32,
    "num_layers": 2,
    "kernel_size": 3,
    "dropout_rate": 0.1
}

lightning_module = WaveNetLightningModule(model_kwargs=model_kwargs, lr=1e-3, weight_decay=1e-8)
```

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

### unwrap_or_else

Source: https://ts.gluon.ai/stable/_modules/gluonts/maybe.html

Get the value if it is not None, or invoke a factory function to get a fallback value.

```APIDOC
## unwrap_or_else

### Description
Get ``val`` if it is not ``None``, or invoke ``factory`` to get a fallback.

### Parameters
- **val** (OptionalOrMaybe[T]) - The optional value to unwrap.
- **factory** (Callable[[], T]) - The factory function to call if the value is None.

### Returns
- **T** - The unwrapped value or the result of the factory function.

### Example
```python
unwrap_or_else([1, 2, 3], list)
# Output: [1, 2, 3]
unwrap_or_else(None, list)
# Output: []
```
```

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

### Define Get Operation

Source: https://ts.gluon.ai/stable/_modules/gluonts/dataset/schema/translate.html

The `Get` operation extracts a specified field from an input item.

```python
class Get(Op):
    """
    Extracts the field ``name`` from the input.
    """

    name: str

    def __call__(self, item):
        return item[self.name]

    def fields(self):
        return [self.name]
```

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

### DLinearLightningModule Initialization

Source: https://ts.gluon.ai/stable/_modules/gluonts/torch/model/d_linear/lightning_module.html

Initializes the DLinearLightningModule with model arguments, learning rate, and weight decay. It saves hyperparameters and sets up the DLinearModel and input description.

```python
import lightning.pytorch as pl
import torch

from gluonts.core.component import validated
from gluonts.itertools import select

from .module import DLinearModel



class DLinearLightningModule(pl.LightningModule):
    """
    A ``pl.LightningModule`` class that can be used to train a ``DLinearModel``
    with PyTorch Lightning.

    This is a thin layer around a (wrapped) ``DLinearModel`` object,
    that exposes the methods to evaluate training and validation loss.

    Parameters
    ----------
    model_kwargs
        Keyword arguments to construct the ``DLinearModel`` to be trained.
    loss
        Loss function to be used for training.
    lr
        Learning rate.
    weight_decay
        Weight decay regularization parameter.
    """

    @validated()
    def __init__(
        self,
        model_kwargs: dict,
        lr: float = 1e-3,
        weight_decay: float = 1e-8,
    ):
        super().__init__()
        self.save_hyperparameters()
        self.model = DLinearModel(**model_kwargs)
        self.lr = lr
        self.weight_decay = weight_decay
        self.inputs = self.model.describe_inputs()
```

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

### Installer Class for Package Management

Source: https://ts.gluon.ai/stable/_modules/gluonts/shell/sagemaker/dyn.html

Manages the installation of Python packages from various sources (files, directories, archives, requirements files) into a specified target directory. It handles cleanup of temporary files after installation.

```python
# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License.
# A copy of the License is located at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# or in the "license" file accompanying this file. This file is distributed
# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied. See the License for the specific language governing
# permissions and limitations under the License.

"""
`gluonts.shell.sagemaker.dyn`
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Dynamic code loading for `gluonts.shell`.
"""


import os
import shutil
import subprocess
import sys
import tarfile
import tempfile
import zipfile
from functools import partial
from pathlib import Path
from typing import Optional

from gluonts.util import safe_extractall



class Installer:
    def __init__(self, packages):
        self.packages = packages
        self.cleanups = []


    def cleanup(self):
        for cleanup in self.cleanups:
            cleanup()


    def copy_install(self, path: Path):
        if path.is_file():
            shutil.copy(path, self.packages)
        elif path.is_dir():
            shutil.copytree(path, self.packages / path.name)


    def pip_install(self, path: Path):
        subprocess.check_call(
            [
                sys.executable,
                "-m",
                "pip",
                "install",
                "--upgrade",
                "--target",
                str(self.packages),
                str(path),
            ]
        )


    def install_requirement(self, path: Path):
        subprocess.check_call(
            [
                sys.executable,
                "-m",
                "pip",
                "install",
                "--upgrade",
                "--target",
                str(self.packages),
                "--requirement",
                str(path),
            ]
        )


    def install(self, path):
        if path.is_file():
            if tarfile.is_tarfile(path):
                self.handle_archive(tarfile.open, safe_extractall, path)

            elif zipfile.is_zipfile(path):
                self.handle_archive(
                    zipfile.ZipFile, zipfile.ZipFile.extractall, path
                )

            elif path.match("requirements*.txt"):
                self.install_requirement(path)

            elif path.suffix == ".py":
                self.copy_install(path)

        elif path.is_dir():
            if (path / "setup.py").exists():
                self.pip_install(path)
            elif (path / "__init__.py").exists():
                self.copy_install(path)
            else:
                for subpath in path.iterdir():
                    self.install(subpath)


    def handle_archive(self, open_fn, extractall_fn, path):
        with open_fn(path) as archive:
            tempdir = tempfile.mkdtemp()
            self.cleanups.append(
                partial(shutil.rmtree, tempdir, ignore_errors=True)
            )

            extractall_fn(archive, tempdir)
            self.install(Path(tempdir))
```

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

### TrainEnv Initialization and Configuration Loading

Source: https://ts.gluon.ai/stable/_modules/gluonts/shell/sagemaker/train.html

Initializes the training environment by loading input data configuration, identifying data channels, determining the current host, and parsing hyperparameters and environment variables. This sets up the necessary context for training.

```python
class TrainEnv:
    def __init__(self, path: Path = Path("/opt/ml")) -> None:
        self.path = TrainPaths(path)
        self.inputdataconfig = self._load_inputdataconfig()
        self.channels = self._load_channels()
        self.current_host = self._get_current_host()

        hyperparameters, env = self._load_hyperparameters()
        self.hyperparameters = hyperparameters
        self.env = env
```

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

### Initialize and Run Evaluator

Source: https://ts.gluon.ai/stable/tutorials/forecasting/extended_tutorial.ipynb

Initialize the Evaluator with desired quantiles and then use it to compute aggregate and per-item metrics.

```python
evaluator = Evaluator(quantiles=[0.1, 0.5, 0.9])
agg_metrics, item_metrics = evaluator(tss, forecasts)
```

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

### RandomYield Sampling Example

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.itertools.html

Demonstrates `RandomYield` for sampling elements from multiple iterables. The first example shows sampling from a list with a probability of 1 for the first iterable. The second example uses `Cyclic` to sample indefinitely.

```python
>>> from toolz import take
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> it = iter(RandomYield([a, b], probabilities=[1, 0]))
>>> list(take(5, it))
[1, 2, 3]
```

```python
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> it = iter(RandomYield([Cyclic(a), b], probabilities=[1, 0]))
>>> list(take(5, it))
[1, 2, 3, 1, 2]
```

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

### Compile Notebooks

Source: https://ts.gluon.ai/stable/community/devsetup.html

Use 'just' to compile notebooks to .md files. This is useful for updating tutorial content.

```bash
just compile_notebooks skip

```

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

### DLinearLightningModule

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.torch.model.d_linear.lightning_module.html

Initializes the DLinearLightningModule with model configuration, learning rate, and weight decay.

```APIDOC
class DLinearLightningModule(model_kwargs: dict, lr: float = 0.001, weight_decay: float = 1e-08)

Parameters:
    model_kwargs (dict): Keyword arguments to construct the DLinearModel to be trained.
    lr (float): Learning rate. Defaults to 0.001.
    weight_decay (float): Weight decay regularization parameter. Defaults to 1e-08.
```

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

### Install with R Extra

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install GluonTS with the 'R' extra to enable integration with R packages like 'forecast'.

```bash
pip install "gluonts[R]"

```

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

### sample Method

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.mx.distribution.html

Draws samples from the distribution.

```APIDOC
## sample

### Description
Draw samples from the distribution.
If num_samples is given the first dimension of the output will be num_samples.

### Parameters
- **num_samples** (Optional[int]): Number of samples to be drawn.
- **dtype** (Type): Data-type of the samples. Defaults to numpy.float32.

### Returns
- A tensor containing samples. This has shape (*batch_shape, *eval_shape) if num_samples = None and (num_samples, *batch_shape, *eval_shape) otherwise.

### Return type
Tensor
```

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

### Install GluonTS with MXNet Support

Source: https://ts.gluon.ai/

Install GluonTS with support for MXNet models. Ensure you have Python 3.7 or newer.

```bash
pip install "gluonts[mxnet]"
```

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

### sample

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.torch.distributions.html

Returns samples from the distribution.

```APIDOC
## sample

### Description
Returns samples from the distribution.

### Parameters
* `_sample_shape` (torch.Size) - Optional: The shape of the samples to generate.

### Returns
* samples of shape (*sample_shape, *batch_shape)
```

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

### Install GluonTS with PyTorch Support

Source: https://ts.gluon.ai/

Install GluonTS with support for PyTorch models. Ensure you have Python 3.7 or newer.

```bash
pip install "gluonts[torch]"
```

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

### Initialize ServeEnv for SageMaker

Source: https://ts.gluon.ai/stable/_modules/gluonts/shell/sagemaker/serve.html

Initializes the serving environment, setting up paths and checking for batch transform mode. It uses ServePaths to manage directory structures.

```python
import os
from pathlib import Path

class ServeEnv:
    def __init__(self, path: Path = Path("/opt/ml")) -> None:
        self.path = ServePaths(path)

        self.sagemaker_batch = (
            os.environ.get("SAGEMAKER_BATCH", "false") == "true"
        )
```

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

### WarmStart

Source: https://ts.gluon.ai/stable/_modules/gluonts/mx/trainer/callback.html

A callback to warm-start a predictor by copying parameters.

```APIDOC
## WarmStart

### Description
Initializes a new network with parameters from a pre-trained predictor. This is useful for transfer learning or fine-tuning.

### Method
`on_network_initializing_end`

### Parameters
- `training_network` (nn.HybridBlock) - The network being initialized.

### Usage
```python
predictor = load_predictor(...) # Load a pre-trained predictor
callback = WarmStart(predictor=predictor)
# Use this callback during training setup
```
```

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

### periods_between Function

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.dataset.split.html

Counts the number of periods that fit between a start and end period, inclusive. The frequency is determined by the start period.

```APIDOC
## gluonts.dataset.split.periods_between(_start : pandas._libs.tslibs.period.Period_, _end : pandas._libs.tslibs.period.Period_) -> int

Count how many periods fit between `start` and `end` (inclusive). The frequency is taken from `start`.
For example:
```
>>> start = pd.Period("2021-01-01 00", freq="2H")
>>> end = pd.Period("2021-01-01 11", "2H")
>>> periods_between(start, end)
6

```

```
>>> start = pd.Period("2021-03-03 23:00", freq="30T")
>>> end = pd.Period("2021-03-04 03:29", freq="30T")
>>> periods_between(start, end)
9

```
```

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

### TransformedISQF Initialization

Source: https://ts.gluon.ai/stable/_modules/gluonts/mx/distribution/isqf.html

Initializes a `TransformedISQF` distribution, which wraps a base ISQF distribution and applies a list of transformations. This is useful for creating more complex distributions by composing ISQF with invertible transformations.

```python
class TransformedISQF(TransformedDistribution, ISQF):
    # DistributionOutput class for the case when loc/scale is not None
    @validated()
    def __init__(self,
        base_distribution: ISQF,
        transforms: List[Bijection]
    ) -> None:
        super().__init__(base_distribution, transforms)
```

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

### WaveNetLightningModule Initialization

Source: https://ts.gluon.ai/stable/api/gluonts/gluonts.torch.model.wavenet.lightning_module.html

Initializes the WaveNetLightningModule with model arguments, learning rate, and weight decay.

```APIDOC
## class gluonts.torch.model.wavenet.lightning_module.WaveNetLightningModule

### Description
LightningModule wrapper over WaveNet.

### Parameters
* **model_kwargs** (dict) - Keyword arguments to pass to WaveNet.
* **lr** (float, optional) - Learning rate, by default 1e-3.
* **weight_decay** (float, optional) - Weight decay, by default 1e-8.
```

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

### Install with PyTorch Extra

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install GluonTS with the 'torch' extra to include dependencies required for PyTorch-based models, including PyTorch and PyTorch Lightning.

```bash
pip install "gluonts[torch]"

```

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

### create_lightning_module

Source: https://ts.gluon.ai/stable/_modules/gluonts/torch/model/wavenet/estimator.html

Initializes and returns a WaveNetLightningModule with specified hyperparameters.

```APIDOC
## create_lightning_module

### Description
Initializes and returns a WaveNetLightningModule with specified hyperparameters.

### Returns
- pl.LightningModule: An instance of WaveNetLightningModule.
```

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

### Install R forecast package

Source: https://ts.gluon.ai/stable/_modules/gluonts/ext/r_forecast/_univariate_predictor.html

To use the RForecastPredictor, you need to install the R 'forecast' and 'nnfor' packages. This command can be run directly from your terminal.

```bash
R -e 'install.packages(c("forecast", "nnfor"), repos="https://cloud.r-project.org")' # noqa
```

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

### Initialize Choose Recipe

Source: https://ts.gluon.ai/stable/_modules/gluonts/dataset/artificial/recipe.html

Initializes a recipe that selects options based on a selector. Use when you need to dynamically choose between different data generation paths.

```python
class Choose(Lifted):
    @validated()
    def __init__(
        self, options: ValueOrCallable, selector: ValueOrCallable
    ) -> None:
        self.options = options
        self.selector = selector

    def __call__(self, x, length, **kwargs):
        options = resolve(self.options, x, length, **kwargs)
        selector = resolve(self.selector, x, length, **kwargs)
        e = np.eye(options.shape[0])
        out = np.sum(e[selector] * options.T, axis=1)
        return out
```

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

### Import rpy2 and Check Installation

Source: https://ts.gluon.ai/stable/_modules/gluonts/ext/r_forecast/_predictor.html

Attempts to import necessary modules from the rpy2 library and sets a flag indicating whether rpy2 is installed.

```python
try:
    import rpy2.robjects.packages as rpackages
    from rpy2 import rinterface, robjects
    from rpy2.rinterface_lib import callbacks
    from rpy2.rinterface_lib.embedded import RRuntimeError
except ImportError as e:
    rpy2_error_message = str(e)
    RPY2_IS_INSTALLED = False
else:
    RPY2_IS_INSTALLED = True
```

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

### Count periods between two periods

Source: https://ts.gluon.ai/stable/_modules/gluonts/dataset/split.html

Counts the number of periods that fit between a start and end period, inclusive. The frequency is determined by the start period.

```python
start = pd.Period("2021-01-01 00", freq="2H")
end = pd.Period("2021-01-01 11", "2H")
periods_between(start, end)
```

```python
start = pd.Period("2021-03-03 23:00", freq="30T")
end = pd.Period("2021-03-04 03:29", freq="30T")
periods_between(start, end)
```

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

### sample

Source: https://ts.gluon.ai/stable/_modules/gluonts/torch/distributions/binned_uniforms.html

Generates samples from the distribution.

```APIDOC
## sample(self, sample_shape=torch.Size())

### Description
Returns samples from the distribution.

### Parameters
* **sample_shape** (torch.Size, optional) - The shape of the samples to generate. Defaults to an empty Size().

### Returns
- samples (tensor): Samples of shape (*sample_shape, *batch_shape).
```

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

### Settings Initialization with Class Defaults

Source: https://ts.gluon.ai/stable/_modules/gluonts/core/settings.html

Initializes a `Settings` instance, processing class-level type and default declarations. It sets up an internal linked list for context management.

```python
# If subclassed, `_cls_types` can contain declarations which we need to
# execute.
for key, (ty, default) in self._cls_types.items():
    self._declare(key, ty, default=default)

# Same thing for dependencies.

```

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

### Install R and Forecast Package

Source: https://ts.gluon.ai/stable/getting_started/install.html

Install the R 'forecast' and 'nnfor' packages using the R command line. This is a prerequisite for using GluonTS's R-Forecast integration.

```bash
R -e 'install.packages(c("forecast", "nnfor"), repos="https://cloud.r-project.org")'

```
Tokens:
Raw