quantile-forest 1.3.2__tar.gz → 1.3.4__tar.gz

{quantile-forest-1.3.2/quantile_forest.egg-info → quantile-forest-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantile-forest
-Version: 1.3.2
+Version: 1.3.4
 Summary: scikit-learn compatible quantile forests.
 Home-page: https://zillow.github.io/quantile-forest
 Download-URL: https://pypi.org/project/quantile-forest/#files
@@ -31,7 +31,7 @@ Requires-Dist: numpy>=1.23
 Requires-Dist: scipy>=1.4
 Requires-Dist: scikit-learn>=1.0
 
-# quantile-forest
+# quantile-forest <a href="https://zillow.github.io/quantile-forest/"><img align="right" src="https://zillow.github.io/quantile-forest/_static/quantile-forest-logo.png" height="50"></img></a>
 
 [![PyPI - Version](https://img.shields.io/pypi/v/quantile-forest)](https://pypi.org/project/quantile-forest)
 [![License](https://img.shields.io/github/license/zillow/quantile-forest)](https://github.com/zillow/quantile-forest/blob/main/LICENSE)

{quantile-forest-1.3.2 → quantile-forest-1.3.4}/README.md

@@ -1,4 +1,4 @@
-# quantile-forest
+# quantile-forest <a href="https://zillow.github.io/quantile-forest/"><img align="right" src="https://zillow.github.io/quantile-forest/_static/quantile-forest-logo.png" height="50"></img></a>
 
 [![PyPI - Version](https://img.shields.io/pypi/v/quantile-forest)](https://pypi.org/project/quantile-forest)
 [![License](https://img.shields.io/github/license/zillow/quantile-forest)](https://github.com/zillow/quantile-forest/blob/main/LICENSE)

{quantile-forest-1.3.2 → quantile-forest-1.3.4}/docs/conf.py

@@ -16,6 +16,7 @@ import sys
 from datetime import datetime
 
 sys.path.insert(0, os.path.abspath("."))
+sys.path.insert(0, os.path.abspath(".."))
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -104,11 +105,12 @@ html_theme = "pydata_sphinx_theme"
 
 html_theme_options = {
     # "navbar_start": ["navbar-logo", "navbar-project"],
-    "navbar_start": ["navbar-project"],
+    "navbar_start": ["navbar-logo", "navbar-project"],
     "navbar_center": ["navbar-nav"],
     "navbar_end": ["theme-switcher", "navbar-icon-links"],
     "primary_sidebar_end": [],
     "footer_items": [],
+    "logo": {"image_dark": "_static/quantile-forest-logo-white.png"},
     "icon_links": [
         {
             "name": "GitHub",
@@ -124,11 +126,20 @@ html_context = {"default_mode": "light"}
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ["_static", "_images"]
 
 # Output file base name for HTML help builder.
 html_short_title = "quantile-forest"
 
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+html_logo = "_static/quantile-forest-logo.png"
+
+# The name of an image file (relative to this directory) to use as a favicon of
+# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+html_favicon = "_static/favicon.ico"
+
 htmlhelp_basename = "quantile-forestdoc"
 
 
@@ -150,7 +161,10 @@ html_sidebars = {
 
 # -- Options for autodoc ------------------------------------------------------
 
-autodoc_default_flags = ["members", "inherited-members"]
+autodoc_default_options = {
+    "members": True,
+    "inherited-members": True,
+}
 
 # Generate autosummary even if no references.
 autosummary_generate = True

{quantile-forest-1.3.2 → quantile-forest-1.3.4}/docs/index.rst

@@ -1,7 +1,7 @@
 :html_theme.sidebar_secondary.remove:
 
-quantile-forest Documentation
-=============================
+quantile-forest
+===============
 .. role:: raw-html(raw)
    :format: html
 
@@ -23,21 +23,21 @@ quantile-forest Documentation
       :link-type: ref
       :link-alt: Getting started
 
-      A guide that provides installation instructions and information on testing the package.
+      A guide that provides installation requirements and instructions, as well as procedures for developers.
 
    .. grid-item-card:: User Guide
       :link: user_guide
       :link-type: ref
       :link-alt: User guide
 
-      Check out the User Guide for information on the key concepts behind quantile forests.
+      Information on the key concepts behind quantile forests and how they apply to this package.
 
    .. grid-item-card:: Examples
       :link: example-gallery
       :link-type: ref
       :link-alt: Examples
 
-      General-purpose, introductory and illustrative examples of using quantile forests.
+      Examples that demonstrate the broad applications and introductory concepts of quantile forests.
 
    .. grid-item-card:: API
       :link: api

{quantile-forest-1.3.2 → quantile-forest-1.3.4}/docs/install.rst

@@ -59,6 +59,7 @@ Documentation
 To build the documentation, run::
 
   $ pip install -r ./docs/sphinx_requirements.txt
+  $ mkdir -p ./docs/_images
   $ sphinx-build -b html ./docs ./docs/_build
 
 .. toctree::

{quantile-forest-1.3.2 → quantile-forest-1.3.4}/docs/sphinxext/gallery.py

@@ -1,31 +1,24 @@
 """Adapted from Vega-Altair. BSD-3-Clause License. https://github.com/altair-viz/altair"""
 
 import hashlib
-import os
 import json
+import os
 import random
-from operator import itemgetter
-import warnings
 import shutil
+import warnings
+from operator import itemgetter
 
 import jinja2
-
+from altair.utils.execeval import eval_block
 from docutils import nodes
-from docutils.statemachine import ViewList
 from docutils.parsers.rst import Directive
 from docutils.parsers.rst.directives import flag
-
+from docutils.statemachine import ViewList
 from sphinx.util.nodes import nested_parse_with_titles
 
-from .utils import (
-    get_docstring_and_rest,
-    prev_this_next,
-    create_thumbnail,
-    create_generic_image,
-)
-from altair.utils.execeval import eval_block
+from examples import iter_examples
 
-from quantile_forest.tests.examples import iter_examples
+from .utils import create_generic_image, create_thumbnail, get_docstring_and_rest, prev_this_next
 
 EXAMPLE_MODULE = "examples"
 
@@ -257,8 +250,7 @@ class MiniGalleryDirective(Directive):
 def main(app):
     gallery_dir = app.builder.config.gallery_dir
     target_dir = os.path.join(app.builder.srcdir, gallery_dir)
-    # image_dir = os.path.join(app.builder.srcdir, "_images")
-    image_dir = os.path.join(app.builder.srcdir, "_static")
+    image_dir = os.path.join(app.builder.srcdir, "_images")
 
     gallery_ref = app.builder.config.gallery_ref
     gallery_title = app.builder.config.gallery_title

{quantile-forest-1.3.2 → quantile-forest-1.3.4}/docs/user_guide.rst

@@ -75,6 +75,10 @@ Default quantiles can be specified at model initialization using the `default_qu
     >>> reg.fit(X_train, y_train)
     RandomForestQuantileRegressor(default_quantiles=[0.25, 0.5, 0.75])
     >>> y_pred = reg.predict(X_test)  # predicts using the default quantiles
+    >>> y_pred.ndim == 2
+    True
+    >>> y_pred.shape[1] == 3
+    True
 
 The default quantiles can be overwritten at prediction time by specifying a value for `quantiles`:
 
@@ -82,6 +86,8 @@ The default quantiles can be overwritten at prediction time by specifying a valu
     >>> reg.fit(X_train, y_train)
     RandomForestQuantileRegressor(default_quantiles=[0.25, 0.5, 0.75])
     >>> y_pred = reg.predict(X_test, quantiles=0.5)  # uses override quantiles
+    >>> y_pred.ndim == 1
+    True
 
 The output of the `predict` method is an array with one column for each specified quantile or a single column if no quantiles are specified. The order of the output columns corresponds to the order of the quantiles, which can be specified in any order (i.e., they do not need to be monotonically ordered)::
 
@@ -89,7 +95,7 @@ The output of the `predict` method is an array with one column for each specifie
     >>> (y_pred[:, 0] >= y_pred[:, 1]).all()
     True
 
-Multi-target quantile regression is also supported. If the target values are multi-dimensional, then the final output column will correspond to the number of targets::
+Multi-target quantile regression is also supported. If the target values are multi-dimensional, then the second output column will correspond to the number of targets::
 
     >>> from sklearn import datasets
     >>> from quantile_forest import RandomForestQuantileRegressor
@@ -105,25 +111,24 @@ Multi-target quantile regression is also supported. If the target values are mul
     True
     >>> y_pred.shape[0] == len(X)
     True
-    >>> y_pred.shape[1] == len(quantiles)
+    >>> y_pred.shape[-1] == len(quantiles)
     True
-    >>> y_pred.shape[-1] == y.shape[1]
+    >>> y_pred.shape[1] == y.shape[1]
     True
 
 Quantile Weighting
 ~~~~~~~~~~~~~~~~~~
 
-By default, the predict method calculates quantiles by weighting each sample inversely according to the size of its leaf node (`weighted_leaves = True`). If `weighted_leaves = False`, each sample in a leaf (including repeated bootstrap samples) will be given equal weight. Note that this leaf-based weighting can only be used with weighted quantiles.
-
 By default, the predict method calculates quantiles using a weighted quantile method (`weighted_quantile = True`), which assigns a weight to each sample in the training set based on the number of times that it co-occurs in the same leaves as the test sample. When the number of samples in the training set is larger than the expected size of this list (i.e., :math:`n_{train} \gg n_{trees} \cdot n_{leaves} \cdot n_{leafsamples}`), it can be more efficient to calculate an unweighted quantile (`weighted_quantile = False`), which aggregates the list of training `y` values for each leaf node to which the test sample belongs across all trees. For a given input, both methods can return the same output values::
 
     >>> import numpy as np
-    >>> kwargs = {"weighted_leaves": False}
-    >>> y_pred_weighted = reg.predict(X_test, weighted_quantile=True, **kwargs)
-    >>> y_pred_unweighted = reg.predict(X_test, weighted_quantile=False, **kwargs)
+    >>> y_pred_weighted = reg.predict(X_test, weighted_quantile=True)
+    >>> y_pred_unweighted = reg.predict(X_test, weighted_quantile=False)
     >>> np.allclose(y_pred_weighted, y_pred_unweighted)
     True
 
+By default, the predict method calculates quantiles by giving each sample in a leaf (including repeated bootstrap samples) equal weight (`weighted_leaves = False`). If `weighted_leaves = True`, each sample will be weighted inversely according to the size of its leaf node. Note that this leaf-based weighting can only be used with weighted quantiles.
+
 Out-of-Bag Estimation
 ~~~~~~~~~~~~~~~~~~~~~
 
@@ -195,13 +200,15 @@ Proximity counts are counts of the number of times that two samples share a leaf
     >>> X, y = datasets.load_diabetes(return_X_y=True)
     >>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
     >>> reg = RandomForestQuantileRegressor().fit(X_train, y_train)
-    >>> proximities = reg.proximity_counts(X_test)
+    >>> proximities = reg.proximity_counts(X_test)  # proximity counts for X_test
 
 For each test sample, the method outputs a list of tuples of the training index and proximity count, listed in descending order by proximity count. For example, a test sample with an output of [(1, 5), (0, 3), (3, 1)], means that the test sample shared 5, 3, and 1 leaf nodes with the training samples that were (zero-)indexed as 1, 0, and 3 during model fitting, respectively.
 
 The maximum number of proximity counts output per test sample can be limited by specifying `max_proximities`::
 
     >>> proximities = reg.proximity_counts(X_test, max_proximities=10)
+    >>> np.all([len(prox) <= 10 for prox in proximities])
+    True
 
 Out-of-bag (OOB) proximity counts can be returned by specifying `oob_score = True`::
 

{quantile-forest-1.3.2/quantile_forest/tests → quantile-forest-1.3.4}/examples/plot_quantile_conformalized.py

@@ -6,8 +6,10 @@ An example that demonstrates the use of a quantile regression forest (QRF) to
 construct reliable prediction intervals using conformalized quantile
 regression (CQR). CQR offers prediction intervals that attain valid coverage,
 while QRF may require additional calibration for reliable interval estimates.
-Adapted from "Prediction intervals: Quantile Regression Forests" by Carl McBride
-Ellis:
+Notice that in this example, by using CQR we obtain a level of coverage (i.e.,
+percentage of samples that actaully fall within their prediction interval)
+that is closer to the target level. Adapted from "Prediction intervals:
+Quantile Regression Forests" by Carl McBride Ellis:
 https://www.kaggle.com/code/carlmcbrideellis/prediction-intervals-quantile-regression-forests.
 """
 
@@ -79,7 +81,9 @@ def qrf_strategy(alpha, X_train, X_test, y_train, y_test):
     # Calculate the point predictions on the test data.
     y_pred = qrf.predict(X_test, quantiles="mean", aggregate_leaves_first=False)
 
-    return sort_y_values(y_test, y_pred, y_pis)
+    y_values = sort_y_values(y_test, y_pred, y_pis)
+
+    return pd.DataFrame(y_values).pipe(lambda x: x * 100_000).assign(strategy="qrf")
 
 
 def cqr_strategy(alpha, X_train, X_test, y_train, y_test):
@@ -119,32 +123,32 @@ def cqr_strategy(alpha, X_train, X_test, y_train, y_test):
     # Calculate the point predictions on the test data.
     y_pred = qrf.predict(X_test, quantiles="mean", aggregate_leaves_first=False)
 
-    return sort_y_values(y_test, y_pred, y_pis)
+    y_values = sort_y_values(y_test, y_pred, y_pis)
+
+    return pd.DataFrame(y_values).pipe(lambda x: x * 100_000).assign(strategy="cqr")
 
 
 # Get strategy outputs as a data frame.
 args = (alpha, X_train, X_test, y_train, y_test)
-df = pd.concat(
-    [
-        pd.DataFrame(qrf_strategy(*args)).pipe(lambda x: x * 100_000).assign(strategy="qrf"),
-        pd.DataFrame(cqr_strategy(*args)).pipe(lambda x: x * 100_000).assign(strategy="cqr"),
-    ]
-)
+df = pd.concat([qrf_strategy(*args), cqr_strategy(*args)])
 
-# Add coverage and mean width metrics to the data frame.
-df = df.merge(
+# Calculate coverage and width metrics.
+metrics = (
     df.groupby("strategy")
     .apply(
-        lambda x: pd.Series(
+        lambda grp: pd.Series(
             {
-                "coverage": coverage_score(x["y_test"], x["y_pred_low"], x["y_pred_upp"]),
-                "width": mean_width_score(x["y_pred_low"], x["y_pred_upp"]),
+                "coverage": coverage_score(grp["y_test"], grp["y_pred_low"], grp["y_pred_upp"]),
+                "width": mean_width_score(grp["y_pred_low"], grp["y_pred_upp"]),
             }
         )
     )
     .reset_index()
 )
 
+# Merge the metrics into the data frame.
+df = df.merge(metrics, on="strategy", how="left")
+
 
 def plot_prediction_intervals(df, domain):
     click = alt.selection_point(fields=["y_label"], bind="legend")
@@ -220,12 +224,10 @@ def plot_prediction_intervals(df, domain):
     )
 
     text_coverage = (
-        base.transform_aggregate(
-            coverage="mean(coverage)", width="mean(width)", groupby=["strategy"]
-        )
+        base.transform_aggregate(coverage="mean(coverage)", groupby=["strategy"])
         .transform_calculate(
             coverage_text=(
-                "'Coverage: ' + format(datum.coverage * 100, '.1f') + '%'"
+                f"'Coverage: ' + format({alt.datum['coverage'] * 100}, '.1f') + '%'"
                 f" + ' (target = {cov_pct}%)'"
             )
         )
@@ -237,10 +239,10 @@ def plot_prediction_intervals(df, domain):
         )
     )
     text_with = (
-        base.transform_aggregate(
-            coverage="mean(coverage)", width="mean(width)", groupby=["strategy"]
+        base.transform_aggregate(width="mean(width)", groupby=["strategy"])
+        .transform_calculate(
+            width_text=f"'Interval Width: ' + format({alt.datum['width']}, '$,d')"
         )
-        .transform_calculate(width_text="'Interval Width: ' + format(datum.width, '$,d')")
         .mark_text(align="left", baseline="top")
         .encode(
             x=alt.value(5),

{quantile-forest-1.3.2/quantile_forest/tests → quantile-forest-1.3.4}/examples/plot_quantile_example.py

@@ -8,17 +8,18 @@ the predictions to a ground truth function used to generate noisy samples.
 """
 
 import altair as alt
-import pandas as pd
 import numpy as np
+import pandas as pd
 from sklearn.model_selection import train_test_split
 
 from quantile_forest import RandomForestQuantileRegressor
 
 n_samples = 1000
 bounds = [0, 10]
+quantiles = [0.025, 0.5, 0.975]
 
 
-def make_toy_dataset(n_samples, bounds, random_seed=0):
+def make_toy_dataset(n_samples, bounds, add_noise=True, random_seed=0):
     rng = np.random.RandomState(random_seed)
 
     x = rng.uniform(*bounds, size=n_samples)
@@ -26,109 +27,94 @@ def make_toy_dataset(n_samples, bounds, random_seed=0):
 
     sigma = 0.25 + x / 10
     noise = rng.lognormal(sigma=sigma) - np.exp(sigma**2 / 2)
-    y = f + noise
+    y = f + (noise if add_noise else 0)
 
     return np.atleast_2d(x).T, y
 
 
-X, y = make_toy_dataset(n_samples, bounds)
+# Create noisy data for modeling and non-noisy function data for illustration.
+X, y = make_toy_dataset(n_samples, bounds, add_noise=True, random_seed=0)
+X_func, y_func = make_toy_dataset(n_samples, bounds, add_noise=False, random_seed=0)
 
 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
 
-X_sampled = np.atleast_2d(np.linspace(*bounds, n_samples)).T
-y_sampled = (X_sampled * np.sin(X_sampled)).reshape(-1)
-
 qrf = RandomForestQuantileRegressor(max_depth=3, min_samples_leaf=5, random_state=0)
 qrf.fit(X_train, y_train)
 
-y_pred = qrf.predict(X_sampled, quantiles=[0.025, 0.5, 0.975])
+y_pred_func = qrf.predict(X_func, quantiles=quantiles)
+y_pred_test = qrf.predict(X_test, quantiles=quantiles)
 
-df_train = pd.DataFrame(
+df = pd.DataFrame(
     {
-        "X_sampled": X_sampled.reshape(-1),
-        "y_sampled": y_sampled,
-        "y_pred_low": y_pred[:, 0],
-        "y_pred_med": y_pred[:, 1],
-        "y_pred_upp": y_pred[:, 2],
+        "X": np.concatenate([X_func.reshape(-1), X_test.reshape(-1)]),
+        "y": np.concatenate([y_func, y_test]),
+        "y_pred": np.concatenate([y_pred_func[:, 1], y_pred_test[:, 1]]),
+        "y_pred_low": np.concatenate([y_pred_func[:, 0], y_pred_test[:, 0]]),
+        "y_pred_upp": np.concatenate([y_pred_func[:, 2], y_pred_test[:, 2]]),
+        "test": [False] * len(y_func) + [True] * len(y_test),
     }
 )
 
-df_test = pd.DataFrame(
-    {
-        "X_test": X_test.reshape(-1),
-        "y_test": y_test,
-    }
-)
-
-
-def plot_fit_and_intervals(df_train, df_test):
-    df_train = df_train.copy()
-    df_test = df_test.copy()
-
-    df_train = df_train.assign(
-        **{
-            "y_true_label": "f(x) = x sin(x)",
-            "y_pred_label": "Predicted Median",
-            "y_area_label": "Predicted 95% Interval",
-        }
-    )
-
-    df_test["point_label"] = "Test Observations"
 
+def plot_fit_and_intervals(df):
     points = (
-        alt.Chart(df_test)
+        alt.Chart(df.assign(**{"point_label": "Test Observations"}))
+        .transform_filter(alt.datum["test"])  # filter to test data
         .mark_circle(color="#f2a619")
         .encode(
-            x=alt.X("X_test:Q", scale=alt.Scale(nice=False)),
-            y=alt.Y("y_test:Q", title=""),
+            x=alt.X("X:Q", scale=alt.Scale(nice=False)),
+            y=alt.Y("y:Q", title=""),
             color=alt.Color("point_label:N", scale=alt.Scale(range=["#f2a619"]), title=None),
             tooltip=[
-                alt.Tooltip("X_test:Q", format=",.3f", title="X"),
-                alt.Tooltip("y_test:Q", format=",.3f", title="Y"),
+                alt.Tooltip("X:Q", format=",.3f", title="X"),
+                alt.Tooltip("y:Q", format=",.3f", title="Y"),
             ],
         )
     )
 
     line_true = (
-        alt.Chart(df_train)
+        alt.Chart(df.assign(**{"y_true_label": "f(x) = x sin(x)"}))
+        .transform_filter(~alt.datum["test"])  # filter to training data
         .mark_line(color="black", size=3)
         .encode(
-            x=alt.X("X_sampled:Q", scale=alt.Scale(nice=False)),
-            y=alt.Y("y_sampled:Q", title="f(x)"),
+            x=alt.X("X:Q", scale=alt.Scale(nice=False)),
+            y=alt.Y("y:Q", title="f(x)"),
             color=alt.Color("y_true_label:N", scale=alt.Scale(range=["black"]), title=None),
             tooltip=[
-                alt.Tooltip("X_sampled:Q", format=",.3f", title="X"),
-                alt.Tooltip("y_sampled:Q", format=",.3f", title="Y"),
+                alt.Tooltip("X:Q", format=",.3f", title="X"),
+                alt.Tooltip("y:Q", format=",.3f", title="Y"),
             ],
         )
     )
 
     line_pred = (
-        alt.Chart(df_train)
+        alt.Chart(df.assign(**{"y_pred_label": "Predicted Median"}))
+        .transform_filter(~alt.datum["test"])  # filter to training data
         .mark_line(color="#006aff", size=5)
         .encode(
-            x=alt.X("X_sampled:Q", scale=alt.Scale(nice=False)),
-            y=alt.Y("y_pred_med:Q", title=""),
+            x=alt.X("X:Q", scale=alt.Scale(nice=False)),
+            y=alt.Y("y_pred:Q", title=""),
             color=alt.Color("y_pred_label:N", scale=alt.Scale(range=["#006aff"]), title=None),
             tooltip=[
-                alt.Tooltip("X_sampled:Q", format=",.3f", title="X"),
-                alt.Tooltip("y_sampled:Q", format=",.3f", title="Y"),
-                alt.Tooltip("y_pred_med:Q", format=",.3f", title="Predicted Y"),
+                alt.Tooltip("X:Q", format=",.3f", title="X"),
+                alt.Tooltip("y:Q", format=",.3f", title="Y"),
+                alt.Tooltip("y_pred:Q", format=",.3f", title="Predicted Y"),
             ],
         )
     )
 
     area_pred = (
-        alt.Chart(df_train)
+        alt.Chart(df)
+        .transform_filter(~alt.datum["test"])  # filter to training data
         .mark_area(color="#e0f2ff", opacity=0.8)
         .encode(
-            x=alt.X("X_sampled:Q", scale=alt.Scale(nice=False), title="x"),
+            x=alt.X("X:Q", scale=alt.Scale(nice=False), title="x"),
             y=alt.Y("y_pred_low:Q", title=""),
             y2=alt.Y2("y_pred_upp:Q", title=None),
             tooltip=[
-                alt.Tooltip("X_sampled:Q", format=",.3f", title="X"),
-                alt.Tooltip("y_sampled:Q", format=",.3f", title="Y"),
-                alt.Tooltip("y_pred_med:Q", format=",.3f", title="Predicted Y"),
+                alt.Tooltip("X:Q", format=",.3f", title="X"),
+                alt.Tooltip("y:Q", format=",.3f", title="Y"),
+                alt.Tooltip("y_pred:Q", format=",.3f", title="Predicted Y"),
                 alt.Tooltip("y_pred_low:Q", format=",.3f", title="Predicted Lower Y"),
                 alt.Tooltip("y_pred_upp:Q", format=",.3f", title="Predicted Upper Y"),
             ],
@@ -153,5 +139,5 @@ def plot_fit_and_intervals(df_train, df_test):
     return chart
 
 
-chart = plot_fit_and_intervals(df_train, df_test)
+chart = plot_fit_and_intervals(df)
 chart