plot

skforecast.plot.plot.set_dark_theme

set_dark_theme(custom_style=None)

Set aspects of the visual theme for all matplotlib plots. This function changes the global defaults for all plots using the matplotlib rcParams system. The theme includes specific colors for figure and axes backgrounds, gridlines, text, labels, and ticks. It also sets the font size and line width.

Parameters:

Name	Type	Description	Default
custom_style	dict	Optional dictionary containing custom styles to be added or override the default dark theme. It is applied after the default theme is set by using the plt.rcParams.update() method.	None

Returns:

Type	Description
None

Source code in skforecast/plot/plot.py

def set_dark_theme(
    custom_style: dict | None = None
) -> None:
    """
    Set aspects of the visual theme for all matplotlib plots.
    This function changes the global defaults for all plots using the matplotlib
    rcParams system. The theme includes specific colors for figure and axes
    backgrounds, gridlines, text, labels, and ticks. It also sets the font size
    and line width.

    Parameters
    ----------
    custom_style : dict, default None
        Optional dictionary containing custom styles to be added or override the
        default dark theme. It is applied after the default theme is set by
        using the `plt.rcParams.update()` method.

    Returns
    -------
    None

    """

    plt.style.use('fivethirtyeight')
    dark_style = {
        'figure.facecolor': '#001633',
        'axes.facecolor': '#001633',
        'savefig.facecolor': '#001633',
        'axes.grid': True,
        'axes.grid.which': 'both',
        'axes.spines.left': False,
        'axes.spines.right': False,
        'axes.spines.top': False,
        'axes.spines.bottom': False,
        'grid.color': '#212946',
        'grid.linewidth': '1',
        'text.color': '0.9',
        'axes.labelcolor': '0.9',
        'xtick.color': '0.9',
        'ytick.color': '0.9',
        'font.size': 10,
        'lines.linewidth': 1.5
    }

    if custom_style is not None:
        dark_style.update(custom_style)

    plt.rcParams.update(dark_style)

skforecast.plot.plot.plot_residuals

plot_residuals(
    residuals=None,
    y_true=None,
    y_pred=None,
    fig=None,
    **fig_kw
)

Parameters:

Name	Type	Description	Default
residuals	pandas Series, numpy ndarray	Values of residuals. If None, residuals are calculated internally using y_true and y_pred.	None.
y_true	pandas Series, numpy ndarray	Ground truth (correct) values. Ignored if residuals is not None.	None.
y_pred	pandas Series, numpy ndarray	Values of predictions. Ignored if residuals is not None.	None.
fig	Figure	Pre-existing fig for the plot. Otherwise, call matplotlib.pyplot.figure() internally.	None.
fig_kw	dict	Other keyword arguments are passed to matplotlib.pyplot.figure()	{}

Returns:

Name	Type	Description
fig	Figure	Matplotlib Figure.

Source code in skforecast/plot/plot.py

