fixes

Author: MatthewMiddlehurst

tsml/compose/_channel_ensemble.py

@@ -204,17 +204,17 @@ class ChannelEnsembleClassifier(ClassifierMixin, _BaseChannelEnsemble):
     Examples
     --------
     >>> from tsml.compose import ChannelEnsembleClassifier
-    >>> from tsml.interval_based import IntervalForestClassifier
+    >>> from tsml.dummy import DummyClassifier
     >>> from tsml.utils.testing import generate_3d_test_data
     >>> X, y = generate_3d_test_data(n_samples=8, series_length=10, random_state=0)
     >>> reg = ChannelEnsembleClassifier(
-    ...     estimators=("tsf", IntervalForestClassifier(n_estimators=2), "all-split"),
+    ...     estimators=("d", DummyClassifier(), "all-split"),
     ...     random_state=0,
     ... )
     >>> reg.fit(X, y)
     ChannelEnsembleClassifier(...)
     >>> reg.predict(X)
-    array([0, 1, 1, 0, 0, 1, 0, 1])
+    array([0, 0, 0, 0, 0, 0, 0, 0])
     """
 
     def __init__(self, estimators, remainder="drop", random_state=None):
@@ -349,12 +349,12 @@ def get_test_params(
         params : dict or list of dict
             Parameters to create testing instances of the class.
         """
-        from tsml.interval_based import IntervalForestClassifier
+        from tsml.dummy import DummyClassifier
 
         return {
             "estimators": [
-                ("tsf1", IntervalForestClassifier(n_estimators=2), 0),
-                ("tsf2", IntervalForestClassifier(n_estimators=2), 0),
+                ("d1", DummyClassifier(), 0),
+                ("d2", DummyClassifier(), 0),
             ]
         }
 
@@ -411,19 +411,19 @@ class ChannelEnsembleRegressor(RegressorMixin, _BaseChannelEnsemble):
     Examples
     --------
     >>> from tsml.compose import ChannelEnsembleRegressor
-    >>> from tsml.interval_based import IntervalForestRegressor
+    >>> from tsml.dummy import DummyRegressor
     >>> from tsml.utils.testing import generate_3d_test_data
     >>> X, y = generate_3d_test_data(n_samples=8, series_length=10,
     ...                              regression_target=True, random_state=0)
     >>> reg = ChannelEnsembleRegressor(
-    ...     estimators=("tsf", IntervalForestRegressor(n_estimators=2), "all-split"),
+    ...     estimators=("d", DummyRegressor(), "all-split"),
     ...     random_state=0,
     ... )
     >>> reg.fit(X, y)
     ChannelEnsembleRegressor(...)
     >>> reg.predict(X)
-    array([0.31798318, 1.41426301, 1.06414747, 0.6924721 , 0.56660146,
-           1.26538944, 0.52324808, 1.0939405 ])
+    array([0.8672557, 0.8672557, 0.8672557, 0.8672557, 0.8672557, 0.8672557,
+           0.8672557, 0.8672557], dtype=float32)
     """
 
     def __init__(self, estimators, remainder="drop", random_state=None):
@@ -518,12 +518,12 @@ def get_test_params(
         params : dict or list of dict
             Parameters to create testing instances of the class.
         """
-        from tsml.interval_based import IntervalForestRegressor
+        from tsml.dummy import DummyRegressor
 
         return {
             "estimators": [
-                ("tsf1", IntervalForestRegressor(n_estimators=2), 0),
-                ("tsf2", IntervalForestRegressor(n_estimators=2), 0),
+                ("d1", DummyRegressor(), 0),
+                ("d2", DummyRegressor(), 0),
             ]
         }
 

tsml/compose/tests/test_channel_ensemble.py

@@ -9,25 +9,21 @@
     _check_key_type,
     _get_channel,
 )
-from tsml.interval_based import IntervalForestClassifier, IntervalForestRegressor
+from tsml.dummy import DummyClassifier, DummyRegressor
 from tsml.utils.testing import generate_3d_test_data, generate_unequal_test_data
 
 
 def test_single_estimator():
     """Test that a single estimator is correctly applied to all channels."""
     X, y = generate_3d_test_data(n_channels=3)
 
-    ens = ChannelEnsembleClassifier(
-        estimators=[("tsf", IntervalForestClassifier(n_estimators=2), "all")]
-    )
+    ens = ChannelEnsembleClassifier(estimators=[("d", DummyClassifier(), "all")])
     ens.fit(X, y)
 
     assert len(ens.estimators_[0][2]) == 3
     assert ens.predict(X).shape == (X.shape[0],)
 
-    ens = ChannelEnsembleRegressor(
-        estimators=[("tsf", IntervalForestRegressor(n_estimators=2), "all")]
-    )
+    ens = ChannelEnsembleRegressor(estimators=[("d", DummyRegressor(), "all")])
     ens.fit(X, y)
 
     assert len(ens.estimators_[0][2]) == 3
@@ -38,18 +34,14 @@ def test_single_estimator_split():
     """Test that a single split estimator correctly creates an estimator per channel."""
     X, y = generate_3d_test_data(n_channels=3)
 
-    ens = ChannelEnsembleClassifier(
-        estimators=("tsf", IntervalForestClassifier(n_estimators=2), "all-split")
-    )
+    ens = ChannelEnsembleClassifier(estimators=("d", DummyClassifier(), "all-split"))
     ens.fit(X, y)
 
     assert len(ens.estimators_) == 3
     assert isinstance(ens.estimators_[0][2], int)
     assert ens.predict(X).shape == (X.shape[0],)
 
-    ens = ChannelEnsembleRegressor(
-        estimators=("tsf", IntervalForestRegressor(n_estimators=2), "all-split")
-    )
+    ens = ChannelEnsembleRegressor(estimators=("d", DummyRegressor(), "all-split"))
     ens.fit(X, y)
 
     assert len(ens.estimators_) == 3
@@ -62,17 +54,17 @@ def test_remainder():
     X, y = generate_3d_test_data(n_channels=3)
 
     ens = ChannelEnsembleClassifier(
-        estimators=[("tsf", IntervalForestClassifier(n_estimators=2), 0)],
-        remainder=IntervalForestClassifier(n_estimators=2),
+        estimators=[("d", DummyClassifier(), 0)],
+        remainder=DummyClassifier(),
     )
     ens.fit(X, y)
 
     assert len(ens._remainder[2]) == 2
     assert ens.predict(X).shape == (X.shape[0],)
 
     ens = ChannelEnsembleRegressor(
-        estimators=[("tsf", IntervalForestRegressor(n_estimators=2), 0)],
-        remainder=IntervalForestRegressor(n_estimators=2),
+        estimators=[("d", DummyRegressor(), 0)],
+        remainder=DummyRegressor(),
     )
     ens.fit(X, y)
 

tsml/transformations/tests/test_interval_extraction.py

@@ -96,17 +96,6 @@ def parametrize_with_checks(estimators: List[BaseEstimator]) -> Callable:
     See Also
     --------
     check_estimator : Check if estimator adheres to tsml or scikit-learn conventions.
-
-    Examples
-    --------
-    >>> from tsml.utils.testing import parametrize_with_checks
-    >>> from tsml.interval_based import IntervalForestRegressor
-    >>> from tsml.vector import RotationForestClassifier
-    >>> @parametrize_with_checks(
-    ...     [IntervalForestRegressor(), RotationForestClassifier()]
-    ... )
-    ... def test_tsml_compatible_estimator(estimator, check):
-    ...     check(estimator)
     """
     import pytest