Repository: aeon-toolkit/aeon
Pull request #2223 (2024-10-18 08:24:54)

[DOC] Add BORF to papers_using_aeon.md
#### Reference Issues/PRs

Adding BORF (Bag-Of-Receptive-Fields) reference in `papers_using_aeon.md`. See also #2062 

##### For all contributions
- [x] I've added myself to the [list of contributors](https://github.com/aeon-toolkit/aeon/blob/main/.all-contributorsrc). Alternatively, you can use the [@all-contributors](https://allcontributors.org/docs/en/bot/usage) bot to do this for you.
- [x] The PR title starts with either [ENH], [MNT], [DOC], [BUG], [REF], [DEP] or [GOV] indicating whether the PR topic is related to enhancement, maintenance, documentation, bugs, refactoring, deprecation or governance.


aeon-actions-bot[bot]: 
## Thank you for contributing to `aeon`

I have added the following labels to this PR based on the title: **[ $\\color{#F3B9F8}{\\textsf{documentation}}$ ]**.


The [Checks](https://github.com/aeon-toolkit/aeon/pull/2223/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.

### PR CI actions

These checkboxes will add labels to enable/disable CI functionality for this PR. This may not take effect immediately, and a new commit may be required to run the new configuration.

- [ ] Run `pre-commit` checks for all files
- [ ] Run `mypy` typecheck tests
- [ ] Run all `pytest` tests and configurations
- [ ] Run all notebook example tests
- [ ] Run numba-disabled `codecov` tests
- [ ] Stop automatic `pre-commit` fixes (always disabled for drafts)
- [ ] Disable numba cache loading
- [ ] Push an empty commit to re-run CI checks
    

Patch:
diff --git a/aeon/anomaly_detection/__init__.py b/aeon/anomaly_detection/__init__.py
index 294d18b1..f189b7a8 100644
--- a/aeon/anomaly_detection/__init__.py
+++ b/aeon/anomaly_detection/__init__.py
@@ -9,8 +9,10 @@ __all__ = [
     "STOMP",
     "LeftSTAMPi",
     "IsolationForest",
+    "COPOD",
 ]
 
+from aeon.anomaly_detection._copod import COPOD
 from aeon.anomaly_detection._dwt_mlead import DWT_MLEAD
 from aeon.anomaly_detection._iforest import IsolationForest
 from aeon.anomaly_detection._kmeans import KMeansAD
diff --git a/aeon/anomaly_detection/_copod.py b/aeon/anomaly_detection/_copod.py
new file mode 100644
index 00000000..d1fc88dc
--- /dev/null
+++ b/aeon/anomaly_detection/_copod.py
@@ -0,0 +1,87 @@
+"""COPOD for anomaly detection."""
+
+__maintainer__ = []
+__all__ = ["COPOD"]
+
+from typing import Union
+
+import numpy as np
+
+from aeon.anomaly_detection._pyodadapter import PyODAdapter
+from aeon.utils.validation._dependencies import _check_soft_dependencies
+
+
+class COPOD(PyODAdapter):
+    """COPOD for anomaly detection.
+
+    This class implements the COPOD using PyODAdadpter to be used in the aeon framework.
+    The parameter `n_jobs` is passed to COPOD model from PyOD, `window_size` and
+    `stride` are used to construct the sliding windows.
+
+    .. list-table:: Capabilities
+       :stub-columns: 1
+       * - Input data format
+         - univariate and multivariate
+       * - Output data format
+         - anomaly scores
+       * - Learning Type
+         - unsupervised or semi-supervised
+
+    Parameters
+    ----------
+    n_jobs : int, default=1
+        The number of jobs to run in parallel for the COPOD model.
+
+    window_size : int, default=10
+        Size of the sliding window.
+
+    stride : int, default=1
+        Stride of the sliding window.
+    """
+
+    _tags = {
+        "capability:multivariate": True,
+        "capability:univariate": True,
+        "capability:missing_values": False,
+        "fit_is_empty": False,
+        "python_dependencies": ["pyod"],
+    }
+
+    def __init__(self, n_jobs: int = 1, window_size: int = 10, stride: int = 1):
+        _check_soft_dependencies(*self._tags["python_dependencies"])
+        from pyod.models.copod import COPOD
+
+        model = COPOD(n_jobs=n_jobs)
+        self.n_jobs = n_jobs
+        super().__init__(model, window_size=window_size, stride=stride)
+
+    def _fit(self, X: np.ndarray, y: Union[np.ndarray, None] = None) -> None:
+        super()._fit(X, y)
+
+    def _predict(self, X: np.ndarray) -> np.ndarray:
+        return super()._predict(X)
+
+    def _fit_predict(
+        self, X: np.ndarray, y: Union[np.ndarray, None] = None
+    ) -> np.ndarray:
+        return super()._fit_predict(X, y)
+
+    @classmethod
+    def get_test_params(cls, parameter_set="default") -> dict:
+        """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 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 {}
diff --git a/aeon/anomaly_detection/_dwt_mlead.py b/aeon/anomaly_detection/_dwt_mlead.py
index 73772ace..2d9a036b 100644
--- a/aeon/anomaly_detection/_dwt_mlead.py
+++ b/aeon/anomaly_detection/_dwt_mlead.py
@@ -236,7 +236,7 @@ class DWT_MLEAD(BaseAnomalyDetector):
         return counter[:n]
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Only supports 'default'-parameter set.
@@ -253,7 +253,6 @@ class DWT_MLEAD(BaseAnomalyDetector):
             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 {
             "start_level": 2,
diff --git a/aeon/anomaly_detection/_iforest.py b/aeon/anomaly_detection/_iforest.py
index 54469c02..c0980309 100644
--- a/aeon/anomaly_detection/_iforest.py
+++ b/aeon/anomaly_detection/_iforest.py
@@ -137,7 +137,7 @@ class IsolationForest(PyODAdapter):
         return super()._fit_predict(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -152,7 +152,6 @@ class IsolationForest(PyODAdapter):
             Parameters to create testing instances of the class.
             Each dict are parameters to construct an "interesting" test instance, i.e.,
             `IsolationForest(**params)` creates a valid test instance.
-            `create_test_instance` uses the first (or only) dictionary in `params`.
         """
         return {
             "n_estimators": 10,
diff --git a/aeon/anomaly_detection/_kmeans.py b/aeon/anomaly_detection/_kmeans.py
index 403aee5f..07b98ebe 100644
--- a/aeon/anomaly_detection/_kmeans.py
+++ b/aeon/anomaly_detection/_kmeans.py
@@ -171,7 +171,7 @@ class KMeansAD(BaseAnomalyDetector):
         return point_anomaly_scores
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -186,7 +186,6 @@ class KMeansAD(BaseAnomalyDetector):
             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 {
             "n_clusters": 5,
diff --git a/aeon/anomaly_detection/_merlin.py b/aeon/anomaly_detection/_merlin.py
index e86020d0..36474553 100644
--- a/aeon/anomaly_detection/_merlin.py
+++ b/aeon/anomaly_detection/_merlin.py
@@ -208,7 +208,7 @@ class MERLIN(BaseAnomalyDetector):
         return C[d_max], np.sqrt(D[d_max])
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -223,6 +223,5 @@ class MERLIN(BaseAnomalyDetector):
             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 {"min_length": 4, "max_length": 7}
diff --git a/aeon/anomaly_detection/_pyodadapter.py b/aeon/anomaly_detection/_pyodadapter.py
index e492d718..637e9340 100644
--- a/aeon/anomaly_detection/_pyodadapter.py
+++ b/aeon/anomaly_detection/_pyodadapter.py
@@ -158,7 +158,7 @@ class PyODAdapter(BaseAnomalyDetector):
         return point_anomaly_scores
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -173,7 +173,6 @@ class PyODAdapter(BaseAnomalyDetector):
             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`.
         """
         _check_soft_dependencies(*cls._tags["python_dependencies"])
 
diff --git a/aeon/anomaly_detection/_stomp.py b/aeon/anomaly_detection/_stomp.py
index d6f988a5..93d89c44 100644
--- a/aeon/anomaly_detection/_stomp.py
+++ b/aeon/anomaly_detection/_stomp.py
@@ -118,7 +118,7 @@ class STOMP(BaseAnomalyDetector):
             )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -133,7 +133,6 @@ class STOMP(BaseAnomalyDetector):
             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 {
             "window_size": 10,
diff --git a/aeon/base/_base.py b/aeon/base/_base.py
index 402cd9ea..5fef2c05 100644
--- a/aeon/base/_base.py
+++ b/aeon/base/_base.py
@@ -20,13 +20,14 @@ class BaseAeonEstimator(BaseEstimator, ABC):
     Contains the following methods:
 
     reset estimator to post-init  - reset(keep)
-    clonee stimator (copy)        - clone(random_state)
+    clone stimator (copy)         - clone(random_state)
     inspect tags (class method)   - get_class_tags()
     inspect tags (one tag, class) - get_class_tag(tag_name, tag_value_default,
                                                                     raise_error)
     inspect tags (all)            - get_tags()
     inspect tags (one tag)        - get_tag(tag_name, tag_value_default, raise_error)
     setting dynamic tags          - set_tags(**tag_dict)
+    get fitted parameters         - get_fitted_params(deep)
 
     All estimators have the attribute:
 
@@ -349,7 +350,7 @@ class BaseAeonEstimator(BaseEstimator, ABC):
             )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """
         Return testing parameter settings for the estimator.
 
@@ -365,17 +366,16 @@ class BaseAeonEstimator(BaseEstimator, ABC):
             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`.
         """
         # default parameters = empty dict
         return {}
 
     @classmethod
-    def create_test_instance(cls, parameter_set="default", return_first=True):
+    def _create_test_instance(cls, parameter_set="default", return_first=True):
         """
         Construct Estimator instance if possible.
 
-        Calls the `get_test_params` method and returns an instance or list of instances
+        Calls the `_get_test_params` method and returns an instance or list of instances
         using the returned dict or list of dict.
 
         Parameters
@@ -393,7 +393,7 @@ class BaseAeonEstimator(BaseEstimator, ABC):
             Instance of the class with default parameters. If return_first
             is False, returns list of instances.
         """
-        params = cls.get_test_params(parameter_set=parameter_set)
+        params = cls._get_test_params(parameter_set=parameter_set)
 
         if isinstance(params, list):
             if return_first:
@@ -418,6 +418,19 @@ class BaseAeonEstimator(BaseEstimator, ABC):
             "aeon estimators do not have a _validate_data method."
         )
 
+    def get_metadata_routing(self):
+        """Sklearn metadata routing."""
+        raise NotImplementedError(
+            "aeon estimators do not have a get_metadata_routing method."
+        )
+
+    @classmethod
+    def _get_default_requests(cls):
+        """Sklearn metadata request defaults."""
+        from sklearn.utils._metadata_requests import MetadataRequest
+
+        return MetadataRequest(None)
+
 
 def _clone_estimator(base_estimator, random_state=None):
     """Clone an estimator."""
diff --git a/aeon/classification/compose/_channel_ensemble.py b/aeon/classification/compose/_channel_ensemble.py
index 1a967a75..e8a2f340 100644
--- a/aeon/classification/compose/_channel_ensemble.py
+++ b/aeon/classification/compose/_channel_ensemble.py
@@ -248,7 +248,7 @@ class ChannelEnsembleClassifier(_BaseChannelEnsembleClassifier):
         super().__init__(estimators, verbose=verbose)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -267,7 +267,6 @@ class ChannelEnsembleClassifier(_BaseChannelEnsembleClassifier):
             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`.
         """
         from aeon.classification.dictionary_based import ContractableBOSS
         from aeon.classification.interval_based import CanonicalIntervalForestClassifier
diff --git a/aeon/classification/compose/_ensemble.py b/aeon/classification/compose/_ensemble.py
index a8df5253..119f016d 100644
--- a/aeon/classification/compose/_ensemble.py
+++ b/aeon/classification/compose/_ensemble.py
@@ -160,7 +160,7 @@ class ClassifierEnsemble(BaseCollectionEnsemble, BaseClassifier):
             return clf
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -175,12 +175,11 @@ class ClassifierEnsemble(BaseCollectionEnsemble, BaseClassifier):
             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 {
             "classifiers": [
-                KNeighborsTimeSeriesClassifier.create_test_instance(),
-                DummyClassifier.create_test_instance(),
+                KNeighborsTimeSeriesClassifier._create_test_instance(),
+                DummyClassifier._create_test_instance(),
             ],
             "weights": [2, 1],
         }
@@ -408,7 +407,7 @@ class WeightedEnsembleClassifier(_HeterogenousMetaEstimator, BaseClassifier):
         return y_proba
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -423,23 +422,22 @@ class WeightedEnsembleClassifier(_HeterogenousMetaEstimator, BaseClassifier):
             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`.
         """
         from aeon.classification import DummyClassifier
         from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier
 
         params1 = {
             "classifiers": [
-                KNeighborsTimeSeriesClassifier.create_test_instance(),
-                DummyClassifier.create_test_instance(),
+                KNeighborsTimeSeriesClassifier._create_test_instance(),
+                DummyClassifier._create_test_instance(),
             ],
             "weights": [42, 1],
         }
 
         params2 = {
             "classifiers": [
-                KNeighborsTimeSeriesClassifier.create_test_instance(),
-                DummyClassifier.create_test_instance(),
+                KNeighborsTimeSeriesClassifier._create_test_instance(),
+                DummyClassifier._create_test_instance(),
             ],
             "weights": 2,
             "cv": 3,
diff --git a/aeon/classification/compose/_pipeline.py b/aeon/classification/compose/_pipeline.py
index 9b2ec98c..69b122fc 100644
--- a/aeon/classification/compose/_pipeline.py
+++ b/aeon/classification/compose/_pipeline.py
@@ -87,7 +87,7 @@ class ClassifierPipeline(BaseCollectionPipeline, BaseClassifier):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -102,7 +102,6 @@ class ClassifierPipeline(BaseCollectionPipeline, BaseClassifier):
             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`.
         """
         from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier
         from aeon.transformations.collection import Truncator
diff --git a/aeon/classification/convolution_based/_arsenal.py b/aeon/classification/convolution_based/_arsenal.py
index f55afc52..a24a57d9 100644
--- a/aeon/classification/convolution_based/_arsenal.py
+++ b/aeon/classification/convolution_based/_arsenal.py
@@ -395,7 +395,7 @@ class Arsenal(BaseClassifier):
         return results, weight, oob
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -417,7 +417,6 @@ class Arsenal(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"num_kernels": 20, "n_estimators": 5}
diff --git a/aeon/classification/convolution_based/_minirocket.py b/aeon/classification/convolution_based/_minirocket.py
index bb20bb39..dc3ef18a 100644
--- a/aeon/classification/convolution_based/_minirocket.py
+++ b/aeon/classification/convolution_based/_minirocket.py
@@ -194,7 +194,7 @@ class MiniRocketClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -213,7 +213,6 @@ class MiniRocketClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"num_kernels": 100}
diff --git a/aeon/classification/convolution_based/_multirocket.py b/aeon/classification/convolution_based/_multirocket.py
index 7ca894b9..a0c1767e 100644
--- a/aeon/classification/convolution_based/_multirocket.py
+++ b/aeon/classification/convolution_based/_multirocket.py
@@ -198,7 +198,7 @@ class MultiRocketClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -217,7 +217,6 @@ class MultiRocketClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"num_kernels": 100}
diff --git a/aeon/classification/convolution_based/_rocket.py b/aeon/classification/convolution_based/_rocket.py
index c8f82864..8509fde2 100644
--- a/aeon/classification/convolution_based/_rocket.py
+++ b/aeon/classification/convolution_based/_rocket.py
@@ -194,7 +194,7 @@ class RocketClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -213,7 +213,6 @@ class RocketClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"num_kernels": 100}
diff --git a/aeon/classification/deep_learning/_cnn.py b/aeon/classification/deep_learning/_cnn.py
index 771e58d0..5b87cab9 100644
--- a/aeon/classification/deep_learning/_cnn.py
+++ b/aeon/classification/deep_learning/_cnn.py
@@ -302,7 +302,7 @@ class TimeCNNClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -321,7 +321,6 @@ class TimeCNNClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/classification/deep_learning/_encoder.py b/aeon/classification/deep_learning/_encoder.py
index 2765c4cb..1773d1ea 100644
--- a/aeon/classification/deep_learning/_encoder.py
+++ b/aeon/classification/deep_learning/_encoder.py
@@ -285,7 +285,7 @@ class EncoderClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -304,7 +304,6 @@ class EncoderClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 8,
diff --git a/aeon/classification/deep_learning/_fcn.py b/aeon/classification/deep_learning/_fcn.py
index 5484f45b..e79ea652 100644
--- a/aeon/classification/deep_learning/_fcn.py
+++ b/aeon/classification/deep_learning/_fcn.py
@@ -306,7 +306,7 @@ class FCNClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -325,7 +325,6 @@ class FCNClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/classification/deep_learning/_inception_time.py b/aeon/classification/deep_learning/_inception_time.py
index 135ced4a..8afc1dde 100644
--- a/aeon/classification/deep_learning/_inception_time.py
+++ b/aeon/classification/deep_learning/_inception_time.py
@@ -342,7 +342,7 @@ class InceptionTimeClassifier(BaseClassifier):
         return probs
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -361,7 +361,6 @@ class InceptionTimeClassifier(BaseClassifier):
             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`.
         """
         param1 = {
             "n_classifiers": 1,
@@ -725,7 +724,7 @@ class IndividualInceptionClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -744,7 +743,6 @@ class IndividualInceptionClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/classification/deep_learning/_lite_time.py b/aeon/classification/deep_learning/_lite_time.py
index 43f58dfd..94e26ced 100644
--- a/aeon/classification/deep_learning/_lite_time.py
+++ b/aeon/classification/deep_learning/_lite_time.py
@@ -258,7 +258,7 @@ class LITETimeClassifier(BaseClassifier):
         return probs
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -277,7 +277,6 @@ class LITETimeClassifier(BaseClassifier):
             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`.
         """
         param1 = {
             "n_classifiers": 1,
@@ -568,7 +567,7 @@ class IndividualLITEClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -587,7 +586,6 @@ class IndividualLITEClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/classification/deep_learning/_mlp.py b/aeon/classification/deep_learning/_mlp.py
index 48eb8f71..0f0d538c 100644
--- a/aeon/classification/deep_learning/_mlp.py
+++ b/aeon/classification/deep_learning/_mlp.py
@@ -271,7 +271,7 @@ class MLPClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -290,7 +290,6 @@ class MLPClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/classification/deep_learning/_resnet.py b/aeon/classification/deep_learning/_resnet.py
index 963faec2..fe754548 100644
--- a/aeon/classification/deep_learning/_resnet.py
+++ b/aeon/classification/deep_learning/_resnet.py
@@ -317,7 +317,7 @@ class ResNetClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -336,7 +336,6 @@ class ResNetClassifier(BaseDeepClassifier):
             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`.
         """
         param = {
             "n_epochs": 10,
diff --git a/aeon/classification/deep_learning/_tapnet.py b/aeon/classification/deep_learning/_tapnet.py
index 2ad04882..48cc486f 100644
--- a/aeon/classification/deep_learning/_tapnet.py
+++ b/aeon/classification/deep_learning/_tapnet.py
@@ -246,7 +246,7 @@ class TapNetClassifier(BaseDeepClassifier):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -261,7 +261,6 @@ class TapNetClassifier(BaseDeepClassifier):
             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`.
         """
         param1 = {
             "n_epochs": 20,
diff --git a/aeon/classification/dictionary_based/_boss.py b/aeon/classification/dictionary_based/_boss.py
index da821b72..856074b2 100644
--- a/aeon/classification/dictionary_based/_boss.py
+++ b/aeon/classification/dictionary_based/_boss.py
@@ -396,7 +396,7 @@ class BOSSEnsemble(BaseClassifier):
         return correct / train_size
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -418,7 +418,6 @@ class BOSSEnsemble(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/dictionary_based/_cboss.py b/aeon/classification/dictionary_based/_cboss.py
index a649741b..652b4a76 100644
--- a/aeon/classification/dictionary_based/_cboss.py
+++ b/aeon/classification/dictionary_based/_cboss.py
@@ -420,7 +420,7 @@ class ContractableBOSS(BaseClassifier):
         return correct / train_size
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -445,7 +445,6 @@ class ContractableBOSS(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_parameter_samples": 10, "max_ensemble_size": 5}
diff --git a/aeon/classification/dictionary_based/_mrseql.py b/aeon/classification/dictionary_based/_mrseql.py
index 1426844f..b515d31e 100644
--- a/aeon/classification/dictionary_based/_mrseql.py
+++ b/aeon/classification/dictionary_based/_mrseql.py
@@ -106,7 +106,9 @@ class MrSEQLClassifier(BaseClassifier):
         return self.clf_.predict_proba(_X)
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -125,6 +127,5 @@ class MrSEQLClassifier(BaseClassifier):
             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 {}
diff --git a/aeon/classification/dictionary_based/_mrsqm.py b/aeon/classification/dictionary_based/_mrsqm.py
index ce793f54..4cf98014 100644
--- a/aeon/classification/dictionary_based/_mrsqm.py
+++ b/aeon/classification/dictionary_based/_mrsqm.py
@@ -123,7 +123,9 @@ class MrSQMClassifier(BaseClassifier):
         return self.clf_.predict_proba(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -142,7 +144,6 @@ class MrSQMClassifier(BaseClassifier):
             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 {
             "features_per_rep": 50,
diff --git a/aeon/classification/dictionary_based/_muse.py b/aeon/classification/dictionary_based/_muse.py
index f4f0feea..10594821 100644
--- a/aeon/classification/dictionary_based/_muse.py
+++ b/aeon/classification/dictionary_based/_muse.py
@@ -345,7 +345,7 @@ class MUSE(BaseClassifier):
         return X_new
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -360,7 +360,6 @@ class MUSE(BaseClassifier):
             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 {
             "window_inc": 4,
diff --git a/aeon/classification/dictionary_based/_redcomets.py b/aeon/classification/dictionary_based/_redcomets.py
index f8510945..6ddbb7cf 100644
--- a/aeon/classification/dictionary_based/_redcomets.py
+++ b/aeon/classification/dictionary_based/_redcomets.py
@@ -596,7 +596,7 @@ class REDCOMETS(BaseClassifier):
         return sax_parallel_res
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -610,9 +610,7 @@ class REDCOMETS(BaseClassifier):
         dict
             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``.
+            `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
         """
         return {
             "variant": 3,
diff --git a/aeon/classification/dictionary_based/_tde.py b/aeon/classification/dictionary_based/_tde.py
index 97a98ecb..f8af016b 100644
--- a/aeon/classification/dictionary_based/_tde.py
+++ b/aeon/classification/dictionary_based/_tde.py
@@ -530,7 +530,7 @@ class TemporalDictionaryEnsemble(BaseClassifier):
         return correct / train_size
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -555,7 +555,6 @@ class TemporalDictionaryEnsemble(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/dictionary_based/_weasel.py b/aeon/classification/dictionary_based/_weasel.py
index dee61e3b..03b86a8c 100644
--- a/aeon/classification/dictionary_based/_weasel.py
+++ b/aeon/classification/dictionary_based/_weasel.py
@@ -316,7 +316,7 @@ class WEASEL(BaseClassifier):
         return 1 if self.n_timepoints < 100 else self.window_inc
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -331,7 +331,6 @@ class WEASEL(BaseClassifier):
             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 {
             "window_inc": 4,
diff --git a/aeon/classification/dictionary_based/_weasel_v2.py b/aeon/classification/dictionary_based/_weasel_v2.py
index 0dd7539b..b8d014a0 100644
--- a/aeon/classification/dictionary_based/_weasel_v2.py
+++ b/aeon/classification/dictionary_based/_weasel_v2.py
@@ -236,7 +236,7 @@ class WEASEL_V2(BaseClassifier):
             return super()._predict_proba(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -251,7 +251,6 @@ class WEASEL_V2(BaseClassifier):
             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 {"feature_selection": "none"}
 
diff --git a/aeon/classification/distance_based/_elastic_ensemble.py b/aeon/classification/distance_based/_elastic_ensemble.py
index 8bd0d6d3..c2b159f8 100644
--- a/aeon/classification/distance_based/_elastic_ensemble.py
+++ b/aeon/classification/distance_based/_elastic_ensemble.py
@@ -491,7 +491,9 @@ class ElasticEnsemble(BaseClassifier):
             )
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -510,7 +512,6 @@ class ElasticEnsemble(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/distance_based/_time_series_neighbors.py b/aeon/classification/distance_based/_time_series_neighbors.py
index 870dded9..d0f7144e 100644
--- a/aeon/classification/distance_based/_time_series_neighbors.py
+++ b/aeon/classification/distance_based/_time_series_neighbors.py
@@ -219,7 +219,9 @@ class KNeighborsTimeSeriesClassifier(BaseClassifier):
         return closest_idx, ws
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -234,7 +236,6 @@ class KNeighborsTimeSeriesClassifier(BaseClassifier):
             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`.
         """
         # non-default distance and algorithm
         params1 = {"distance": "euclidean"}
diff --git a/aeon/classification/early_classification/_probability_threshold.py b/aeon/classification/early_classification/_probability_threshold.py
index f34d8cd1..79d2f498 100644
--- a/aeon/classification/early_classification/_probability_threshold.py
+++ b/aeon/classification/early_classification/_probability_threshold.py
@@ -460,7 +460,7 @@ class ProbabilityThresholdEarlyClassifier(BaseEarlyClassifier):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -479,7 +479,6 @@ class ProbabilityThresholdEarlyClassifier(BaseEarlyClassifier):
             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`.
         """
         from aeon.classification.feature_based import SummaryClassifier
         from aeon.classification.interval_based import TimeSeriesForestClassifier
diff --git a/aeon/classification/early_classification/_teaser.py b/aeon/classification/early_classification/_teaser.py
index aded30f6..8a01bbba 100644
--- a/aeon/classification/early_classification/_teaser.py
+++ b/aeon/classification/early_classification/_teaser.py
@@ -622,7 +622,7 @@ class TEASER(BaseEarlyClassifier):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -641,7 +641,6 @@ class TEASER(BaseEarlyClassifier):
             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`.
         """
         from aeon.classification.feature_based import SummaryClassifier
         from aeon.classification.interval_based import TimeSeriesForestClassifier
diff --git a/aeon/classification/feature_based/_catch22.py b/aeon/classification/feature_based/_catch22.py
index c99475cf..16834220 100644
--- a/aeon/classification/feature_based/_catch22.py
+++ b/aeon/classification/feature_based/_catch22.py
@@ -234,7 +234,7 @@ class Catch22Classifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -253,7 +253,6 @@ class Catch22Classifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/feature_based/_fresh_prince.py b/aeon/classification/feature_based/_fresh_prince.py
index 2760c226..54c4dcb9 100644
--- a/aeon/classification/feature_based/_fresh_prince.py
+++ b/aeon/classification/feature_based/_fresh_prince.py
@@ -200,7 +200,7 @@ class FreshPRINCEClassifier(BaseClassifier):
         return self._tsfresh.fit_transform(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -222,7 +222,6 @@ class FreshPRINCEClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/feature_based/_signature_classifier.py b/aeon/classification/feature_based/_signature_classifier.py
index 445efb7b..88308436 100644
--- a/aeon/classification/feature_based/_signature_classifier.py
+++ b/aeon/classification/feature_based/_signature_classifier.py
@@ -193,7 +193,7 @@ class SignatureClassifier(BaseClassifier):
         return self.pipeline.predict_proba(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -212,7 +212,6 @@ class SignatureClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"estimator": RandomForestClassifier(n_estimators=10)}
diff --git a/aeon/classification/feature_based/_summary.py b/aeon/classification/feature_based/_summary.py
index 43e6b33d..b42c4b6b 100644
--- a/aeon/classification/feature_based/_summary.py
+++ b/aeon/classification/feature_based/_summary.py
@@ -174,7 +174,7 @@ class SummaryClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -193,7 +193,6 @@ class SummaryClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"estimator": RandomForestClassifier(n_estimators=10)}
diff --git a/aeon/classification/feature_based/_tsfresh.py b/aeon/classification/feature_based/_tsfresh.py
index fcb9159f..23d79e44 100644
--- a/aeon/classification/feature_based/_tsfresh.py
+++ b/aeon/classification/feature_based/_tsfresh.py
@@ -220,7 +220,7 @@ class TSFreshClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -239,7 +239,6 @@ class TSFreshClassifier(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/hybrid/_hivecote_v1.py b/aeon/classification/hybrid/_hivecote_v1.py
index 71f05fe2..22925487 100644
--- a/aeon/classification/hybrid/_hivecote_v1.py
+++ b/aeon/classification/hybrid/_hivecote_v1.py
@@ -292,7 +292,7 @@ class HIVECOTEV1(BaseClassifier):
         return dists / dists.sum(axis=1, keepdims=True)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -311,7 +311,6 @@ class HIVECOTEV1(BaseClassifier):
             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`.
         """
         from sklearn.ensemble import RandomForestClassifier
 
diff --git a/aeon/classification/hybrid/_hivecote_v2.py b/aeon/classification/hybrid/_hivecote_v2.py
index 1b77f329..53cd94ef 100644
--- a/aeon/classification/hybrid/_hivecote_v2.py
+++ b/aeon/classification/hybrid/_hivecote_v2.py
@@ -325,7 +325,7 @@ class HIVECOTEV2(BaseClassifier):
         return dists / dists.sum(axis=1, keepdims=True)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -347,7 +347,6 @@ class HIVECOTEV2(BaseClassifier):
             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`.
         """
         from sklearn.ensemble import RandomForestClassifier
 
diff --git a/aeon/classification/hybrid/_rist.py b/aeon/classification/hybrid/_rist.py
index 2a036cd8..d3db7585 100644
--- a/aeon/classification/hybrid/_rist.py
+++ b/aeon/classification/hybrid/_rist.py
@@ -134,7 +134,7 @@ class RISTClassifier(BaseRIST, BaseClassifier):
     }
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return unit test parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/classification/interval_based/_cif.py b/aeon/classification/interval_based/_cif.py
index 92ee2f3c..a0c91d37 100644
--- a/aeon/classification/interval_based/_cif.py
+++ b/aeon/classification/interval_based/_cif.py
@@ -233,7 +233,7 @@ class CanonicalIntervalForestClassifier(BaseIntervalForest, BaseClassifier):
         return super()._fit_predict_proba(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -258,7 +258,6 @@ class CanonicalIntervalForestClassifier(BaseIntervalForest, BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10, "n_intervals": 2, "att_subsample_size": 4}
diff --git a/aeon/classification/interval_based/_drcif.py b/aeon/classification/interval_based/_drcif.py
index af3ed647..650bcf42 100644
--- a/aeon/classification/interval_based/_drcif.py
+++ b/aeon/classification/interval_based/_drcif.py
@@ -260,7 +260,7 @@ class DrCIFClassifier(BaseIntervalForest, BaseClassifier):
         return super()._fit_predict_proba(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -285,7 +285,6 @@ class DrCIFClassifier(BaseIntervalForest, BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10, "n_intervals": 2, "att_subsample_size": 4}
diff --git a/aeon/classification/interval_based/_interval_forest.py b/aeon/classification/interval_based/_interval_forest.py
index e7729cee..f1593adf 100644
--- a/aeon/classification/interval_based/_interval_forest.py
+++ b/aeon/classification/interval_based/_interval_forest.py
@@ -225,7 +225,7 @@ class IntervalForestClassifier(BaseIntervalForest, BaseClassifier):
         return super()._fit_predict_proba(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -250,7 +250,6 @@ class IntervalForestClassifier(BaseIntervalForest, BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10, "n_intervals": 2}
diff --git a/aeon/classification/interval_based/_interval_pipelines.py b/aeon/classification/interval_based/_interval_pipelines.py
index 5b71b57d..d29044e4 100644
--- a/aeon/classification/interval_based/_interval_pipelines.py
+++ b/aeon/classification/interval_based/_interval_pipelines.py
@@ -211,7 +211,7 @@ class RandomIntervalClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -230,7 +230,6 @@ class RandomIntervalClassifier(BaseClassifier):
             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`.
         """
         from aeon.utils.numba.stats import row_mean, row_numba_min
 
@@ -450,7 +449,7 @@ class SupervisedIntervalClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -469,7 +468,6 @@ class SupervisedIntervalClassifier(BaseClassifier):
             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`.
         """
         from aeon.utils.numba.stats import row_mean, row_numba_min
 
diff --git a/aeon/classification/interval_based/_rise.py b/aeon/classification/interval_based/_rise.py
index ef3235bd..b298fa59 100644
--- a/aeon/classification/interval_based/_rise.py
+++ b/aeon/classification/interval_based/_rise.py
@@ -195,7 +195,7 @@ class RandomIntervalSpectralEnsembleClassifier(BaseIntervalForest, BaseClassifie
         return super()._fit_predict_proba(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -221,7 +221,6 @@ class RandomIntervalSpectralEnsembleClassifier(BaseIntervalForest, BaseClassifie
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10}
diff --git a/aeon/classification/interval_based/_rstsf.py b/aeon/classification/interval_based/_rstsf.py
index 19cb902f..9280a4a0 100644
--- a/aeon/classification/interval_based/_rstsf.py
+++ b/aeon/classification/interval_based/_rstsf.py
@@ -172,7 +172,7 @@ class RSTSF(BaseClassifier):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -191,7 +191,6 @@ class RSTSF(BaseClassifier):
             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 {
             "n_estimators": 2,
diff --git a/aeon/classification/interval_based/_stsf.py b/aeon/classification/interval_based/_stsf.py
index b6bf3c92..f782cb47 100644
--- a/aeon/classification/interval_based/_stsf.py
+++ b/aeon/classification/interval_based/_stsf.py
@@ -186,7 +186,7 @@ class SupervisedTimeSeriesForest(BaseIntervalForest, BaseClassifier):
         return super()._fit_predict_proba(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -211,7 +211,6 @@ class SupervisedTimeSeriesForest(BaseIntervalForest, BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10}
diff --git a/aeon/classification/interval_based/_tsf.py b/aeon/classification/interval_based/_tsf.py
index a624fc99..17ecd5f7 100644
--- a/aeon/classification/interval_based/_tsf.py
+++ b/aeon/classification/interval_based/_tsf.py
@@ -198,7 +198,7 @@ class TimeSeriesForestClassifier(BaseIntervalForest, BaseClassifier):
         return super()._fit_predict_proba(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -223,7 +223,6 @@ class TimeSeriesForestClassifier(BaseIntervalForest, BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10}
diff --git a/aeon/classification/ordinal_classification/_ordinal_tde.py b/aeon/classification/ordinal_classification/_ordinal_tde.py
index 982aab1f..886ff470 100644
--- a/aeon/classification/ordinal_classification/_ordinal_tde.py
+++ b/aeon/classification/ordinal_classification/_ordinal_tde.py
@@ -514,7 +514,7 @@ class OrdinalTDE(BaseClassifier):
         return mae
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -533,7 +533,6 @@ class OrdinalTDE(BaseClassifier):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/classification/shapelet_based/_ls.py b/aeon/classification/shapelet_based/_ls.py
index 06cc9fbc..1398054a 100644
--- a/aeon/classification/shapelet_based/_ls.py
+++ b/aeon/classification/shapelet_based/_ls.py
@@ -209,7 +209,9 @@ class LearningShapeletClassifier(BaseClassifier):
         return self.clf_.locate(self.transformed_data_)
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -228,6 +230,5 @@ class LearningShapeletClassifier(BaseClassifier):
             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 {"max_iter": 50, "batch_size": 10}
diff --git a/aeon/classification/shapelet_based/_rdst.py b/aeon/classification/shapelet_based/_rdst.py
index 4288686f..cd1756c9 100644
--- a/aeon/classification/shapelet_based/_rdst.py
+++ b/aeon/classification/shapelet_based/_rdst.py
@@ -265,7 +265,9 @@ class RDSTClassifier(BaseClassifier):
             return dists
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -284,6 +286,5 @@ class RDSTClassifier(BaseClassifier):
             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 {"max_shapelets": 20}
diff --git a/aeon/classification/shapelet_based/_stc.py b/aeon/classification/shapelet_based/_stc.py
index 3add6f52..c0ac9df2 100644
--- a/aeon/classification/shapelet_based/_stc.py
+++ b/aeon/classification/shapelet_based/_stc.py
@@ -318,7 +318,9 @@ class ShapeletTransformClassifier(BaseClassifier):
         return self._transformer.fit_transform(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -343,7 +345,6 @@ class ShapeletTransformClassifier(BaseClassifier):
             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`.
         """
         from sklearn.ensemble import RandomForestClassifier
 
diff --git a/aeon/classification/sklearn/_wrapper.py b/aeon/classification/sklearn/_wrapper.py
index 79362af2..889f1811 100644
--- a/aeon/classification/sklearn/_wrapper.py
+++ b/aeon/classification/sklearn/_wrapper.py
@@ -47,7 +47,7 @@ class SklearnClassifierWrapper(BaseClassifier):
         return self.classifier_.predict_proba(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -62,7 +62,6 @@ class SklearnClassifierWrapper(BaseClassifier):
             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 {
             "classifier": RandomForestClassifier(n_estimators=5),
diff --git a/aeon/clustering/_clara.py b/aeon/clustering/_clara.py
index 0121922f..4f44f5ad 100644
--- a/aeon/clustering/_clara.py
+++ b/aeon/clustering/_clara.py
@@ -211,7 +211,7 @@ class TimeSeriesCLARA(BaseClusterer):
         return -self.inertia_
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -227,7 +227,6 @@ class TimeSeriesCLARA(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_clarans.py b/aeon/clustering/_clarans.py
index 0d15bc7b..f1c9eff8 100644
--- a/aeon/clustering/_clarans.py
+++ b/aeon/clustering/_clarans.py
@@ -185,7 +185,7 @@ class TimeSeriesCLARANS(TimeSeriesKMedoids):
         self.n_iter_ = 0
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -200,7 +200,6 @@ class TimeSeriesCLARANS(TimeSeriesKMedoids):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_elastic_som.py b/aeon/clustering/_elastic_som.py
index 6b8899e2..e7d7d346 100644
--- a/aeon/clustering/_elastic_som.py
+++ b/aeon/clustering/_elastic_som.py
@@ -382,7 +382,7 @@ class ElasticSOM(BaseClusterer):
         return X[list(range(self.n_clusters))]
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -398,7 +398,6 @@ class ElasticSOM(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_k_means.py b/aeon/clustering/_k_means.py
index c947be4a..550d3894 100644
--- a/aeon/clustering/_k_means.py
+++ b/aeon/clustering/_k_means.py
@@ -408,7 +408,7 @@ class TimeSeriesKMeans(BaseClusterer):
         return curr_pw, curr_labels, curr_inertia, cluster_centres
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -424,7 +424,6 @@ class TimeSeriesKMeans(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_k_medoids.py b/aeon/clustering/_k_medoids.py
index 9a0a91ae..1f36f75e 100644
--- a/aeon/clustering/_k_medoids.py
+++ b/aeon/clustering/_k_medoids.py
@@ -541,7 +541,7 @@ class TimeSeriesKMedoids(BaseClusterer):
         return np.array(medoid_idxs)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -557,7 +557,6 @@ class TimeSeriesKMedoids(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_k_sc.py b/aeon/clustering/_k_sc.py
index 24caa8e9..1ace94b2 100644
--- a/aeon/clustering/_k_sc.py
+++ b/aeon/clustering/_k_sc.py
@@ -130,7 +130,7 @@ class KSpectralCentroid(TimeSeriesKMeans):
             self._average_params["max_shift"] = temp_max_shift
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -146,7 +146,6 @@ class KSpectralCentroid(TimeSeriesKMeans):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_k_shape.py b/aeon/clustering/_k_shape.py
index 9bcf4d16..3da2aca0 100644
--- a/aeon/clustering/_k_shape.py
+++ b/aeon/clustering/_k_shape.py
@@ -153,7 +153,7 @@ class TimeSeriesKShape(BaseClusterer):
         return self._tslearn_k_shapes.predict(_X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -169,7 +169,6 @@ class TimeSeriesKShape(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_k_shapes.py b/aeon/clustering/_k_shapes.py
index 7d323c9a..cdad5803 100644
--- a/aeon/clustering/_k_shapes.py
+++ b/aeon/clustering/_k_shapes.py
@@ -154,7 +154,7 @@ class TimeSeriesKShapes(BaseClusterer):
         return self._tslearn_k_shapes.predict(_X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -170,7 +170,6 @@ class TimeSeriesKShapes(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/_kernel_k_means.py b/aeon/clustering/_kernel_k_means.py
index 23ab8430..6511c6a3 100644
--- a/aeon/clustering/_kernel_k_means.py
+++ b/aeon/clustering/_kernel_k_means.py
@@ -176,7 +176,7 @@ class TimeSeriesKernelKMeans(BaseClusterer):
         return self._tslearn_kernel_k_means.predict(_X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default") -> dict:
+    def _get_test_params(cls, parameter_set="default") -> dict:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -192,7 +192,6 @@ class TimeSeriesKernelKMeans(BaseClusterer):
             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 {
             "n_clusters": 2,
diff --git a/aeon/clustering/compose/_pipeline.py b/aeon/clustering/compose/_pipeline.py
index 63f9c805..38d3214f 100644
--- a/aeon/clustering/compose/_pipeline.py
+++ b/aeon/clustering/compose/_pipeline.py
@@ -67,7 +67,7 @@ class ClustererPipeline(BaseCollectionPipeline, BaseClusterer):
     >>> X_train, y_train = load_unit_test(split="train")
     >>> X_test, y_test = load_unit_test(split="test")
     >>> pipeline = ClustererPipeline(
-    ...     Resizer(length=10), TimeSeriesKMeans.create_test_instance()
+    ...     Resizer(length=10), TimeSeriesKMeans._create_test_instance()
     ... )
     >>> pipeline.fit(X_train, y_train)
     ClustererPipeline(...)
@@ -92,7 +92,7 @@ class ClustererPipeline(BaseCollectionPipeline, BaseClusterer):
         raise NotImplementedError("Pipeline does not support scoring.")
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -107,7 +107,6 @@ class ClustererPipeline(BaseCollectionPipeline, BaseClusterer):
             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`.
         """
         from aeon.clustering import TimeSeriesKMeans
         from aeon.transformations.collection import Truncator
@@ -120,5 +119,5 @@ class ClustererPipeline(BaseCollectionPipeline, BaseClusterer):
                 Truncator(truncated_length=5),
                 SevenNumberSummaryTransformer(),
             ],
-            "clusterer": TimeSeriesKMeans.create_test_instance(),
+            "clusterer": TimeSeriesKMeans._create_test_instance(),
         }
diff --git a/aeon/clustering/deep_learning/_ae_fcn.py b/aeon/clustering/deep_learning/_ae_fcn.py
index 50089a6b..00758178 100644
--- a/aeon/clustering/deep_learning/_ae_fcn.py
+++ b/aeon/clustering/deep_learning/_ae_fcn.py
@@ -327,7 +327,7 @@ class AEFCNClusterer(BaseDeepClusterer):
         return self._estimator.score(latent_space)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -346,7 +346,6 @@ class AEFCNClusterer(BaseDeepClusterer):
             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`.
         """
         param1 = {
             "n_epochs": 1,
diff --git a/aeon/clustering/deep_learning/_ae_resnet.py b/aeon/clustering/deep_learning/_ae_resnet.py
index 170e57b2..56d12cb4 100644
--- a/aeon/clustering/deep_learning/_ae_resnet.py
+++ b/aeon/clustering/deep_learning/_ae_resnet.py
@@ -343,7 +343,7 @@ class AEResNetClusterer(BaseDeepClusterer):
         return self._estimator.score(latent_space)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -362,7 +362,6 @@ class AEResNetClusterer(BaseDeepClusterer):
             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`.
         """
         param = {
             "n_epochs": 1,
diff --git a/aeon/clustering/feature_based/_catch22.py b/aeon/clustering/feature_based/_catch22.py
index 6c716e24..0b6b2e32 100644
--- a/aeon/clustering/feature_based/_catch22.py
+++ b/aeon/clustering/feature_based/_catch22.py
@@ -218,7 +218,7 @@ class Catch22Clusterer(BaseClusterer):
         raise NotImplementedError("Catch22Clusterer does not support scoring.")
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -233,7 +233,6 @@ class Catch22Clusterer(BaseClusterer):
             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 {
             "features": (
diff --git a/aeon/clustering/feature_based/_tsfresh.py b/aeon/clustering/feature_based/_tsfresh.py
index d708afa6..7d30b396 100644
--- a/aeon/clustering/feature_based/_tsfresh.py
+++ b/aeon/clustering/feature_based/_tsfresh.py
@@ -7,6 +7,8 @@ __maintainer__ = ["MatthewMiddlehurst"]
 __all__ = ["TSFreshClusterer"]
 
 
+from typing import Optional
+
 import numpy as np
 from sklearn.cluster import KMeans
 
@@ -43,6 +45,8 @@ class TSFreshClusterer(BaseClusterer):
         If `RandomState` instance, random_state is the random number generator;
         If `None`, the random number generator is the `RandomState` instance used
         by `np.random`.
+    n_clusters : int, default=8
+        Number of clusters for KMeans (or other estimators that support n_clusters).
 
     See Also
     --------
@@ -76,12 +80,13 @@ class TSFreshClusterer(BaseClusterer):
 
     def __init__(
         self,
-        default_fc_parameters="efficient",
+        default_fc_parameters: str = "efficient",
         estimator=None,
-        verbose=0,
-        n_jobs=1,
-        chunksize=None,
-        random_state=None,
+        verbose: int = 0,
+        n_jobs: int = 1,
+        chunksize: Optional[int] = None,
+        random_state: Optional[int] = None,
+        n_clusters: int = 8,  # Default value as 8
     ):
         self.default_fc_parameters = default_fc_parameters
         self.estimator = estimator
@@ -90,13 +95,14 @@ class TSFreshClusterer(BaseClusterer):
         self.n_jobs = n_jobs
         self.chunksize = chunksize
         self.random_state = random_state
+        self.n_clusters = n_clusters
 
         self._transformer = None
         self._estimator = None
 
         super().__init__()
 
-    def _fit(self, X, y=None):
+    def _fit(self, X: np.ndarray, y: Optional[np.ndarray] = None):
         """Fit a pipeline on cases X.
 
         Parameters
@@ -121,10 +127,21 @@ class TSFreshClusterer(BaseClusterer):
             n_jobs=self._n_jobs,
             chunksize=self.chunksize,
         )
-        self._estimator = _clone_estimator(
-            (KMeans() if self.estimator is None else self.estimator),
-            self.random_state,
-        )
+
+        n_clusters = 8 if self.n_clusters is None else self.n_clusters
+
+        if self.estimator is None:
+            self._estimator = _clone_estimator(
+                KMeans(n_clusters=n_clusters), self.random_state
+            )
+        else:
+            if (
+                hasattr(self.estimator, "n_clusters")
+                and self.estimator.n_clusters is None
+            ):
+                self.estimator.n_clusters = self.n_clusters
+
+            self._estimator = _clone_estimator(self.estimator, self.random_state)
 
         if self.verbose < 2:
             self._transformer.show_warnings = False
@@ -147,7 +164,7 @@ class TSFreshClusterer(BaseClusterer):
 
         return self
 
-    def _predict(self, X) -> np.ndarray:
+    def _predict(self, X: np.ndarray) -> np.ndarray:
         """Predict class values of n instances in X.
 
         Parameters
@@ -162,7 +179,7 @@ class TSFreshClusterer(BaseClusterer):
         """
         return self._estimator.predict(self._transformer.transform(X))
 
-    def _predict_proba(self, X) -> np.ndarray:
+    def _predict_proba(self, X: np.ndarray) -> np.ndarray:
         """Predict class values of n instances in X.
 
         Parameters
@@ -194,11 +211,11 @@ class TSFreshClusterer(BaseClusterer):
                 dists[i, preds[i]] = 1
             return dists
 
-    def _score(self, X, y=None):
+    def _score(self, X: np.ndarray, y: Optional[np.ndarray] = None):
         raise NotImplementedError("TSFreshClusterer does not support scoring.")
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set: str = "default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -213,8 +230,8 @@ class TSFreshClusterer(BaseClusterer):
             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 {
             "default_fc_parameters": "minimal",
+            "n_clusters": 3,
         }
diff --git a/aeon/regression/compose/_ensemble.py b/aeon/regression/compose/_ensemble.py
index c0b7d53d..838456a9 100644
--- a/aeon/regression/compose/_ensemble.py
+++ b/aeon/regression/compose/_ensemble.py
@@ -106,7 +106,7 @@ class RegressorEnsemble(BaseCollectionEnsemble, BaseRegressor):
             return reg
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -121,12 +121,11 @@ class RegressorEnsemble(BaseCollectionEnsemble, BaseRegressor):
             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 {
             "regressors": [
-                KNeighborsTimeSeriesRegressor.create_test_instance(),
-                DummyRegressor.create_test_instance(),
+                KNeighborsTimeSeriesRegressor._create_test_instance(),
+                DummyRegressor._create_test_instance(),
             ],
             "weights": [2, 1],
         }
diff --git a/aeon/regression/compose/_pipeline.py b/aeon/regression/compose/_pipeline.py
index 00bb1d4d..764cc714 100644
--- a/aeon/regression/compose/_pipeline.py
+++ b/aeon/regression/compose/_pipeline.py
@@ -82,7 +82,7 @@ class RegressorPipeline(BaseCollectionPipeline, BaseRegressor):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -97,7 +97,6 @@ class RegressorPipeline(BaseCollectionPipeline, BaseRegressor):
             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`.
         """
         from aeon.regression.distance_based import KNeighborsTimeSeriesRegressor
         from aeon.transformations.collection import Truncator
diff --git a/aeon/regression/convolution_based/_minirocket.py b/aeon/regression/convolution_based/_minirocket.py
index 2c723b5f..3e79965b 100644
--- a/aeon/regression/convolution_based/_minirocket.py
+++ b/aeon/regression/convolution_based/_minirocket.py
@@ -146,7 +146,7 @@ class MiniRocketRegressor(BaseRegressor):
         return self.pipeline_.predict(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/regression/convolution_based/_multirocket.py b/aeon/regression/convolution_based/_multirocket.py
index 4218434a..4cdf782c 100644
--- a/aeon/regression/convolution_based/_multirocket.py
+++ b/aeon/regression/convolution_based/_multirocket.py
@@ -152,7 +152,7 @@ class MultiRocketRegressor(BaseRegressor):
         return self.pipeline_.predict(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/regression/convolution_based/_rocket.py b/aeon/regression/convolution_based/_rocket.py
index 92c2ae7b..5bee6b51 100644
--- a/aeon/regression/convolution_based/_rocket.py
+++ b/aeon/regression/convolution_based/_rocket.py
@@ -146,7 +146,7 @@ class RocketRegressor(BaseRegressor):
         return self.pipeline_.predict(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/regression/deep_learning/_cnn.py b/aeon/regression/deep_learning/_cnn.py
index 58f0f4a5..c636c700 100644
--- a/aeon/regression/deep_learning/_cnn.py
+++ b/aeon/regression/deep_learning/_cnn.py
@@ -312,7 +312,7 @@ class TimeCNNRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -331,7 +331,6 @@ class TimeCNNRegressor(BaseDeepRegressor):
             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`.
         """
         param = {
             "n_epochs": 10,
diff --git a/aeon/regression/deep_learning/_encoder.py b/aeon/regression/deep_learning/_encoder.py
index 4b73047c..2183d5ee 100644
--- a/aeon/regression/deep_learning/_encoder.py
+++ b/aeon/regression/deep_learning/_encoder.py
@@ -298,7 +298,7 @@ class EncoderRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -317,7 +317,6 @@ class EncoderRegressor(BaseDeepRegressor):
             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`.
         """
         param1 = {
             "n_epochs": 8,
diff --git a/aeon/regression/deep_learning/_fcn.py b/aeon/regression/deep_learning/_fcn.py
index 374feb5b..361bc2ee 100644
--- a/aeon/regression/deep_learning/_fcn.py
+++ b/aeon/regression/deep_learning/_fcn.py
@@ -306,7 +306,7 @@ class FCNRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -325,7 +325,6 @@ class FCNRegressor(BaseDeepRegressor):
             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`.
         """
         param = {
             "n_epochs": 10,
diff --git a/aeon/regression/deep_learning/_inception_time.py b/aeon/regression/deep_learning/_inception_time.py
index 19493ac6..bc13532a 100644
--- a/aeon/regression/deep_learning/_inception_time.py
+++ b/aeon/regression/deep_learning/_inception_time.py
@@ -327,7 +327,7 @@ class InceptionTimeRegressor(BaseRegressor):
         return ypreds
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -346,7 +346,6 @@ class InceptionTimeRegressor(BaseRegressor):
             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`.
         """
         param1 = {
             "n_regressors": 1,
@@ -699,7 +698,7 @@ class IndividualInceptionRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -718,7 +717,6 @@ class IndividualInceptionRegressor(BaseDeepRegressor):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/regression/deep_learning/_lite_time.py b/aeon/regression/deep_learning/_lite_time.py
index 56e33849..f0712a5a 100644
--- a/aeon/regression/deep_learning/_lite_time.py
+++ b/aeon/regression/deep_learning/_lite_time.py
@@ -240,7 +240,7 @@ class LITETimeRegressor(BaseRegressor):
         return vals
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -259,7 +259,6 @@ class LITETimeRegressor(BaseRegressor):
             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`.
         """
         param1 = {
             "n_regressors": 1,
@@ -549,7 +548,7 @@ class IndividualLITERegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -568,7 +567,6 @@ class IndividualLITERegressor(BaseDeepRegressor):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/regression/deep_learning/_mlp.py b/aeon/regression/deep_learning/_mlp.py
index cb9907fe..d593eb7b 100644
--- a/aeon/regression/deep_learning/_mlp.py
+++ b/aeon/regression/deep_learning/_mlp.py
@@ -264,7 +264,7 @@ class MLPRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -283,7 +283,6 @@ class MLPRegressor(BaseDeepRegressor):
             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`.
         """
         param = {
             "n_epochs": 10,
diff --git a/aeon/regression/deep_learning/_resnet.py b/aeon/regression/deep_learning/_resnet.py
index 48f2d3c5..7592d4e6 100644
--- a/aeon/regression/deep_learning/_resnet.py
+++ b/aeon/regression/deep_learning/_resnet.py
@@ -328,7 +328,7 @@ class ResNetRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -347,7 +347,6 @@ class ResNetRegressor(BaseDeepRegressor):
             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`.
         """
         param = {
             "n_epochs": 10,
diff --git a/aeon/regression/deep_learning/_tapnet.py b/aeon/regression/deep_learning/_tapnet.py
index 4a03f02c..09dd2921 100644
--- a/aeon/regression/deep_learning/_tapnet.py
+++ b/aeon/regression/deep_learning/_tapnet.py
@@ -250,7 +250,7 @@ class TapNetRegressor(BaseDeepRegressor):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -269,7 +269,6 @@ class TapNetRegressor(BaseDeepRegressor):
             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`.
         """
         param1 = {
             "n_epochs": 10,
diff --git a/aeon/regression/distance_based/_time_series_neighbors.py b/aeon/regression/distance_based/_time_series_neighbors.py
index 510fa30a..5c065939 100644
--- a/aeon/regression/distance_based/_time_series_neighbors.py
+++ b/aeon/regression/distance_based/_time_series_neighbors.py
@@ -183,7 +183,9 @@ class KNeighborsTimeSeriesRegressor(BaseRegressor):
         return closest_idx, ws
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> Union[dict, list[dict]]:
+    def _get_test_params(
+        cls, parameter_set: str = "default"
+    ) -> Union[dict, list[dict]]:
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -198,7 +200,6 @@ class KNeighborsTimeSeriesRegressor(BaseRegressor):
             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`.
         """
         # non-default distance and algorithm
         params1 = {"distance": "euclidean"}
diff --git a/aeon/regression/feature_based/_catch22.py b/aeon/regression/feature_based/_catch22.py
index 579ec874..87e158ca 100644
--- a/aeon/regression/feature_based/_catch22.py
+++ b/aeon/regression/feature_based/_catch22.py
@@ -195,7 +195,7 @@ class Catch22Regressor(BaseRegressor):
         return self._estimator.predict(self._transformer.transform(X))
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -214,7 +214,6 @@ class Catch22Regressor(BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/regression/feature_based/_fresh_prince.py b/aeon/regression/feature_based/_fresh_prince.py
index 029e7535..491e5a3f 100644
--- a/aeon/regression/feature_based/_fresh_prince.py
+++ b/aeon/regression/feature_based/_fresh_prince.py
@@ -180,7 +180,7 @@ class FreshPRINCERegressor(BaseRegressor):
         return self._tsfresh.fit_transform(X, y)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -202,7 +202,6 @@ class FreshPRINCERegressor(BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/regression/feature_based/_summary.py b/aeon/regression/feature_based/_summary.py
index 4e2f89ee..eba030d9 100644
--- a/aeon/regression/feature_based/_summary.py
+++ b/aeon/regression/feature_based/_summary.py
@@ -145,7 +145,7 @@ class SummaryRegressor(BaseRegressor):
         return self._estimator.predict(self._transformer.transform(X))
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -164,7 +164,6 @@ class SummaryRegressor(BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"estimator": RandomForestRegressor(n_estimators=10)}
diff --git a/aeon/regression/feature_based/_tsfresh.py b/aeon/regression/feature_based/_tsfresh.py
index 8ed45eff..8d34eaaa 100644
--- a/aeon/regression/feature_based/_tsfresh.py
+++ b/aeon/regression/feature_based/_tsfresh.py
@@ -186,7 +186,7 @@ class TSFreshRegressor(BaseRegressor):
         return self._estimator.predict(self._transformer.transform(X))
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -205,7 +205,6 @@ class TSFreshRegressor(BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/regression/hybrid/_rist.py b/aeon/regression/hybrid/_rist.py
index e96beb24..f7471ef4 100644
--- a/aeon/regression/hybrid/_rist.py
+++ b/aeon/regression/hybrid/_rist.py
@@ -126,7 +126,7 @@ class RISTRegressor(BaseRIST, BaseRegressor):
     }
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return unit test parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/regression/interval_based/_cif.py b/aeon/regression/interval_based/_cif.py
index 34fede19..61b02906 100644
--- a/aeon/regression/interval_based/_cif.py
+++ b/aeon/regression/interval_based/_cif.py
@@ -194,7 +194,7 @@ class CanonicalIntervalForestRegressor(BaseIntervalForest, BaseRegressor):
             self.set_tags(**{"python_dependencies": "pycatch22"})
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -216,7 +216,6 @@ class CanonicalIntervalForestRegressor(BaseIntervalForest, BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10, "n_intervals": 2, "att_subsample_size": 4}
diff --git a/aeon/regression/interval_based/_drcif.py b/aeon/regression/interval_based/_drcif.py
index f76f3871..15254796 100644
--- a/aeon/regression/interval_based/_drcif.py
+++ b/aeon/regression/interval_based/_drcif.py
@@ -220,7 +220,7 @@ class DrCIFRegressor(BaseIntervalForest, BaseRegressor):
             self.set_tags(**{"python_dependencies": d})
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -242,7 +242,6 @@ class DrCIFRegressor(BaseIntervalForest, BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10, "n_intervals": 2, "att_subsample_size": 4}
diff --git a/aeon/regression/interval_based/_interval_forest.py b/aeon/regression/interval_based/_interval_forest.py
index 746d2249..3ddc52de 100644
--- a/aeon/regression/interval_based/_interval_forest.py
+++ b/aeon/regression/interval_based/_interval_forest.py
@@ -201,7 +201,7 @@ class IntervalForestRegressor(BaseIntervalForest, BaseRegressor):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -223,7 +223,6 @@ class IntervalForestRegressor(BaseIntervalForest, BaseRegressor):
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10, "n_intervals": 2}
diff --git a/aeon/regression/interval_based/_interval_pipelines.py b/aeon/regression/interval_based/_interval_pipelines.py
index 04cce958..42ceb467 100644
--- a/aeon/regression/interval_based/_interval_pipelines.py
+++ b/aeon/regression/interval_based/_interval_pipelines.py
@@ -183,7 +183,7 @@ class RandomIntervalRegressor(BaseRegressor):
         return self._estimator.predict(self._transformer.transform(X))
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -202,7 +202,6 @@ class RandomIntervalRegressor(BaseRegressor):
             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`.
         """
         from aeon.utils.numba.stats import row_mean, row_numba_min
 
diff --git a/aeon/regression/interval_based/_rise.py b/aeon/regression/interval_based/_rise.py
index 82d317e6..40506552 100644
--- a/aeon/regression/interval_based/_rise.py
+++ b/aeon/regression/interval_based/_rise.py
@@ -162,7 +162,7 @@ class RandomIntervalSpectralEnsembleRegressor(BaseIntervalForest, BaseRegressor)
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -185,7 +185,6 @@ class RandomIntervalSpectralEnsembleRegressor(BaseIntervalForest, BaseRegressor)
             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`.
         """
         if parameter_set == "results_comparison":
             return {"n_estimators": 10}
diff --git a/aeon/regression/interval_based/_tsf.py b/aeon/regression/interval_based/_tsf.py
index 1a82635c..b01575f0 100644
--- a/aeon/regression/interval_based/_tsf.py
+++ b/aeon/regression/interval_based/_tsf.py
@@ -162,7 +162,7 @@ class TimeSeriesForestRegressor(BaseIntervalForest, BaseRegressor):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -181,7 +181,6 @@ class TimeSeriesForestRegressor(BaseIntervalForest, BaseRegressor):
             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 {
             "n_estimators": 2,
diff --git a/aeon/regression/shapelet_based/_rdst.py b/aeon/regression/shapelet_based/_rdst.py
index 6f0a0b9b..f8f27773 100644
--- a/aeon/regression/shapelet_based/_rdst.py
+++ b/aeon/regression/shapelet_based/_rdst.py
@@ -218,7 +218,7 @@ class RDSTRegressor(BaseRegressor):
         return self._estimator.predict(X_t)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -237,6 +237,5 @@ class RDSTRegressor(BaseRegressor):
             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 {"max_shapelets": 20}
diff --git a/aeon/regression/sklearn/_wrapper.py b/aeon/regression/sklearn/_wrapper.py
index da8b37fa..caf00f15 100644
--- a/aeon/regression/sklearn/_wrapper.py
+++ b/aeon/regression/sklearn/_wrapper.py
@@ -44,7 +44,7 @@ class SklearnRegressorWrapper(BaseRegressor):
         return self.regressor_.predict(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -59,7 +59,6 @@ class SklearnRegressorWrapper(BaseRegressor):
             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 {
             "regressor": RandomForestRegressor(n_estimators=5),
diff --git a/aeon/segmentation/_binseg.py b/aeon/segmentation/_binseg.py
index ad54b047..af649590 100644
--- a/aeon/segmentation/_binseg.py
+++ b/aeon/segmentation/_binseg.py
@@ -124,7 +124,7 @@ class BinSegSegmenter(BaseSegmenter):
         return pd.IntervalIndex.from_arrays(start, end)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -139,6 +139,5 @@ class BinSegSegmenter(BaseSegmenter):
             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 {"n_cps": 1}
diff --git a/aeon/segmentation/_clasp.py b/aeon/segmentation/_clasp.py
index 4aed2f86..46dbc190 100644
--- a/aeon/segmentation/_clasp.py
+++ b/aeon/segmentation/_clasp.py
@@ -301,7 +301,7 @@ class ClaSPSegmenter(BaseSegmenter):
         return pd.IntervalIndex.from_arrays(start, end)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -316,6 +316,5 @@ class ClaSPSegmenter(BaseSegmenter):
             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 {"period_length": 5, "n_cps": 1}
diff --git a/aeon/segmentation/_eagglo.py b/aeon/segmentation/_eagglo.py
index 8ffa22cc..d482c47d 100644
--- a/aeon/segmentation/_eagglo.py
+++ b/aeon/segmentation/_eagglo.py
@@ -350,7 +350,7 @@ class EAggloSegmenter(BaseSegmenter):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> list[dict]:
+    def _get_test_params(cls, parameter_set: str = "default") -> list[dict]:
         """Test parameters."""
         return [
             {"alpha": 1.0, "penalty": None},
diff --git a/aeon/segmentation/_fluss.py b/aeon/segmentation/_fluss.py
index 261044f9..de32b9ed 100644
--- a/aeon/segmentation/_fluss.py
+++ b/aeon/segmentation/_fluss.py
@@ -137,7 +137,7 @@ class FLUSSSegmenter(BaseSegmenter):
         return pd.IntervalIndex.from_arrays(start, end)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -152,6 +152,5 @@ class FLUSSSegmenter(BaseSegmenter):
             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 {"period_length": 5, "n_regimes": 2}
diff --git a/aeon/segmentation/_ggs.py b/aeon/segmentation/_ggs.py
index c423dd28..6fef5773 100644
--- a/aeon/segmentation/_ggs.py
+++ b/aeon/segmentation/_ggs.py
@@ -514,7 +514,7 @@ class GreedyGaussianSegmenter(BaseSegmenter):
         return labels
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """
         Return testing parameter settings for the estimator.
 
diff --git a/aeon/segmentation/_hidalgo.py b/aeon/segmentation/_hidalgo.py
index ae34ac99..c70010b7 100644
--- a/aeon/segmentation/_hidalgo.py
+++ b/aeon/segmentation/_hidalgo.py
@@ -653,7 +653,7 @@ class HidalgoSegmenter(BaseSegmenter):
         return self._Z
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -671,7 +671,6 @@ class HidalgoSegmenter(BaseSegmenter):
             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 {
             "metric": "euclidean",
diff --git a/aeon/segmentation/_hmm.py b/aeon/segmentation/_hmm.py
index 49c8b277..6b829603 100644
--- a/aeon/segmentation/_hmm.py
+++ b/aeon/segmentation/_hmm.py
@@ -386,7 +386,7 @@ class HMMSegmenter(BaseSegmenter):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/segmentation/_igts.py b/aeon/segmentation/_igts.py
index ba3c2561..20d63243 100644
--- a/aeon/segmentation/_igts.py
+++ b/aeon/segmentation/_igts.py
@@ -389,7 +389,7 @@ class InformationGainSegmenter(BaseSegmenter):
         return self._igts.__repr__()
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/transformations/collection/_acf.py b/aeon/transformations/collection/_acf.py
index 24c97676..47809551 100644
--- a/aeon/transformations/collection/_acf.py
+++ b/aeon/transformations/collection/_acf.py
@@ -23,8 +23,9 @@ class AutocorrelationFunctionTransformer(BaseCollectionTransformer):
 
     Parameters
     ----------
-    n_lags : int or callable, default=100
-        The maximum number of autocorrelation terms to use. If callable, the
+    n_lags : int, None or callable, default=None
+        The maximum number of autocorrelation terms to use. If None, set to
+        n_timepoints/4. If callable, the
         function should take a 3D numpy array of shape (n_cases, n_channels,
         n_timepoints) and return an integer.
     min_values : int, default=0
@@ -54,7 +55,7 @@ class AutocorrelationFunctionTransformer(BaseCollectionTransformer):
 
     def __init__(
         self,
-        n_lags=100,
+        n_lags=None,
         min_values=0,
     ):
         self.n_lags = n_lags
@@ -64,8 +65,10 @@ class AutocorrelationFunctionTransformer(BaseCollectionTransformer):
 
     def _transform(self, X, y=None):
         n_cases, n_channels, n_timepoints = X.shape
-
-        lags = self.n_lags(X) if callable(self.n_lags) else self.n_lags
+        if self.n_lags is None:
+            lags = n_timepoints / 4
+        else:
+            lags = self.n_lags(X) if callable(self.n_lags) else self.n_lags
         if lags > n_timepoints - self.min_values:
             lags = n_timepoints - self.min_values
         if lags < 0:
@@ -114,7 +117,7 @@ class AutocorrelationFunctionTransformer(BaseCollectionTransformer):
         return X_t
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -129,7 +132,6 @@ class AutocorrelationFunctionTransformer(BaseCollectionTransformer):
             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 {
             "n_lags": 4,
diff --git a/aeon/transformations/collection/_ar_coefficient.py b/aeon/transformations/collection/_ar_coefficient.py
index 45b96257..4a483d9a 100644
--- a/aeon/transformations/collection/_ar_coefficient.py
+++ b/aeon/transformations/collection/_ar_coefficient.py
@@ -89,7 +89,7 @@ class ARCoefficientTransformer(BaseCollectionTransformer):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -104,7 +104,6 @@ class ARCoefficientTransformer(BaseCollectionTransformer):
             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 {
             "order": 4,
diff --git a/aeon/transformations/collection/_broadcaster.py b/aeon/transformations/collection/_broadcaster.py
index 500ca1d0..742e24d2 100644
--- a/aeon/transformations/collection/_broadcaster.py
+++ b/aeon/transformations/collection/_broadcaster.py
@@ -145,7 +145,7 @@ class SeriesToCollectionBroadcaster(BaseCollectionTransformer):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -160,7 +160,6 @@ class SeriesToCollectionBroadcaster(BaseCollectionTransformer):
             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`.
         """
         from aeon.testing.mock_estimators._mock_series_transformers import (
             MockUnivariateSeriesTransformer,
diff --git a/aeon/transformations/collection/_resize.py b/aeon/transformations/collection/_resize.py
index c8189300..abfd6969 100644
--- a/aeon/transformations/collection/_resize.py
+++ b/aeon/transformations/collection/_resize.py
@@ -83,7 +83,7 @@ class Resizer(BaseCollectionTransformer):
         return np.array(Xt)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Returns
@@ -92,7 +92,6 @@ class Resizer(BaseCollectionTransformer):
             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`.
         """
         params = {"length": 10}
         return params
diff --git a/aeon/transformations/collection/_truncate.py b/aeon/transformations/collection/_truncate.py
index 8818b138..2c20c1e0 100644
--- a/aeon/transformations/collection/_truncate.py
+++ b/aeon/transformations/collection/_truncate.py
@@ -105,7 +105,7 @@ class Truncator(BaseCollectionTransformer):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -121,7 +121,6 @@ class Truncator(BaseCollectionTransformer):
             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`
         """
         params = {"truncated_length": 5}
         return params
diff --git a/aeon/transformations/collection/channel_selection/_channel_scorer.py b/aeon/transformations/collection/channel_selection/_channel_scorer.py
index e4289f66..4306cdfe 100644
--- a/aeon/transformations/collection/channel_selection/_channel_scorer.py
+++ b/aeon/transformations/collection/channel_selection/_channel_scorer.py
@@ -129,7 +129,7 @@ class ChannelScorer(BaseChannelSelector):
         return self
 
     @classmethod
-    def get_test_params(cls, parameter_set: str = "default") -> TypingDict[str, any]:
+    def _get_test_params(cls, parameter_set: str = "default") -> TypingDict[str, any]:
         """Return testing parameter settings for the estimator.
 
         Parameters
diff --git a/aeon/transformations/collection/compose/_pipeline.py b/aeon/transformations/collection/compose/_pipeline.py
index 3f66b2c4..a20f198e 100644
--- a/aeon/transformations/collection/compose/_pipeline.py
+++ b/aeon/transformations/collection/compose/_pipeline.py
@@ -76,7 +76,7 @@ class CollectionTransformerPipeline(BaseCollectionPipeline, BaseCollectionTransf
         super().__init__(transformers=transformers, _estimator=None)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -91,7 +91,6 @@ class CollectionTransformerPipeline(BaseCollectionPipeline, BaseCollectionTransf
             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`.
         """
         from aeon.transformations.collection import Truncator
         from aeon.transformations.collection.feature_based import (
diff --git a/aeon/transformations/collection/convolution_based/rocketGPU/_rocket_gpu.py b/aeon/transformations/collection/convolution_based/rocketGPU/_rocket_gpu.py
index fbfd5d18..547c077a 100644
--- a/aeon/transformations/collection/convolution_based/rocketGPU/_rocket_gpu.py
+++ b/aeon/transformations/collection/convolution_based/rocketGPU/_rocket_gpu.py
@@ -226,7 +226,7 @@ class ROCKETGPU(BaseROCKETGPU):
         return output_rocket
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the transformer.
 
         Parameters
@@ -242,7 +242,6 @@ class ROCKETGPU(BaseROCKETGPU):
             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`
         """
         params = {
             "n_filters": 5,
diff --git a/aeon/transformations/collection/dictionary_based/_paa.py b/aeon/transformations/collection/dictionary_based/_paa.py
index 2e8690e6..f9efae75 100644
--- a/aeon/transformations/collection/dictionary_based/_paa.py
+++ b/aeon/transformations/collection/dictionary_based/_paa.py
@@ -124,7 +124,7 @@ class PAA(BaseCollectionTransformer):
             return X_inverse_paa
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -140,7 +140,6 @@ class PAA(BaseCollectionTransformer):
             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`
         """
         params = {"n_segments": 10}
         return params
diff --git a/aeon/transformations/collection/dictionary_based/_sax.py b/aeon/transformations/collection/dictionary_based/_sax.py
index b5f86c5d..fe49423b 100644
--- a/aeon/transformations/collection/dictionary_based/_sax.py
+++ b/aeon/transformations/collection/dictionary_based/_sax.py
@@ -229,7 +229,7 @@ class SAX(BaseCollectionTransformer):
         return breakpoints, breakpoints_mid
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -245,7 +245,6 @@ class SAX(BaseCollectionTransformer):
             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`
         """
         params = {"n_segments": 10, "alphabet_size": 8}
         return params
diff --git a/aeon/transformations/collection/dictionary_based/_sfa.py b/aeon/transformations/collection/dictionary_based/_sfa.py
index 8a67793c..49476483 100644
--- a/aeon/transformations/collection/dictionary_based/_sfa.py
+++ b/aeon/transformations/collection/dictionary_based/_sfa.py
@@ -1151,7 +1151,7 @@ class SFA(BaseCollectionTransformer):
         return letters
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -1167,7 +1167,6 @@ class SFA(BaseCollectionTransformer):
             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`
         """
         # small window size for testing
         params = {"window_size": 4}
diff --git a/aeon/transformations/collection/dictionary_based/_sfa_fast.py b/aeon/transformations/collection/dictionary_based/_sfa_fast.py
index ede46bdb..78e3a18b 100644
--- a/aeon/transformations/collection/dictionary_based/_sfa_fast.py
+++ b/aeon/transformations/collection/dictionary_based/_sfa_fast.py
@@ -690,7 +690,7 @@ class SFAFast(BaseCollectionTransformer):
         )
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -705,7 +705,6 @@ class SFAFast(BaseCollectionTransformer):
             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`
         """
         # small window size for testing
         params = {
diff --git a/aeon/transformations/collection/feature_based/_tsfresh.py b/aeon/transformations/collection/feature_based/_tsfresh.py
index c9bb8150..4e027332 100644
--- a/aeon/transformations/collection/feature_based/_tsfresh.py
+++ b/aeon/transformations/collection/feature_based/_tsfresh.py
@@ -302,7 +302,7 @@ class TSFreshFeatureExtractor(_TSFreshFeatureExtractor):
         return Xt.to_numpy()
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -318,7 +318,6 @@ class TSFreshFeatureExtractor(_TSFreshFeatureExtractor):
             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`
         """
         features_to_calc = [
             "dim_0__quantile__q_0.6",
@@ -665,7 +664,7 @@ class TSFreshRelevantFeatureExtractor(_TSFreshFeatureExtractor):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -681,7 +680,6 @@ class TSFreshRelevantFeatureExtractor(_TSFreshFeatureExtractor):
             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`
         """
         params = {
             "default_fc_parameters": "efficient",
diff --git a/aeon/transformations/collection/interval_based/_random_intervals.py b/aeon/transformations/collection/interval_based/_random_intervals.py
index c43b01f5..afcae013 100644
--- a/aeon/transformations/collection/interval_based/_random_intervals.py
+++ b/aeon/transformations/collection/interval_based/_random_intervals.py
@@ -475,7 +475,7 @@ class RandomIntervals(BaseCollectionTransformer):
         return True
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -490,7 +490,6 @@ class RandomIntervals(BaseCollectionTransformer):
             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`
         """
         if parameter_set == "results_comparison":
             return {"n_intervals": 3}
diff --git a/aeon/transformations/collection/interval_based/_supervised_intervals.py b/aeon/transformations/collection/interval_based/_supervised_intervals.py
index 5f787e6f..fcdc1faf 100644
--- a/aeon/transformations/collection/interval_based/_supervised_intervals.py
+++ b/aeon/transformations/collection/interval_based/_supervised_intervals.py
@@ -545,7 +545,7 @@ class SupervisedIntervals(BaseCollectionTransformer):
         return True
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -560,7 +560,6 @@ class SupervisedIntervals(BaseCollectionTransformer):
             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`
         """
         if parameter_set == "results_comparison":
             return {
diff --git a/aeon/transformations/collection/shapelet_based/_dilated_shapelet_transform.py b/aeon/transformations/collection/shapelet_based/_dilated_shapelet_transform.py
index b18c5f25..2d47bc42 100644
--- a/aeon/transformations/collection/shapelet_based/_dilated_shapelet_transform.py
+++ b/aeon/transformations/collection/shapelet_based/_dilated_shapelet_transform.py
@@ -346,7 +346,7 @@ class RandomDilatedShapeletTransform(BaseCollectionTransformer):
             self.threshold_percentiles_ = np.asarray(self.threshold_percentiles_)
 
     @classmethod
-    def get_test_params(
+    def _get_test_params(
         cls, parameter_set: str = "default"
     ) -> "Union[Dict, TypingList[Dict]]":
         """Return testing parameter settings for the estimator.
@@ -364,7 +364,6 @@ class RandomDilatedShapeletTransform(BaseCollectionTransformer):
             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`
         """
         if parameter_set == "default":
             params = {"max_shapelets": 10}
diff --git a/aeon/transformations/collection/shapelet_based/_shapelet_transform.py b/aeon/transformations/collection/shapelet_based/_shapelet_transform.py
index 34c47850..bed9582d 100644
--- a/aeon/transformations/collection/shapelet_based/_shapelet_transform.py
+++ b/aeon/transformations/collection/shapelet_based/_shapelet_transform.py
@@ -395,7 +395,7 @@ class RandomShapeletTransform(BaseCollectionTransformer):
         return output
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -410,7 +410,6 @@ class RandomShapeletTransform(BaseCollectionTransformer):
             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`
         """
         if parameter_set == "results_comparison":
             return {"max_shapelets": 10, "n_shapelet_samples": 500}
diff --git a/aeon/transformations/collection/signature_based/_signature_method.py b/aeon/transformations/collection/signature_based/_signature_method.py
index 92767c97..7255defe 100644
--- a/aeon/transformations/collection/signature_based/_signature_method.py
+++ b/aeon/transformations/collection/signature_based/_signature_method.py
@@ -98,7 +98,7 @@ class SignatureTransformer(BaseCollectionTransformer):
         return self.signature_method.transform(X)
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -114,7 +114,6 @@ class SignatureTransformer(BaseCollectionTransformer):
             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`
         """
         params = {
             "augmentation_list": ("basepoint", "addtime"),
diff --git a/aeon/transformations/series/_acf.py b/aeon/transformations/series/_acf.py
index 56d4dab1..1e354cba 100644
--- a/aeon/transformations/series/_acf.py
+++ b/aeon/transformations/series/_acf.py
@@ -111,7 +111,7 @@ class AutoCorrelationSeriesTransformer(BaseSeriesTransformer):
         return X_t
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -127,7 +127,6 @@ class AutoCorrelationSeriesTransformer(BaseSeriesTransformer):
             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 [{}, {"n_lags": 1}]
 
@@ -235,7 +234,7 @@ class StatsModelsACF(BaseSeriesTransformer):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -251,7 +250,6 @@ class StatsModelsACF(BaseSeriesTransformer):
             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 [{}, {"n_lags": 1}]
 
@@ -350,7 +348,7 @@ class StatsModelsPACF(BaseSeriesTransformer):
         return Xt
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -366,6 +364,5 @@ class StatsModelsPACF(BaseSeriesTransformer):
             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 [{}, {"n_lags": 1}]
diff --git a/aeon/transformations/series/_bkfilter.py b/aeon/transformations/series/_bkfilter.py
index d213e67d..62440d1a 100644
--- a/aeon/transformations/series/_bkfilter.py
+++ b/aeon/transformations/series/_bkfilter.py
@@ -103,7 +103,7 @@ class BKFilter(BaseSeriesTransformer):
         return XTr
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -119,7 +119,6 @@ class BKFilter(BaseSeriesTransformer):
             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`
         """
         params = {"low": 6, "high": 24, "K": 12}
         return params
diff --git a/aeon/transformations/series/_scaled_logit.py b/aeon/transformations/series/_scaled_logit.py
index 7466b2f1..be483b99 100644
--- a/aeon/transformations/series/_scaled_logit.py
+++ b/aeon/transformations/series/_scaled_logit.py
@@ -137,7 +137,7 @@ class ScaledLogitSeriesTransformer(BaseSeriesTransformer):
         return X_inv_transformed
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -153,7 +153,6 @@ class ScaledLogitSeriesTransformer(BaseSeriesTransformer):
             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`
         """
         test_params = [
             {"lower_bound": None, "upper_bound": None},
diff --git a/docs/api_reference/anomaly_detection.rst b/docs/api_reference/anomaly_detection.rst
index 665f6f8f..8adc1168 100644
--- a/docs/api_reference/anomaly_detection.rst
+++ b/docs/api_reference/anomaly_detection.rst
@@ -69,6 +69,7 @@ Detectors
     :toctree: auto_generated/
     :template: class.rst
 
+    COPOD
     DWT_MLEAD
     IsolationForest
     KMeansAD
diff --git a/docs/examples.md b/docs/examples.md
index 1d8508a0..542352ae 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -108,7 +108,7 @@ Shapelet based TSC
 :::
 
 :::{grid-item-card}
-:img-top: images/logo/aeon-logo-blue-2-transparent.png
+:img-top: examples/classification/img/early_classification.png
 :class-img-top: aeon-card-image-m
 :link: /examples/classification/early_classification.ipynb
 :link-type: ref
@@ -155,7 +155,7 @@ Overview of Time Series Clustering (TSCL)
 :::
 
 :::{grid-item-card}
-:img-top: images/logo/aeon-logo-blue-2-transparent.png
+:img-top: examples/clustering/img/partitional.png
 :class-img-top: aeon-card-image-m
 :link: /examples/clustering/partitional_clustering.ipynb
 :link-type: ref
@@ -301,7 +301,7 @@ ClaSP segmentation
 :::
 
 :::{grid-item-card}
-:img-top: images/logo/aeon-logo-blue-2-transparent.png
+:img-top: examples/segmentation/img/hidalgo.png
 :class-img-top: aeon-card-image-m
 :link: /examples/segmentation/hidalgo_segmentation.ipynb
 :link-type: ref
@@ -350,7 +350,7 @@ Using aeon distances with scikit-learn
 
 
 :::{grid-item-card}
-:img-top: images/logo/aeon-logo-blue-2-transparent.png
+:img-top: examples/similarity_search/img/sim_search.png
 :class-img-top: aeon-card-image-m
 :link: /examples/similarity_search/similarity_search.ipynb
 :link-type: ref
@@ -361,7 +361,7 @@ Intro to similarity search
 :::
 
 :::{grid-item-card}
-:img-top: images/logo/aeon-logo-blue-2-transparent.png
+:img-top: examples/similarity_search/img/distance_profile.png
 :class-img-top: aeon-card-image-m
 :link: /examples/similarity_search/distance_profiles.ipynb
 :link-type: ref
@@ -372,7 +372,7 @@ Deep dive into distance profiles
 :::
 
 :::{grid-item-card}
-:img-top: images/logo/aeon-logo-blue-2-transparent.png
+:img-top: examples/similarity_search/img/code_speed.png
 :class-img-top: aeon-card-image-m
 :link: /examples/similarity_search/code_speed.ipynb
 :link-type: ref
diff --git a/docs/papers_using_aeon.md b/docs/papers_using_aeon.md
index c9c127ed..5764664d 100644
--- a/docs/papers_using_aeon.md
+++ b/docs/papers_using_aeon.md
@@ -18,6 +18,10 @@ the paper and a link to the code in your personal GitHub or other repository.
   and experimental evaluation of recent time series classification algorithms.
   Data Mining and Knowledge Discovery, online first, open access.
   [Paper](https://link.springer.com/article/10.1007/s10618-024-01022-1) [Webpage/Code](https://tsml-eval.readthedocs.io/en/stable/publications/2023/tsc_bakeoff/tsc_bakeoff_2023.html)
+- Spinnato, F. and Guidotti, R. and Monreale, A. and Nanni, M. (2024). Fast, Interpretable,
+  and Deterministic Time Series Classification With a Bag-of-Receptive-Fields.
+  IEEE Access, vol. 12, (pp. 137893-137912).
+  [Paper](https://ieeexplore.ieee.org/document/10684604) [Code](https://github.com/fspinna/borf)
 
 - Schäfer, P, and Leser, U. (2023). WEASEL 2.0: a random dilated dictionary transform
   for fast, accurate and memory constrained time series classification.


Test patch:
diff --git a/aeon/anomaly_detection/tests/test_copod.py b/aeon/anomaly_detection/tests/test_copod.py
new file mode 100644
index 00000000..b1cddaa4
--- /dev/null
+++ b/aeon/anomaly_detection/tests/test_copod.py
@@ -0,0 +1,61 @@
+"""Tests for the COPOD class."""
+
+import numpy as np
+import pytest
+
+from aeon.anomaly_detection import COPOD
+from aeon.testing.data_generation import make_example_1d_numpy
+from aeon.utils.validation._dependencies import _check_soft_dependencies
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("pyod", severity="none"),
+    reason="required soft dependency PyOD not available",
+)
+def test_copod_default():
+    """Test COPOD."""
+    series = make_example_1d_numpy(n_timepoints=80, random_state=0)
+    series[50:58] -= 2
+
+    copod = COPOD(window_size=10, stride=1)
+    pred = copod.fit_predict(series, axis=0)
+
+    assert pred.shape == (80,)
+    assert pred.dtype == np.float_
+    assert 50 <= np.argmax(pred) <= 60
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("pyod", severity="none"),
+    reason="required soft dependency PyOD not available",
+)
+def test_copod_pyod_parameters():
+    """Test parameters are correctly passed to the PyOD model."""
+    params = {"n_jobs": 2}
+    copod = COPOD(**params)
+
+    assert copod.pyod_model.n_jobs == params["n_jobs"]
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("pyod", severity="none"),
+    reason="required soft dependency PyOD not available",
+)
+def test_aeon_copod_with_pyod_copod():
+    """Test COPOD with PyOD COPOD."""
+    from pyod.models.copod import COPOD as PyODCOPOD
+
+    series = make_example_1d_numpy(n_timepoints=100, random_state=0)
+    series[20:30] -= 2
+
+    # fit and predict with aeon COPOD
+    copod = COPOD(window_size=1, stride=1)
+    copod_preds = copod.fit_predict(series)
+
+    # fit and predict with PyOD COPOD
+    _series = series.reshape(-1, 1)
+    pyod_copod = PyODCOPOD()
+    pyod_copod.fit(_series)
+    pyod_copod_preds = pyod_copod.decision_function(_series)
+
+    assert np.allclose(copod_preds, pyod_copod_preds)
diff --git a/aeon/classification/interval_based/tests/test_interval_pipelines.py b/aeon/classification/interval_based/tests/test_interval_pipelines.py
index ca4b4dfb..4e0f120f 100644
--- a/aeon/classification/interval_based/tests/test_interval_pipelines.py
+++ b/aeon/classification/interval_based/tests/test_interval_pipelines.py
@@ -27,9 +27,11 @@ def test_random_interval_classifier(cls):
 
 def test_parameter_sets():
     """Test results comparison parameter sets."""
-    paras = SupervisedIntervalClassifier.get_test_params(
+    paras = SupervisedIntervalClassifier._get_test_params(
         parameter_set="results_comparison"
     )
     assert paras["n_intervals"] == 2
-    paras = RandomIntervalClassifier.get_test_params(parameter_set="results_comparison")
+    paras = RandomIntervalClassifier._get_test_params(
+        parameter_set="results_comparison"
+    )
     assert paras["n_intervals"] == 3
diff --git a/aeon/classification/tests/test_sklearn_compatability.py b/aeon/classification/tests/test_sklearn_compatability.py
index 0e084fe2..e6b66684 100644
--- a/aeon/classification/tests/test_sklearn_compatability.py
+++ b/aeon/classification/tests/test_sklearn_compatability.py
@@ -61,18 +61,18 @@ COMPOSITE_ESTIMATORS = [
     Pipeline(
         [
             ("transform", Resizer(length=10)),
-            ("clf", CanonicalIntervalForestClassifier.create_test_instance()),
+            ("clf", CanonicalIntervalForestClassifier._create_test_instance()),
         ]
     ),
     VotingClassifier(
         estimators=[
-            ("clf1", CanonicalIntervalForestClassifier.create_test_instance()),
-            ("clf2", CanonicalIntervalForestClassifier.create_test_instance()),
-            ("clf3", CanonicalIntervalForestClassifier.create_test_instance()),
+            ("clf1", CanonicalIntervalForestClassifier._create_test_instance()),
+            ("clf2", CanonicalIntervalForestClassifier._create_test_instance()),
+            ("clf3", CanonicalIntervalForestClassifier._create_test_instance()),
         ]
     ),
     CalibratedClassifierCV(
-        estimator=CanonicalIntervalForestClassifier.create_test_instance(),
+        estimator=CanonicalIntervalForestClassifier._create_test_instance(),
         cv=2,
     ),
 ]
@@ -80,7 +80,7 @@ COMPOSITE_ESTIMATORS = [
 
 def test_sklearn_cross_validation():
     """Test sklearn cross-validation works with aeon data and classifiers."""
-    clf = CanonicalIntervalForestClassifier.create_test_instance()
+    clf = CanonicalIntervalForestClassifier._create_test_instance()
     X, y = make_example_3d_numpy(n_cases=20, n_channels=2, n_timepoints=30)
     scores = cross_val_score(clf, X, y=y, cv=KFold(n_splits=2))
     assert isinstance(scores, np.ndarray)
@@ -99,7 +99,7 @@ def test_sklearn_cross_validation_iterators(cross_validation_method):
 @pytest.mark.parametrize("parameter_tuning_method", PARAMETER_TUNING_METHODS)
 def test_sklearn_parameter_tuning(parameter_tuning_method):
     """Test if sklearn parameter tuners can handle aeon data and classifiers."""
-    clf = CanonicalIntervalForestClassifier.create_test_instance()
+    clf = CanonicalIntervalForestClassifier._create_test_instance()
     param_grid = {"n_intervals": [2, 3], "att_subsample_size": [2, 3]}
     X, y = make_example_3d_numpy(n_cases=20, n_channels=2, n_timepoints=30)
 
diff --git a/aeon/clustering/compose/tests/test_pipeline.py b/aeon/clustering/compose/tests/test_pipeline.py
index 5225e1d2..a263e187 100644
--- a/aeon/clustering/compose/tests/test_pipeline.py
+++ b/aeon/clustering/compose/tests/test_pipeline.py
@@ -44,7 +44,7 @@ def test_clusterer_pipeline(transformers):
     X_train, y_train = make_example_3d_numpy(n_cases=10, n_timepoints=12)
     X_test, _ = make_example_3d_numpy(n_cases=10, n_timepoints=12)
 
-    c = TimeSeriesKMeans.create_test_instance()
+    c = TimeSeriesKMeans._create_test_instance()
     pipeline = ClustererPipeline(transformers=transformers, clusterer=c)
     pipeline.fit(X_train, y_train)
     c.fit(X_train, y_train)
@@ -240,7 +240,7 @@ def test_multivariate_tag_inference():
     assert not t3.get_tag("capability:multivariate")
 
     # todo revisit with mock clusterer
-    c1 = TimeSeriesKMeans.create_test_instance()
+    c1 = TimeSeriesKMeans._create_test_instance()
     # c2 = ContractableBOSS(n_parameter_samples=5, max_ensemble_size=3)
     c3 = KMeans(n_clusters=2, max_iter=3, random_state=0)
 
diff --git a/aeon/performance_metrics/forecasting/tests/test_metrics.py b/aeon/performance_metrics/forecasting/tests/test_metrics.py
index 1d7fef49..a0aed57e 100644
--- a/aeon/performance_metrics/forecasting/tests/test_metrics.py
+++ b/aeon/performance_metrics/forecasting/tests/test_metrics.py
@@ -37,7 +37,7 @@ def test_gmse_function():
 
 
 def test_linex_function():
-    """Doctest from mean_linex_error."""
+    """Test from mean_linex_error."""
     y_true = np.array([3, -0.5, 2, 7, 2])
     y_pred = np.array([2.5, 0.0, 2, 8, 1.25])
     assert np.allclose(mean_linex_error(y_true, y_pred), 0.19802627763937575)
diff --git a/aeon/performance_metrics/forecasting/tests/test_performance_measures.py b/aeon/performance_metrics/forecasting/tests/test_performance_measures.py
index 3d1c819e..7ad7783a 100644
--- a/aeon/performance_metrics/forecasting/tests/test_performance_measures.py
+++ b/aeon/performance_metrics/forecasting/tests/test_performance_measures.py
@@ -2,18 +2,23 @@
 
 __maintainer__ = []
 
+import inspect
+
 import numpy as np
 import pandas as pd
 import pytest
 from pandas.api.types import is_numeric_dtype
 
 from aeon.performance_metrics.forecasting import (
+    geometric_mean_absolute_error,
     geometric_mean_relative_absolute_error,
     geometric_mean_relative_squared_error,
+    geometric_mean_squared_error,
     mean_absolute_error,
     mean_absolute_percentage_error,
     mean_absolute_scaled_error,
     mean_asymmetric_error,
+    mean_linex_error,
     mean_relative_absolute_error,
     mean_squared_error,
     mean_squared_percentage_error,
@@ -27,6 +32,7 @@ from aeon.performance_metrics.forecasting import (
     median_squared_scaled_error,
     relative_loss,
 )
+from aeon.performance_metrics.forecasting._functions import _get_kwarg
 from aeon.testing.data_generation._legacy import make_series
 
 RANDOM_SEED = 42
@@ -493,3 +499,60 @@ def test_y_true_y_pred_inconsistent_n_variables_raises_error(metric_func_name):
         ValueError, match="y_true and y_pred have different number of output"
     ):
         metric_func(y_true, y_pred, y_train=y_train, y_pred_benchmark=y_pred_benchmark)
+
+
+def test_kwargs():
+    """Test get_kwarg with None."""
+    with pytest.raises(ValueError):
+        _get_kwarg(None)
+
+
+functions = [
+    median_squared_scaled_error,
+    mean_squared_error,
+    # geometric_mean_relative_absolute_error,
+    geometric_mean_relative_squared_error,
+    mean_absolute_error,
+    mean_absolute_percentage_error,
+    mean_absolute_scaled_error,
+    mean_asymmetric_error,
+    mean_relative_absolute_error,
+    mean_squared_percentage_error,
+    mean_squared_scaled_error,
+    median_absolute_error,
+    median_absolute_percentage_error,
+    median_absolute_scaled_error,
+    median_relative_absolute_error,
+    median_squared_error,
+    median_squared_percentage_error,
+    relative_loss,
+    mean_linex_error,
+    geometric_mean_absolute_error,
+    geometric_mean_squared_error,
+]
+
+
+@pytest.mark.parametrize("function", functions)
+def test_check_inputs(function):
+    """Test check_consistent_lengths function in metrics."""
+    kwargs = {
+        "y_train": np.array([3, -0.5, 2, 7, 2]),
+        "y_pred_benchmark": np.array([2.5, 0.0, 2, 8, 1.25]),
+    }
+    y_true = np.array([3, -0.5, 2, 7, 2])
+    y_pred = np.array([2.5, 0.0, 2, 8, 1.25])
+    function(y_true, y_pred, **kwargs)
+    if "horizon_weight" in inspect.signature(function).parameters:
+        with pytest.raises(ValueError):
+            function(y_true, y_pred, horizon_weight=[0.1, 0.2], **kwargs)
+    y_pred = np.array([[2.5, 0.0, 2, 8, 1.25], [2.5, 0.0, 2, 8, 1.25]])
+    with pytest.raises(ValueError):
+        function(y_true, y_pred, **kwargs)
+    y_true = np.array([[3, -0.5, 2, 7], [3, -0.5, 2, 7]])
+    with pytest.raises(ValueError):
+        function(y_true, y_pred, **kwargs)
+    y_true = np.array(
+        [[2.5, 0.0, 2, 8, 1.25], [2.5, 0.0, 2, 8, 1.25], [2.5, 0.0, 2, 8, 1.25]]
+    )
+    with pytest.raises(ValueError):
+        function(y_true, y_pred, **kwargs)
diff --git a/aeon/pipeline/tests/test_make_pipeline.py b/aeon/pipeline/tests/test_make_pipeline.py
index ea8d5df6..2e52134d 100644
--- a/aeon/pipeline/tests/test_make_pipeline.py
+++ b/aeon/pipeline/tests/test_make_pipeline.py
@@ -23,7 +23,7 @@ from aeon.transformations.collection.feature_based import SevenNumberSummaryTran
         [SevenNumberSummaryTransformer(), RandomForestClassifier(n_estimators=2)],
         [Padder(pad_length=15), DummyRegressor()],
         [SevenNumberSummaryTransformer(), RandomForestRegressor(n_estimators=2)],
-        [Padder(pad_length=15), TimeSeriesKMeans.create_test_instance()],
+        [Padder(pad_length=15), TimeSeriesKMeans._create_test_instance()],
         [SevenNumberSummaryTransformer(), KMeans(n_clusters=2, max_iter=3)],
         [Padder(pad_length=15), SevenNumberSummaryTransformer()],
         [Padder(pad_length=15), Tabularizer(), StandardScaler()],
diff --git a/aeon/regression/interval_based/tests/test_cif.py b/aeon/regression/interval_based/tests/test_cif.py
index 83deef37..db5d811f 100644
--- a/aeon/regression/interval_based/tests/test_cif.py
+++ b/aeon/regression/interval_based/tests/test_cif.py
@@ -8,7 +8,7 @@ def test_cif():
     dr = CanonicalIntervalForestRegressor(use_pycatch22=True)
     d = dr.get_tag("python_dependencies")
     assert d == "pycatch22"
-    paras = CanonicalIntervalForestRegressor.get_test_params(
+    paras = CanonicalIntervalForestRegressor._get_test_params(
         parameter_set="contracting"
     )
     assert paras["time_limit_in_minutes"] == 5
diff --git a/aeon/regression/interval_based/tests/test_dr_cif.py b/aeon/regression/interval_based/tests/test_dr_cif.py
index 145c172e..d6cf83d3 100644
--- a/aeon/regression/interval_based/tests/test_dr_cif.py
+++ b/aeon/regression/interval_based/tests/test_dr_cif.py
@@ -8,6 +8,6 @@ def test_dr_cif():
     dr = DrCIFRegressor(use_pycatch22=True)
     d = dr.get_tag("python_dependencies")
     assert d[0] == "pycatch22"
-    paras = DrCIFRegressor.get_test_params(parameter_set="contracting")
+    paras = DrCIFRegressor._get_test_params(parameter_set="contracting")
     assert paras["time_limit_in_minutes"] == 5
     assert paras["att_subsample_size"] == 2
diff --git a/aeon/regression/interval_based/tests/test_interval_forest.py b/aeon/regression/interval_based/tests/test_interval_forest.py
index 55651660..173fe7df 100644
--- a/aeon/regression/interval_based/tests/test_interval_forest.py
+++ b/aeon/regression/interval_based/tests/test_interval_forest.py
@@ -5,6 +5,6 @@ from aeon.regression.interval_based import IntervalForestRegressor
 
 def test_cif():
     """Test with IntervalForestRegressor contracting."""
-    paras = IntervalForestRegressor.get_test_params(parameter_set="contracting")
+    paras = IntervalForestRegressor._get_test_params(parameter_set="contracting")
     assert paras["time_limit_in_minutes"] == 5
     assert paras["n_intervals"] == 2
diff --git a/aeon/testing/estimator_checking/_estimator_checking.py b/aeon/testing/estimator_checking/_estimator_checking.py
index 4bca59e2..a6ba9dc1 100644
--- a/aeon/testing/estimator_checking/_estimator_checking.py
+++ b/aeon/testing/estimator_checking/_estimator_checking.py
@@ -43,9 +43,9 @@ def parametrize_with_checks(
     ----------
     estimators : list of aeon BaseAeonEstimator instances or classes
         Estimators to generate checks for. If an item is a class, an instance will
-        be created using BaseAeonEstimator.create_test_instance().
+        be created using BaseAeonEstimator._create_test_instance().
     use_first_parameter_set : bool, default=False
-        If True, only the first parameter set from get_test_params will be used if a
+        If True, only the first parameter set from _get_test_params will be used if a
         class is passed.
 
     Returns
@@ -117,13 +117,13 @@ def check_estimator(
     ----------
     estimator : aeon BaseAeonEstimator instance or class
         Estimator to run checks on. If estimator is a class, an instance will
-        be created using BaseAeonEstimator.create_test_instance().
+        be created using BaseAeonEstimator._create_test_instance().
     raise_exceptions : bool, optional, default=False
         Whether to return exceptions/failures in the results dict, or raise them
             if False: returns exceptions in returned `results` dict
             if True: raises exceptions as they occur
     use_first_parameter_set : bool, default=False
-        If True, only the first parameter set from get_test_params will be used if a
+        If True, only the first parameter set from _get_test_params will be used if a
         class is passed.
     checks_to_run : str or list of str, default=None
         Name(s) of checks to run. This should include the function name of the check to
diff --git a/aeon/testing/estimator_checking/_yield_classification_checks.py b/aeon/testing/estimator_checking/_yield_classification_checks.py
index ba8ceed8..1a019b3d 100644
--- a/aeon/testing/estimator_checking/_yield_classification_checks.py
+++ b/aeon/testing/estimator_checking/_yield_classification_checks.py
@@ -100,7 +100,7 @@ def check_classifier_against_expected_results(estimator_class):
             continue
 
         # we only use the first estimator instance for testing
-        estimator_instance = estimator_class.create_test_instance(
+        estimator_instance = estimator_class._create_test_instance(
             parameter_set="results_comparison"
         )
         # set random seed if possible
@@ -141,7 +141,7 @@ def check_classifier_tags_consistent(estimator_class):
     if multivariate:
         X = np.random.random((10, 2, 20))
         y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1])
-        inst = estimator_class.create_test_instance(parameter_set="default")
+        inst = estimator_class._create_test_instance(parameter_set="default")
         inst.fit(X, y)
         inst.predict(X)
         inst.predict_proba(X)
@@ -166,7 +166,7 @@ def check_classifier_does_not_override_final_methods(estimator_class):
 
 def check_contracted_classifier(estimator_class, datatype):
     """Test classifiers that can be contracted."""
-    estimator_instance = estimator_class.create_test_instance(
+    estimator_instance = estimator_class._create_test_instance(
         parameter_set="contracting"
     )
 
diff --git a/aeon/testing/estimator_checking/_yield_clustering_checks.py b/aeon/testing/estimator_checking/_yield_clustering_checks.py
index 6f74139f..4843f130 100644
--- a/aeon/testing/estimator_checking/_yield_clustering_checks.py
+++ b/aeon/testing/estimator_checking/_yield_clustering_checks.py
@@ -43,7 +43,7 @@ def check_clusterer_tags_consistent(estimator_class):
     multivariate = estimator_class.get_class_tag("capability:multivariate")
     if multivariate:
         X = np.random.random((10, 2, 10))
-        inst = estimator_class.create_test_instance(parameter_set="default")
+        inst = estimator_class._create_test_instance(parameter_set="default")
         inst.fit(X)
         inst.predict(X)
         inst.predict_proba(X)
diff --git a/aeon/testing/estimator_checking/_yield_collection_transformation_checks.py b/aeon/testing/estimator_checking/_yield_collection_transformation_checks.py
index ee7636d5..c62b9d54 100644
--- a/aeon/testing/estimator_checking/_yield_collection_transformation_checks.py
+++ b/aeon/testing/estimator_checking/_yield_collection_transformation_checks.py
@@ -35,7 +35,7 @@ def check_channel_selectors(estimator_class):
     """
     X, _ = make_example_3d_numpy(n_cases=20, n_channels=6, n_timepoints=30)
     y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
-    cs = estimator_class.create_test_instance(return_first=True)
+    cs = estimator_class._create_test_instance(return_first=True)
     assert not cs.get_tag("fit_is_empty")
     cs.fit(X, y)
     assert cs.channels_selected_ is not None
diff --git a/aeon/testing/estimator_checking/_yield_early_classification_checks.py b/aeon/testing/estimator_checking/_yield_early_classification_checks.py
index 1b071ee6..9459b394 100644
--- a/aeon/testing/estimator_checking/_yield_early_classification_checks.py
+++ b/aeon/testing/estimator_checking/_yield_early_classification_checks.py
@@ -56,7 +56,7 @@ def check_early_classifier_against_expected_results(estimator_class):
             continue
 
         # we only use the first estimator instance for testing
-        estimator_instance = estimator_class.create_test_instance(
+        estimator_instance = estimator_class._create_test_instance(
             parameter_set="results_comparison"
         )
         # set random seed if possible
diff --git a/aeon/testing/estimator_checking/_yield_estimator_checks.py b/aeon/testing/estimator_checking/_yield_estimator_checks.py
index 34370855..20664bea 100644
--- a/aeon/testing/estimator_checking/_yield_estimator_checks.py
+++ b/aeon/testing/estimator_checking/_yield_estimator_checks.py
@@ -91,7 +91,7 @@ def _yield_all_aeon_checks(
     if has_dependencies:
         if isclass(estimator) and issubclass(estimator, BaseAeonEstimator):
             estimator_class = estimator
-            estimator_instances = estimator.create_test_instance(
+            estimator_instances = estimator._create_test_instance(
                 return_first=use_first_parameter_set
             )
         elif isinstance(estimator, BaseAeonEstimator):
@@ -230,24 +230,23 @@ def _yield_estimator_checks(estimator_class, estimator_instances, datatypes):
 
 
 def check_create_test_instance(estimator_class):
-    """Check create_test_instance logic and basic constructor functionality.
+    """Check _create_test_instance logic and basic constructor functionality.
 
-    create_test_instance and create_test_instances_and_names are the
-    key methods used to create test instances in testing.
-    If this test does not pass, validity of the other tests cannot be guaranteed.
+    _create_test_instance is the key method used to create test instances in testing.
+    If this test does not pass, the validity of the other tests cannot be guaranteed.
 
     Also tests inheritance and super call logic in the constructor.
 
     Tests that:
-    * create_test_instance results in an instance of estimator_class
+    * _create_test_instance results in an instance of estimator_class
     * __init__ calls super.__init__
     * _tags_dynamic attribute for tag inspection is present after construction
     """
-    estimator = estimator_class.create_test_instance()
+    estimator = estimator_class._create_test_instance()
 
     # Check that method does not construct object of other class than itself
     assert isinstance(estimator, estimator_class), (
-        "object returned by create_test_instance must be an instance of the class, "
+        "object returned by _create_test_instance must be an instance of the class, "
         f"found {type(estimator)}"
     )
 
@@ -311,8 +310,8 @@ def check_set_params_sklearn(estimator_class):
     we use the other test parameter settings (which are assumed valid).
     This guarantees settings which play along with the __init__ content.
     """
-    estimator = estimator_class.create_test_instance()
-    test_params = estimator_class.get_test_params()
+    estimator = estimator_class._create_test_instance()
+    test_params = estimator_class._get_test_params()
     if not isinstance(test_params, list):
         test_params = [test_params]
 
@@ -342,8 +341,8 @@ def check_constructor(estimator_class):
     """Check that the constructor has sklearn compatible signature and behaviour.
 
     Based on sklearn check_estimator testing of __init__ logic.
-    Uses create_test_instance to create an instance.
-    Assumes test_create_test_instance has passed and certified create_test_instance.
+    Uses _create_test_instance to create an instance.
+    Assumes test_create_test_instance has passed and certified _create_test_instance.
 
     Tests that:
     * constructor has no varargs
@@ -358,7 +357,7 @@ def check_constructor(estimator_class):
     msg = "constructor __init__ should have no varargs"
     assert getfullargspec(estimator_class.__init__).varkw is None, msg
 
-    estimator = estimator_class.create_test_instance()
+    estimator = estimator_class._create_test_instance()
     assert isinstance(estimator, estimator_class)
 
     # Ensure that each parameter is set in init
@@ -382,7 +381,7 @@ def check_constructor(estimator_class):
 
     params = estimator.get_params()
 
-    test_params = estimator_class.get_test_params()
+    test_params = estimator_class._get_test_params()
     if isinstance(test_params, list):
         test_params = test_params[0]
     test_params = test_params.keys()
@@ -392,7 +391,7 @@ def check_constructor(estimator_class):
     for param in init_params:
         assert param.default != param.empty, (
             "parameter `%s` for %s has no default value and is not "
-            "set in `get_test_params`" % (param.name, estimator.__class__.__name__)
+            "set in _get_test_params" % (param.name, estimator.__class__.__name__)
         )
         if type(param.default) is type:
             assert param.default in [np.float64, np.int64]
diff --git a/aeon/testing/estimator_checking/_yield_regression_checks.py b/aeon/testing/estimator_checking/_yield_regression_checks.py
index 0c62c0f6..3a8e5388 100644
--- a/aeon/testing/estimator_checking/_yield_regression_checks.py
+++ b/aeon/testing/estimator_checking/_yield_regression_checks.py
@@ -71,7 +71,7 @@ def check_regressor_against_expected_results(estimator_class):
             continue
 
         # we only use the first estimator instance for testing
-        estimator_instance = estimator_class.create_test_instance(
+        estimator_instance = estimator_class._create_test_instance(
             parameter_set="results_comparison"
         )
         # set random seed if possible
@@ -115,7 +115,7 @@ def check_regressor_tags_consistent(estimator_class):
     if multivariate:
         X = np.random.random((10, 2, 20))
         y = np.random.random(10)
-        inst = estimator_class.create_test_instance(parameter_set="default")
+        inst = estimator_class._create_test_instance(parameter_set="default")
         inst.fit(X, y)
         inst.predict(X)
 
diff --git a/aeon/testing/estimator_checking/_yield_soft_dependency_checks.py b/aeon/testing/estimator_checking/_yield_soft_dependency_checks.py
index 4539fafd..83c6f96b 100644
--- a/aeon/testing/estimator_checking/_yield_soft_dependency_checks.py
+++ b/aeon/testing/estimator_checking/_yield_soft_dependency_checks.py
@@ -30,12 +30,12 @@ def check_python_version_softdep(estimator_class):
 
     # should be compatible with python version and able to construct
     if _check_python_version(estimator_class, severity="none"):
-        estimator_class.create_test_instance()
+        estimator_class._create_test_instance()
     # should raise a specific error if python version is incompatible
     else:
         pyspec = estimator_class.get_class_tag("python_version", None)
         with pytest.raises(ModuleNotFoundError) as ex_info:
-            estimator_class.create_test_instance()
+            estimator_class._create_test_instance()
         assert "requires python version to be" in str(ex_info.value), (
             f"Estimator {estimator_class.__name__} has python version bound "
             f"{pyspec} according to tags, but does not raise an appropriate "
@@ -54,11 +54,11 @@ def check_python_dependency_softdep(estimator_class):
 
     # should be compatible with installed dependencies and able to construct
     if softdeps is None or _check_soft_dependencies(softdeps, severity="none"):
-        estimator_class.create_test_instance()
+        estimator_class._create_test_instance()
     # should raise a specific error if any soft dependencies are missing
     else:
         with pytest.raises(ModuleNotFoundError) as ex_info:
-            estimator_class.create_test_instance()
+            estimator_class._create_test_instance()
         assert (
             "is a soft dependency and not included in the base aeon installation"
             in str(ex_info.value)
diff --git a/aeon/testing/estimator_checking/_yield_transformation_checks.py b/aeon/testing/estimator_checking/_yield_transformation_checks.py
index 6bb5f0d9..6383c879 100644
--- a/aeon/testing/estimator_checking/_yield_transformation_checks.py
+++ b/aeon/testing/estimator_checking/_yield_transformation_checks.py
@@ -59,7 +59,7 @@ def check_transformer_against_expected_results(estimator_class):
             continue
 
         # we only use the first estimator instance for testing
-        estimator_instance = estimator_class.create_test_instance(
+        estimator_instance = estimator_class._create_test_instance(
             parameter_set="results_comparison"
         )
         # set random seed if possible
diff --git a/aeon/testing/estimator_checking/tests/test_check_estimator.py b/aeon/testing/estimator_checking/tests/test_check_estimator.py
index 1b2faa0e..f8f5b41f 100644
--- a/aeon/testing/estimator_checking/tests/test_check_estimator.py
+++ b/aeon/testing/estimator_checking/tests/test_check_estimator.py
@@ -44,7 +44,7 @@ def test_parametrize_with_checks_classes(check):
     assert equal, msg
 
 
-test_instances = [c.create_test_instance() for c in list(test_classes.values())]
+test_instances = [c._create_test_instance() for c in list(test_classes.values())]
 test_instances = {c.__class__.__name__: c for c in test_instances}
 
 
@@ -63,7 +63,7 @@ def test_parametrize_with_checks_instances(check):
 @pytest.mark.parametrize("estimator_class", list(test_classes.values()))
 def test_check_estimator_passed(estimator_class):
     """Test that check_estimator returns only passed tests for examples we know pass."""
-    estimator = estimator_class.create_test_instance()
+    estimator = estimator_class._create_test_instance()
 
     result_class = check_estimator(estimator_class, verbose=False)
     assert all(x == "PASSED" for x in result_class.values())
diff --git a/aeon/testing/expected_results/results_reproduction/classifier_results_reproduction.py b/aeon/testing/expected_results/results_reproduction/classifier_results_reproduction.py
index 441a4964..aff13ceb 100644
--- a/aeon/testing/expected_results/results_reproduction/classifier_results_reproduction.py
+++ b/aeon/testing/expected_results/results_reproduction/classifier_results_reproduction.py
@@ -116,153 +116,159 @@ def _print_array(test_name, array):
 
 def _print_results_for_classifier(classifier_name, dataset_name):
     if classifier_name == "ChannelEnsembleClassifier":
-        classifier = ChannelEnsembleClassifier.create_test_instance(
+        classifier = ChannelEnsembleClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "WeightedEnsembleClassifier":
-        classifier = WeightedEnsembleClassifier.create_test_instance(
+        classifier = WeightedEnsembleClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "ClassifierPipeline":
-        classifier = ClassifierPipeline.create_test_instance(
+        classifier = ClassifierPipeline._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "BOSSEnsemble":
-        classifier = BOSSEnsemble.create_test_instance(
+        classifier = BOSSEnsemble._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "ContractableBOSS":
-        classifier = ContractableBOSS.create_test_instance(
+        classifier = ContractableBOSS._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "MUSE":
-        classifier = MUSE.create_test_instance(parameter_set="results_comparison")
+        classifier = MUSE._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "TemporalDictionaryEnsemble":
-        classifier = TemporalDictionaryEnsemble.create_test_instance(
+        classifier = TemporalDictionaryEnsemble._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "WEASEL":
-        classifier = WEASEL.create_test_instance(parameter_set="results_comparison")
+        classifier = WEASEL._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "WEASEL_V2":
-        classifier = WEASEL_V2.create_test_instance(parameter_set="results_comparison")
+        classifier = WEASEL_V2._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "REDCOMETS":
-        classifier = REDCOMETS.create_test_instance(parameter_set="results_comparison")
+        classifier = REDCOMETS._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "ElasticEnsemble":
-        classifier = ElasticEnsemble.create_test_instance(
+        classifier = ElasticEnsemble._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "KNeighborsTimeSeriesClassifier":
-        classifier = KNeighborsTimeSeriesClassifier.create_test_instance(
+        classifier = KNeighborsTimeSeriesClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "Catch22Classifier":
-        classifier = Catch22Classifier.create_test_instance(
+        classifier = Catch22Classifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "FreshPRINCEClassifier":
-        classifier = FreshPRINCEClassifier.create_test_instance(
+        classifier = FreshPRINCEClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "RandomIntervalClassifier":
-        classifier = RandomIntervalClassifier.create_test_instance(
+        classifier = RandomIntervalClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "QUANTClassifier":
-        classifier = QUANTClassifier.create_test_instance(
+        classifier = QUANTClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "SignatureClassifier":
-        classifier = SignatureClassifier.create_test_instance(
+        classifier = SignatureClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "SummaryClassifier":
-        classifier = SummaryClassifier.create_test_instance(
+        classifier = SummaryClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "TSFreshClassifier":
-        classifier = TSFreshClassifier.create_test_instance(
+        classifier = TSFreshClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "HIVECOTEV1":
-        classifier = HIVECOTEV1.create_test_instance(parameter_set="results_comparison")
+        classifier = HIVECOTEV1._create_test_instance(
+            parameter_set="results_comparison"
+        )
     elif classifier_name == "HIVECOTEV2":
-        classifier = HIVECOTEV2.create_test_instance(parameter_set="results_comparison")
+        classifier = HIVECOTEV2._create_test_instance(
+            parameter_set="results_comparison"
+        )
     elif classifier_name == "CanonicalIntervalForestClassifier":
-        classifier = CanonicalIntervalForestClassifier.create_test_instance(
+        classifier = CanonicalIntervalForestClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "DrCIFClassifier":
-        classifier = DrCIFClassifier.create_test_instance(
+        classifier = DrCIFClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "IntervalForestClassifier":
-        classifier = IntervalForestClassifier.create_test_instance(
+        classifier = IntervalForestClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "RandomIntervalSpectralEnsembleClassifier":
-        classifier = RandomIntervalSpectralEnsembleClassifier.create_test_instance(
+        classifier = RandomIntervalSpectralEnsembleClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "RSTSF":
-        classifier = RSTSF.create_test_instance(parameter_set="results_comparison")
+        classifier = RSTSF._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "SupervisedTimeSeriesForest":
-        classifier = SupervisedTimeSeriesForest.create_test_instance(
+        classifier = SupervisedTimeSeriesForest._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "TimeSeriesForestClassifier":
-        classifier = TimeSeriesForestClassifier.create_test_instance(
+        classifier = TimeSeriesForestClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "Arsenal":
-        classifier = Arsenal.create_test_instance(parameter_set="results_comparison")
+        classifier = Arsenal._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "RocketClassifier":
-        classifier = RocketClassifier.create_test_instance(
+        classifier = RocketClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "HydraClassifier":
-        classifier = HydraClassifier.create_test_instance(
+        classifier = HydraClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "MultiRocketHydraClassifier":
-        classifier = MultiRocketHydraClassifier.create_test_instance(
+        classifier = MultiRocketHydraClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "OrdinalTDE":
-        classifier = OrdinalTDE.create_test_instance(parameter_set="results_comparison")
+        classifier = OrdinalTDE._create_test_instance(
+            parameter_set="results_comparison"
+        )
     elif classifier_name == "ShapeletTransformClassifier":
-        classifier = ShapeletTransformClassifier.create_test_instance(
+        classifier = ShapeletTransformClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "LearningShapeletClassifier":
-        classifier = LearningShapeletClassifier.create_test_instance(
+        classifier = LearningShapeletClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "MrSQMClassifier":
-        classifier = MrSQMClassifier.create_test_instance(
+        classifier = MrSQMClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "SASTClassifier":
-        classifier = SASTClassifier.create_test_instance(
+        classifier = SASTClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "ContinuousIntervalTree":
-        classifier = ContinuousIntervalTree.create_test_instance(
+        classifier = ContinuousIntervalTree._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "RotationForestClassifier":
-        classifier = RotationForestClassifier.create_test_instance(
+        classifier = RotationForestClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "ProbabilityThresholdEarlyClassifier":
-        classifier = ProbabilityThresholdEarlyClassifier.create_test_instance(
+        classifier = ProbabilityThresholdEarlyClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "BaseEarlyClassifier":
-        classifier = BaseEarlyClassifier.create_test_instance(
+        classifier = BaseEarlyClassifier._create_test_instance(
             parameter_set="results_comparison"
         )
     elif classifier_name == "TEASER":
-        classifier = TEASER.create_test_instance(parameter_set="results_comparison")
+        classifier = TEASER._create_test_instance(parameter_set="results_comparison")
     elif classifier_name == "TEASER-IF":
         classifier = TEASER(
             classification_points=[6, 10, 16, 24],
diff --git a/aeon/testing/expected_results/results_reproduction/regressor_results_reproduction.py b/aeon/testing/expected_results/results_reproduction/regressor_results_reproduction.py
index 5c47340e..9d300787 100644
--- a/aeon/testing/expected_results/results_reproduction/regressor_results_reproduction.py
+++ b/aeon/testing/expected_results/results_reproduction/regressor_results_reproduction.py
@@ -60,67 +60,67 @@ def _print_array(test_name, array):
 
 def _print_results_for_regressor(regressor_name, dataset_name):
     if regressor_name == "FreshPRINCERegressor":
-        regressor = FreshPRINCERegressor.create_test_instance(
+        regressor = FreshPRINCERegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "Catch22Regressor":
-        regressor = Catch22Regressor.create_test_instance(
+        regressor = Catch22Regressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "SummaryRegressor":
-        regressor = SummaryRegressor.create_test_instance(
+        regressor = SummaryRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "TSFreshRegressor":
-        regressor = TSFreshRegressor.create_test_instance(
+        regressor = TSFreshRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "HydraRegressor":
-        regressor = HydraRegressor.create_test_instance(
+        regressor = HydraRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "MultiRocketHydraRegressor":
-        regressor = MultiRocketHydraRegressor.create_test_instance(
+        regressor = MultiRocketHydraRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "RocketRegressor":
-        regressor = RocketRegressor.create_test_instance(
+        regressor = RocketRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "KNeighborsTimeSeriesRegressor":
-        regressor = KNeighborsTimeSeriesRegressor.create_test_instance(
+        regressor = KNeighborsTimeSeriesRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "RISTRegressor":
-        regressor = RISTRegressor.create_test_instance(
+        regressor = RISTRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "CanonicalIntervalForestRegressor":
-        regressor = CanonicalIntervalForestRegressor.create_test_instance(
+        regressor = CanonicalIntervalForestRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "DrCIFRegressor":
-        regressor = DrCIFRegressor.create_test_instance(
+        regressor = DrCIFRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "IntervalForestRegressor":
-        regressor = IntervalForestRegressor.create_test_instance(
+        regressor = IntervalForestRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "RandomIntervalRegressor":
-        regressor = RandomIntervalRegressor.create_test_instance(
+        regressor = RandomIntervalRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "RandomIntervalSpectralEnsembleRegressor":
-        regressor = RandomIntervalSpectralEnsembleRegressor.create_test_instance(
+        regressor = RandomIntervalSpectralEnsembleRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "TimeSeriesForestRegressor":
-        regressor = TimeSeriesForestRegressor.create_test_instance(
+        regressor = TimeSeriesForestRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     elif regressor_name == "RDSTRegressor":
-        regressor = RDSTRegressor.create_test_instance(
+        regressor = RDSTRegressor._create_test_instance(
             parameter_set="results_comparison"
         )
     else:
diff --git a/aeon/testing/expected_results/results_reproduction/transform_results_reproduction.py b/aeon/testing/expected_results/results_reproduction/transform_results_reproduction.py
index 75d79f20..3b8e8809 100644
--- a/aeon/testing/expected_results/results_reproduction/transform_results_reproduction.py
+++ b/aeon/testing/expected_results/results_reproduction/transform_results_reproduction.py
@@ -45,15 +45,15 @@ def _print_array(test_name, array):
 
 def _print_results_for_transformer(transformer_name, dataset_name):
     if transformer_name == "RandomIntervals":
-        transformer = RandomIntervals.create_test_instance(
+        transformer = RandomIntervals._create_test_instance(
             parameter_set="results_comparison"
         )
     elif transformer_name == "SupervisedIntervals":
-        transformer = SupervisedIntervals.create_test_instance(
+        transformer = SupervisedIntervals._create_test_instance(
             parameter_set="results_comparison"
         )
     elif transformer_name == "RandomShapeletTransform":
-        transformer = RandomShapeletTransform.create_test_instance(
+        transformer = RandomShapeletTransform._create_test_instance(
             parameter_set="results_comparison"
         )
     else:
diff --git a/aeon/testing/mock_estimators/_mock_classifiers.py b/aeon/testing/mock_estimators/_mock_classifiers.py
index 6b4acd3c..af18857a 100644
--- a/aeon/testing/mock_estimators/_mock_classifiers.py
+++ b/aeon/testing/mock_estimators/_mock_classifiers.py
@@ -63,7 +63,7 @@ class MockClassifierMultiTestParams(BaseClassifier):
         return np.zeros(shape=(len(X),))
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the estimator.
 
         Parameters
@@ -78,6 +78,5 @@ class MockClassifierMultiTestParams(BaseClassifier):
             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 [{"return_ones": False}, {"return_ones": True}]
diff --git a/aeon/testing/mock_estimators/_mock_segmenters.py b/aeon/testing/mock_estimators/_mock_segmenters.py
index e8005a1c..82ff6a81 100644
--- a/aeon/testing/mock_estimators/_mock_segmenters.py
+++ b/aeon/testing/mock_estimators/_mock_segmenters.py
@@ -26,7 +26,7 @@ class MockSegmenter(BaseSegmenter):
         return np.array([1])
 
     @classmethod
-    def get_test_params(cls, parameter_set="default"):
+    def _get_test_params(cls, parameter_set="default"):
         """
         Return testing parameter settings for the estimator.
 
diff --git a/aeon/visualisation/estimator/tests/test_shapelet_plotting.py b/aeon/visualisation/estimator/tests/test_shapelet_plotting.py
index c4f01f03..5b2708cb 100644
--- a/aeon/visualisation/estimator/tests/test_shapelet_plotting.py
+++ b/aeon/visualisation/estimator/tests/test_shapelet_plotting.py
@@ -97,7 +97,9 @@ def test_ShapeletTransformerVisualizer(transformer_class):
     import matplotlib.pyplot as plt
 
     X, y = make_example_3d_numpy()
-    shp_transformer = transformer_class(**transformer_class.get_test_params()).fit(X, y)
+    shp_transformer = transformer_class(**transformer_class._get_test_params()).fit(
+        X, y
+    )
     shp_vis = ShapeletTransformerVisualizer(shp_transformer)
 
     fig = shp_vis.plot(0)
@@ -126,7 +128,7 @@ def test_ShapeletClassifierVisualizer(classifier_class):
     import matplotlib.pyplot as plt
 
     X, y = make_example_3d_numpy()
-    shp_transformer = classifier_class(**classifier_class.get_test_params()).fit(X, y)
+    shp_transformer = classifier_class(**classifier_class._get_test_params()).fit(X, y)
     shp_vis = ShapeletClassifierVisualizer(shp_transformer)
 
     fig = shp_vis.plot(0)