def plot_residuals(
    residuals: np.ndarray | pd.Series | None = None,
    y_true: np.ndarray | pd.Series | None = None,
    y_pred: np.ndarray | pd.Series | None = None,
    fig: matplotlib.figure.Figure | None = None,
    **fig_kw
) -> matplotlib.figure.Figure:
    """
    Parameters
    ----------
    residuals : pandas Series, numpy ndarray, default None.
        Values of residuals. If `None`, residuals are calculated internally using
        `y_true` and `y_pred`.
    y_true : pandas Series, numpy ndarray, default None.
        Ground truth (correct) values. Ignored if residuals is not `None`.
    y_pred : pandas Series, numpy ndarray, default None. 
        Values of predictions. Ignored if residuals is not `None`.
    fig : matplotlib.figure.Figure, default None. 
        Pre-existing fig for the plot. Otherwise, call matplotlib.pyplot.figure()
        internally.
    fig_kw : dict
        Other keyword arguments are passed to matplotlib.pyplot.figure()

    Returns
    -------
    fig: matplotlib.figure.Figure
        Matplotlib Figure.

    """

    if residuals is None and (y_true is None or y_pred is None):
        raise ValueError(
            "If `residuals` argument is None then, `y_true` and `y_pred` must be provided."
        )

    if residuals is None:
        residuals = y_true - y_pred

    if fig is None:
        fig = plt.figure(constrained_layout=True, **fig_kw)

    gs  = matplotlib.gridspec.GridSpec(2, 2, figure=fig)
    ax1 = fig.add_subplot(gs[0, :])
    ax2 = fig.add_subplot(gs[1, 0])
    ax3 = fig.add_subplot(gs[1, 1])

    ax1.plot(residuals)
    residuals_kde = np.asarray(residuals, dtype=float)
    residuals_kde = residuals_kde[~np.isnan(residuals_kde)]
    hist_color = "C0"
    _, bin_edges, _ = ax2.hist(
        residuals_kde,
        bins=30,
        facecolor=matplotlib.colors.to_rgba(hist_color, 0.5),
        edgecolor=matplotlib.rcParams["patch.edgecolor"],
        linewidth=0.5,
    )
    if residuals_kde.size > 1 and np.ptp(residuals_kde) > 0:
        kde = gaussian_kde(residuals_kde)
        x_kde = np.linspace(bin_edges[0], bin_edges[-1], 200)
        bin_width = bin_edges[1] - bin_edges[0]
        ax2.plot(x_kde, kde(x_kde) * residuals_kde.size * bin_width, color=hist_color)
    ax2.set_ylabel("Count")
    plot_acf(residuals, ax=ax3, lags=60)

    ax1.set_title("Residuals")
    ax2.set_title("Distribution")
    ax3.set_title("Autocorrelation")

    return fig

skforecast.plot.plot.plot_prediction_distribution

plot_prediction_distribution(
    bootstrapping_predictions, bw_method=None, **fig_kw
)

Ridge plot of bootstrapping predictions. This plot is very useful to understand the uncertainty of forecasting predictions.

Parameters:

Name	Type	Description	Default
bootstrapping_predictions	pandas DataFrame	Bootstrapping predictions created with Forecaster.predict_bootstrapping.	required
bw_method	(str, scalar, Callable)	The method used to calculate the estimator bandwidth. This can be 'scott', 'silverman', a scalar constant or a Callable. If None (default), 'scott' is used. See scipy.stats.gaussian_kde for more information.	None
fig_kw	dict	All additional keyword arguments are passed to the pyplot.figure call.	{}

Returns:

Name	Type	Description
fig	Figure	Matplotlib Figure.

Source code in skforecast/plot/plot.py

def plot_prediction_distribution(
    bootstrapping_predictions: pd.DataFrame,
    bw_method: Any | None = None,
    **fig_kw
) -> matplotlib.figure.Figure:
    """
    Ridge plot of bootstrapping predictions. This plot is very useful to understand 
    the uncertainty of forecasting predictions.

    Parameters
    ----------
    bootstrapping_predictions : pandas DataFrame
        Bootstrapping predictions created with `Forecaster.predict_bootstrapping`.
    bw_method : str, scalar, Callable, default None
        The method used to calculate the estimator bandwidth. This can be 'scott', 
        'silverman', a scalar constant or a Callable. If None (default), 'scott' 
        is used. See scipy.stats.gaussian_kde for more information.
    fig_kw : dict
        All additional keyword arguments are passed to the `pyplot.figure` call.

    Returns
    -------
    fig : matplotlib.figure.Figure
        Matplotlib Figure.

    """

    index = bootstrapping_predictions.index.astype(str).to_list()[::-1]
    palette = plt.get_cmap('cubehelix')(np.linspace(0.15, 0.7, len(index)))
    fig, axs = plt.subplots(len(index), 1, sharex=True, **fig_kw)
    if not isinstance(axs, np.ndarray):
        axs = np.array([axs])

    for i, step in enumerate(index):
        # NOTE: Rows are selected by position because the labels in `index` are
        # strings, which do not match the labels of an integer index.
        step_predictions = bootstrapping_predictions.iloc[-(i + 1), :]
        plot = step_predictions.plot.kde(ax=axs[i], bw_method=bw_method, lw=0.5)

        # Fill density area
        x = plot.get_children()[0]._x
        y = plot.get_children()[0]._y
        axs[i].fill_between(x, y, color=palette[i])
        prediction_mean = step_predictions.mean()

        # Closest point on x to the prediction mean
        idx = np.abs(x - prediction_mean).argmin()
        axs[i].vlines(x[idx], ymin=0, ymax=y[idx], linestyle="dashed", color='w')

        axs[i].spines['top'].set_visible(False)
        axs[i].spines['right'].set_visible(False)
        axs[i].spines['bottom'].set_visible(False)
        axs[i].spines['left'].set_visible(False)
        axs[i].set_yticklabels([])
        axs[i].set_yticks([])
        axs[i].set_ylabel(step, rotation='horizontal')
        axs[i].set_xlabel('prediction')

    fig.subplots_adjust(hspace=-0)
    fig.suptitle('Forecasting distribution per step')

    return fig

