Repository: aeon-toolkit/aeon
Pull request #1331 (2024-03-23 12:30:47)

[DOCS] hard code shapelet classifiers in notebook
Hard codes the results generator for shapelets to accomodate new shapelet based classifiers, see #1247 

review-notebook-app[bot]: Check out this pull request on&nbsp; <a href="https://app.reviewnb.com/aeon-toolkit/aeon/pull/1331"><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>
aeon-actions-bot[bot]: 
## Thank you for contributing to `aeon`

I did not find any labels to add based on the title. Please add the [ENH], [MNT], [BUG], [DOC], [REF], [DEP] and/or [GOV] tags to your pull requests titles. For now you can add the labels manually.
I would have added the following labels to this PR based on the changes made: **[ $\\color{#45FD64}{\\textsf{examples}}$ ]**, however some package labels are already present.

The [Checks](https://github.com/aeon-toolkit/aeon/pull/1331/checks) tab will show the status of our automated tests. You can click on individual test runs in the tab or "Details" in the panel below to see more information if there is a failure.

If our `pre-commit` code quality check fails, any trivial fixes will automatically be pushed to your PR unless it is a draft.

Don't hesitate to ask questions on the `aeon` [Slack](
https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA) channel if you have any.
    

Patch:
diff --git a/aeon/forecasting/base/_base.py b/aeon/forecasting/base/_base.py
index f0a338af..40a4af13 100644
--- a/aeon/forecasting/base/_base.py
+++ b/aeon/forecasting/base/_base.py
@@ -45,17 +45,11 @@ import pandas as pd
 from scipy.stats import norm
 
 from aeon.base import BaseEstimator
-from aeon.datatypes import (
-    VectorizedDF,
-    check_is_scitype,
-    convert_to,
-    mtype_to_scitype,
-    scitype_to_mtype,
-)
+from aeon.datatypes import VectorizedDF, convert_to, mtype_to_scitype
 from aeon.forecasting.base._fh import ForecastingHorizon
 from aeon.utils.datetime import _shift
 from aeon.utils.index_functions import get_cutoff, update_data
-from aeon.utils.validation import is_collection, is_hierarchical, is_single_series
+from aeon.utils.validation import validate_input
 from aeon.utils.validation._dependencies import _check_estimator_deps
 from aeon.utils.validation.forecasting import check_alpha, check_cv, check_fh, check_X
 from aeon.utils.validation.series import check_equal_time_index
@@ -1323,22 +1317,10 @@ class BaseForecaster(BaseEstimator):
         y_inner_abstract_type = mtype_to_scitype(y_inner_type, return_unique=True)
         X_inner_abstract_type = mtype_to_scitype(X_inner_type, return_unique=True)
 
-        ALLOWED_ABSTRACT_TYPES = ["Series", "Panel", "Hierarchical"]
-        FORBIDDEN_TYPES = ["numpy2D", "pd-wide"]
-
-        for abs in ALLOWED_ABSTRACT_TYPES:
-            types = set(scitype_to_mtype(abs))
-            types = list(types.difference(FORBIDDEN_TYPES))
-
         # checking y
         if y is not None:
-            if is_hierarchical(y):
-                y_type = "Hierarchical"
-            elif is_collection(y):
-                y_type = "Panel"
-            elif is_single_series(y):
-                y_type = "Series"
-            else:
+            valid, y_metadata = validate_input(y)
+            if not valid:
                 raise TypeError(
                     "y must be in an aeon compatible format, "
                     "of abstract type Series, Panel or Hierarchical, for instance a "
@@ -1350,11 +1332,6 @@ class BaseForecaster(BaseEstimator):
                     "where mtype is the string of the type specification you want for "
                     "y. Possible mtype specification strings are as follows. "
                 )
-            # TODO: Still need to extract the correct "scitype and "mtype" of y,
-            #  is_univariate and _check_missing without check_is_scitype
-            _, _, y_metadata = check_is_scitype(
-                y, scitype=ALLOWED_ABSTRACT_TYPES, return_metadata=True, var_name="y"
-            )
 
             y_type = y_metadata["scitype"]
             self._y_mtype_last_seen = y_metadata["mtype"]
@@ -1383,31 +1360,20 @@ class BaseForecaster(BaseEstimator):
 
         # checking X
         if X is not None:
-            # checking y
-            if X is not None:
-                if is_hierarchical(X):
-                    X_type = "Hierarchical"
-                elif is_collection(X):
-                    X_type = "Panel"
-                elif is_single_series(X):
-                    X_type = "Series"
-                else:
-                    raise TypeError(
-                        "y must be in an aeon compatible format, "
-                        "of abstract type Series, Panel or Hierarchical, for instance a"
-                        "pandas.DataFrame with aeon compatible time indices, or with "
-                        "MultiIndex and last(-1) level an aeon compatible time index."
-                        "For further details see  examples/forecasting, or "
-                        "examples/datasets. If you think y is already in an aeon "
-                        "supported input format, run aeon.datatypes.check_raise(y, "
-                        "mtype) to diagnose the error, where mtype is the string of "
-                        "the type specification you want for y. "
-                        "Possible mtype specification strings are as follows. "
-                    )
-            # TODO: Still need to extract the "scitype" of y without check_is_scitype
-            _, _, X_metadata = check_is_scitype(
-                X, scitype=ALLOWED_ABSTRACT_TYPES, return_metadata=True, var_name="X"
-            )
+            valid, X_metadata = validate_input(X)
+            if not valid:
+                raise TypeError(
+                    "y must be in an aeon compatible format, "
+                    "of abstract type Series, Panel or Hierarchical, for instance a"
+                    "pandas.DataFrame with aeon compatible time indices, or with "
+                    "MultiIndex and last(-1) level an aeon compatible time index."
+                    "For further details see  examples/forecasting, or "
+                    "examples/datasets. If you think y is already in an aeon "
+                    "supported input format, run aeon.datatypes.check_raise(y, "
+                    "mtype) to diagnose the error, where mtype is the string of "
+                    "the type specification you want for y. "
+                    "Possible mtype specification strings are as follows. "
+                )
             X_type = X_metadata["scitype"]
             X_requires_vectorization = X_type not in X_inner_abstract_type
             requires_vectorization = requires_vectorization or X_requires_vectorization
diff --git a/aeon/forecasting/model_selection/_split.py b/aeon/forecasting/model_selection/_split.py
index e9b12ffd..c950a738 100644
--- a/aeon/forecasting/model_selection/_split.py
+++ b/aeon/forecasting/model_selection/_split.py
@@ -16,7 +16,7 @@ import pandas as pd
 from sklearn.model_selection import train_test_split as _train_test_split
 
 from aeon.base import BaseObject
-from aeon.datatypes import check_is_scitype, convert_to
+from aeon.datatypes import convert_to
 from aeon.forecasting.base import ForecastingHorizon
 from aeon.forecasting.base._fh import VALID_FORECASTING_HORIZON_TYPES
 from aeon.utils.index_functions import get_index_for_series, get_time_index, get_window
@@ -35,6 +35,7 @@ from aeon.utils.validation import (
     is_single_series,
     is_timedelta,
     is_timedelta_or_date_offset,
+    validate_input,
 )
 from aeon.utils.validation.forecasting import (
     VALID_CUTOFF_TYPES,
@@ -523,13 +524,7 @@ class BaseSplitter(BaseObject):
                 "run aeon.datatypes.check_raise(y, mtype) to diagnose the error, "
                 "where mtype is the string of the type specification you want for y. "
             )
-        # TODO: Still need to extract the "mtype" of y without check_is_scitype
-        _, _, y_metadata = check_is_scitype(
-            y,
-            scitype=["Hierarchical", "Panel", "Series"],
-            return_metadata=True,
-            var_name="y",
-        )
+        _, y_metadata = validate_input(y)
 
         y_inner = convert_to(y, to_type=PANDAS_MTYPES)
 
diff --git a/aeon/transformations/base.py b/aeon/transformations/base.py
index d122f9bf..1fa423d4 100644
--- a/aeon/transformations/base.py
+++ b/aeon/transformations/base.py
@@ -50,7 +50,7 @@ import numpy as np
 import pandas as pd
 
 from aeon.base import BaseEstimator
-from aeon.datatypes import VectorizedDF, check_is_scitype, convert_to, mtype_to_scitype
+from aeon.datatypes import VectorizedDF, convert_to, mtype_to_scitype
 from aeon.datatypes._series_as_panel import convert_to_scitype
 from aeon.utils.index_functions import update_data
 from aeon.utils.sklearn import (
@@ -58,12 +58,7 @@ from aeon.utils.sklearn import (
     is_sklearn_regressor,
     is_sklearn_transformer,
 )
-from aeon.utils.validation import (
-    is_collection,
-    is_hierarchical,
-    is_single_series,
-    is_univariate_series,
-)
+from aeon.utils.validation import is_univariate_series, validate_input
 from aeon.utils.validation._dependencies import _check_estimator_deps
 
 # single/multiple primitives
@@ -808,21 +803,14 @@ class BaseTransformer(BaseEstimator):
         X_inner_scitype = mtype_to_scitype(X_inner_type, return_unique=True)
         y_inner_scitype = mtype_to_scitype(y_inner_type, return_unique=True)
 
-        ALLOWED_SCITYPES = ["Series", "Panel", "Hierarchical"]
         ALLOWED_MTYPES = self.ALLOWED_INPUT_TYPES
-        if not (is_hierarchical(X) or is_collection(X) or is_single_series(X)):
+
+        valid, X_metadata = validate_input(X)
+        if not valid:
             raise TypeError(
                 "must be in an aeon compatible format for storing series, hierarchical "
                 "series or collections of series."
             )
-        # checking X
-        _, _, X_metadata = check_is_scitype(
-            X,
-            scitype=ALLOWED_SCITYPES,
-            return_metadata=True,
-            var_name="X",
-        )
-
         X_scitype = X_metadata["scitype"]
         X_mtype = X_metadata["mtype"]
         # remember these for potential back-conversion (in transform etc)
@@ -851,20 +839,9 @@ class BaseTransformer(BaseEstimator):
         # end checking X
 
         if y_inner_type != ["None"] and y is not None:
-            if "Table" in y_inner_scitype:
-                y_possible_scitypes = "Table"
-            elif X_scitype == "Series":
-                y_possible_scitypes = "Series"
-            elif X_scitype == "Panel":
-                y_possible_scitypes = "Panel"
-            elif X_scitype == "Hierarchical":
-                y_possible_scitypes = ["Panel", "Hierarchical"]
-            if not (is_hierarchical(y) or is_collection(y) or is_single_series(y)):
+            valid, y_metadata = validate_input(y)
+            if not valid:
                 raise TypeError("Error, y is not a valid type for X type.")
-            # TODO: Still need to extract the "scitype" of y without check_is_scitype
-            _, _, y_metadata = check_is_scitype(
-                y, scitype=y_possible_scitypes, return_metadata=True, var_name="y"
-            )
             y_scitype = y_metadata["scitype"]
         else:
             # y_scitype is used below - set to None if y is None
diff --git a/aeon/utils/index_functions.py b/aeon/utils/index_functions.py
index ee8de2da..fc55aa35 100644
--- a/aeon/utils/index_functions.py
+++ b/aeon/utils/index_functions.py
@@ -3,8 +3,13 @@
 import numpy as np
 import pandas as pd
 
-from aeon.datatypes import check_is_scitype, convert_to
-from aeon.utils.validation import is_collection, is_hierarchical, is_single_series
+from aeon.datatypes import convert_to
+from aeon.utils.validation import (
+    is_collection,
+    is_hierarchical,
+    is_single_series,
+    validate_input,
+)
 
 
 def _get_index(x):
@@ -414,18 +419,14 @@ def get_window(obj, window_length=None, lag=None):
     """
     if obj is None or (window_length is None and lag is None):
         return obj
-    valid = is_hierarchical(obj) or is_collection(obj) or is_single_series(obj)
+    valid, metadata = validate_input(obj)
     if not valid:
-        raise ValueError("obj must be of Series, Panel, or Hierarchical scitype")
-    # TODO: Still need to extract the "mtype" without check_is_scitype
-    _, _, metadata = check_is_scitype(
-        obj, scitype=["Series", "Panel", "Hierarchical"], return_metadata=True
-    )
+        raise ValueError("obj must be of Series, Collection, or Hierarchical scitype")
     obj_in_mtype = metadata["mtype"]
 
     obj = convert_to(obj, GET_WINDOW_SUPPORTED_MTYPES)
 
-    # numpy3D (Panel) or np.npdarray (Series)
+    # numpy3D (Collection) or np.npdarray (Series)
     if isinstance(obj, np.ndarray):
         # if 2D or 3D, we need to subset by last, not first dimension
         # if 1D, we need to subset by first dimension
@@ -449,7 +450,8 @@ def get_window(obj, window_length=None, lag=None):
             obj_subset = obj_subset.swapaxes(1, -1)
         return obj_subset
 
-    # pd.DataFrame(Series), pd-multiindex (Panel) and pd_multiindex_hier (Hierarchical)
+    # pd.DataFrame(Series), pd-multiindex (Collection) and pd_multiindex_hier (
+    # Hierarchical)
     if isinstance(obj, pd.DataFrame):
         cutoff = get_cutoff(obj)
 
@@ -510,13 +512,9 @@ def get_slice(obj, start=None, end=None):
     if (start is None and end is None) or obj is None:
         return obj
 
-    valid = is_hierarchical(obj) or is_collection(obj) or is_single_series(obj)
+    valid, metadata = validate_input(obj)
     if not valid:
         raise ValueError("obj must be of Series, Panel, or Hierarchical scitype")
-    # TODO: Still need to extract the "mtype" without check_is_scitype
-    _, _, metadata = check_is_scitype(
-        obj, scitype=["Series", "Panel", "Hierarchical"], return_metadata=True
-    )
     obj_in_mtype = metadata["mtype"]
 
     obj = convert_to(obj, GET_WINDOW_SUPPORTED_MTYPES)
diff --git a/aeon/utils/validation/__init__.py b/aeon/utils/validation/__init__.py
index 194119c3..766f98b4 100644
--- a/aeon/utils/validation/__init__.py
+++ b/aeon/utils/validation/__init__.py
@@ -23,6 +23,8 @@ __all__ = [
     "is_collection",
     "is_tabular",
     "is_hierarchical",
+    "is_valid_input",
+    "validate_input",
 ]
 
 import os
@@ -32,6 +34,7 @@ from typing import Union
 import numpy as np
 import pandas as pd
 
+from aeon.utils.validation._input import is_valid_input, validate_input
 from aeon.utils.validation.collection import (
     get_n_cases,
     get_type,
diff --git a/aeon/utils/validation/_dependencies.py b/aeon/utils/validation/_dependencies.py
index af589308..28ea1d35 100644
--- a/aeon/utils/validation/_dependencies.py
+++ b/aeon/utils/validation/_dependencies.py
@@ -1,6 +1,6 @@
 """Utility to check soft dependency imports, and raise warnings or errors."""
 
-__maintainer__ = []
+__maintainer__ = ["TonyBagnall"]
 
 import io
 import sys
diff --git a/aeon/utils/validation/_input.py b/aeon/utils/validation/_input.py
new file mode 100644
index 00000000..d2ed62a7
--- /dev/null
+++ b/aeon/utils/validation/_input.py
@@ -0,0 +1,93 @@
+"""Input checks for aeon types.
+
+time series input should either be a single series, a collection of series or a
+hierarchical time series. Each of these abstract types is stored in either pandas or
+numpy data structure.
+"""
+
+__maintainer__ = ["TonyBagnall"]
+
+import numpy as np
+import pandas as pd
+
+from aeon.utils.validation.collection import (
+    get_type,
+    has_missing,
+    is_collection,
+    is_univariate,
+)
+from aeon.utils.validation.series import is_hierarchical, is_single_series
+
+
+def is_valid_input(X):
+    """Test if input valid.
+
+    Parameters
+    ----------
+    X : array-like
+        Input data to be checked.
+
+    Returns
+    -------
+    bool
+        True if input is either a single series, a collection or a hierarchy.
+    """
+    if is_hierarchical(X) or is_collection(X) or is_single_series(X):
+        return True
+    return False
+
+
+def validate_input(X):
+    """Validate input.
+
+    Parameters
+    ----------
+    X : array-like
+        Input data to be checked.
+
+    Returns
+    -------
+    valid: bool
+        True if input is either a single series, a collection or a hierarchy.
+    metadata: dict
+        Dictionary containing metadata about the input. This includes the
+        abstract type (Series, Collection or Hierarchy, the data type (see LOCATION),
+        whether the data is univariate and whether it contains missing values.
+    """
+    metadata = {}
+    if is_hierarchical(X):
+        metadata["scitype"] = "Hierarchical"
+        metadata["mtype"] = "pd_multiindex_hier"
+        if X.ndim == 2 and (X.shape[0] == 1 or X.shape[1] == 1):
+            metadata["is_univariate"] = True
+        else:
+            metadata["is_univariate"] = False
+        metadata["has_nans"] = X.isna().any().any()
+    elif is_single_series(X):
+        metadata["scitype"] = "Series"
+        if isinstance(X, np.ndarray):
+            metadata["mtype"] = "np.ndarray"
+            metadata["has_nans"] = np.isnan(X).any()
+            if X.ndim == 1:
+                metadata["is_univariate"] = True
+            elif X.ndim == 2 and (X.shape[0] == 1 or X.shape[1] == 1):
+                metadata["is_univariate"] = True
+            else:
+                metadata["is_univariate"] = False
+        elif isinstance(X, pd.Series):
+            metadata["mtype"] = "pd.Series"
+            metadata["is_univariate"] = True
+            metadata["has_nans"] = X.isna().any()
+        else:
+            metadata["mtype"] = "pd.DataFrame"
+            metadata["is_univariate"] = X.shape[1] == 1
+            metadata["has_nans"] = X.isna().any().any()
+    elif is_collection(X):
+        metadata["scitype"] = "Panel"
+        metadata["mtype"] = get_type(X)
+        metadata["is_univariate"] = is_univariate(X)
+        metadata["has_nans"] = has_missing(X)
+
+    else:
+        return False, None
+    return True, metadata
diff --git a/aeon/utils/validation/annotation.py b/aeon/utils/validation/annotation.py
index 5e2adb72..4301e79a 100644
--- a/aeon/utils/validation/annotation.py
+++ b/aeon/utils/validation/annotation.py
@@ -1,6 +1,7 @@
 """Series of checks for annotation classes."""
 
-__maintainer__ = []
+__maintainer__ = ["TonyBagnall"]
+
 __all__ = ["check_fmt", "check_labels"]
 
 
diff --git a/aeon/utils/validation/collection.py b/aeon/utils/validation/collection.py
index 897bbacd..5d9d9a7f 100644
--- a/aeon/utils/validation/collection.py
+++ b/aeon/utils/validation/collection.py
@@ -3,9 +3,21 @@
 import numpy as np
 import pandas as pd
 
+__maintainer__ = ["TonyBagnall"]
+
 
 def is_tabular(X):
-    """Check X is a 2D table."""
+    """Check if input is a 2D table.
+
+    Parameters
+    ----------
+    X : array-like
+
+    Returns
+    -------
+    bool
+        True if input is 2D, False otherwise.
+    """
     if isinstance(X, np.ndarray):
         if X.ndim != 2:
             return False
@@ -15,12 +27,33 @@ def is_tabular(X):
 
 
 def is_collection(X):
-    """Check X is a valid collection data structure."""
-    try:
-        get_type(X)
-        return True
-    except (TypeError, ValueError):
-        return False
+    """Check X is a valid collection data structure.
+
+    Currently this is limited to 3D numpy, hierarchical pandas and nested pandas.
+
+    Parameters
+    ----------
+    X : array-like
+        Input data to be checked.
+
+    Returns
+    -------
+    bool
+        True if input is a collection, False otherwise.
+    """
+    if isinstance(X, np.ndarray):
+        if X.ndim == 3:
+            return True
+    if isinstance(X, pd.DataFrame):
+        if X.index.nlevels == 2:
+            return True
+        if is_nested_univ_dataframe(X):
+            return True
+    if isinstance(X, list):
+        if isinstance(X[0], np.ndarray):
+            if X[0].ndim == 2:
+                return True
+    return False
 
 
 def is_nested_univ_dataframe(X):
@@ -31,6 +64,11 @@ def is_nested_univ_dataframe(X):
     X: collection
         See aeon.registry.COLLECTIONS_DATA_TYPES for details
         on aeon supported data structures.
+
+    Returns
+    -------
+    bool
+        True if input is a nested dataframe, False otherwise.
     """
     # Otherwise check all entries are pd.Series
     if not isinstance(X, pd.DataFrame):
@@ -76,13 +114,12 @@ def _nested_univ_is_equal(X):
 
 
 def _is_pd_wide(X):
-    """Check whether the input nested DataFrame is "pd-wide" type."""
+    """Check whether the input DataFrame is "pd-wide" type."""
     # only test is if all values are float.
     if isinstance(X, pd.DataFrame) and not isinstance(X.index, pd.MultiIndex):
         if is_nested_univ_dataframe(X):
             return False
-        float_cols = X.select_dtypes(include=[float]).columns
-        for col in float_cols:
+        for col in X:
             if not np.issubdtype(X[col].dtype, np.floating):
                 return False
         return True
@@ -142,15 +179,14 @@ def get_type(X):
             return "numpy2D"
         else:
             raise ValueError(
-                f"ERROR np.ndarray must be either 2D or 3D but found " f"{X.ndim}"
+                f"ERROR np.ndarray must be 2D or 3D but found " f"{X.ndim}"
             )
     elif isinstance(X, list):  # np-list or df-list
         if isinstance(X[0], np.ndarray):  # if one a numpy they must all be 2D numpy
             for a in X:
                 if not (isinstance(a, np.ndarray) and a.ndim == 2):
                     raise TypeError(
-                        f"ERROR np-list np.ndarray must be either 2D or "
-                        f"3D, found {a.ndim}"
+                        f"ERROR nnp-list must contain 2D np.ndarray but found {a.ndim}"
                     )
             return "np-list"
         elif isinstance(X[0], pd.DataFrame):
diff --git a/aeon/utils/validation/forecasting.py b/aeon/utils/validation/forecasting.py
index 63d396d6..171a4848 100644
--- a/aeon/utils/validation/forecasting.py
+++ b/aeon/utils/validation/forecasting.py
@@ -13,7 +13,7 @@ __all__ = [
     "check_sp",
     "check_regressor",
 ]
-__maintainer__ = []
+__maintainer__ = ["TonyBagnall"]
 
 from datetime import timedelta
 from typing import Optional, Union
diff --git a/aeon/utils/validation/panel.py b/aeon/utils/validation/panel.py
index 672be8d7..c331bd49 100644
--- a/aeon/utils/validation/panel.py
+++ b/aeon/utils/validation/panel.py
@@ -1,14 +1,15 @@
 """Utilities for validating panel data."""
 
-__maintainer__ = []
 __all__ = [
     "check_X",
     "check_y",
     "check_X_y",
 ]
 
+__maintainer__ = ["TonyBagnall"]
 import numpy as np
 import pandas as pd
+from deprecated.sphinx import deprecated
 from sklearn.utils.validation import check_consistent_length
 
 from aeon.utils.conversion import convert_collection
@@ -18,6 +19,13 @@ VALID_X_TYPES = (pd.DataFrame, np.ndarray)  # nested pd.DataFrame, 2d or 3D np.n
 VALID_Y_TYPES = (pd.Series, np.ndarray)  # 1-d vector
 
 
+# TODO: remove in v0.9.0
+@deprecated(
+    version="0.8.0",
+    reason="check_X in utils.validation will be removed in v0.9.0, it has been "
+    "replaced by functionality that splits validation and conversion.",
+    category=FutureWarning,
+)
 def check_X(
     X,
     enforce_univariate=False,
@@ -111,6 +119,13 @@ def check_X(
     return X
 
 
+# TODO: remove in v0.9.0
+@deprecated(
+    version="0.8.0",
+    reason="check_y in utils.validation will be removed in v0.9.0, it has been "
+    "replaced by functionality that splits validation and conversion.",
+    category=FutureWarning,
+)
 def check_y(y, enforce_min_cases=1, coerce_to_numpy=False):
     """Validate input data.
 
@@ -146,6 +161,12 @@ def check_y(y, enforce_min_cases=1, coerce_to_numpy=False):
     return y
 
 
+@deprecated(
+    version="0.8.0",
+    reason="check_X_y in utils.validation will be removed in v0.9.0, it has been "
+    "replaced by functionality that splits validation and conversion.",
+    category=FutureWarning,
+)
 def check_X_y(
     X,
     y,
diff --git a/aeon/utils/validation/series.py b/aeon/utils/validation/series.py
index f47e1edb..45e7d293 100644
--- a/aeon/utils/validation/series.py
+++ b/aeon/utils/validation/series.py
@@ -1,6 +1,5 @@
 """Functions for checking input data."""
 
-__maintainer__ = []
 __all__ = [
     "check_series",
     "check_time_index",
@@ -9,6 +8,7 @@ __all__ = [
     "is_hierarchical",
     "is_single_series",
 ]
+__maintainer__ = ["TonyBagnall"]
 
 from typing import Union
 
@@ -45,6 +45,8 @@ def is_single_series(y):
     if isinstance(y, pd.DataFrame):
         if "object" in y.dtypes.values:
             return False
+        if y.index.nlevels > 1:
+            return False
         return True
     if isinstance(y, np.ndarray):
         if y.ndim > 2:
@@ -512,7 +514,7 @@ def is_pdmultiindex_hierarchical(y):
         True if y is pd multindex hierarchical.
 
     """
-    if not isinstance(y, pd.DataFrame) and not isinstance(y.index, pd.MultiIndex):
+    if not isinstance(y, pd.DataFrame) or not isinstance(y.index, pd.MultiIndex):
         return False
     if not y.columns.is_unique:
         return False
diff --git a/examples/classification/shapelet_based.ipynb b/examples/classification/shapelet_based.ipynb
index 250db6a0..63907e21 100644
--- a/examples/classification/shapelet_based.ipynb
+++ b/examples/classification/shapelet_based.ipynb
@@ -15,13 +15,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "outputs": [
     {
      "data": {
-      "text/plain": "[('ShapeletTransformClassifier',\n  aeon.classification.shapelet_based._stc.ShapeletTransformClassifier)]"
+      "text/plain": "[('MrSQMClassifier',\n  aeon.classification.shapelet_based._mrsqm.MrSQMClassifier),\n ('RDSTClassifier', aeon.classification.shapelet_based._rdst.RDSTClassifier),\n ('ShapeletTransformClassifier',\n  aeon.classification.shapelet_based._stc.ShapeletTransformClassifier)]"
      },
-     "execution_count": 2,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -56,8 +56,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
+   "execution_count": 2,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Shape of transformed data =  (40, 8)\n",
+      " Distance of second series to third shapelet =  1.302772121165026\n",
+      " Shapelets + random forest acc =  0.95\n"
+     ]
+    }
+   ],
    "source": [
     "X, y = load_basic_motions(split=\"train\")\n",
     "rst = RandomShapeletTransform(n_shapelet_samples=100, max_shapelets=10, random_state=42)\n",
@@ -87,25 +97,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 3,
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Quality =  0.8112781244589999\n",
-      "Length =  38\n",
-      "position =  8\n",
+      "Quality =  0.81127812\n",
+      "Length =  39\n",
+      "position =  55\n",
       "Channel =  0\n",
-      "Origin Instance Index =  13\n",
+      "Origin Instance Index =  11\n",
       "Class label =  running\n",
-      "Shapelet =  [ 0.80928584  1.26598641  1.26598641  0.50311921  0.63023046  0.63023046\n",
-      "  0.11160244 -1.38265413 -2.42561733 -0.63775503  0.51153018  0.51153018\n",
-      "  0.49074957  0.9142872   0.62033438  0.119901   -1.85423662 -2.14976266\n",
-      " -0.0038555   0.91317676  0.10631423  0.28619945  0.21756569  0.40019312\n",
-      " -0.00474682 -1.59844468 -1.59844468 -0.25564779  1.08972374  0.66380345\n",
-      "  0.71833283  0.7425672   0.3354944   0.14130263 -1.59331817 -1.59331817\n",
-      "  0.54917717  0.54917717]\n"
+      "Shapelet =  [-0.85667017 -1.88711152 -0.8751295   0.80633757  1.10838333  0.69810992\n",
+      "  0.85713394  1.23190921  0.01801365 -1.29683966 -1.94694259 -0.37487726\n",
+      " -0.37487726  1.39471462  0.74922685  0.74922685  0.22343376  0.22343376\n",
+      " -0.7730703  -1.37591995 -0.80376393  1.32758071  0.99778845  0.6013481\n",
+      "  0.83711118  0.93684593  0.93684593 -1.30429475 -1.64522057 -0.56312308\n",
+      "  0.96855713  0.56796251  0.35714242  0.62066541  0.65135287 -0.80531237\n",
+      " -1.49170075 -1.18512797  0.69685753]\n"
      ]
     }
    ],
@@ -134,29 +144,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 4,
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " walking shapelet from channel  (0.616271397965, 12, 24, 0, 32, 'badminton', array([-0.64704846, -0.6359159 , -0.6027561 , -0.60881816, -0.58686402,\n",
-      "       -0.51156492, -0.44793226, -0.04608355,  0.71941478,  2.12366136,\n",
-      "        2.00632024, -0.76241302]))\n"
+      " Badminton shapelet from channel 0 (x-dimension) (0.65194393, 74, 7, 1, 1, 'standing', array([-5.27667376, -0.94911454,  0.90433173,  1.26316864,  2.34760078,\n",
+      "        1.84408   ,  0.9192852 ,  0.9192852 , -1.29868372, -1.29868372,\n",
+      "       -1.5476774 , -1.03000413,  0.27593674, -0.70184658,  0.37460295,\n",
+      "        1.27398121,  1.02881837,  0.64543662, -0.0669839 , -0.54373096,\n",
+      "       -0.55716134, -0.56605101, -0.08611633,  0.31270572,  0.25642625,\n",
+      "        0.5512744 ,  0.78929504,  0.73385326,  0.73385326, -0.26777726,\n",
+      "       -0.63967737, -0.63967737, -0.5539071 , -0.5539071 ,  0.3867047 ,\n",
+      "        0.3867047 ,  0.88832979,  0.85074214,  0.46901267,  0.0925433 ,\n",
+      "       -0.34444436, -0.72498936, -0.83763127, -0.53034818, -0.05869122,\n",
+      "        0.46600593,  1.02537238,  0.81800526,  0.51709059,  0.17497366,\n",
+      "       -0.31072836, -0.64876695, -0.89102368, -0.60834799, -0.0627886 ,\n",
+      "        0.42532723,  0.95696668,  0.91077086,  0.77491818,  0.14283377,\n",
+      "        0.14283377, -1.08722874, -1.08722874, -0.65706914, -0.65706914,\n",
+      "        0.28210933,  0.74159654,  0.8064869 ,  0.8064869 ,  0.19889294,\n",
+      "       -0.16601048, -0.78706337, -0.76364317, -0.63789726]))\n"
      ]
     },
     {
      "data": {
-      "text/plain": "<matplotlib.legend.Legend at 0x248962784f0>"
+      "text/plain": "<matplotlib.legend.Legend at 0x2ce6adcd2e0>"
      },
-     "execution_count": 47,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "text/plain": "<Figure size 640x480 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -198,22 +220,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 5,
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "('MrSQMClassifier', <class 'aeon.classification.shapelet_based._mrsqm.MrSQMClassifier'>)\n",
-      "('RDSTClassifier', <class 'aeon.classification.shapelet_based._rdst.RDSTClassifier'>)\n",
-      "('ShapeletTransformClassifier', <class 'aeon.classification.shapelet_based._stc.ShapeletTransformClassifier'>)\n"
+      "MrSQMClassifier\n",
+      "RDSTClassifier\n",
+      "ShapeletTransformClassifier\n"
      ]
     }
    ],
    "source": [
     "from aeon.registry import all_estimators\n",
     "\n",
-    "est = all_estimators(\"classifier\", filter_tags={\"algorithm_type\": \"shapelet\"})\n",
+    "est = [\"MrSQMClassifier\", \"RDSTClassifier\", \"ShapeletTransformClassifier\"]\n",
     "for c in est:\n",
     "    print(c)"
    ],
