Repository: sktime/sktime
Pull request #6375 (2024-05-01 23:53:19)

[DOC] fixed wrong sentence in the documentation
<!--
Welcome to sktime, and thanks for contributing!
Please have a look at our contribution guide:
https://www.sktime.net/en/latest/get_involved/contributing.html
-->

#### Reference Issues/PRs
NA
#### What does this implement/fix? Explain your changes.
There was a mistake in the description of the capabilities of the  `"np.ndarray"` mtype. As the example shows, it is capable to represent multivariate series.

#### Does your contribution introduce a new dependency? If yes, which one?
No
#### What should a reviewer concentrate their feedback on?
Proof read :)
#### Did you add any tests for the change?
NA
#### Any other comments?
NA
#### PR checklist
<!--
Please go through the checklist below. Please feel free to remove points if they are not applicable.
-->

##### For all contributions
- [X] I've added myself to the [list of contributors](https://github.com/sktime/sktime/blob/main/CONTRIBUTORS.md) with any new badges I've earned :-)
  How to: add yourself to the [all-contributors file](https://github.com/sktime/sktime/blob/main/.all-contributorsrc) in the `sktime` root directory (not the `CONTRIBUTORS.md`). Common badges: `code` - fixing a bug, or adding code logic. `doc` - writing or improving documentation or docstrings. `bug` - reporting or diagnosing a bug (get this plus `code` if you also fixed the bug in the PR).`maintenance` - CI, test framework, release.
  See here for [full badge reference](https://allcontributors.org/docs/en/emoji-key)
- [ ] Optionally, for added estimators: I've added myself and possibly to the `maintainers` tag - do this if you want to become the owner or maintainer of an estimator you added.
  See here for further details on the [algorithm maintainer role](https://www.sktime.net/en/latest/get_involved/governance.html#algorithm-maintainers).
- [X] The PR title starts with either [ENH], [MNT], [DOC], or [BUG]. [BUG] - bugfix, [MNT] - CI, test framework, [ENH] - adding or improving code, [DOC] - writing or improving documentation or docstrings.

##### For new estimators
- [ ] I've added the estimator to the API reference - in `docs/source/api_reference/taskname.rst`, follow the pattern.
- [ ] I've added one or more illustrative usage examples to the docstring, in a pydocstyle compliant `Examples` section.
- [ ] If the estimator relies on a soft dependency, I've set the `python_dependencies` tag and ensured
  dependency isolation, see the [estimator dependencies guide](https://www.sktime.net/en/latest/developer_guide/dependencies.html#adding-a-soft-dependency).

<!--
Thanks for contributing!
-->


review-notebook-app[bot]: Check out this pull request on&nbsp; <a href="https://app.reviewnb.com/sktime/sktime/pull/6375"><img align="absmiddle"  alt="ReviewNB" height="28" class="BotMessageButtonImage" src="https://raw.githubusercontent.com/ReviewNB/support/master/images/button_reviewnb.png"/></a> 

 See visual diffs & provide feedback on Jupyter Notebooks. 

---

 <i>Powered by <a href='https://www.reviewnb.com/?utm_source=gh'>ReviewNB</a></i>

Patch:
diff --git a/.all-contributorsrc b/.all-contributorsrc
index 4d039c995..630f97689 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -2803,6 +2803,15 @@
       "contributions": [
         "maintenance"
       ]
+    },
+    {
+      "login": "helloplayer1",
+      "name": "Julian Haderlein",
+      "avatar_url": "https://avatars.githubusercontent.com/u/32032467?v=4",
+      "profile": "https://github.com/helloplayer1",
+      "contributions": [
+        "doc"
+      ]
     }
   ]
 }
diff --git a/README.md b/README.md
index 13655d3f1..bad9a6f9b 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,7 @@ Questions and feedback are extremely welcome! We strongly believe in the value o
 | :woman_technologist: **Usage Questions**          | [GitHub Discussions] · [Stack Overflow] |
 | :speech_balloon: **General Discussion**        | [GitHub Discussions] |
 | :factory: **Contribution & Development** | `dev-chat` channel · [Discord] |
-| :globe_with_meridians: **Meet-ups and collaboration sessions** | [Discord] - Fridays 4 pm UTC, dev/meet-ups channel |
+| :globe_with_meridians: **Meet-ups and collaboration sessions** | [Discord] - Fridays 13 UTC, dev/meet-ups channel |
 
 [github issue tracker]: https://github.com/sktime/sktime/issues
 [github discussions]: https://github.com/sktime/sktime/discussions
diff --git a/docs/source/api_reference/forecasting.rst b/docs/source/api_reference/forecasting.rst
index bfd68ecf0..97cc002fe 100644
--- a/docs/source/api_reference/forecasting.rst
+++ b/docs/source/api_reference/forecasting.rst
@@ -364,6 +364,8 @@ Deep learning based forecasters
     LTSFNLinearForecaster
 
 .. currentmodule:: sktime.forecasting.hf_transformers_forecaster
+
+.. autosummary::
     :toctree: auto_generated/
     :template: class.rst
 
diff --git a/docs/source/api_reference/split.rst b/docs/source/api_reference/split.rst
index ee1b27fb7..742ce6c0b 100644
--- a/docs/source/api_reference/split.rst
+++ b/docs/source/api_reference/split.rst
@@ -47,6 +47,7 @@ They have tag ``"split_type"="temporal"``.
     SingleWindowSplitter
     SlidingWindowSplitter
     ExpandingWindowSplitter
+    ExpandingCutoffSplitter
     ExpandingGreedySplitter
     TemporalTrainTestSplitter
 
diff --git a/docs/source/api_reference/transformations.rst b/docs/source/api_reference/transformations.rst
index d07f454ae..1bedaa6f2 100644
--- a/docs/source/api_reference/transformations.rst
+++ b/docs/source/api_reference/transformations.rst
@@ -137,6 +137,14 @@ These transformers extract simple summary features.
     RandomIntervalFeatureExtractor
     FittedParamExtractor
 
+.. currentmodule:: sktime.transformations.series.adi_cv
+
+.. autosummary::
+    :toctree: auto_generated/
+    :template: class.rst
+
+    ADICVTransformer
+
 Shapelets, wavelets, and convolution
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/docs/source/developer_guide/deprecation.rst b/docs/source/developer_guide/deprecation.rst
index 74eabe412..4d0db2c4f 100644
--- a/docs/source/developer_guide/deprecation.rst
+++ b/docs/source/developer_guide/deprecation.rst
@@ -4,13 +4,44 @@
 Deprecation
 ===========
 
-Before we can make changes to sktime's user interface, we need to make sure that users have time to make the necessary adjustments in their code.
-For this reason, we first need to deprecate functionality and change it only in a next release.
+``sktime`` aims to be stable and reliable towards its users.
+Our high-level policy to ensure this is:
 
-.. note::
+"``sktime`` should never break user code without a clear and actionable warning
+given at least one (MINOR) release cycle in advance."
+
+Here, "break" expressly includes a change to abstract logic, such as the algorithm
+being used, not just changes that lead to exceptions or performance degradation.
+
+For instance, if a user has code
+
+.. code:: python
+
+    from sktime.forecasting.foo import BarForecaster
+
+    bar = BarForecaster(42, x=43)
+    bar.fit(y_train, fh=[1, 2, 3])
+    y_pred = bar.predict()
+
+then no release of ``sktime`` should change, without warning:
+
+* import location of ``BarForecaster``
+* argument signature of ``BarForecaster``, including name, order, and defaults of arguments
+* the abstract algorithm that ``BarForecaster`` carries out for the given arguments
+
+Changes that can be carried out without warning:
+
+* adding more arguments at the end of the argument list, with a default value that retains prior behaviour,
+  as long as the new arguments are well-documented
+* pure refactoring of internal code, as long as the public API remains the same
+* changing the implementation without changing the abstract algorithm, e.g., for performance reasons
+
+The deprecation policy outlined in this document provides details on how to carry out
+changes that need change or deprecation handling, in a user-friendly and reliable way.
+
+It is accompanied by formulaic patterns for developers, with examples,
+and a process for release managers, to make the policy easy to follow.
 
-    For upcoming changes and next releases, see our `Milestones <https://github.com/sktime/sktime/milestones?direction=asc&sort=due_date&state=open>`_.
-    For our long-term plan, see our :ref:`roadmap`.
 
 Deprecation policy
 ==================
diff --git a/examples/00_sktime_intro.ipynb b/examples/00_sktime_intro.ipynb
index 63e324972..7c2e3ecb9 100644
--- a/examples/00_sktime_intro.ipynb
+++ b/examples/00_sktime_intro.ipynb
@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -9,7 +8,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -22,24 +20,24 @@
    "source": [
     "### Vision statement\n",
     "\n",
-    "* an easy-to-use, easy-to-extend, comprehensive **python framework** for ML and AI with time series\n",
-    "* **open source, permissive license, free to use**\n",
-    "* **openly and transparently governed**\n",
-    "* **friendly, responsive, kind and inclusive** community, with an active commitment to ensure fairness and equal opportunity\n",
-    "* an academically and commercially **neutral space**, with an **ecosystem integration** ambition and neutral point of view\n",
-    "* an **educational platform**, providing mentoring and upskilling opportunities for all career stages, especially early career"
+    "- an easy-to-use, easy-to-extend, comprehensive **python framework** for ML and AI with time series\n",
+    "- **open source, permissive license, free to use**\n",
+    "- **openly and transparently governed**\n",
+    "- **friendly, responsive, kind and inclusive** community, with an active commitment to ensure fairness and equal opportunity\n",
+    "- an academically and commercially **neutral space**, with an **ecosystem integration** ambition and neutral point of view\n",
+    "- an **educational platform**, providing mentoring and upskilling opportunities for all career stages, especially early career\n"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "`sktime` is a vibrant, welcoming community with mentoring opportunities!\n",
-    "- We *love* new contributors. Even if you are new to open source software development!\n",
-    "- Check out the ``sktime`` [new contributors guide](https://www.sktime.net/en/latest/get_involved/contributing.html)\n",
+    "\n",
+    "- We _love_ new contributors. Even if you are new to open source software development!\n",
+    "- Check out the `sktime` [new contributors guide](https://www.sktime.net/en/latest/get_involved/contributing.html)\n",
     "- join our [discord](https://discord.com/invite/54ACzaFsn7) and/or one of our regular meetups!\n",
-    "- follow us on [LinkedIn](https://www.linkedin.com/company/scikit-time/)!"
+    "- follow us on [LinkedIn](https://www.linkedin.com/company/scikit-time/)!\n"
    ]
   },
   {
@@ -48,9 +46,9 @@
    "source": [
     "Further reading:\n",
     "\n",
-    "* `sktime` [notebook tutorials on binder](https://mybinder.org/v2/gh/sktime/sktime/main?filepath=examples)\n",
-    "* recorded [video tutorials](https://www.youtube.com/playlist?list=PLKs3UgGjlWHqNzu0LEOeLKvnjvvest2d0)\n",
-    "* find a bug or type? [tutorial feedback thread](https://github.com/sktime/sktime/issues/1447)"
+    "- `sktime` [notebook tutorials on binder](https://mybinder.org/v2/gh/sktime/sktime/main?filepath=examples)\n",
+    "- recorded [video tutorials](https://www.youtube.com/playlist?list=PLKs3UgGjlWHqNzu0LEOeLKvnjvvest2d0)\n",
+    "- find a bug or type? [tutorial feedback thread](https://github.com/sktime/sktime/issues/1447)"
    ]
   },
   {
@@ -80,6 +78,7 @@
    "metadata": {},
    "source": [
     "`sktime` follows the `sklearn` / `skbase` interface:\n",
+    "\n",
     "- unified interface for objects/estimators\n",
     "- modular design, strategy patterns\n",
     "- composable, composites are interface homogeneous\n",
@@ -88,7 +87,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -132,7 +130,8 @@
     "from sklearn.model_selection import train_test_split\n",
     "\n",
     "X, y = load_iris(return_X_y=True, as_frame=True)\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y)"
+    "random_seed = 60\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=random_seed)"
    ]
   },
   {
@@ -169,39 +168,39 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>68</th>\n",
-       "      <td>6.2</td>\n",
-       "      <td>2.2</td>\n",
-       "      <td>4.5</td>\n",
-       "      <td>1.5</td>\n",
+       "      <th>59</th>\n",
+       "      <td>5.2</td>\n",
+       "      <td>2.7</td>\n",
+       "      <td>3.9</td>\n",
+       "      <td>1.4</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>116</th>\n",
-       "      <td>6.5</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>5.5</td>\n",
-       "      <td>1.8</td>\n",
+       "      <th>52</th>\n",
+       "      <td>6.9</td>\n",
+       "      <td>3.1</td>\n",
+       "      <td>4.9</td>\n",
+       "      <td>1.5</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>138</th>\n",
-       "      <td>6.0</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>4.8</td>\n",
+       "      <th>108</th>\n",
+       "      <td>6.7</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>5.8</td>\n",
        "      <td>1.8</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>87</th>\n",
-       "      <td>6.3</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>4.4</td>\n",
+       "      <th>36</th>\n",
+       "      <td>5.5</td>\n",
+       "      <td>3.5</td>\n",
        "      <td>1.3</td>\n",
+       "      <td>0.2</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>5.1</td>\n",
-       "      <td>3.5</td>\n",
+       "      <th>134</th>\n",
+       "      <td>6.1</td>\n",
+       "      <td>2.6</td>\n",
+       "      <td>5.6</td>\n",
        "      <td>1.4</td>\n",
-       "      <td>0.2</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -209,11 +208,11 @@
       ],
       "text/plain": [
        "     sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
-       "68                 6.2               2.2                4.5               1.5\n",
-       "116                6.5               3.0                5.5               1.8\n",
-       "138                6.0               3.0                4.8               1.8\n",
-       "87                 6.3               2.3                4.4               1.3\n",
-       "0                  5.1               3.5                1.4               0.2"
+       "59                 5.2               2.7                3.9               1.4\n",
+       "52                 6.9               3.1                4.9               1.5\n",
+       "108                6.7               2.5                5.8               1.8\n",
+       "36                 5.5               3.5                1.3               0.2\n",
+       "134                6.1               2.6                5.6               1.4"
       ]
      },
      "execution_count": 3,