skforecast.plot.plot.plot_prediction_intervals

plot_prediction_intervals(
    predictions,
    y_true=None,
    target_variable=None,
    initial_x_zoom=None,
    title=None,
    xaxis_title=None,
    yaxis_title=None,
    ax=None,
    kwargs_subplots={"figsize": (7, 3)},
    kwargs_fill_between={
        "color": "#444444",
        "alpha": 0.3,
        "zorder": 1,
    },
)

Plot predicted intervals vs real values using matplotlib.

Parameters:

Name	Type	Description	Default
predictions	pandas DataFrame	Predicted values and intervals of a single series. Expected columns are 'pred', 'lower_bound' and 'upper_bound', and 'y_true' when y_true is not given (the predictions of the backtesting functions include it). With multiple series, filter the rows of one level first.	required
y_true	pandas Series, pandas DataFrame	Real values of target variable. If None, the column 'y_true' of predictions is used. Changed in version 0.27.0: optional when predictions has the column 'y_true'.	None
target_variable	str	Name of target variable, the column of y_true to plot. It can be omitted when y_true is a pandas Series or has a single column. Changed in version 0.27.0: optional.	None
initial_x_zoom	list	Initial zoom of x-axis, by default None.	None
title	str	Title of the plot, by default None.	None
xaxis_title	str	Title of x-axis, by default None.	None
yaxis_title	str	Title of y-axis, by default None.	None
ax	matplotlib axes	Axes where to plot, by default None.	None
kwargs_subplots	dict	Additional keyword arguments (key, value mappings) to pass to plt.subplots.	{'figsize': (7, 3)}
kwargs_fill_between	dict	Additional keyword arguments (key, value mappings) to pass to ax.fill_between.	{'color': '#444444', 'alpha': 0.3}

Returns:

Type	Description
None

Source code in skforecast/plot/plot.py