@@ -223,13 +245,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "outputs": [
     {
      "data": {
       "text/plain": "(112, 3)"
      },
-     "execution_count": 2,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -238,7 +260,7 @@
     "from aeon.benchmarking import get_estimator_results_as_array\n",
     "from aeon.datasets.tsc_data_lists import univariate\n",
     "\n",
-    "names = [t[0].replace(\"Classifier\", \"\") for t in est]\n",
+    "names = [t.replace(\"Classifier\", \"\") for t in est]\n",
     "results, present_names = get_estimator_results_as_array(\n",
     "    names, univariate, include_missing=False\n",
     ")\n",
@@ -250,13 +272,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 7,
    "outputs": [
     {
      "data": {
       "text/plain": "(<Figure size 600x220 with 1 Axes>, <Axes: >)"
      },
-     "execution_count": 3,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -280,13 +302,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "outputs": [
     {
      "data": {
       "text/plain": "(<Figure size 1000x600 with 1 Axes>, <Axes: >)"
      },
-     "execution_count": 4,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -311,6 +333,30 @@
    "execution_count": null,
    "outputs": [],
    "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "is_executing": true
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "is_executing": true
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [],
+   "source": [],
    "metadata": {
     "collapsed": false
    }
diff --git a/examples/forecasting/forecasting.ipynb b/examples/forecasting/forecasting.ipynb
index 34e39766..4d186b23 100644
--- a/examples/forecasting/forecasting.ipynb
+++ b/examples/forecasting/forecasting.ipynb
@@ -2725,10 +2725,10 @@
      "evalue": "name 'load_airline' is not defined",
      "output_type": "error",
      "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[1], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# step 1: splitting historical data\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mload_airline\u001b[49m()\n\u001b[0;32m      3\u001b[0m y_train, y_test \u001b[38;5;241m=\u001b[39m temporal_train_test_split(y, test_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m36\u001b[39m)\n\u001b[0;32m      5\u001b[0m \u001b[38;5;66;03m# step 2: running the basic forecasting workflow\u001b[39;00m\n",
-      "\u001b[1;31mNameError\u001b[0m: name 'load_airline' is not defined"
+      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[1;31mNameError\u001B[0m                                 Traceback (most recent call last)",
+      "Cell \u001B[1;32mIn[1], line 2\u001B[0m\n\u001B[0;32m      1\u001B[0m \u001B[38;5;66;03m# step 1: splitting historical data\u001B[39;00m\n\u001B[1;32m----> 2\u001B[0m y \u001B[38;5;241m=\u001B[39m \u001B[43mload_airline\u001B[49m()\n\u001B[0;32m      3\u001B[0m y_train, y_test \u001B[38;5;241m=\u001B[39m temporal_train_test_split(y, test_size\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m36\u001B[39m)\n\u001B[0;32m      5\u001B[0m \u001B[38;5;66;03m# step 2: running the basic forecasting workflow\u001B[39;00m\n",
+      "\u001B[1;31mNameError\u001B[0m: name 'load_airline' is not defined"
      ]
     }
    ],


Test patch:
diff --git a/aeon/testing/utils/data_gen/_test_examples.py b/aeon/testing/utils/data_gen/_test_examples.py
index ed04ee33..4f53ecc0 100644
--- a/aeon/testing/utils/data_gen/_test_examples.py
+++ b/aeon/testing/utils/data_gen/_test_examples.py
@@ -69,9 +69,28 @@ mih2 = pd.concat(mih2list)
 mih2 = mih2.set_index(["foo", "bar", "timepoints"])
 mih_examples = [mih1, mih2]
 
+np1 = np.array([1, 2, 3, 4, 5])
+np2 = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
+np_examples = [np1, np2]
+
+
+def get_hierarchical_examples():
+    """Get hierarchical for tests."""
+    return mih_examples
+
+
+def get_series_examples():
+    """Get single series examples."""
+    return [series_examples, dataframe_examples]
+
+
+def get_collection_examples():
+    """Get example collections."""
+    return [mih1]
+
 
 def get_examples(datatype: str):
-    """Create two examples of each possible pandas type."""
+    """Create two examples of each possible type."""
     if datatype == "pd.Series":
         return series_examples
     elif datatype == "pd.DataFrame":
@@ -80,5 +99,7 @@ def get_examples(datatype: str):
         return multiindex_examples
     elif datatype == "pd_multiindex_hier":
         return mih_examples
+    elif datatype == "np.ndarray":
+        return np_examples
     else:
         raise ValueError(f"Unknown datatype : {datatype} in get examples.")
diff --git a/aeon/transformations/tests/test_base.py b/aeon/transformations/tests/test_base.py
index 8aebd5c6..cc0f3fe2 100644
--- a/aeon/transformations/tests/test_base.py
+++ b/aeon/transformations/tests/test_base.py
@@ -3,6 +3,7 @@
 Each test covers a "decision path" in the base class boilerplate,
     with a focus on frequently breaking paths in base class refactor and bugfixing.
 The path taken depends on tags of a given transformer, and input data type.
+Concrete transformer classes from aeon are imported to cover
 Concrete transformer classes from aeon are imported to cover
     different combinations of transformer tags.
 Transformer scenarios cover different combinations of input data types.
@@ -388,7 +389,7 @@ class _DummyFour(BaseTransformer):
     }
 
     def _transform(self, X, y=None):
-        return np.array([0])
+        return np.array([0.0])
 
 
 def test_series_in_primitives_out_supported_fit_in_transform():
@@ -411,9 +412,9 @@ def test_series_in_primitives_out_supported_fit_in_transform():
     assert est.get_tag("output_data_type") == "Primitives"
     scenario = TransformerFitTransformSeriesUnivariate()
     Xt = scenario.run(est, method_sequence=["fit", "transform"])
-    assert is_tabular(Xt), "fit.transform does not return a Table when given a Series"
     # length of Xt should be one, for a single series passed
     assert len(Xt) == 1
+    assert is_tabular(Xt), "fit.transform does not return a Table when given a Series"
 
 
 def test_panel_in_primitives_out_not_supported_fit_in_transform():
@@ -479,7 +480,7 @@ class _DummyFive(BaseTransformer):
     }
 
     def _transform(self, X, y=None):
-        return np.array([0])
+        return np.array([0.0])
 
 
 def test_series_in_primitives_out_not_supported_fit_in_transform():
@@ -613,8 +614,8 @@ def test_numpy_format_outputs():
     bc = BoxCoxTransformer()
 
     u1d = bc.fit_transform(X[0][0])
-    # 2d numpy arrays are (length, channels) while 3d numpy arrays are
-    # (cases, channels, length)
+    # 2d numpy arrays are (n_timepoints, n_channels) while 3d numpy arrays are
+    # (n_cases, n_channels, n_timepoints)
     u2d = bc.fit_transform(X[0].transpose()).transpose()
     u3d = bc.fit_transform(X)
 
diff --git a/aeon/utils/validation/tests/test_collection.py b/aeon/utils/validation/tests/test_collection.py
index 0e873475..166d6f03 100644
--- a/aeon/utils/validation/tests/test_collection.py
+++ b/aeon/utils/validation/tests/test_collection.py
@@ -1,5 +1,6 @@
 """Test check collection functionality."""
 
+import numpy as np
 import pandas as pd
 import pytest
 
@@ -9,7 +10,10 @@ from aeon.utils import COLLECTIONS_DATA_TYPES
 from aeon.utils.validation.collection import (
     _is_pd_wide,
     _nested_univ_is_equal,
+    get_type,
+    has_missing,
     is_nested_univ_dataframe,
+    is_tabular,
 )
 
 
@@ -46,3 +50,44 @@ def test_is_pd_wide(data):
         assert _is_pd_wide(EQUAL_LENGTH_UNIVARIATE[data])
     else:
         assert not _is_pd_wide(EQUAL_LENGTH_UNIVARIATE[data])
+
+
+def test_is_tabular():
+    """Test is_tabular function."""
+    d1 = np.random.random(size=(10, 10))
+    assert is_tabular(d1)
+    assert is_tabular(pd.DataFrame(d1))
+    assert not is_tabular(np.random.random(size=(10, 10, 10)))
+    assert not is_tabular(np.random.random(size=(10)))
+
+
+def test_get_type():
+    """Test get_type function."""
+    np_list = [np.array([1, 2, 3, 4, 5]), np.array([4, 5, 6, 7, 8])]
+    with pytest.raises(TypeError, match="np-list must contain 2D np.ndarray"):
+        get_type(np_list)
+    dp_list = [pd.DataFrame(np.random.random(size=(10, 10))), np.array([1, 2, 3, 4, 5])]
+    with pytest.raises(TypeError, match="df-list must only contain pd.DataFrame"):
+        get_type(dp_list)
+    res = get_type(pd.DataFrame(np.random.random(size=(10, 10))))
+    assert res == "pd-wide"
+    data = {
+        "Double_Column": [1.5, 2.3, 3.6, 4.8, 5.2],
+        "String_Column": ["Apple", "Banana", "Cherry", "Date", "Elderberry"],
+    }
+    df = pd.DataFrame(data)
+    with pytest.raises(TypeError, match="contains non float values"):
+        get_type(df)
+
+
+def test_has_missing():
+    """Test has_missing function."""
+    d1 = np.random.random(size=(10, 10))
+    assert not has_missing(d1)
+    d1[0, 0] = np.nan
+    assert has_missing(d1)
+    d2 = np.random.random(size=(10, 10))
+    l1 = [d1, d1]
+    assert has_missing(l1)
+    l2 = [pd.DataFrame(d1), pd.DataFrame(d2)]
+    assert has_missing(l2)
diff --git a/aeon/utils/validation/tests/test_forecasting.py b/aeon/utils/validation/tests/test_forecasting.py
index d0555546..e2c485e0 100644
--- a/aeon/utils/validation/tests/test_forecasting.py
+++ b/aeon/utils/validation/tests/test_forecasting.py
@@ -12,6 +12,7 @@ from pytest import raises
 from aeon.forecasting.base import ForecastingHorizon
 from aeon.forecasting.model_selection._split import BaseSplitter
 from aeon.utils.validation.forecasting import (
+    _check_valid_prediction_intervals,
     check_cv,
     check_fh,
     check_sp,
@@ -80,3 +81,55 @@ def test_check_functions():
         check_sp("FOO")
     with raises(ValueError, match="`sp` must be an int"):
         check_sp("BAR", enforce_list=True)
+
+
+def test_check_valid_prediction_intervals():
+    """Test _check_valid_prediction_intervals."""
+    # DataFrame that meets all criteria
+    idx = pd.date_range("20200101", periods=3)
+    cols = pd.MultiIndex.from_tuples(
+        [(1, 0.9, "upper"), (1, 0.9, "lower"), (2, 0.8, "upper"), (2, 0.8, "lower")],
+        names=["model", "coverage", "interval"],
+    )
+    valid_df = pd.DataFrame(np.random.rand(3, 4), index=idx, columns=cols)
+
+    # Not a DataFrame
+    not_a_df = [1, 2, 3]
+
+    # DataFrame with non-unique columns
+    non_unique_cols = valid_df.copy()
+    non_unique_cols.columns = ["A", "A", "B", "B"]
+
+    # DataFrame with non-numeric columns
+    non_numeric_cols = valid_df.copy()
+    non_numeric_cols["text"] = ["one", "two", "three"]
+
+    # DataFrame with non-monotonic index
+    non_monotonic_index = valid_df.iloc[::-1]
+
+    # DataFrame with incorrect MultiIndex levels
+    incorrect_levels = valid_df.copy()
+    incorrect_levels.columns = pd.MultiIndex.from_tuples(
+        [(1, "0.9"), (1, "0.9"), (2, "0.8"), (2, "0.8")]
+    )
+
+    # DataFrame with incorrect coverage values
+    incorrect_coverage = valid_df.copy()
+    incorrect_coverage.columns = pd.MultiIndex.from_tuples(
+        [(1, 1.1, "upper"), (1, -0.1, "lower"), (2, 0.8, "upper"), (2, 0.8, "lower")]
+    )
+
+    # DataFrame with incorrect interval values
+    incorrect_interval = valid_df.copy()
+    incorrect_interval.columns = pd.MultiIndex.from_tuples(
+        [(1, 0.9, "up"), (1, 0.9, "down"), (2, 0.8, "upper"), (2, 0.8, "lower")]
+    )
+
+    assert _check_valid_prediction_intervals(valid_df)
+    assert not _check_valid_prediction_intervals(not_a_df)
+    assert not _check_valid_prediction_intervals(non_unique_cols)
+    assert not _check_valid_prediction_intervals(non_numeric_cols)
+    assert not _check_valid_prediction_intervals(non_monotonic_index)
+    assert not _check_valid_prediction_intervals(incorrect_levels)
+    assert not _check_valid_prediction_intervals(incorrect_coverage)
+    assert not _check_valid_prediction_intervals(incorrect_interval)
diff --git a/aeon/utils/validation/tests/test_input.py b/aeon/utils/validation/tests/test_input.py
new file mode 100644
index 00000000..e1e7f9f1
--- /dev/null
+++ b/aeon/utils/validation/tests/test_input.py
@@ -0,0 +1,75 @@
+"""Test functions for input validation."""
+
+import pytest
+
+from aeon.testing.utils.data_gen import get_examples
+from aeon.testing.utils.data_gen._collection import EQUAL_LENGTH_UNIVARIATE
+from aeon.utils.validation._input import is_hierarchical, is_valid_input, validate_input
+from aeon.utils.validation.collection import is_collection
+from aeon.utils.validation.series import is_single_series
+
+# Tests limited to these input, some  collection types are ambiguous
+COLLECTIONS = ["numpy3D", "nested_univ", "pd-multiindex"]
+SERIES = ["pd.Series", "pd.DataFrame", "np.ndarray"]
+HIERARCHICAL = ["pd_multiindex_hier"]
+PANDAS_TYPES = ["pd.Series", "pd.DataFrame", "pd-multiindex", "pd_multiindex_hier"]
+
+
+@pytest.mark.parametrize("data", COLLECTIONS)
+def test_input_collections(data):
+    """Test is_collection with correct input."""
+    assert is_collection(EQUAL_LENGTH_UNIVARIATE[data])
+    assert not is_single_series(EQUAL_LENGTH_UNIVARIATE[data])
+    assert not is_hierarchical(EQUAL_LENGTH_UNIVARIATE[data])
+
+
+@pytest.mark.parametrize("data_type", HIERARCHICAL)
+def test_input_hierarchy(data_type):
+    """Test validation checks for hierarchical input."""
+    data = get_examples(data_type)
+    for d in data:
+        assert not is_collection(d)
+        assert not is_single_series(d)
+        assert is_hierarchical(d)
+        b, m = validate_input(d)
+        assert b
+        assert m["scitype"] == "Hierarchical"
+        assert m["mtype"] == data_type
+        b, m = validate_input("A string")
+        assert not b
+        assert m is None
+
+
+@pytest.mark.parametrize("data_type", SERIES)
+def test_input_series(data_type):
+    """Test  validation checks for single series."""
+    data = get_examples(data_type)
+    for d in data:
+        assert not is_collection(d)
+        assert is_single_series(d)
+        assert not is_hierarchical(d)
+        b, m = validate_input(d)
+        assert b
+        assert m["scitype"] == "Series"
+        assert m["mtype"] == data_type
+
+
+@pytest.mark.parametrize("data_type", COLLECTIONS)
+def test_input_collection(data_type):
+    """Test is_collection with correct input."""
+    d = EQUAL_LENGTH_UNIVARIATE[data_type]
+    assert is_collection(d)
+    assert not is_single_series(d)
+    assert not is_hierarchical(d)
+    b, m = validate_input(d)
+    assert b
+    assert m["scitype"] == "Panel"
+    assert m["mtype"] == data_type
+
+
+@pytest.mark.parametrize("panda_type", PANDAS_TYPES)
+def test_pandas_valid_input(panda_type):
+    """Test is_valid_input."""
+    res = get_examples(panda_type)
+    for r in res:
+        assert is_valid_input(r)
diff --git a/aeon/utils/validation/tests/test_series.py b/aeon/utils/validation/tests/test_series.py
index e5366f1c..2bf97a8d 100644
--- a/aeon/utils/validation/tests/test_series.py
+++ b/aeon/utils/validation/tests/test_series.py
@@ -9,11 +9,17 @@ import pytest
 from aeon.testing.utils.data_gen import make_example_nested_dataframe
 from aeon.utils.validation.series import (
     _check_is_multivariate,
+    _check_pd_dataframe,
+    _common_checks,
     check_consistent_index_type,
     check_equal_time_index,
     check_is_univariate,
     check_series,
     check_time_index,
+    get_index_for_series,
+    is_pdmultiindex_hierarchical,
+    is_pred_interval_proba,
+    is_pred_quantiles_proba,
     is_univariate_series,
 )
 
@@ -113,3 +119,80 @@ def test_check_consistent_index_type():
     # An exception should be raised because index types are inconsistent
     with pytest.raises(TypeError):
         check_consistent_index_type(index1, index2)
+
+
+def test_df_checks():
+    """Test check_pd_dataframe function."""
+    data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    df = pd.DataFrame(data)
+    n1 = np.random.random(size=(10, 10))
+    _check_pd_dataframe(df)
+    assert _common_checks(df)
+    assert not _common_checks(n1)
+    assert not is_pred_interval_proba(n1)
+    assert not is_pred_quantiles_proba(n1)
+    assert not is_pdmultiindex_hierarchical(n1)
+    assert isinstance(get_index_for_series(n1), pd.RangeIndex)
+    assert isinstance(get_index_for_series(df), pd.RangeIndex)
+
+    columns = ["A", "B", "B"]  # Notice the duplicate column name 'B'
+    df = pd.DataFrame(data, columns=columns)
+    assert not _common_checks(df)
+    with pytest.raises(ValueError, match="must have unique column indices"):
+        _check_pd_dataframe(df)
+
+    index_strings = ["a", "b", "c"]
+    # Creating the DataFrame
+    df = pd.DataFrame(data, index=index_strings)
+    with pytest.raises(ValueError, match="is not supported for series"):
+        _check_pd_dataframe(df)
+    data = {
+        "Column1": [1, 2, {"a": 1, "b": 2}],
+        # The third entry is a dictionary, which is an object
+        "Column2": ["A", "B", "C"],
+    }
+    # Creating the DataFrame
+    df = pd.DataFrame(data)
+    with pytest.raises(ValueError, match="should not have column of 'object' dtype"):
+        _check_pd_dataframe(df)
+    assert not _common_checks(df)
+    index_non_monotonic = [1, 3, 2, 5, 4]  # This index is not monotonic increasing
+    data = {"Column1": [10, 20, 30, 40, 50], "Column2": ["A", "B", "C", "D", "E"]}
+
+    # Creating the DataFrame
+    df = pd.DataFrame(data, index=index_non_monotonic)
+    assert not _common_checks(df)
+
+
+def test_is_pred_interval_proba():
+    """Test is pred interval proba."""
+    # Create a correct MultiIndex DataFrame
+    idx = pd.MultiIndex.from_tuples(
+        [(1, 0.9, "upper"), (1, 0.9, "lower")], names=["level_0", "coverage", "bound"]
+    )
+    df_correct = pd.DataFrame([[0.1, 0.2]], columns=idx)
+
+    # Create a DataFrame with incorrect MultiIndex levels
+    idx_wrong_levels = pd.MultiIndex.from_tuples(
+        [(1, "upper"), (1, "lower")], names=["level_0", "bound"]
+    )
+    df_wrong_levels = pd.DataFrame([[0.1, 0.2]], columns=idx_wrong_levels)
+
+    # Create a DataFrame with incorrect data type in coverage level
+    idx_wrong_dtype = pd.MultiIndex.from_tuples(
+        [(1, "0.9", "upper"), (1, "0.9", "lower")],
+        names=["level_0", "coverage", "bound"],
+    )
+    df_wrong_dtype = pd.DataFrame([[0.1, 0.2]], columns=idx_wrong_dtype)
+
+    # Create a DataFrame with incorrect coverage values
+    idx_wrong_values = pd.MultiIndex.from_tuples(
+        [(1, 1.5, "upper"), (1, -0.1, "lower")], names=["level_0", "coverage", "bound"]
+    )
+    df_wrong_values = pd.DataFrame([[0.1, 0.2]], columns=idx_wrong_values)
+
+    # Assertions
+    assert is_pred_interval_proba(df_correct)
+    assert not is_pred_interval_proba(df_wrong_levels)
+    assert not is_pred_interval_proba(df_wrong_dtype)
+    assert not is_pred_interval_proba(df_wrong_values)