@@ -233,12 +232,12 @@
     {
      "data": {
       "text/plain": [
-       "68     1\n",
-       "116    2\n",
-       "138    2\n",
-       "87     1\n",
-       "0      0\n",
-       "Name: target, dtype: int32"
+       "59     1\n",
+       "52     1\n",
+       "108    2\n",
+       "36     0\n",
+       "134    2\n",
+       "Name: target, dtype: int64"
       ]
      },
      "execution_count": 4,
@@ -284,51 +283,51 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>37</th>\n",
-       "      <td>4.9</td>\n",
-       "      <td>3.6</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.1</td>\n",
+       "      <th>69</th>\n",
+       "      <td>5.6</td>\n",
+       "      <td>2.5</td>\n",
+       "      <td>3.9</td>\n",
+       "      <td>1.1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>63</th>\n",
+       "      <th>71</th>\n",
        "      <td>6.1</td>\n",
-       "      <td>2.9</td>\n",
-       "      <td>4.7</td>\n",
-       "      <td>1.4</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>62</th>\n",
-       "      <td>6.0</td>\n",
-       "      <td>2.2</td>\n",
+       "      <td>2.8</td>\n",
        "      <td>4.0</td>\n",
-       "      <td>1.0</td>\n",
+       "      <td>1.3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>130</th>\n",
-       "      <td>7.4</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>6.1</td>\n",
-       "      <td>1.9</td>\n",
+       "      <th>97</th>\n",
+       "      <td>6.2</td>\n",
+       "      <td>2.9</td>\n",
+       "      <td>4.3</td>\n",
+       "      <td>1.3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>47</th>\n",
-       "      <td>4.6</td>\n",
+       "      <th>42</th>\n",
+       "      <td>4.4</td>\n",
        "      <td>3.2</td>\n",
-       "      <td>1.4</td>\n",
+       "      <td>1.3</td>\n",
        "      <td>0.2</td>\n",
        "    </tr>\n",
+       "    <tr>\n",
+       "      <th>73</th>\n",
+       "      <td>6.1</td>\n",
+       "      <td>2.8</td>\n",
+       "      <td>4.7</td>\n",
+       "      <td>1.2</td>\n",
+       "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "     sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
-       "37                 4.9               3.6                1.4               0.1\n",
-       "63                 6.1               2.9                4.7               1.4\n",
-       "62                 6.0               2.2                4.0               1.0\n",
-       "130                7.4               2.8                6.1               1.9\n",
-       "47                 4.6               3.2                1.4               0.2"
+       "    sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
+       "69                5.6               2.5                3.9               1.1\n",
+       "71                6.1               2.8                4.0               1.3\n",
+       "97                6.2               2.9                4.3               1.3\n",
+       "42                4.4               3.2                1.3               0.2\n",
+       "73                6.1               2.8                4.7               1.2"
       ]
      },
      "execution_count": 5,
@@ -348,8 +347,8 @@
     {
      "data": {
       "text/plain": [
-       "array([0, 1, 1, 2, 0, 1, 0, 1, 2, 2, 0, 2, 1, 0, 2, 0, 0, 2, 2, 1, 1, 0,\n",
-       "       2, 1, 1, 2, 2, 0, 0, 1, 2, 1, 1, 0, 1, 1, 0, 2])"
+       "array([1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 2, 1, 2, 1, 2, 1, 0, 2, 2, 0,\n",
+       "       1, 0, 0, 0, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0, 1, 0])"
       ]
      },
      "execution_count": 6,
@@ -373,7 +372,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -390,8 +388,8 @@
     {
      "data": {
       "text/plain": [
-       "array([0, 1, 1, 2, 0, 1, 0, 1, 2, 2, 0, 2, 1, 0, 2, 0, 0, 2, 2, 1, 1, 0,\n",
-       "       2, 1, 1, 2, 2, 0, 0, 1, 2, 1, 1, 0, 1, 1, 0, 2])"
+       "array([1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 2, 1, 2, 1, 2, 1, 0, 2, 2, 0,\n",
+       "       1, 0, 0, 0, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0, 1, 0])"
       ]
      },
      "execution_count": 7,
@@ -415,11 +413,10 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "in object oriented design terminology, this is called **\"strategy pattern\"**\n",
+    "In object oriented design terminology, this is called **\"strategy pattern\"**\n",
     "\n",
     "= different estimators can be switched out without change to the interface\n",
     "\n",
@@ -430,7 +427,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -457,6 +453,7 @@
        " 'min_samples_leaf': 1,\n",
        " 'min_samples_split': 2,\n",
        " 'min_weight_fraction_leaf': 0.0,\n",
+       " 'monotonic_cst': None,\n",
        " 'n_estimators': 100,\n",
        " 'n_jobs': None,\n",
        " 'oob_score': False,\n",
@@ -475,7 +472,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -491,7 +487,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -499,21 +494,19 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "| Task | Status | Links |\n",
-    "|---|---|---|\n",
-    "| **Forecasting** | stable | [Tutorial](https://www.sktime.net/en/latest/examples/01_forecasting.html) · [API Reference](https://www.sktime.net/en/latest/api_reference/forecasting.html) · [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/forecasting.py)  |\n",
-    "| **Time Series Classification** | stable | [Tutorial](https://github.com/sktime/sktime/blob/main/examples/02_classification.ipynb) · [API Reference](https://www.sktime.net/en/latest/api_reference/classification.html) · [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/classification.py) |\n",
-    "| **Time Series Regression** | stable | [API Reference](https://www.sktime.net/en/latest/api_reference/regression.html) |\n",
-    "| **Transformations** | stable | [Tutorial](https://github.com/sktime/sktime/blob/main/examples/03_transformers.ipynb) · [API Reference](https://www.sktime.net/en/latest/api_reference/transformations.html) · [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/transformer.py)  |\n",
-    "| **Parameter fitting** | maturing | [API Reference](https://www.sktime.net/en/latest/api_reference/param_est.html) · [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/transformer.py)  |\n",
-    "| **Time Series Clustering** | maturing | [API Reference](https://www.sktime.net/en/latest/api_reference/clustering.html) ·  [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/clustering.py) |\n",
-    "| **Time Series Distances/Kernels** | maturing | [Tutorial](https://github.com/sktime/sktime/blob/main/examples/03_transformers.ipynb) · [API Reference](https://www.sktime.net/en/latest/api_reference/dists_kernels.html) · [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/dist_kern_panel.py) |\n",
-    "| **Annotation** | experimental | [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/annotation.py) |\n",
-    "| **Distributions and simulation** | experimental |  |"
+    "|------|--------|-------|\n",
+    "| **Forecasting**     |  stable      |>>[Tutorial](https://www.sktime.net/en/latest/examples/01_forecasting.html) >> [API Reference](https://www.sktime.net/en/latest/api_reference/forecasting.html) >> [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/forecasting.py)|\n",
+    "| **Time Series Classification** | stable |>>[Tutorial](https://github.com/sktime/sktime/blob/main/examples/02_classification.ipynb) >> [API Reference](https://www.sktime.net/en/latest/api_reference/classification.html) >> [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/classification.py)|\n",
+    "| **Transformations** | stable |>>[Tutorial](https://github.com/sktime/sktime/blob/main/examples/03_transformers.ipynb) >> [API Reference](https://www.sktime.net/en/latest/api_reference/transformations.html) >> [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/transformer.py)|\n",
+    "| **Parameter fitting** | maturing |>>[API Reference](https://www.sktime.net/en/latest/api_reference/param_est.html) >> [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/transformer.py)|\n",
+    "| **Time Series Clustering** | maturing |>>[API Reference](https://www.sktime.net/en/latest/api_reference/clustering.html) >> [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/clustering.py)|\n",
+    "| **Time Series Distances/Kernels** | maturing |>>[Tutorial](https://github.com/sktime/sktime/blob/main/examples/03_transformers.ipynb) >> [API Reference](https://www.sktime.net/en/latest/api_reference/dists_kernels.html) >> [Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/dist_kern_panel.py)|\n",
+    "| **Annotation** | experimental |>>[Extension Template](https://github.com/sktime/sktime/blob/main/extension_templates/annotation.py)|\n",
+    "|**Distributions and simulation** | experimental |  None  |"
    ]
   },
   {
@@ -524,21 +517,12 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Example - forecasting"
    ]
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "![](./img/forecasting.png)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 9,
@@ -571,7 +555,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x400 with 1 Axes>"
       ]
@@ -587,7 +571,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -595,7 +578,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -712,7 +694,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -720,21 +701,20 @@
     "\n",
     "the package space for time series is highly fragmented:\n",
     "\n",
-    "* lots of great implementations and methods out there!\n",
-    "* but many different interfaces, not composable like `sklearn`\n",
+    "- lots of great implementations and methods out there!\n",
+    "- but many different interfaces, not composable like `sklearn`\n",
     "\n",
     "`sktime` integrates the ecosystem - in friendly collaboration with all the packages out there!\n",
     "\n",
-    "* unified interface standard\n",
-    "* highly composable\n",
-    "* mini-package manager on estiator/module level\n",
-    "* easily extensible - 3rd party plugins, other packages\n",
+    "- unified interface standard\n",
+    "- highly composable\n",
+    "- mini-package manager on estiator/module level\n",
+    "- easily extensible - 3rd party plugins, other packages\n",
     "\n",
     "![](./img/unified_framework.png)"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -746,11 +726,11 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "---\n",
+    "<hr>\n",
+    "\n",
     "### Credits: notebook 0 - `sktime` and `sklearn` intro\n",
     "\n",
     "notebook creation: fkiraly, marrov\n",
@@ -758,15 +738,13 @@
     "some vignettes based on existing `sktime` tutorials, credit: fkiraly, miraep8\n",
     "\n",
     "slides (png/jpg):\n",
-    "\n",
     "* from fkiraly's postgraduate course at UCL, Principles and Patterns in Data Scientific Software Engineering\n",
     "* ecosystem slide: fkiraly, mloning\n",
     "* learning tasks: fkiraly, mloning\n",
     "\n",
+    "<hr>\n",
     "\n",
-    "---\n",
-    "\n",
-    "#### many thanks to [all `sktime` contributors](https://www.sktime.net/en/latest/about/contributors.html)!\n"
+    "#### many thanks to [all `sktime` contributors](https://www.sktime.net/en/latest/about/contributors.html)!"
    ]
   },
   {
@@ -775,8 +753,7 @@
    "source": [
     "Citations & credits in academic research papers:\n",
     "\n",
-    "`sktime` toolbox:\n",
-    " [sktime: A unified interface for machine learning with time series](https://arxiv.org/abs/1909.07872)\n",
+    "`sktime` toolbox: [sktime: A unified interface for machine learning with time series](https://arxiv.org/abs/1909.07872)\n",
     "\n",
     "`sktime` design principles: [Designing machine learning toolboxes: Concepts, principles and patterns](https://arxiv.org/abs/2101.04938)"
    ]
@@ -784,7 +761,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.8.13 ('pydata22')",
+   "display_name": "skt",
    "language": "python",
    "name": "python3"
   },