def plot_prediction_intervals(
    predictions: pd.DataFrame,
    y_true: pd.Series | pd.DataFrame | None = None,
    target_variable: str | None = None,
    initial_x_zoom: list[str] | None = None,
    title: str | None = None,
    xaxis_title: str | None = None,
    yaxis_title: str | None = None,
    ax: plt.Axes | None = None,
    kwargs_subplots: dict[str, Any] = {'figsize': (7, 3)},
    kwargs_fill_between: dict[str, Any] = {'color': '#444444', 'alpha': 0.3, 'zorder': 1}
):
    """
    Plot predicted intervals vs real values using matplotlib.

    Parameters
    ----------
    predictions : pandas DataFrame
        Predicted values and intervals of a single series. Expected columns are
        'pred', 'lower_bound' and 'upper_bound', and 'y_true' when `y_true` is
        not given (the predictions of the backtesting functions include it). With
        multiple series, filter the rows of one level first.
    y_true : pandas Series, pandas DataFrame, default None
        Real values of target variable. If `None`, the column 'y_true' of
        `predictions` is used.
        **Changed in version 0.27.0:** optional when `predictions` has the
        column 'y_true'.
    target_variable : str, default None
        Name of target variable, the column of `y_true` to plot. It can be
        omitted when `y_true` is a pandas Series or has a single column.
        **Changed in version 0.27.0:** optional.
    initial_x_zoom : list, default None
        Initial zoom of x-axis, by default None.
    title : str, default None
        Title of the plot, by default None.
    xaxis_title : str, default None
        Title of x-axis, by default None.
    yaxis_title : str, default None
        Title of y-axis, by default None.
    ax : matplotlib axes, default None
        Axes where to plot, by default None.
    kwargs_subplots : dict, default {'figsize': (7, 3)}
        Additional keyword arguments (key, value mappings) to pass to `plt.subplots`.
    kwargs_fill_between : dict, default {'color': '#444444', 'alpha': 0.3}
        Additional keyword arguments (key, value mappings) to pass to `ax.fill_between`.

    Returns
    -------
    None

    """

    if 'level' in predictions.columns and predictions['level'].nunique() > 1:
        raise ValueError(
            "`predictions` contains more than one level. Filter the rows of one "
            "level before plotting, for example: "
            "`predictions[predictions['level'] == 'level_name']`."
        )

    if y_true is None:
        if 'y_true' not in predictions.columns:
            raise ValueError(
                "`y_true` must be provided when `predictions` does not have the "
                "column 'y_true' (the predictions of the backtesting functions "
                "include it)."
            )
        y_true_to_plot = predictions['y_true']
    else:
        if isinstance(y_true, pd.Series):
            y_true = y_true.to_frame()
        if target_variable is None:
            if y_true.shape[1] != 1:
                raise ValueError(
                    "`target_variable` must be provided when `y_true` has more "
                    "than one column."
                )
            target_variable = y_true.columns[0]
        y_true_to_plot = y_true.loc[predictions.index, target_variable]

    if ax is None:
        fig, ax = plt.subplots(**kwargs_subplots)

    # NOTE: matplotlib is used directly instead of the pandas plotting backend
    # to avoid the deprecated pandas matplotlib converters.
    ax.plot(y_true_to_plot.index, y_true_to_plot.to_numpy(), label='real value')
    ax.plot(predictions.index, predictions['pred'].to_numpy(), label='prediction')
    ax.fill_between(
        predictions.index,
        predictions['lower_bound'].to_numpy(),
        predictions['upper_bound'].to_numpy(),
        label='prediction interval',
        **kwargs_fill_between
    )
    ax.set_ylabel(yaxis_title)
    ax.set_xlabel(xaxis_title)
    ax.set_title(title)
    ax.legend()

    if isinstance(predictions.index, pd.DatetimeIndex):
        locator = AutoDateLocator()
        ax.xaxis.set_major_locator(locator)
        ax.xaxis.set_major_formatter(ConciseDateFormatter(locator))

    if initial_x_zoom is not None:
        if isinstance(predictions.index, pd.DatetimeIndex):
            initial_x_zoom = pd.to_datetime(initial_x_zoom)
        ax.set_xlim(initial_x_zoom)

skforecast.plot.plot.backtesting_gif_creator

backtesting_gif_creator(
    data,
    cv,
    series_to_plot=None,
    plot_last_window=False,
    filename="backtesting.gif",
    plt_style="ggplot",
    figsize=(9, 4),
    colors=None,
    title_template="Backtesting — Fold {fold_num} (refit: {refit})",
    fps=2,
    dpi=100,
)

Create a GIF of the backtesting folds using Matplotlib FuncAnimation.

Parameters:

Name	Type	Description	Default
data	pandas Series, pandas DataFrame	Time series data to be used for backtesting. Can be a single series or multiple series.	required
cv	TimeSeriesFold	TimeSeriesFold object with the information needed to split the data into folds.	required
series_to_plot	list	List of series names to plot. If None, all series will be plotted.	None
plot_last_window	bool	Whether to plot the last window of the time series. If True, window_size must be specified in the cv object.	False
filename	str	Name of the output GIF file.	"backtesting.gif"
figsize	tuple	Size of the figure.	(9, 4)
plt_style	str	Style to use for the plots. See Matplotlib styles for available options here: https://matplotlib.org/stable/gallery/style_sheets/style_sheets_reference.html.	"ggplot"
colors	dict	Dictionary with colors for the different elements of the plot. Must contain the following keys: ['train', 'last_window', 'gap', 'test', 'v_lines']. Defaults colors are {"train": "#329239", "last_window": "#f7931a", "gap": "#4d4d4d", "test": "#0d579b", "v_lines": "#252525"}	None
title_template	str	Template for the title of each plot.	"Backtesting — Fold {fold_num} (refit: {refit})"
fps	int	Frames per second for the GIF.	2
dpi	int	Dots per inch for the GIF.	100

Returns:

Name	Type	Description
filename_path	Path	Path to the output GIF file.

Source code in skforecast/plot/plot.py