@@ -798,13 +775,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "e61b44dca3bf47c8973c8cd627825697e2dad493e19dd6592afda0a0a3c312a0"
-   }
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/examples/02a_classification_multivariate_cnn.ipynb b/examples/02a_classification_multivariate_cnn.ipynb
deleted file mode 100644
index f4b464240..000000000
--- a/examples/02a_classification_multivariate_cnn.ipynb
+++ /dev/null
@@ -1,136 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Multi-variate time series classification using a simple CNN\n",
-    "\n",
-    "In this notebook, we use sktime to perform for multi-variate time series classification by deep learning."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "from sklearn.model_selection import GridSearchCV\n",
-    "\n",
-    "from sktime.classification.deep_learning.cnn import CNNClassifier\n",
-    "from sktime.datasets import load_basic_motions\n",
-    "\n",
-    "sns.set_style(\"whitegrid\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Load a dataset\n",
-    "The Basic Motions dataset, from [timeseriesclassification.com](http://www.timeseriesclassification.com), has time series in six dimensions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "X_train, y_train = load_basic_motions(split=\"train\", return_X_y=True)\n",
-    "X_test, y_test = load_basic_motions(split=\"test\", return_X_y=True)\n",
-    "print(X_train.shape)\n",
-    "print(X_test.shape)\n",
-    "print(type(X_train.iloc[1, 1]))\n",
-    "X_train.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The class labels\n",
-    "np.unique(y_train)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train a deep neural network classifier\n",
-    "Here we choose to use the CNN (convolutional neural network) classifier. Other classifiers provided by sktime-dl include MLP, ResNet, InceptionTime and MCDCNN (Multi Channel Deep Convolutional Neural Network)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "network = CNNClassifier(n_epochs=50, verbose=True)\n",
-    "network.fit(X_train, y_train)\n",
-    "network.score(X_test, y_test)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Grid Search\n",
-    "sktime-dl is compatible with scikit-learn and can use sklearn's GridSearchCV.\n",
-    "\n",
-    "Here we search over two parameters, CNN kernel size and pooling size."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "param_grid = {\"kernel_size\": [7, 9], \"avg_pool_size\": [3, 5]}\n",
-    "grid = GridSearchCV(network, param_grid=param_grid, cv=3)\n",
-    "grid.fit(X_train, y_train)\n",
-    "\n",
-    "print(\"Best cross-validation accuracy: {:.2f}\".format(grid.best_score_))\n",
-    "print(\"Test set score: {:.2f}\".format(grid.score(X_test, y_test)))\n",
-    "print(\"Best parameters: {}\".format(grid.best_params_))"
-   ]
-  }
- ],
- "metadata": {
-  "file_extension": ".py",
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "mimetype": "text/x-python",
-  "name": "python",
-  "npconvert_exporter": "python",
-  "pygments_lexer": "ipython3",
-  "version": 3
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/02b_classification_multivariate_lstmfcn.ipynb b/examples/02b_classification_multivariate_lstmfcn.ipynb
deleted file mode 100644
index f31975c52..000000000
--- a/examples/02b_classification_multivariate_lstmfcn.ipynb
+++ /dev/null
@@ -1,116 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Multi-variate time series classification using a simple CNN\n",
-    "\n",
-    "In this notebook, we use sktime to perform for multi-variate time series classification by deep learning.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "\n",
-    "from sktime.classification.deep_learning.lstmfcn import LSTMFCNClassifier\n",
-    "from sktime.datasets import load_basic_motions\n",
-    "\n",
-    "sns.set_style(\"whitegrid\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Load a dataset\n",
-    "\n",
-    "The Basic Motions dataset, from [timeseriesclassification.com](http://www.timeseriesclassification.com), has time series in six dimensions.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "X_train, y_train = load_basic_motions(split=\"train\", return_X_y=True)\n",
-    "X_test, y_test = load_basic_motions(split=\"test\", return_X_y=True)\n",
-    "print(X_train.shape)\n",
-    "print(X_test.shape)\n",
-    "print(type(X_train.iloc[1, 1]))\n",
-    "X_train.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The class labels\n",
-    "np.unique(y_train)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train a LSTM-FCN\n",
-    "\n",
-    "In this exampe we use a LSTM-FCN (LongShort Term Memory Fully Convolutional Network) classifier originally implemented in sktime-dl.\n",
-    "Other classifiers provided by sktime-dl include CNN, MLP, ResNet, InceptionTime and MCDCNN.\n",
-    "\n",
-    "The LSTM-FCN estimator is compatible with scikit-learn and can use sklearn's GridSearchCV."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "network = LSTMFCNClassifier(n_epochs=65, verbose=0)\n",
-    "network.fit(X_train, y_train)\n",
-    "network.score(X_test, y_test)"
-   ]
-  }
- ],
- "metadata": {
-  "file_extension": ".py",
-  "kernelspec": {
-   "display_name": "Python 3.9.6 64-bit ('sktime')",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.6"
-  },
-  "mimetype": "text/x-python",
-  "name": "python",
-  "npconvert_exporter": "python",
-  "pygments_lexer": "ipython3",
-  "version": 3,
-  "vscode": {
-   "interpreter": {
-    "hash": "b1429b21f9b0cdf277ed408d65e56e85a8ed0b1a3006279bd7cbcc8cf36ab395"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/02c_classification_multivariate_inceptiontime.ipynb b/examples/02c_classification_multivariate_inceptiontime.ipynb
deleted file mode 100644
index 6094630fd..000000000
--- a/examples/02c_classification_multivariate_inceptiontime.ipynb
+++ /dev/null
@@ -1,153 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Multi-variate time series classification using InceptionTime\n",
-    "\n",
-    "In this notebook, we use InceptionTime to perform for multi-variate time series classification by deep learning."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "\"\"\" Imports \"\"\"\n",
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "from sklearn.model_selection import GridSearchCV\n",
-    "\n",
-    "from sktime.classification.deep_learning.inceptiontime import InceptionTimeClassifier\n",
-    "from sktime.datasets import load_basic_motions\n",
-    "\n",
-    "sns.set_style(\"whitegrid\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Load a dataset\n",
-    "The Basic Motions dataset, from [timeseriesclassification.com](http://www.timeseriesclassification.com), has time series in six dimensions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "X_train, y_train = load_basic_motions(split=\"train\", return_X_y=True)\n",
-    "X_test, y_test = load_basic_motions(split=\"test\", return_X_y=True)\n",
-    "print(X_train.shape)\n",
-    "print(X_test.shape)\n",
-    "X_train.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# The class labels\n",
-    "np.unique(y_train)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train a deep neural network classifier\n",
-    "Here we choose to use the InceptionTime classifier. Other classifiers provided by sktime-dl include MLP, ResNet, MCDCNN (Multi Channel Deep Convolutional Neural Network)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "network = InceptionTimeClassifier(n_epochs=75, verbose=False)\n",
-    "network.fit(X_train, y_train)\n",
-    "network.score(X_test, y_test)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Grid Search\n",
-    "sktime-dl is compatible with scikit-learn and can use sklearn's GridSearchCV.\n",
-    "\n",
-    "Here we search over two parameters, CNN kernel size and pooling size."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "param_grid = {\"nb_filters\": [16, 32], \"bottleneck_size\": [16, 32]}\n",
-    "grid = GridSearchCV(network, param_grid=param_grid, cv=5)\n",
-    "# commented fit call to pass checks (meet time constraints)\n",
-    "# grid.fit(X_train, y_train)\n",
-    "\n",
-    "# print(\"Best cross-validation accuracy: {:.2f}\".format(grid.best_score_))\n",
-    "# print(\"Test set score: {:.2f}\".format(grid.score(X_test, y_test)))\n",
-    "# print(\"Best parameters: {}\".format(grid.best_params_))"
-   ]
-  }
- ],
- "metadata": {
-  "file_extension": ".py",
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "mimetype": "text/x-python",
-  "name": "python",
-  "npconvert_exporter": "python",
-  "pygments_lexer": "ipython3",
-  "version": 3
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/AA_datatypes_and_datasets.ipynb b/examples/AA_datatypes_and_datasets.ipynb
index acff86913..adb440011 100644
--- a/examples/AA_datatypes_and_datasets.ipynb
+++ b/examples/AA_datatypes_and_datasets.ipynb
@@ -339,7 +339,7 @@
     "* variable names: the `\"np.ndarray\"` mtype cannot represent variable names.\n",
     "* time points: the rows of `obj` correspond to different, distinct time points. \n",
     "* time index: The time index is implicit and by-convention. The `i`-th row (for an integer `i`) is interpreted as an observation at the time point `i`.\n",
-    "* capabilities: cannot represent multivariate series; cannot represent unequally spaced series"
+    "* capabilities: can represent multivariate series; cannot represent unequally spaced series"
    ]
   },
   {
diff --git a/pyproject.toml b/pyproject.toml
index a673f0ee8..ae8a7e8fb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -80,7 +80,7 @@ all_extras = [
   "arch>=5.6,<7.1.0",
   "cloudpickle",
   "dash!=2.9.0",
-  "dask<2024.4.2; extra == 'dataframe'",
+  "dask<2024.5.1; extra == 'dataframe'",
   "dtw-python",
   'esig==0.9.7; python_version < "3.10"',
   'filterpy>=1.4.5; python_version < "3.11"',
@@ -95,7 +95,7 @@ all_extras = [
   'numba<0.60,>=0.53',
   'pmdarima!=1.8.1,<3.0.0,>=1.8; python_version < "3.12"',
   'prophet>=1.1; python_version < "3.12"',
-  "pycatch22<0.4.4",
+  "pycatch22<0.4.6",
   "pykalman<0.10,>=0.9.5",
   'pyod>=0.8; python_version < "3.11"',
   "pyts<0.14.0; python_version < '3.12'",
@@ -121,7 +121,7 @@ all_extras_pandas2 = [
   "arch>=5.6,<7.1.0",
   "cloudpickle",
   "dash!=2.9.0",
-  "dask<2024.4.2; extra == 'dataframe'",
+  "dask<2024.5.1; extra == 'dataframe'",
   "dtw-python",
   'esig==0.9.7; python_version < "3.10"',
   'filterpy>=1.4.5; python_version < "3.11"',
@@ -136,7 +136,7 @@ all_extras_pandas2 = [
   'numba<0.60,>=0.53',
   'pmdarima!=1.8.1,<3.0.0,>=1.8; python_version < "3.12"',
   'prophet>=1.1; python_version < "3.12"',
-  "pycatch22<0.4.4",
+  "pycatch22<0.4.6",
   "pykalman<0.10,>=0.9.5",
   'pyod>=0.8; python_version < "3.11"',
   "scikit_posthocs>=0.6.5",
@@ -207,10 +207,10 @@ regression = [
 transformations = [
   'esig<0.10,>=0.9.7; python_version < "3.11"',
   "filterpy<1.5,>=1.4.5",
-  "holidays>=0.29,<0.48",
+  "holidays>=0.29,<0.50",
   "mne>=1.5,<1.8",
   'numba<0.60,>=0.53',
-  "pycatch22>=0.4,<0.4.4",
+  "pycatch22>=0.4,<0.4.6",
   "pykalman<0.10,>=0.9.5",
   "statsmodels<0.15,>=0.12.1",
   'stumpy<1.13,>=1.5.1; python_version < "3.12"',
@@ -273,7 +273,7 @@ dl = [
   'neuralforecast<1.8.0,>=1.6.4; python_version < "3.11"',
   'tensorflow<2.17,>=2; python_version < "3.12"',
   'torch; python_version < "3.12"',
-  'transformers[torch]; python_version < "3.12"',
+  'transformers[torch]<4.41.0; python_version < "3.12"',
 ]
 mlflow = [
   "mlflow",
diff --git a/sktime/classification/base.py b/sktime/classification/base.py
index cca5c0e8e..4f09ca6da 100644
--- a/sktime/classification/base.py
+++ b/sktime/classification/base.py
@@ -727,6 +727,9 @@ class BaseClassifier(BasePanelMixin):
         y_proba = self._predict_proba(X)
         y_pred = y_proba.argmax(axis=1)
 
+        # restore class labels if they were not originally integer
+        y_pred = self.classes_[y_pred]
+
         return y_pred
 
     def _predict_proba(self, X) -> np.ndarray:
diff --git a/sktime/classification/dictionary_based/_boss.py b/sktime/classification/dictionary_based/_boss.py
index 0bcb4def2..0c1b234b1 100644
--- a/sktime/classification/dictionary_based/_boss.py
+++ b/sktime/classification/dictionary_based/_boss.py
@@ -639,9 +639,7 @@ class IndividualBOSS(BaseClassifier):
             Predicted class labels.
         """
         test_bags = self._transformer.transform(X)
-        data_type = type(self._class_vals[0])
-        if data_type == np.str_ or data_type == str:
-            data_type = "object"
+        data_type = self._class_vals.dtype
 
         classes = np.zeros(test_bags.shape[0], dtype=data_type)
 
diff --git a/sktime/classification/distance_based/_proximity_forest.py b/sktime/classification/distance_based/_proximity_forest.py
index 1626b7e42..eb35e836e 100644
--- a/sktime/classification/distance_based/_proximity_forest.py
+++ b/sktime/classification/distance_based/_proximity_forest.py
@@ -900,33 +900,6 @@ class ProximityStump(BaseClassifier):
         self.entropy = gini_gain(self.y, self.y_branches)
         return self
 
-    def _predict(self, X) -> np.ndarray:
-        """Predicts labels for sequences in X.
-
-        Parameters
-        ----------
-        X : array-like or sparse matrix of shape = [n_instances, n_columns]
-            The training input samples.
-            If a Pandas data frame is passed (sktime format)
-            If a Pandas data frame is passed, a check is performed that it
-            only has one column.
-            If not, an exception is thrown, since this classifier does not
-            yet have
-            multivariate capability.
-
-        Returns
-        -------
-        y : array-like, shape =  [n_instances] - predicted class labels
-        """
-        distributions = self._predict_proba(X)
-        predictions = []
-        for instance_index in range(0, X.shape[0]):
-            distribution = distributions[instance_index]
-            prediction = np.argmax(distribution)
-            predictions.append(prediction)
-
-        return np.array(predictions)
-
     def _predict_proba(self, X) -> np.ndarray:
         """Find probability estimates for each class for all cases in X.
 
@@ -1118,33 +1091,6 @@ class ProximityTree(BaseClassifier):
 
         return self
 
-    def _predict(self, X) -> np.ndarray:
-        """Predicts labels for sequences in X.
-
-        Parameters
-        ----------
-        X : array-like or sparse matrix of shape = [n_instances, n_columns]
-            The training input samples.
-            If a Pandas data frame is passed (sktime format)
-            If a Pandas data frame is passed, a check is performed that it
-            only has one column.
-            If not, an exception is thrown, since this classifier does not
-            yet have
-            multivariate capability.
-
-        Returns
-        -------
-        y : array-like, shape =  [n_instances] - predicted class labels
-        """
-        distributions = self._predict_proba(X)
-        predictions = []
-        for instance_index in range(0, X.shape[0]):
-            distribution = distributions[instance_index]
-            prediction = np.argmax(distribution)
-            predictions.append(prediction)
-
-        return np.array(predictions)
-
     def _predict_proba(self, X) -> np.ndarray:
         """Find probability estimates for each class for all cases in X.
 
@@ -1494,33 +1440,6 @@ class ProximityForest(BaseClassifier):
         """
         return tree.predict_proba(X)
 
-    def _predict(self, X) -> np.ndarray:
-        """Predicts labels for sequences in X.
-
-        Parameters
-        ----------
-        X : array-like or sparse matrix of shape = [n_instances, n_columns]
-            The training input samples.
-            If a Pandas data frame is passed (sktime format)
-            If a Pandas data frame is passed, a check is performed that it
-            only has one column.
-            If not, an exception is thrown, since this classifier does not
-            yet have
-            multivariate capability.
-
-        Returns
-        -------
-        y : array-like, shape =  [n_instances] - predicted class labels
-        """
-        distributions = self._predict_proba(X)
-        predictions = []
-        for instance_index in range(0, X.shape[0]):
-            distribution = distributions[instance_index]
-            prediction = np.argmax(distribution)
-            predictions.append(prediction)
-
-        return np.array(predictions)
-
     def _predict_proba(self, X) -> np.ndarray:
         """Find probability estimates for each class for all cases in X.
 
diff --git a/sktime/classification/ensemble/_bagging.py b/sktime/classification/ensemble/_bagging.py
index 17bbcf391..ccb55f30c 100644
--- a/sktime/classification/ensemble/_bagging.py
+++ b/sktime/classification/ensemble/_bagging.py
@@ -163,6 +163,7 @@ class BaggingClassifier(BaseClassifier):
             n_features_ = n_features
 
         self.estimators_ = []
+        self._col_ixis = []
         for _i in range(n_estimators):
             esti = estimator.clone()
             row_iloc = pd.RangeIndex(n)
@@ -183,6 +184,7 @@ class BaggingClassifier(BaseClassifier):
 
             yi = y[row_ss]
             self.estimators_ += [esti.fit(Xi, yi)]
+            self._col_ixis += [col_ix_i]
 
         return self
 
@@ -200,7 +202,14 @@ class BaggingClassifier(BaseClassifier):
             Predicted probabilities using the ordering in classes_.
         """
         classes = pd.Index(self.classes_)
-        y_probas = [est.predict_proba(X) for est in self.estimators_]
+
+        y_probas = []
+        for esti, col_ix_i in zip(self.estimators_, self._col_ixis):
+            Xi = X.loc[:, col_ix_i]
+            if self.bootstrap_features:
+                Xi.columns = pd.RangeIndex(len(col_ix_i))
+
+            y_probas += [esti.predict_proba(Xi)]
 
         est_shape = (len(y_probas[0]), len(classes))
         y_proba_np = np.zeros((len(y_probas), est_shape[0], est_shape[1]))
@@ -238,16 +247,16 @@ class BaggingClassifier(BaseClassifier):
             instance.
             ``create_test_instance`` uses the first (or only) dictionary in ``params``.
         """
-        from sktime.classification.dummy import DummyClassifier
+        from sktime.classification.feature_based import SummaryClassifier
 
-        params1 = {"estimator": DummyClassifier()}
+        params1 = {"estimator": SummaryClassifier()}
         params2 = {
-            "estimator": DummyClassifier(),
+            "estimator": SummaryClassifier(),
             "n_samples": 0.5,
             "n_features": 0.5,
         }
         params3 = {
-            "estimator": DummyClassifier(),
+            "estimator": SummaryClassifier(),
             "n_samples": 7,
             "n_features": 2,
             "bootstrap": False,
@@ -255,7 +264,7 @@ class BaggingClassifier(BaseClassifier):
         }
 
         # force-create a classifier that cannot handle multivariate
-        univariate_dummy = DummyClassifier()
+        univariate_dummy = SummaryClassifier()
         univariate_dummy.set_tags(**{"capability:multivariate": False})
         # this should still result in a multivariate classifier
         params4 = {
diff --git a/sktime/datatypes/_adapter/dask_to_pd.py b/sktime/datatypes/_adapter/dask_to_pd.py
index 7e07fa458..aa6bc5bb5 100644
--- a/sktime/datatypes/_adapter/dask_to_pd.py
+++ b/sktime/datatypes/_adapter/dask_to_pd.py
@@ -44,11 +44,11 @@ def convert_dask_to_pandas(obj):
 
     Parameters
     ----------
-    obj : pandas.DataFrame
+    obj : dask DataFrame
 
     Returns
     -------
-    dask DataFrame
+    pandas.DataFrame
         MultiIndex levels 0 .. -1 of X are converted to columns of name
         __index__[indexname], where indexname is name of multiindex level,
         or the integer index if the level has no name
@@ -86,7 +86,7 @@ def convert_pandas_to_dask(obj, npartitions=1, chunksize=None, sort=True):
 
     Parameters
     ----------
-    obj : dask DataFrame
+    obj : pandas.DataFrame
     npartitions : int or None, optional, default = 1
         npartitions passed to dask from_pandas when converting obj to dask
     chunksize : int or None, optional, default = None
@@ -96,7 +96,7 @@ def convert_pandas_to_dask(obj, npartitions=1, chunksize=None, sort=True):
 
     Returns
     -------
-    pandas.DataFrame
+    dask DataFrame
         MultiIndex levels 0 .. -1 of X are converted to columns of name
         __index__[indexname], where indexname is name of multiindex level,
         or the integer index if the level has no name
diff --git a/sktime/forecasting/statsforecast.py b/sktime/forecasting/statsforecast.py
index 4b0d24a41..7564901ad 100644
--- a/sktime/forecasting/statsforecast.py
+++ b/sktime/forecasting/statsforecast.py
@@ -655,10 +655,6 @@ class StatsForecastAutoTBATS(_GeneralisedStatsForecastAdapter):
         Number of observations per unit of time. Ex: 24 Hourly data.
     use_boxcox : bool (default=None)
         Whether or not to use a Box-Cox transformation. By default tries both.
-    bc_lower_bound : float (default=0.0)
-        Lower bound for the Box-Cox transformation.
-    bc_upper_bound : float (default=1.5)
-        Upper bound for the Box-Cox transformation.
     use_trend : bool (default=None)
         Whether or not to use a trend component. By default tries both.
     use_damped_trend : bool (default=None)
@@ -666,6 +662,10 @@ class StatsForecastAutoTBATS(_GeneralisedStatsForecastAdapter):
     use_arma_errors : bool (default=True)
         Whether or not to use a ARMA errors.
         Default is True and this evaluates both models.
+    bc_lower_bound : float (default=0.0)
+        Lower bound for the Box-Cox transformation.
+    bc_upper_bound : float (default=1.0)
+        Upper bound for the Box-Cox transformation.
 
     See Also
     --------
@@ -699,12 +699,16 @@ class StatsForecastAutoTBATS(_GeneralisedStatsForecastAdapter):
         use_trend: Optional[bool] = None,
         use_damped_trend: Optional[bool] = None,
         use_arma_errors: bool = True,
+        bc_lower_bound: float = 0.0,
+        bc_upper_bound: float = 1.0,
     ):
         self.seasonal_periods = seasonal_periods
         self.use_boxcox = use_boxcox
         self.use_trend = use_trend
         self.use_damped_trend = use_damped_trend
         self.use_arma_errors = use_arma_errors
+        self.bc_lower_bound = bc_lower_bound
+        self.bc_upper_bound = bc_upper_bound
 
         super().__init__()
 
@@ -716,11 +720,13 @@ class StatsForecastAutoTBATS(_GeneralisedStatsForecastAdapter):
 
     def _get_statsforecast_params(self) -> dict:
         return {
-            "seasonal_periods": self.seasonal_periods,
+            "season_length": self.seasonal_periods,
             "use_boxcox": self.use_boxcox,
             "use_trend": self.use_trend,
             "use_damped_trend": self.use_damped_trend,
             "use_arma_errors": self.use_arma_errors,
+            "bc_lower_bound": self.bc_lower_bound,
+            "bc_upper_bound": self.bc_upper_bound,
         }
 
     @classmethod
@@ -745,7 +751,21 @@ class StatsForecastAutoTBATS(_GeneralisedStatsForecastAdapter):
         """
         del parameter_set  # to avoid being detected as unused by `vulture` etc.
 
-        params = [{"seasonal_periods": 3}, {"seasonal_periods": [3, 12]}]
+        params = [
+            {
+                "seasonal_periods": 3,
+                "use_boxcox": True,
+                "bc_lower_bound": 0.25,
+                "bc_upper_bound": 0.75,
+            },
+            {
+                "seasonal_periods": [3, 12],
+                "use_boxcox": False,
+                "use_trend": True,
+                "use_damped_trend": True,
+                "use_arma_errors": False,
+            },
+        ]
 
         return params
 
diff --git a/sktime/networks/base.py b/sktime/networks/base.py
index 7d04a18fb..4cf14fff7 100644
--- a/sktime/networks/base.py
+++ b/sktime/networks/base.py
@@ -4,15 +4,7 @@ __author__ = ["Withington", "TonyBagnall"]
 
 from abc import ABC, abstractmethod
 
-import numpy as np
-import pandas as pd
-
 from sktime.base import BaseObject
-from sktime.forecasting.base import BaseForecaster
-from sktime.utils.validation._dependencies import _check_soft_dependencies
-
-if _check_soft_dependencies("torch", severity="none"):
-    import torch
 
 
 class BaseDeepNetwork(BaseObject, ABC):
@@ -35,244 +27,3 @@ class BaseDeepNetwork(BaseObject, ABC):
         output_layer : a keras layer
         """
         ...
-
-
-class BaseDeepNetworkPyTorch(BaseForecaster, ABC):
-    """Abstract base class for deep learning networks using torch.nn."""
-
-    _tags = {
-        "python_dependencies": "torch",
-        "y_inner_mtype": "pd.DataFrame",
-        "capability:insample": False,
-        "capability:pred_int:insample": False,
-        "scitype:y": "both",
-        "ignores-exogeneous-X": True,
-    }
-
-    def __init__(
-        self,
-        num_epochs=16,
-        batch_size=8,
-        in_channels=1,
-        individual=False,
-        criterion_kwargs=None,
-        optimizer=None,
-        optimizer_kwargs=None,
-        lr=0.001,
-    ):
-        self.num_epochs = num_epochs
-        self.batch_size = batch_size
-        self.in_channels = in_channels
-        self.individual = individual
-        self.criterion_kwargs = criterion_kwargs
-        self.optimizer = optimizer
-        self.optimizer_kwargs = optimizer_kwargs
-        self.lr = lr
-
-        super().__init__()
-
-    def _fit(self, y, fh, X=None):
-        """Fit the network.
-
-        Changes to state:
-            writes to self._network.state_dict
-
-        Parameters
-        ----------
-        X : iterable-style or map-style dataset
-            see (https://pytorch.org/docs/stable/data.html) for more information
-        """
-        from sktime.forecasting.base import ForecastingHorizon
-
-        # save fh and y for prediction later
-        if fh.is_relative:
-            self._fh = fh
-        else:
-            fh = fh.to_relative(self.cutoff)
-            self._fh = fh
-
-        self._y = y
-
-        if type(fh) is ForecastingHorizon:
-            self.network = self._build_network(fh._values[-1])
-        else:
-            self.network = self._build_network(fh)
-
-        if self.criterion:
-            if self.criterion in self.criterions.keys():
-                if self.criterion_kwargs:
-                    self._criterion = self.criterions[self.criterion](
-                        **self.criterion_kwargs
-                    )
-                else:
-                    self._criterion = self.criterions[self.criterion]()
-            else:
-                raise TypeError(
-                    f"Please pass one of {self.criterions.keys()} for `criterion`."
-                )
-        else:
-            # default criterion
-            self._criterion = torch.nn.MSELoss()
-
-        if self.optimizer:
-            if self.optimizer in self.optimizers.keys():
-                if self.optimizer_kwargs:
-                    self._optimizer = self.optimizers[self.optimizer](
-                        self.network.parameters(), lr=self.lr, **self.optimizer_kwargs
-                    )
-                else:
-                    self._optimizer = self.optimizers[self.optimizer](
-                        self.network.parameters(), lr=self.lr
-                    )
-            else:
-                raise TypeError(
-                    f"Please pass one of {self.optimizers.keys()} for `optimizer`."
-                )
-        else:
-            # default optimizer
-            self._optimizer = torch.optim.Adam(self.network.parameters(), lr=self.lr)
-
-        dataloader = self.build_pytorch_train_dataloader(y)
-        self.network.train()
-
-        for _ in range(self.num_epochs):
-            for x, y in dataloader:
-                y_pred = self.network(x)
-                loss = self._criterion(y_pred, y)
-                self._optimizer.zero_grad()
-                loss.backward()
-                self._optimizer.step()
-
-    def _predict(self, X=None, fh=None):
-        """Predict with fitted model."""
-        from torch import cat
-
-        if fh is None:
-            fh = self._fh
-
-        if max(fh._values) > self.network.pred_len or min(fh._values) < 0:
-            raise ValueError(
-                f"fh of {fh} passed to {self.__class__.__name__} is not "
-                "within `pred_len`. Please use a fh that aligns with the `pred_len` of "
-                "the forecaster."
-            )
-
-        if X is None:
-            dataloader = self.build_pytorch_pred_dataloader(self._y, fh)
-        else:
-            dataloader = self.build_pytorch_pred_dataloader(X, fh)
-
-        y_pred = []
-        for x, _ in dataloader:
-            y_pred.append(self.network(x).detach())
-        y_pred = cat(y_pred, dim=0).view(-1, y_pred[0].shape[-1]).numpy()
-        y_pred = y_pred[fh._values.values - 1]
-        y_pred = pd.DataFrame(
-            y_pred, columns=self._y.columns, index=fh.to_absolute_index(self.cutoff)
-        )
-
-        return y_pred
-
-    def build_pytorch_train_dataloader(self, y):
-        """Build PyTorch DataLoader for training."""
-        from torch.utils.data import DataLoader
-
-        if self.custom_dataset_train:
-            if hasattr(self.custom_dataset_train, "build_dataset") and callable(
-                self.custom_dataset_train.build_dataset
-            ):
-                self.custom_dataset_train.build_dataset(y)
-                dataset = self.custom_dataset_train
-            else:
-                raise NotImplementedError(
-                    "Custom Dataset `build_dataset` method is not available. Please "
-                    f"refer to the {self.__class__.__name__}.build_dataset "
-                    "documentation."
-                )
-        else:
-            dataset = PyTorchTrainDataset(
-                y=y,
-                seq_len=self.network.seq_len,
-                fh=self._fh._values[-1],
-            )
-
-        return DataLoader(
-            dataset,
-            self.batch_size,
-        )
-
-    def build_pytorch_pred_dataloader(self, y, fh):
-        """Build PyTorch DataLoader for prediction."""
-        from torch.utils.data import DataLoader
-
-        if self.custom_dataset_pred:
-            if hasattr(self.custom_dataset_pred, "build_dataset") and callable(
-                self.custom_dataset_pred.build_dataset
-            ):
-                self.custom_dataset_train.build_dataset(y)
-                dataset = self.custom_dataset_train
-            else:
-                raise NotImplementedError(
-                    "Custom Dataset `build_dataset` method is not available. Please"
-                    f"refer to the {self.__class__.__name__}.build_dataset"
-                    "documentation."
-                )
-        else:
-            dataset = PyTorchPredDataset(
-                y=y[-self.network.seq_len :],
-                seq_len=self.network.seq_len,
-            )
-
-        return DataLoader(
-            dataset,
-            self.batch_size,
-        )
-
-    def get_y_true(self, y):
-        """Get y_true values for validation."""
-        dataloader = self.build_pytorch_pred_dataloader(y)
-        y_true = [y.flatten().numpy() for _, y in dataloader]
-        return np.concatenate(y_true, axis=0)
-
-
-class PyTorchTrainDataset:
-    """Dataset for use in sktime deep learning forecasters."""
-
-    def __init__(self, y, seq_len, fh):
-        self.y = y.values
-        self.seq_len = seq_len
-        self.fh = fh
-
-    def __len__(self):
-        """Return length of dataset."""
-        return len(self.y) - self.seq_len - self.fh + 1
-
-    def __getitem__(self, i):
-        """Return data point."""
-        from torch import from_numpy, tensor
-
-        return (
-            tensor(self.y[i : i + self.seq_len]).float(),
-            from_numpy(self.y[i + self.seq_len : i + self.seq_len + self.fh]).float(),
-        )
-
-
-class PyTorchPredDataset:
-    """Dataset for use in sktime deep learning forecasters."""
-
-    def __init__(self, y, seq_len):
-        self.y = y.values
-        self.seq_len = seq_len
-
-    def __len__(self):
-        """Return length of dataset."""
-        return 1
-
-    def __getitem__(self, i):
-        """Return data point."""
-        from torch import from_numpy, tensor
-
-        return (
-            tensor(self.y[i : i + self.seq_len]).float(),
-            from_numpy(self.y[i + self.seq_len : i + self.seq_len]).float(),
-        )
diff --git a/sktime/performance_metrics/forecasting/_coerce.py b/sktime/performance_metrics/forecasting/_coerce.py
index ee191f2b7..da61c7c89 100644
--- a/sktime/performance_metrics/forecasting/_coerce.py
+++ b/sktime/performance_metrics/forecasting/_coerce.py
@@ -18,6 +18,8 @@ def _coerce_to_scalar(obj):
 
 def _coerce_to_df(obj):
     """Coerce to pd.DataFrame, from polymorphic input scalar or pandas."""
+    if isinstance(obj, (float, int)):
+        return pd.DataFrame([obj])
     return pd.DataFrame(obj)
 
 
diff --git a/sktime/performance_metrics/forecasting/probabilistic/__init__.py b/sktime/performance_metrics/forecasting/probabilistic/__init__.py
index 5d17073e0..fbab9f8df 100644
--- a/sktime/performance_metrics/forecasting/probabilistic/__init__.py
+++ b/sktime/performance_metrics/forecasting/probabilistic/__init__.py
@@ -17,6 +17,7 @@ __all__ = [
     "EmpiricalCoverage",
     "ConstraintViolation",
     "CRPS",
+    "IntervalWidth",
     "LogLoss",
     "SquaredDistrLoss",
 ]
@@ -25,6 +26,7 @@ from sktime.performance_metrics.forecasting.probabilistic._classes import (
     CRPS,
     ConstraintViolation,
     EmpiricalCoverage,
+    IntervalWidth,
     LogLoss,
     PinballLoss,
     SquaredDistrLoss,
diff --git a/sktime/performance_metrics/forecasting/probabilistic/_classes.py b/sktime/performance_metrics/forecasting/probabilistic/_classes.py
index 42d727677..cfee5b76f 100644
--- a/sktime/performance_metrics/forecasting/probabilistic/_classes.py
+++ b/sktime/performance_metrics/forecasting/probabilistic/_classes.py
@@ -599,6 +599,70 @@ class EmpiricalCoverage(_BaseProbaForecastingErrorMetric):
         return [params1]
 
 
+class IntervalWidth(_BaseProbaForecastingErrorMetric):
+    """Interval width for interval predictions, sometimes also known as sharpness.
+
+    Parameters
+    ----------
+    multioutput : string "uniform_average" or "raw_values" determines how\
+        multioutput results will be treated.
+
+    score_average : bool, optional, default = True
+        specifies whether scores for each quantile should be averaged.
+    """
+
+    _tags = {
+        "scitype:y_pred": "pred_interval",
+        "lower_is_better": True,
+    }
+
+    def __init__(self, multioutput="uniform_average", score_average=True):
+        self.score_average = score_average
+        self.multioutput = multioutput
+        super().__init__(score_average=score_average, multioutput=multioutput)
+
+    def _evaluate_by_index(self, y_true, y_pred, multioutput, **kwargs):
+        """Logic for finding the metric evaluated at each index.
+
+        y_true : pd.Series, pd.DataFrame or np.array of shape (fh,) or \
+            (fh, n_outputs) where fh is the forecasting horizon
+            Ground truth (correct) target values.
+
+        y_pred : pd.Series, pd.DataFrame or np.array of shape (fh,) or  \
+            (fh, n_outputs)  where fh is the forecasting horizon
+            Forecasted values.
+
+        multioutput : string "uniform_average" or "raw_values" determines how \
+            multioutput results will be treated.
+        """
+        lower = y_pred.iloc[:, y_pred.columns.get_level_values(2) == "lower"].to_numpy()
+        upper = y_pred.iloc[:, y_pred.columns.get_level_values(2) == "upper"].to_numpy()
+
+        if not isinstance(y_true, np.ndarray):
+            y_true_np = y_true.to_numpy()
+        else:
+            y_true_np = y_true
+        if y_true_np.ndim == 1:
+            y_true_np = y_true.reshape(-1, 1)
+
+        scores = np.unique(np.round(y_pred.columns.get_level_values(1), 7))
+        vars = np.unique(y_pred.columns.get_level_values(0))
+
+        metric_array = upper - lower
+
+        out_df = pd.DataFrame(
+            metric_array, columns=pd.MultiIndex.from_product([vars, scores])
+        )
+
+        return out_df
+
+    @classmethod
+    def get_test_params(self):
+        """Retrieve test parameters."""
+        params1 = {}
+        return [params1]
+
+
 class ConstraintViolation(_BaseProbaForecastingErrorMetric):
     """Percentage of interval constraint violations for interval predictions.
 
diff --git a/sktime/split/__init__.py b/sktime/split/__init__.py
index 012fc952a..6c1c2e630 100644
--- a/sktime/split/__init__.py
+++ b/sktime/split/__init__.py
@@ -3,6 +3,7 @@
 __all__ = [
     "CutoffSplitter",
     "CutoffFhSplitter",
+    "ExpandingCutoffSplitter",
     "ExpandingGreedySplitter",
     "ExpandingWindowSplitter",
     "InstanceSplitter",
@@ -15,6 +16,7 @@ __all__ = [
 ]
 
 from sktime.split.cutoff import CutoffFhSplitter, CutoffSplitter
+from sktime.split.expandingcutoff import ExpandingCutoffSplitter
 from sktime.split.expandinggreedy import ExpandingGreedySplitter
 from sktime.split.expandingwindow import ExpandingWindowSplitter
 from sktime.split.instance import InstanceSplitter
diff --git a/sktime/split/expandingcutoff.py b/sktime/split/expandingcutoff.py
new file mode 100644
index 000000000..c4ca15d9a
--- /dev/null
+++ b/sktime/split/expandingcutoff.py
@@ -0,0 +1,213 @@
+#!/usr/bin/env python3 -u
+# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
+"""Splitter that successively expands the training window."""
+
+__author__ = ["ninedigits"]
+
+__all__ = [
+    "ExpandingCutoffSplitter",
+]
+
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+from sktime.split.base import BaseSplitter
+from sktime.split.base._common import ACCEPTED_Y_TYPES, _check_fh
+from sktime.utils.validation.forecasting import check_step_length
+
+
+def _is_datetimelike(x):
+    return isinstance(x, (pd.Timestamp, np.datetime64, pd.Period))
+
+
+def _is_int(arg):
+    return isinstance(arg, (int, np.int_))
+
+
+def _validate_cutoff(cutoff):
+    if not (_is_datetimelike(cutoff) or _is_int(cutoff)):
+        raise TypeError(
+            "Cutoff value must be datetime-like or integer but instead "
+            f"found type(cutoff) = {type(cutoff)}"
+        )
+    return cutoff
+
+
+class ExpandingCutoffSplitter(BaseSplitter):
+    """
+    Expanding cutoff splitter for time series data.
+
+    This splitter combines elements of `ExpandingWindowSplitter` and `CutoffSplitter`
+    to create training and testing sets. Unlike `ExpandingWindowSplitter` which begins
+    with a fixed initial window, this splitter uses a specific cutoff point as the
+    starting window for the training set. The training set then expands incrementally
+    in each split until it reaches the end of the series.
+
+    The test set is defined by a forecast horizon relative to the last point in the
+    training set, containing as many subsequent indices as specified by the `fh`
+    parameter.
+
+    The valid types of y-index and cutoff pairings are datelike-datelike, datelike-int,
+    and int-int. When a datelike index is combined with an int cutoff, the cutoff
+    functions as an iloc indexer. When an int index is paired with a positive int
+    cutoff, the cutoff serves as a loc indexer. If the int cutoff is negative, it
+    functions as an iloc indexer.
+                          c
+                          |
+    |---------------------|----fh----|------|
+    | * * * * * * * * * * x x x x x x - - - |
+    | * * * * * * * * * * * x x x x x x - - |
+    | * * * * * * * * * * * * x x x x x x - |
+    | * * * * * * * * * * * * * x x x x x x |
+
+    ``c`` = cutoff date or index.
+
+    ``*`` = training fold.
+
+    ``x`` = test fold.
+
+    Parameters
+    ----------
+    cutoff (int or pd.Timestamp):
+        The initial cutoff point in the series, which marks the beginning of the
+        first test set.
+    fh (int, list, or np.array):
+        Forecasting horizon, determining the size and  indices of the test sets.
+        It can be an integer, a list, or an array.
+    step_length (int):
+        The step length to expand the training set size in each split.
+
+    Examples
+    --------
+    >>> import pandas as pd
+    >>> from sktime.split import ExpandingCutoffSplitter
+    >>> date_range = pd.date_range(start='2020-Q1', end='2021-Q3', freq='QS')
+    >>> y = pd.DataFrame(index=pd.PeriodIndex(date_range, freq='Q'))
+    >>> cutoff = pd.Period('2021-Q1')
+    >>> cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=[1, 2], step_length=1)
+    >>> list(cv.split(y)) # doctest: +SKIP
+    [(array([0, 1, 2, 3]), array([4, 5])), (array([0, 1, 2, 3, 4]), array([5, 6]))]
+    """
+
+    def __init__(self, cutoff, fh, step_length):
+        super().__init__()
+        self.cutoff = _validate_cutoff(cutoff)
+        self.fh = fh
+        self._fh = _check_fh(fh)
+        self.step_length = step_length
+        return
+
+    def _split(self, y, fh=None):
+        """
+        Generate indices to split data into training and testing sets.
+
+        Parameters
+        ----------
+        y : array-like, shape = [n_samples]
+            Time series data.
+        fh : int, default=None
+            Forecast horizon, if None, uses self.fh
+
+        Yields
+        ------
+        train : ndarray
+            The training set indices for that split.
+        test : ndarray
+            The testing set indices for that split.
+        """
+        if fh is None:
+            fh = self._fh
+        offset = fh.to_numpy().max() + 1
+        for cutoff in self.get_cutoffs(y):
+            train_window = np.arange(0, cutoff + 1, step=1)
+            test_window = np.arange(cutoff + 1, cutoff + offset, step=1)
+            yield train_window, test_window
+
+    def _validate_y(self, y):
+        y = self._coerce_to_index(y)
+        cutoff = self.cutoff
+        y0 = y[0]
+        cond1 = _is_datetimelike(y0) and (_is_datetimelike(cutoff) or _is_int(cutoff))
+        cond2 = _is_int(y0) and _is_int(cutoff)
+        if not (cond1 or cond2):
+            raise TypeError(
+                "Valid combinations for y and cutoff types are "
+                "datelike-datelike, datelike-int, or int-int, but instead "
+                f"found {type(y0)}-{type(cutoff)}"
+            )
+        return y
+
+    def _get_first_cutoff_index(self, y_index):
+        y0 = y_index[0]
+        if _is_int(self.cutoff) and self.cutoff < 0:
+            index = len(y_index) + self.cutoff - 1
+            if index < 0:
+                raise IndexError(
+                    f"Cutoff of value {self.cutoff} is out of bounds "
+                    f"for y of length {len(y_index)}"
+                )
+        elif _is_datetimelike(y0) and _is_int(self.cutoff) and (self.cutoff > 0):
+            index = self.cutoff - 1
+        else:
+            index = np.argmax(y_index == self.cutoff) - 1
+            if index == -1:
+                raise TypeError(
+                    "Could not find matching index, make sure that "
+                    f"type(y) {type(y0)} is compatible with type(cutoff) "
+                    f"{type(self.cutoff)}"
+                )
+        return index
+
+    def get_cutoffs(self, y: Optional[ACCEPTED_Y_TYPES] = None) -> np.ndarray:
+        """Return the cutoff points in .iloc[] context.
+
+        Parameters
+        ----------
+        y : pd.Series or pd.Index, optional (default=None)
+            Time series to split
+
+        Returns
+        -------
+        cutoffs : 1D np.ndarray of int
+            iloc location indices, in reference to y, of cutoff indices
+        """
+        if y is None:
+            raise ValueError(
+                f"{self.__class__.__name__} requires `y` to compute the cutoffs."
+            )
+        y = self._validate_y(y)
+        fh = self._fh
+        step_length = check_step_length(self.step_length)
+        cutoff_index = self._get_first_cutoff_index(y)
+        cutoffs = np.array([cutoff_index])
+        offset = fh.to_numpy().max()
+        while cutoff_index + offset < len(y) - 1:
+            cutoff_index += step_length
+            cutoffs = np.append(cutoffs, cutoff_index)
+        return cutoffs
+
+    @classmethod
+    def get_test_params(cls, parameter_set="default"):
+        """Return testing parameter settings for the splitter.
+
+        Parameters
+        ----------
+        parameter_set : str, default="default"
+            Name of the set of test parameters to return, for use in tests. If no
+            special parameters are defined for a value, will return ``"default"`` set.
+
+        Returns
+        -------
+        params : dict or list of dict, default = {}
+            Parameters to create testing instances of the class
+            Each dict are parameters to construct an "interesting" test instance, i.e.,
+            ``MyClass(**params)`` or ``MyClass(**params[i])`` creates a valid test
+            instance.
+            ``create_test_instance`` uses the first (or only) dictionary in ``params``
+        """
+        return [
+            {"fh": [2, 4], "cutoff": 3, "step_length": 1},
+            {"fh": [1, 2, 3], "cutoff": 3, "step_length": 2},
+        ]
diff --git a/sktime/transformations/series/adi_cv.py b/sktime/transformations/series/adi_cv.py
new file mode 100644
index 000000000..f4dd919de
--- /dev/null
+++ b/sktime/transformations/series/adi_cv.py
@@ -0,0 +1,237 @@
+# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
+"""Feature transformer that returns features of time series including categories."""
+
+import pandas as pd
+
+from sktime.transformations.base import BaseTransformer
+
+__author__ = ["shlok191"]
+
+
+class ADICVTransformer(BaseTransformer):
+    r"""Transformer categorizing series into ADI-CV2 classes after Syntetos/Boylan.
+
+    Transforms a time series into a category label, which is one of:
+    ``"smooth"``, ``"erratic"``, ``"intermittent"``, or ``"lumpy"``.
+
+    The labels are based on the Average Demand Interval (ADI) and the Coefficient of
+    Variation (CV2) of the time series, using simple thresholding.
+    Optionally, the transformer can return the ADI and CV2 values as well.
+
+    Let :math:`x_t` be the value of the time series at times :math:`t = 1, 2, \dots, T`,
+    and let :math:`N` be the number of non-zero values in the time series, i.e.,
+    :math:`N = \text{card}\{t: x_t \neq 0\}`.
+
+    The ADI and CV2 are calculated as follows:
+
+    1. Average Demand Interval (ADI): The average time period between
+      time periods with non-zero demands, mathematically defined as:
+
+    .. math:: ADI = \frac{T}{N - 1}
+
+    2. Variance (CV2): Variance calculated on non-zero values
+    in the time series. Mathematical definition is:
+
+    .. math:: CV2 = \frac{1}{N}\sum_{t=1}^{T} x_t^2 - \left(\frac{1}{N}\sum_{t=1}^{T} x_t\right)^2  # noqa: E501
+
+    3. Class: Classification of time series on basis of ADI threshold
+    and CV2 threshold.
+
+    For thresholds ``ADI_threshold`` and ``CV2_threshold``, the classes are:
+
+    1. Smooth: If ``ADI <= adi_threshold`` and ``CV2 <= cv2_threshold``
+    2. Erratic: If ``ADI <= adi_threshold`` and ``CV2 > cv2_threshold``
+    3. Intermittent: If ``ADI > adi_threshold`` and ``cv2 <= cv2_threshold``
+    4. Lumpy: if ``ADI > adi_threshold`` and ``CV2 > cv2_threshold``
+
+    Default values for the thresholds are taken from the paper by Syntetos/Boylan [1].
+    namely, ``adi_threshold = 1.32`` and ``cv2_threshold = 0.49``.
+    They can also be adjusted by passing them as parameters to the transformer.
+
+    Parameters
+    ----------
+    adi_threshold : float (default = 1.32)
+        Specifies the ADI threshold utilized for classifying the time series
+
+    cv2_threshold : float (default = 0.49)
+        Specifies the CV2 threshold utilized for classifying the time series
+
+    features : list[str] | None (default = ['adi', 'cv2', 'class'])
+        Specifies all of the feature values to be calculated
+
+    Examples
+    --------
+    >>> from sktime.transformations.series.adi_cv import ADICVTransformer
+    >>> from sktime.datasets import load_airline
+    >>> y = load_airline()
+    >>> transformer = ADICVTransformer()
+    >>> y_hat = transformer.fit_transform(y)
+
+    References
+    ----------
+    [1]: John E. Boylan, Aris Syntetos: The Accuracy of Intermittent
+    Demand Estimates. International Journal of Forecasting, 1 Apr. 2005
+    """
+
+    _tags = {
+        "scitype:transform-input": "Series",
+        "scitype:transform-output": "Primitives",
+        "scitype:instancewise": False,
+        "scitype:transform-labels": "None",
+        "X_inner_mtype": "pd.DataFrame",
+        "y_inner_mtype": "None",
+        "univariate-only": True,  # Demand being the only variable
+        "requires_y": False,
+        "fit_is_empty": True,
+        "capability:inverse_transform": False,
+        "capability:unequal_length": False,
+        "handles-missing-data": False,
+        "authors": ["shlok191"],
+        "maintainers": ["shlok191"],
+    }
+
+    def __init__(self, features=None, adi_threshold=1.32, cv_threshold=0.49):
+        """Initialize the transformer and processes any provided parameters.
+
+        Parameters
+        ----------
+        features : List[str] | None, optional
+            List of features to compute. Defaults to None (all features)
+
+        adi_threshold : float, optional
+            Threshold for Average Demand Interval. Defaults to 1.32.
+
+        cv_threshold : float, optional
+            Threshold for Variance. Defaults to 0.49.
+
+        Raises
+        ------
+            ValueError: If features is provided and does not
+            contain 'adi','cv2', or 'class'.
+        """
+        self.adi_threshold = adi_threshold
+        self.cv_threshold = cv_threshold
+        self.features = features
+
+        self.features_internal = features
+
+        # Initialize the parent class
+        super().__init__()
+
+        # Checking if the features parameter is valid
+        if features is not None:
+            if not all(feature in ["adi", "cv2", "class"] for feature in features):
+                raise ValueError(
+                    "Error in ADICVTransformer: Invalid features list provided. "
+                    "The features argument must either be None, or a list of str "
+                    "containing one or multiple of the valid feature strings "
+                    "('adi', 'cv2', 'class')."
+                )
+
+        else:
+            # Helpful to transform None to default list for transform function
+            self.features_internal = ["adi", "cv2", "class"]
+
+    def _transform(self, X, y=None):
+        """Transform X and return a transformed version.
+
+        private _transform containing core logic, called from transform
+
+        Parameters
+        ----------
+        X : Series
+            Series of time series data this transform function aims to classify
+
+        y : Series | None, default=None
+            Not required for the classification of the time series
+
+        Returns
+        -------
+        X_transformed : pd.DataFrame
+
+            The returned DataFrame consists of the columns in the features list passed
+            during initialization. Specifically, the columns include (by default):
+
+                1. Average Demand Interval (ADI)
+                2. Variance (CV2)
+                3. categorical class
+        """
+        X_non_zero = X.to_numpy().nonzero()
+        X_non_zero = X.iloc[X_non_zero]
+
+        # Calculating ADI value based on formula from paper
+        adi_value = len(X) / (len(X_non_zero) - 1)
+
+        # Calculating variance for all non-zero values
+        variance = X_non_zero.var().iloc[0]
+        cv2_value = variance / len(X_non_zero)
+
+        # Calculating the class type
+
+        adi_low = adi_value <= self.adi_threshold
+        cv2_low = cv2_value <= self.cv_threshold
+        adi_high = not adi_low
+        cv2_high = not cv2_low
+
+        if adi_low and cv2_low:
+            class_type = "smooth"
+
+        elif adi_low and cv2_high:
+            class_type = "erratic"
+
+        elif adi_high and cv2_low:
+            class_type = "intermittent"
+
+        elif adi_high and cv2_high:
+            class_type = "lumpy"
+
+        # Collecting all values together into dict and converting to DF
+        return_dict = {}
+
+        if "adi" in self.features_internal:
+            return_dict["adi"] = [adi_value]
+
+        if "cv2" in self.features_internal:
+            return_dict["cv2"] = [cv2_value]
+
+        if "class" in self.features_internal:
+            return_dict["class"] = [class_type]
+
+        df = pd.DataFrame(return_dict)
+
+        # Ordering the dataframe in the correct order
+        df = df.loc[:, self.features_internal]
+
+        return df
+
+    # todo: return default parameters, so that a test instance can be created
+    #   required for automated unit and integration testing of estimator
+    @classmethod
+    def get_test_params(cls, parameter_set="default"):
+        """Return testing parameter settings for the estimator.
+
+        Parameters
+        ----------
+        parameter_set : str, default="default"
+            Name of the set of test parameters to return, for use in tests.
+            If no special parameters are defined for a value, will return
+            `"default"` set.
+
+        Returns
+        -------
+        params : dict or list of dict, default = {}
+            Parameters to create testing instances of the class
+            Each dict are parameters to construct an "interesting" test case
+        """
+        # Testing with 0 thresholds for both thresholds
+        # in independent test cases!
+
+        params1 = {}
+        params2 = {"features": None, "adi_threshold": 1.32, "cv_threshold": 0.49}
+        params3 = {
+            "features": ["adi", "class"],
+            "adi_threshold": 1.5,
+            "cv_threshold": 0.2,
+        }
+
+        return [params1, params2, params3]
diff --git a/sktime/utils/git_diff.py b/sktime/utils/git_diff.py
index f5cf6ef72..0d53af9ca 100644
--- a/sktime/utils/git_diff.py
+++ b/sktime/utils/git_diff.py
@@ -126,7 +126,6 @@ def get_changed_lines(file_path, only_indented=True):
         return []
 
 
-@lru_cache
 def get_packages_with_changed_specs():
     """Get packages with changed or added specs.
 
@@ -134,6 +133,20 @@ def get_packages_with_changed_specs():
     -------
     list of str : names of packages with changed or added specs
     """
+    return list(_get_packages_with_changed_specs())
+
+
+@lru_cache
+def _get_packages_with_changed_specs():
+    """Get packages with changed or added specs.
+
+    Private version of get_packages_with_changed_specs,
+    to avoid side effects on the list return.
+
+    Returns
+    -------
+    tuple of str : names of packages with changed or added specs
+    """
     from packaging.requirements import Requirement
 
     changed_lines = get_changed_lines("pyproject.toml")
@@ -161,6 +174,6 @@ def get_packages_with_changed_specs():
         packages.append(pkg)
 
     # make unique
-    packages = list(set(packages))
+    packages = tuple(set(packages))
 
     return packages
diff --git a/sktime/utils/plotting.py b/sktime/utils/plotting.py
index 534a26fa5..fd2667c4d 100644
--- a/sktime/utils/plotting.py
+++ b/sktime/utils/plotting.py
@@ -505,22 +505,46 @@ def plot_windows(cv, y, title="", ax=None):
 
 
 def plot_calibration(y_true, y_pred, ax=None):
-    """Plot the calibration of a probabilistic forecast.
+    r"""Plot the calibration curve for a sample of quantile predictions.
 
-    Calculates internally the calibration of the quantile forecast and
-    visualise it.
+    Visualizes calibration of the quantile predictions.
 
-    x-axis: interval from 0 to 1
-    y-axis: interval from 0 to 1
-    plot elements: the calibration fo the forecast (blue) and the ideal
-        calibration (orange)
+    Computes the following calibration plot:
+
+    Let :math:`p_1, \dots, p_k` be the quantile points at which
+    predictions in ``y_pred`` were queried,
+    e.g., via ``alpha`` in ``predict_quantiles``.
+
+    Let :math:`y_1, \dots, y_N` be the actual values in ``y_true``,
+    and let :math:`\widehat{y}_{i,j}`, for `i = 1 \dots N, j = 1 \dota k`
+    be quantile predictions at quantile point :math:`p_j`,
+    of the conditional distribution of :math:`y_i`, as contained in ``y_pred``.
+
+    We compute the calibration indicators :math:`c_{i, j},`
+    as :math:`c_{i, j} = 1, \{ if } y_i \le \widehat{y}_{i,j} \text{ and } 0, \text{otherwise},`  # noqa: E501
+    and calibration fractions as
+
+    .. math:: \widehat{p}_j = \frac{1}{N} \sum_{i = 1}^N c_{i, j}.
+
+    If the quantile predictions are well-calibrated, we expect :math:`\widehat{p}_j`
+    to be close to :math:`p_j`.
+
+    x-axis: interval from 0 to 1, quantile points
+    y-axis: interval from 0 to 1, calibration fractions
+    plot elements: calibration curve of the quantile predictions (blue) and the ideal
+        calibration curve (orange), the curve with equation y = x.
+        Calibration curve are points :math:`(p_i, \widehat{p}_i), i = 1 \dots, k`;
+        Ideal curve is the curve with equation y = x,
+        containing points :math:`(p_i, p_i)`.
 
     Parameters
     ----------
     y_true : pd.Series, single columned pd.DataFrame, or single columned np.array.
-        The actual values of the forecast
+        The actual values
     y_pred : pd.DataFrame
-        The quantile forecast.
+        The quantile predictions,
+        formatted as returned by ``BaseDistribution.quantile``,
+        or ``predict_quantiles``
     ax : matplotlib.axes.Axes, optional (default=None)
         Axes on which to plot. If None, axes will be created and returned.
 


Test patch:
diff --git a/.github/actions/test-component/action.yml b/.github/actions/test-component/action.yml
index 10852993d..62dfe3bdf 100644
--- a/.github/actions/test-component/action.yml
+++ b/.github/actions/test-component/action.yml
@@ -52,6 +52,7 @@ runs:
       run: >-
         python3
         -m pytest
+        sktime/tests
         sktime/${{ inputs.sktime-component-identifier }}
         --matrixdesign ${{ inputs.sub-sample-estimators }}
         --only_changed_modules ${{ inputs.test-affected-estimators }}
diff --git a/docs/source/developer_guide/testing_framework.rst b/docs/source/developer_guide/testing_framework.rst
index 40ebc982e..7841b26f5 100644
--- a/docs/source/developer_guide/testing_framework.rst
+++ b/docs/source/developer_guide/testing_framework.rst
@@ -68,7 +68,8 @@ See below for more details, or the `pytest documentation on the topic`_.
 The ``sktime`` plug-in for ``pytest`` generates the tuples of fixture values for this.
 In the above example, we loop over the following fixtures lists:
 
-* ``estimator_instance`` over estimator instances, obtained from all ``sktime`` estimators via ``create_test_instances_and_names``
+* ``estimator_instance`` over estimator instances, obtained from all ``sktime`` estimators via ``create_test_instances_and_names``, which
+  constructs instances from parameter settings in estimator classes' ``get_test_params``.
 
 * ``scenario`` objects, which encodes data inputs and method call sequences to ``estimator_instance`` (explained in further detail below).
 
diff --git a/sktime/classification/dictionary_based/tests/test_boss.py b/sktime/classification/dictionary_based/tests/test_boss.py
index 1bba876ec..f803785b1 100644
--- a/sktime/classification/dictionary_based/tests/test_boss.py
+++ b/sktime/classification/dictionary_based/tests/test_boss.py
@@ -25,7 +25,7 @@ def dataset():
 @pytest.mark.parametrize(
     "new_class,expected_dtype",
     [
-        ({"1": "Class1", "2": "Class2"}, object),
+        ({"1": "Class1", "2": "Class2"}, "same"),
         ({"1": 1, "2": 2}, int),
         ({"1": 1.0, "2": 2.0}, float),
         ({"1": True, "2": False}, bool),
@@ -39,6 +39,9 @@ def test_individual_boss_classes(dataset, new_class, expected_dtype):
     # change class
     y_train = np.array([new_class[y] for y in y_train])
 
+    if expected_dtype == "same":
+        expected_dtype = y_train.dtype
+
     # train iboss and predict X_test
     iboss = IndividualBOSS()
     iboss.fit(X_train, y_train)
diff --git a/sktime/classification/tests/test_all_classifiers.py b/sktime/classification/tests/test_all_classifiers.py
index 173edc08a..cd16cdfb5 100644
--- a/sktime/classification/tests/test_all_classifiers.py
+++ b/sktime/classification/tests/test_all_classifiers.py
@@ -120,20 +120,17 @@ class TestAllClassifiers(ClassifierFixtureGenerator, QuickTester):
         # we only use the first estimator instance for testing
         classname = estimator_class.__name__
 
-        # retrieve expected predict_proba output, and skip test if not available
-        if classname in unit_test_proba.keys():
-            expected_probas = unit_test_proba[classname]
-        else:
-            # skip test if no expected probas are registered
-            return None
-
         # if numba is not installed, some estimators may still try to construct
         # numba dependenct estimators in results_comparison
         # if that is the case, we skip the test
+        if classname in unit_test_proba.keys():
+            parameter_set = "results_comparison"
+        else:
+            parameter_set = "default"
         try:
             # we only use the first estimator instance for testing
             estimator_instance = estimator_class.create_test_instance(
-                parameter_set="results_comparison"
+                parameter_set=parameter_set
             )
         except ModuleNotFoundError as e:
             if not _check_soft_dependencies("numba", severity="none"):
@@ -152,10 +149,18 @@ class TestAllClassifiers(ClassifierFixtureGenerator, QuickTester):
 
         # train classifier and predict probas
         estimator_instance.fit(X_train, y_train)
+
+        y_pred = estimator_instance.predict(X_test.iloc[indices])
+        assert y_pred.dtype == y_train.dtype
+        assert set(y_train).issuperset(set(y_pred))
+
         y_proba = estimator_instance.predict_proba(X_test.iloc[indices])
 
-        # assert probabilities are the same
-        _assert_array_almost_equal(y_proba, expected_probas, decimal=2)
+        # retrieve expected predict_proba output, and skip test if not available
+        if classname in unit_test_proba.keys():
+            expected_probas = unit_test_proba[classname]
+            # assert probabilities are the same
+            _assert_array_almost_equal(y_proba, expected_probas, decimal=2)
 
     def test_classifier_on_basic_motions(self, estimator_class):
         """Test classifier on basic motions data."""
diff --git a/sktime/performance_metrics/forecasting/probabilistic/tests/test_probabilistic_metrics.py b/sktime/performance_metrics/forecasting/probabilistic/tests/test_probabilistic_metrics.py
index 2c683a688..b5e450d51 100644
--- a/sktime/performance_metrics/forecasting/probabilistic/tests/test_probabilistic_metrics.py
+++ b/sktime/performance_metrics/forecasting/probabilistic/tests/test_probabilistic_metrics.py
@@ -8,6 +8,7 @@ import pytest
 from sktime.performance_metrics.forecasting.probabilistic import (
     ConstraintViolation,
     EmpiricalCoverage,
+    IntervalWidth,
     PinballLoss,
 )
 from sktime.split import temporal_train_test_split
@@ -20,8 +21,9 @@ quantile_metrics = [
 ]
 
 interval_metrics = [
-    EmpiricalCoverage,
     ConstraintViolation,
+    EmpiricalCoverage,
+    IntervalWidth,
 ]
 
 all_metrics = interval_metrics + quantile_metrics
diff --git a/sktime/performance_metrics/forecasting/tests/test_metrics.py b/sktime/performance_metrics/forecasting/tests/test_metrics.py
index 2a21fc076..cb46d90c3 100644
--- a/sktime/performance_metrics/forecasting/tests/test_metrics.py
+++ b/sktime/performance_metrics/forecasting/tests/test_metrics.py
@@ -144,3 +144,19 @@ def test_make_scorer_sklearn():
     scorer = make_forecasting_scorer(mean_absolute_error, name="MAE")
 
     scorer.evaluate(pd.Series([1, 2, 3]), pd.Series([1, 2, 4]))
+
+
+def test_metric_coercion_bug():
+    """Tests for sensible output when using hierarchical arg with non-hierarchical data.
+
+    Failure case in bug #6413.
+    """
+    from sktime.performance_metrics.forecasting import MeanAbsoluteError
+
+    y_true = np.array([[0.5, 1], [-1, 1], [7, -6]])
+    y_pred = np.array([[0, 2], [-1, 2], [8, -5]])
+    mae = MeanAbsoluteError(multilevel="raw_values", multioutput=[0.4, 0.6])
+    metric = mae(y_true, y_pred)
+
+    assert isinstance(metric, pd.DataFrame)
+    assert metric.shape == (1, 1)
diff --git a/sktime/split/tests/test_expandingcutoff.py b/sktime/split/tests/test_expandingcutoff.py
new file mode 100644
index 000000000..7c7133120
--- /dev/null
+++ b/sktime/split/tests/test_expandingcutoff.py
@@ -0,0 +1,213 @@
+# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
+"""Tests for expanding cutoff splitter."""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from sktime.forecasting.base import ForecastingHorizon
+from sktime.split import ExpandingCutoffSplitter
+from sktime.split.tests.test_split import _check_cv
+from sktime.utils._testing.hierarchical import _make_hierarchical
+from sktime.utils._testing.series import _make_series
+
+
+def test_expandingcutoff_datelike_index_001():
+    """Test datetime index with _check_cv"""
+    y = _make_series(n_timepoints=10, random_state=42)
+    cutoff = y.index[3]
+    fh = ForecastingHorizon([1, 2, 3], freq=y.index.freq)
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+    train_windows, test_windows, cutoffs, n_splits = _check_cv(cv, y)
+    np.testing.assert_array_equal(cutoffs, cv.get_cutoffs(y))
+
+
+def test_expandingcutoff_int_index_002():
+    """Test int index with _check_cv"""
+    y = _make_series(n_timepoints=10, index_type="int", random_state=42)
+    cutoff = y.index[3]
+    fh = ForecastingHorizon([1, 2, 3])
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+    train_windows, test_windows, cutoffs, n_splits = _check_cv(cv, y)
+    np.testing.assert_array_equal(cutoffs, cv.get_cutoffs(y))
+
+
+def test_expandingcutoff_ytype_cutofftype_combos_003a():
+    """Test invalid param combo"""
+    # Datetime cutoff
+    i = 3
+    y1 = _make_series(n_timepoints=10, index_type="datetime", random_state=42)
+    fh = ForecastingHorizon([1, 2, 3])
+    cutoffs = [-7, y1.index[i], 5]
+    step_lengths = [1, 2, 3]
+    for cutoff in cutoffs:
+        for step_length in step_lengths:
+            cv1 = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=step_length)
+            _check_cv(cv1, y1)
+
+
+def test_expandingcutoff_ytype_cutofftype_combos_003b():
+    """Test invalid param combo"""
+    # Datetime cutoff
+    y1 = _make_series(n_timepoints=10, index_type="int", random_state=42)
+    fh = ForecastingHorizon([1, 2, 3])
+    cutoffs = [-7, y1.index[3]]
+    step_lengths = [1, 2, 3]
+    for cutoff in cutoffs:
+        for step_length in step_lengths:
+            cv1 = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=step_length)
+            _check_cv(cv1, y1)
+
+
+def test_expandingcutoff_ytype_cutofftype_combos_003c():
+    """Test invalid param combo"""
+    # Datetime cutoff
+    y1 = _make_series(n_timepoints=10, index_type="int", random_state=42)
+    fh = ForecastingHorizon([1, 2, 3])
+    # Y-index is int but cutoff is datetime
+    with pytest.raises(TypeError):
+        cv1 = ExpandingCutoffSplitter(
+            cutoff=pd.Timestamp("2000-01-01"), fh=fh, step_length=1
+        )
+        _check_cv(cv1, y1)
+
+
+def test_expandingcutoff_splitloc_004():
+    """Test split loc"""
+    y = _make_series(n_timepoints=10, random_state=42)
+    cutoff = y.index[3]
+    fh = ForecastingHorizon([1, 2, 3], freq=y.index.freq)
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+    train_test_values = list(cv.split_loc(y))
+    last_train, last_test = train_test_values[-1]
+    expected_last_train = y.index[0:7]
+    expected_last_test = y.index[7:]
+    test_cases = [(expected_last_train, last_train), (expected_last_test, last_test)]
+    for expected, actual in test_cases:
+        np.testing.assert_array_equal(expected.values, actual.values)
+
+
+def test_expandingcutoff_hiearchical_splitloc_005():
+    """Test hiearchical splitloc with datetime"""
+    y = _make_hierarchical(
+        min_timepoints=6,
+        max_timepoints=10,
+        same_cutoff=True,
+        hierarchy_levels=(1, 2),
+        index_type="datetime",
+        random_state=42,
+    )
+    y_index = y.index.get_level_values(-1)
+    cutoff_index = -4
+    cutoff = y_index[cutoff_index]
+    fh = ForecastingHorizon([1, 2, 3])
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+
+    train_test = list(cv.split_loc(y))
+
+    y_train_expected = (
+        y.groupby(level=-2)
+        .apply(lambda row: row[0:cutoff_index])
+        .index.get_level_values(-1)
+    )
+    y_test_expected = (
+        y.groupby(level=-2)
+        .apply(lambda row: row[cutoff_index : cutoff_index + fh[-1]])
+        .index.get_level_values(-1)
+    )
+    pd.testing.assert_index_equal(
+        y_train_expected, train_test[0][0].get_level_values(-1)
+    )
+    pd.testing.assert_index_equal(
+        y_test_expected, train_test[0][1].get_level_values(-1)
+    )
+
+
+def test_expandingcutoff_hiearchical_forecastbylevel_006():
+    """Test hiearchical with forecast by level"""
+    from sktime.forecasting.compose import ForecastByLevel
+    from sktime.forecasting.model_selection import ForecastingGridSearchCV
+    from sktime.forecasting.naive import NaiveForecaster
+    from sktime.utils._testing.hierarchical import _make_hierarchical
+
+    y = _make_hierarchical(
+        min_timepoints=6,
+        max_timepoints=10,
+        same_cutoff=True,
+        hierarchy_levels=(1, 2),
+        index_type="datetime",
+        random_state=42,
+    )
+    y_index = y.index.get_level_values(-1)
+    last_date = y_index.max()
+    cutoff_index = -4
+    cutoff = y_index[cutoff_index]
+    fh = ForecastingHorizon([1, 2, 3])
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+    forecaster = NaiveForecaster()
+    param_grid = {"strategy": ["last", "mean", "drift"]}
+    gscv = ForecastByLevel(
+        ForecastingGridSearchCV(forecaster=forecaster, param_grid=param_grid, cv=cv)
+    )
+    gscv.fit(y, fh=fh)
+    y_pred = gscv.predict()
+    expected_last_forecast_date = last_date + pd.Timedelta(days=fh[-1])
+    actual_last_forecast_date = y_pred.index.max()
+    assert expected_last_forecast_date, actual_last_forecast_date
+
+
+def test_expandingcutoff_fh_list_007():
+    """Test fh as list with _check_cv"""
+    y = _make_series(n_timepoints=10, random_state=42)
+    cutoff = y.index[3]
+    fh = [1, 2, 3]
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+    train_windows, test_windows, cutoffs, n_splits = _check_cv(cv, y)
+    np.testing.assert_array_equal(cutoffs, cv.get_cutoffs(y))
+
+
+def test_expanding_cutoff_period_008():
+    date_range = pd.date_range(
+        start=pd.Timestamp("2020-Q1"), end=pd.Timestamp("2021-Q4"), freq="QS"
+    )
+    y = pd.DataFrame({"date": date_range})
+    y = y.reset_index()
+    y = y.set_index("date")
+    y.index = pd.PeriodIndex(y.index, freq="Q")
+
+    cutoff = pd.Period("2021-Q1")
+    fh = ForecastingHorizon([1, 2, 3])
+    cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=2)
+    _check_cv(cv, y)
+
+    # pandas periods and timestamps are both datelike but don't work directly
+    cutoff = pd.Timestamp("2021-Q1")
+    with pytest.raises(TypeError):
+        cv = ExpandingCutoffSplitter(cutoff=cutoff, fh=fh, step_length=1)
+        _check_cv(cv, y)
+
+
+def _make_splits_listlike(splits):
+    splits_new = []
+    for train, test in splits:
+        splits_new.append([train.tolist(), test.tolist()])
+    return splits_new
+
+
+def test_expanding_cutoff_docstring_examples():
+    date_range = pd.date_range(start="2020-Q1", end="2021-Q3", freq="QS")
+    y = pd.DataFrame(index=pd.PeriodIndex(date_range, freq="Q"))
+    cv1 = ExpandingCutoffSplitter(cutoff=pd.Period("2021-Q1"), fh=[1, 2], step_length=1)
+    splits1 = list(cv1.split(y))
+
+    cv2 = ExpandingCutoffSplitter(cutoff=4, fh=[1, 2], step_length=1)
+    splits2 = list(cv2.split(y))
+
+    cv3 = ExpandingCutoffSplitter(cutoff=-3, fh=[1, 2], step_length=1)
+    splits3 = list(cv3.split(y))
+
+    assert (
+        _make_splits_listlike(splits1)
+        == _make_splits_listlike(splits2)
+        == _make_splits_listlike(splits3)
+    )
diff --git a/sktime/tests/tests/test_test_utils.py b/sktime/tests/tests/test_test_utils.py
index 6d63812a7..c4f19470b 100644
--- a/sktime/tests/tests/test_test_utils.py
+++ b/sktime/tests/tests/test_test_utils.py
@@ -75,12 +75,12 @@ def test_run_test_for_class():
         assert reason_nodep == "False_no_change"
 
     # now check estimator with soft deps
-    run_nodep = run_test_for_class(f_with_deps)
+    run_wdep = run_test_for_class(f_with_deps)
     assert isinstance(run, bool)
 
     dep_present = _check_estimator_deps(f_with_deps, severity="none")
     if not dep_present:
-        assert not run_nodep
+        assert not run_wdep
 
     res = run_test_for_class(f_with_deps, return_reason=True)
     assert isinstance(res, tuple)
@@ -130,6 +130,9 @@ def test_run_test_for_class():
     if not dep_present:
         assert not run
         assert reason == "False_required_deps_missing"
+    elif not ONLY_CHANGED_MODULES:
+        assert run
+        assert reason == "True_run_always"
     elif run:
         assert reason in POS_REASONS
         assert reason_wdep == reason or reason_nodep == reason
diff --git a/sktime/transformations/series/tests/test_adi_cv.py b/sktime/transformations/series/tests/test_adi_cv.py
new file mode 100644
index 000000000..143c9a73f
--- /dev/null
+++ b/sktime/transformations/series/tests/test_adi_cv.py
@@ -0,0 +1,132 @@
+# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
+"""Tests for adi_cv transformers for time series Series."""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from sktime.transformations.series.adi_cv import ADICVTransformer
+
+
+def _generate_smooth_series(size: int = 750):
+    """Generates a demand time series of the "smooth" category.
+
+    Parameters
+    ----------
+    size : int, optional
+        The size of the generated time series, by default 750
+
+    Returns
+    -------
+    Pandas.Series
+        Returns the generated series in the Pandas Series format.
+    """
+
+    # Generating a smooth series, we keep variance low by keeping the
+    # standard deviation to 0.25. Denoted as scale according to numpy docs
+
+    smooth_series = np.random.normal(loc=10, scale=0.25, size=size)
+
+    return pd.Series(smooth_series)
+
+
+def _generate_erratic_series(size: int = 750):
+    """Generates a demand time series of the "erratic" category.
+
+    Parameters
+    ----------
+    size : int, optional
+        The size of the generated time series, by default 750
+
+    Returns
+    -------
+    Pandas.Series
+        Returns the generated series in the Pandas Series format.
+    """
+
+    # Generating an erratic series, we keep variance high by keeping the
+    # standard deviation to 1 and then squaring the values
+
+    erratic_series = np.random.normal(loc=10, scale=2.5, size=size) ** 2
+
+    return pd.Series(erratic_series)
+
+
+def _generate_intermittent_series(size: int = 750):
+    """Generates a demand time series of the "intermittent" category.
+
+    Parameters
+    ----------
+    size : int, optional
+        The size of the generated time series, by default 750
+
+    Returns
+    -------
+    Pandas.Series
+        Returns the generated series in the Pandas Series format.
+    """
+
+    # Generating an intermittent series, we keep ADI high by
+    # setting only 10% of all values to non-zero values
+
+    intermittent_series = np.zeros(shape=(size,))
+    non_zero_indices = np.random.choice(size, size=size // 10, replace=False)
+
+    intermittent_series[non_zero_indices] = np.random.normal(10, 0.25, size=size // 10)
+
+    return pd.Series(intermittent_series)
+
+
+def _generate_lumpy_series(size: int = 750):
+    """Generates a demand time series of the "lumpy" category.
+
+    Parameters
+    ----------
+    size : int, optional
+        The size of the generated time series, by default 750
+
+    Returns
+    -------
+    Pandas.Series
+        Returns the generated series in the Pandas Series format.
+    """
+
+    # Generating a lumpy series, we keep ADI high by
+    # setting only 10% of all values to non-zero values
+
+    lumpy_series = np.zeros(shape=(size,))
+    non_zero_indices = np.random.choice(size, size=size // 10, replace=False)
+
+    lumpy_series[non_zero_indices] = np.random.normal(10, 2.5, size=size // 10) ** 2
+
+    return pd.Series(lumpy_series)
+
+
+# Defining all of the categories we wish to run tests for
+@pytest.mark.parametrize(
+    "series_generator, expected_class",
+    [
+        (_generate_smooth_series, "smooth"),
+        (_generate_erratic_series, "erratic"),
+        (_generate_intermittent_series, "intermittent"),
+        (_generate_lumpy_series, "lumpy"),
+    ],
+)
+def test_adi_cv_extractor(series_generator, expected_class):
+    """
+    Runs a PyTest for all 4 demand time series categories.
+
+    Parameters
+    ----------
+    series_generator
+        A function that generates a time series in the Pandas Series format.
+
+    expected_class
+        The expected class to be predicted by the transformer.
+    """
+
+    series = series_generator()
+    transformer = ADICVTransformer()
+
+    df = transformer.fit_transform(series)
+    assert df["class"].iloc[0] == expected_class