def backtesting_gif_creator(
    data: pd.Series | pd.DataFrame,
    cv: object,
    series_to_plot: list[str] | None = None,
    plot_last_window: bool = False,
    filename: str = "backtesting.gif",
    plt_style: str = "ggplot",
    figsize: tuple[int, int] = (9, 4),
    colors: dict[str, str] | None = None,
    title_template: str = "Backtesting — Fold {fold_num} (refit: {refit})",
    fps: int = 2,
    dpi: int = 100
) -> Path:
    """
    Create a GIF of the backtesting folds using Matplotlib FuncAnimation.

    Parameters
    ----------
    data : pandas Series, pandas DataFrame
        Time series data to be used for backtesting. Can be a single series or 
        multiple series.
    cv : TimeSeriesFold
        TimeSeriesFold object with the information needed to split the data into folds.
    series_to_plot : list, default None
        List of series names to plot. If None, all series will be plotted.
    plot_last_window : bool, default False
        Whether to plot the last window of the time series. If True, window_size 
        must be specified in the cv object. 
    filename : str, default "backtesting.gif"
        Name of the output GIF file.
    figsize : tuple, default (9, 4)
        Size of the figure.
    plt_style : str, default "ggplot"
        Style to use for the plots. See Matplotlib styles for available options 
        here: https://matplotlib.org/stable/gallery/style_sheets/style_sheets_reference.html.
    colors : dict, default None
        Dictionary with colors for the different elements of the plot. Must 
        contain the following keys: ['train', 'last_window', 'gap', 'test', 'v_lines'].
        Defaults colors are {"train": "#329239", "last_window": "#f7931a",
        "gap": "#4d4d4d", "test": "#0d579b", "v_lines": "#252525"}
    title_template : str, default "Backtesting — Fold {fold_num} (refit: {refit})"
        Template for the title of each plot.
    fps : int, default 2
        Frames per second for the GIF.
    dpi : int, default 100
        Dots per inch for the GIF.

    Returns
    -------
    filename_path : Path
        Path to the output GIF file.

    """

    if isinstance(data, pd.Series):
        data = input_to_frame(
                   data       = data, 
                   input_name = data.name if data.name is not None else 'y'
               )

    if not isinstance(data, pd.DataFrame):
        raise TypeError(
            f"`data` must be a pandas Series or DataFrame. Got {type(data)}."
        )

    if not isinstance(data.index, (pd.RangeIndex, pd.DatetimeIndex)):
        raise TypeError(
            f"`data` must have a pandas RangeIndex or DatetimeIndex. Got {type(data.index)}."
        )

    cv_name = type(cv).__name__
    if cv_name != "TimeSeriesFold":
        raise TypeError(
            f"`cv` must be a 'TimeSeriesFold' object. Got '{cv_name}'."
        )

    if not isinstance(fps, int) or fps <= 0:
        raise TypeError(f"`fps` must be a positive integer. Got {fps}.")
    if not isinstance(dpi, int) or dpi <= 0:
        raise TypeError(f"`dpi` must be a positive integer. Got {dpi}.")

    if series_to_plot is None:
        series_to_plot = data.columns.to_list()
    else:
        if not isinstance(series_to_plot, list):
            raise TypeError(
                f"`series_to_plot` must be a list of column names. Got {type(series_to_plot)}."
            )
        missing_cols = [col for col in series_to_plot if col not in data.columns]
        if missing_cols:
            raise ValueError(f"Columns not found in `data`: {missing_cols}")

    folds = cv.split(X=data)
    if cv.return_all_indexes:
        # NOTE: +1 to prevent iloc pandas from deleting the last observation
        folds = [
            [
                fold[0],
                [fold[1][0], fold[1][-1] + 1],
                (
                    [fold[2][0], fold[2][-1] + 1]
                    if cv.window_size is not None
                    else []
                ),
                [fold[3][0], fold[3][-1] + 1],
                [fold[4][0], fold[4][-1] + 1],
                fold[5],
            ]
            for fold in folds
        ]

    if colors is None:
        colors = {
            "train": "#329239",
            "last_window": "#f7931a",
            "gap": "#4d4d4d",
            "test": "#0d579b",
            "v_lines": "#252525",
        }
    else:
        if not set(colors.keys()) >= {"train", "last_window", "gap", "test", "v_lines"}:
            raise ValueError(
                f"`colors` must contain the following keys: "
                f"{['train', 'last_window', 'gap', 'test', 'v_lines']}"
            )

    y_values = data[series_to_plot].to_numpy().flatten()
    y_min, y_max = np.nanmin(y_values), np.nanmax(y_values)

    # Include some padding to y-axis limits
    y_pad = 0.05 * (y_max - y_min if np.isfinite(y_max - y_min) and (y_max - y_min) > 0 else 1.0)
    y_min_plot = (y_min - y_pad) if np.isfinite(y_min) else -1
    y_max_plot = (y_max + y_pad) if np.isfinite(y_max) else 1

    with plt.style.context(plt_style):
        fig, ax = plt.subplots(figsize=figsize)

        x_index = data.index

        def _draw_fold(ax, fold, title: str):
            ax.clear()

            for col in series_to_plot:
                ax.plot(
                    x_index,
                    data[col].to_numpy(),
                    linewidth=1.5,
                    alpha=0.9,
                    label=col,
                )

            y_min_relative = (y_min - y_min_plot) / (y_max_plot - y_min_plot)
            y_max_relative = (y_max - y_min_plot) / (y_max_plot - y_min_plot)

            # Train
            train_start, train_end = fold[1]
            ax.axvspan(
                x_index[train_start],
                x_index[train_end],
                y_min_relative,
                y_max_relative,
                facecolor=colors["train"],
                alpha=0.2 if plot_last_window else 0.4,
                zorder=0,
                label="Train",
            )

            # last_window
            if plot_last_window:
                if cv.window_size is None:
                    warnings.warn(
                        "Last window cannot be calculated because the `window_size` "
                        "of the `cv` object is None.",
                        IgnoredArgumentWarning
                    )
                else:
                    last_window_start, last_window_end = fold[2]
                    ax.axvspan(
                        x_index[last_window_start],
                        x_index[last_window_end],
                        y_min_relative,
                        y_max_relative,
                        facecolor=colors["last_window"],
                        alpha=0.4,
                        zorder=0,
                        label="Last window",
                    )

            # Gap (if exists)
            gap_start = fold[3][0]
            gap_end = fold[4][0]
            if gap_start != gap_end:
                ax.axvspan(
                    x_index[gap_start],
                    x_index[gap_end],
                    y_min_relative,
                    y_max_relative,
                    facecolor="#bababa",
                    alpha=0.9,
                    zorder=0,
                    label="Gap",
                    hatch="////",
                    edgecolor=colors["gap"], 
                )

            # Test
            test_start, test_end = fold[4]
            ax.axvspan(
                x_index[test_start],
                x_index[test_end - 1],
                y_min_relative,
                y_max_relative,
                facecolor=colors["test"],
                alpha=0.4,
                zorder=0,
                label="Test",
            )

            def vline(ax, i):
                ax.axvline(
                    x_index[i],
                    ymin=y_min_relative,
                    ymax=y_max_relative,
                    lw=1,
                    ls="--",
                    alpha=0.5,
                    color=colors["v_lines"],
                )

            vline(ax, train_end)
            vline(ax, test_start)

            ax.set_ylim(y_min_plot, y_max_plot)
            ax.set_title(title)
            ax.legend(loc="upper left")
            ax.grid(True, alpha=0.8)

        # --------- Animation functions ----------
        def init():
            # Draw the first fold as the initial state
            _draw_fold(ax, folds[0], title=title_template.format(fold_num=1, refit=0))
            return (ax,)

        def update(i):
            fold = folds[i]
            fold_num = min(i + 1, len(folds) - n_extra)
            refit = fold[5] if len(fold) > 4 else i
            title = title_template.format(fold_num=fold_num, refit=refit)
            _draw_fold(ax, fold, title=title)
            return (ax,)

        # --------- Construction and saving ----------
        # Add extra folds for pause at the end
        n_extra = 2
        for i in range(n_extra):
            folds.append(folds[-1])

        ani = FuncAnimation(
            fig,
            update,
            frames=len(folds),
            init_func=init,
            blit=False, 
            repeat=False
        )

        # Save GIF
        writer = PillowWriter(fps=max(1, int(fps)))
        ani.save(Path(filename).with_suffix('.gif'), writer=writer, dpi=dpi)
        plt.close(fig)

    filename_path = os.path.join(os.getcwd(), filename)

    return Path(filename_path)

skforecast.plot.plot.plot_multivariate_time_series_corr

plot_multivariate_time_series_corr(corr, ax=None, **fig_kw)

Heatmap plot of a correlation matrix.

Parameters:

Name	Type	Description	Default
corr	pandas DataFrame	correlation matrix	required
ax	Axes	Pre-existing ax for the plot. Otherwise, call matplotlib.pyplot.subplots() internally.	None
fig_kw	dict	Other keyword arguments are passed to matplotlib.pyplot.subplots()	{}

Returns:

Name	Type	Description
fig	Figure	Matplotlib Figure.

Source code in skforecast/plot/plot.py

def plot_multivariate_time_series_corr(
    corr: pd.DataFrame,
    ax: matplotlib.axes.Axes | None = None,
    **fig_kw
) -> matplotlib.figure.Figure:
    """
    Heatmap plot of a correlation matrix.

    Parameters
    ----------
    corr : pandas DataFrame
        correlation matrix
    ax : matplotlib.axes.Axes, default None
        Pre-existing ax for the plot. Otherwise, call matplotlib.pyplot.subplots() 
        internally.
    fig_kw : dict
        Other keyword arguments are passed to matplotlib.pyplot.subplots()

    Returns
    -------
    fig: matplotlib.figure.Figure
        Matplotlib Figure.

    """

    if ax is None:
        fig, ax = plt.subplots(1, 1, **fig_kw)
    else:
        fig = ax.get_figure()

    values = corr.to_numpy()
    im = ax.imshow(values, cmap='viridis', aspect='auto')
    fig.colorbar(im, ax=ax)

    ax.set_xticks(np.arange(corr.shape[1]))
    ax.set_yticks(np.arange(corr.shape[0]))
    ax.set_xticklabels(corr.columns)
    ax.set_yticklabels(corr.index)

    # Minor ticks to draw separating grid lines between cells
    ax.set_xticks(np.arange(corr.shape[1] + 1) - 0.5, minor=True)
    ax.set_yticks(np.arange(corr.shape[0] + 1) - 0.5, minor=True)
    ax.grid(which='minor', color='w', linewidth=0.5)
    ax.tick_params(which='minor', bottom=False, left=False)

    # Annotate each cell, choosing text color for contrast with the background
    for i in range(values.shape[0]):
        for j in range(values.shape[1]):
            value = values[i, j]
            r, g, b, _ = im.cmap(im.norm(value))
            luminance = 0.299 * r + 0.587 * g + 0.114 * b
            ax.text(
                j, i, f"{value:.2g}",
                ha='center', va='center',
                color='white' if luminance < 0.5 else 'black'
            )

    ax.set_xlabel('Time series')

    return fig