Repository: aeon-toolkit/aeon
Pull request #2526 (2025-02-03 17:22:32)

[MNT] stop segmenters changing state in predict
several segmenters failed the test that predict does not change the state. This PR fixes that. All have fit_is_empty = True. The choice is to not store data or to introduce a fit method. For these three

    "FLUSSSegmenter": ["check_non_state_changing_method"],
    "InformationGainSegmenter": ["check_non_state_changing_method"],
    "GreedyGaussianSegmenter": ["check_non_state_changing_method"],
just stopped storing data not used anywhere. 
edit: will leave clasp, used in notebooks


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

I have added the following labels to this PR based on the title: **[ $\\color{#EC843A}{\\textsf{maintenance}}$ ]**.
I have added the following labels to this PR based on the changes made: **[ $\\color{#0e8a16}{\\textsf{segmentation}}$, $\\color{#2C2F20}{\\textsf{testing}}$, $\\color{#FBCA04}{\\textsf{visualisation}}$ ]**. Feel free to change these if they do not properly represent the PR.

The [Checks](https://github.com/aeon-toolkit/aeon/pull/2526/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
    
TonyBagnall: > (Long time I looked at segmentation) For GG and IGTS changes should be OK, but for Fluss, if you change the `X` you give in predict it won't change the prediction, it feels weird. Couldn't you just remove the self storing of `found_cps` and the others to avoid the state change in predict ?

long time since I looked at this PR :) I just reverted FLUSS for now, will do it for the other two. 

Patch:
diff --git a/.github/utilities/generate_developer_tables.py b/.github/utilities/generate_developer_tables.py
index f03aa848..cbce50c8 100755
--- a/.github/utilities/generate_developer_tables.py
+++ b/.github/utilities/generate_developer_tables.py
@@ -11,6 +11,7 @@ https://github.com/scikit-learn/scikit-learn/blob/main/build_tools/
 generate_authors_table.py
 """
 
+import os
 import sys
 import time
 from os import path
@@ -19,7 +20,7 @@ from pathlib import Path
 import requests
 
 LOGO_URL = "https://avatars2.githubusercontent.com/u/78909809"
-REPO_FOLDER = Path(path.abspath(__file__)).parent.parent
+REPO_FOLDER = Path(path.abspath(__file__)).parent.parent.parent
 
 
 def get(url, auth):
@@ -53,12 +54,14 @@ def get_contributors(auth):
     iw_slug = "aeon-infrastructure-workgroup"
     rmw = []
     rmw_slug = "aeon-release-management-workgroup"
+    sd = []
+    sd_slug = "aeon-supporting-developers"
 
     entry_point = "https://api.github.com/orgs/aeon-toolkit/"
 
     for team_slug, lst in zip(
-        (cocw_slug, cw_slug, cd_slug, fw_slug, iw_slug, rmw_slug),
-        (cocw, cw, cd, fw, iw, rmw),
+        (cocw_slug, cw_slug, cd_slug, fw_slug, iw_slug, rmw_slug, sd_slug),
+        (cocw, cw, cd, fw, iw, rmw, sd),
     ):
         for page in range(5):  # 5 pages, 30 per page
             reply = get(f"{entry_point}teams/{team_slug}/members?page={page}", auth)
@@ -71,6 +74,7 @@ def get_contributors(auth):
     fw = {c["login"] for c in fw}
     iw = {c["login"] for c in iw}
     rmw = {c["login"] for c in rmw}
+    sd = {c["login"] for c in sd}
 
     # get profiles from GitHub
     cocw = [get_profile(login, auth) for login in cocw]
@@ -79,6 +83,7 @@ def get_contributors(auth):
     fw = [get_profile(login, auth) for login in fw]
     iw = [get_profile(login, auth) for login in iw]
     rmw = [get_profile(login, auth) for login in rmw]
+    sd = [get_profile(login, auth) for login in sd]
 
     # sort by last name
     cocw = sorted(cocw, key=key)
@@ -87,6 +92,7 @@ def get_contributors(auth):
     fw = sorted(fw, key=key)
     iw = sorted(iw, key=key)
     rmw = sorted(rmw, key=key)
+    sd = sorted(sd, key=key)
 
     return (
         cocw,
@@ -95,6 +101,7 @@ def get_contributors(auth):
         fw,
         iw,
         rmw,
+        sd,
     )
 
 
@@ -140,9 +147,11 @@ def generate_table(contributors):
 
 
 if __name__ == "__main__":
-    print("access token:", file=sys.stderr)  # noqa: T201
-    token = input()
-    auth = ("user", token)
+    auth = os.getenv("GITHUB_TOKEN")
+    if auth is None:
+        print("access token:", file=sys.stderr)  # noqa: T201
+        token = input()
+        auth = ("user", token)
 
     (
         cocw,
@@ -151,6 +160,7 @@ if __name__ == "__main__":
         fw,
         iw,
         rmw,
+        sd,
     ) = get_contributors(auth)
 
     with open(
@@ -190,3 +200,10 @@ if __name__ == "__main__":
         encoding="utf-8",
     ) as rst_file:
         rst_file.write(generate_table(rmw))
+
+    with open(
+        REPO_FOLDER / "docs" / "about" / "supporting_developers.md",
+        "w+",
+        encoding="utf-8",
+    ) as rst_file:
+        rst_file.write(generate_table(sd))
diff --git a/.github/workflows/periodic_github_maintenace.yml b/.github/workflows/periodic_github_maintenace.yml
deleted file mode 100644
index 95215031..00000000
--- a/.github/workflows/periodic_github_maintenace.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-name: GitHub Maintenance
-
-on:
-  schedule:
-    # every Monday at 01:00 AM UTC
-    - cron:  "0 1 * * 1"
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  contents: write
-
-jobs:
-  stale_branches:
-    runs-on: ubuntu-24.04
-
-    steps:
-      - name: Create app token
-        uses: actions/create-github-app-token@v2
-        id: app-token
-        with:
-          app-id: ${{ vars.PR_APP_ID }}
-          private-key: ${{ secrets.PR_APP_KEY }}
-
-      - name: Stale Branches
-        uses: crs-k/stale-branches@v7.0.1
-        with:
-          repo-token: ${{ steps.app-token.outputs.token }}
-          days-before-stale: 140
-          days-before-delete: 175
-          comment-updates: true
-          tag-committer: true
-          stale-branch-label: "stale branch"
-          compare-branches: "info"
-          pr-check: true
diff --git a/.github/workflows/pr_core_dep_import.yml b/.github/workflows/pr_core_dep_import.yml
index dc1965de..429ee28f 100644
--- a/.github/workflows/pr_core_dep_import.yml
+++ b/.github/workflows/pr_core_dep_import.yml
@@ -5,8 +5,6 @@ on:
     branches:
       - main
   pull_request:
-    branches:
-      - main
     paths:
       - "aeon/**"
       - ".github/workflows/**"
diff --git a/.github/workflows/pr_examples.yml b/.github/workflows/pr_examples.yml
index cf32ccd3..cd36250b 100644
--- a/.github/workflows/pr_examples.yml
+++ b/.github/workflows/pr_examples.yml
@@ -5,8 +5,6 @@ on:
     branches:
       - main
   pull_request:
-    branches:
-      - main
     paths:
       - "examples/**"
       - "aeon/**"
diff --git a/.github/workflows/pr_precommit.yml b/.github/workflows/pr_precommit.yml
index 547b4c6d..95a23228 100644
--- a/.github/workflows/pr_precommit.yml
+++ b/.github/workflows/pr_precommit.yml
@@ -5,8 +5,6 @@ on:
     branches:
       - main
   pull_request_target:
-    branches:
-      - main
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
diff --git a/.github/workflows/pr_typecheck.yml b/.github/workflows/pr_typecheck.yml
index f6082ac5..13ba9bec 100644
--- a/.github/workflows/pr_typecheck.yml
+++ b/.github/workflows/pr_typecheck.yml
@@ -5,8 +5,6 @@ on:
     branches:
       - main
   pull_request:
-    branches:
-      - main
     paths:
       - "aeon/**"
 
diff --git a/.github/workflows/precommit_autoupdate.yml b/.github/workflows/precommit_autoupdate.yml
deleted file mode 100644
index a670feaf..00000000
--- a/.github/workflows/precommit_autoupdate.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-name: Update pre-commit Hooks
-
-on:
-  schedule:
-    # every Monday at 12:30 AM UTC
-    - cron:  "30 0 * * 1"
-  workflow_dispatch:
-
-jobs:
-  pre-commit-auto-update:
-    runs-on: ubuntu-24.04
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Python 3.11
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - uses: browniebroke/pre-commit-autoupdate-action@v1.0.0
-
-      - if: always()
-        name: Create app token
-        uses: actions/create-github-app-token@v2
-        id: app-token
-        with:
-          app-id: ${{ vars.PR_APP_ID }}
-          private-key: ${{ secrets.PR_APP_KEY }}
-
-      - if: always()
-        uses: peter-evans/create-pull-request@v7
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-          commit-message: "Automated `pre-commit` hook update"
-          branch: pre-commit-hooks-update
-          title: "[MNT] Automated `pre-commit` hook update"
-          body: "Automated weekly update to `.pre-commit-config.yaml` hook versions."
-          labels: maintenance, full pre-commit, no changelog
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
deleted file mode 100644
index 3c57528f..00000000
--- a/.github/workflows/scorecard.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-name: Scorecard supply-chain security
-
-on:
-  branch_protection_rule:
-  schedule:
-    - cron: '30 1 * * 6'
-  push:
-    branches:
-      - main
-
-permissions: read-all
-
-jobs:
-  analysis:
-    name: Scorecard analysis
-    runs-on: ubuntu-24.04
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Needed to publish results and get a badge (see publish_results below).
-      id-token: write
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-
-      - name: Run analysis
-        uses: ossf/scorecard-action@v2.4.1
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          publish_results: true
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      - name: Upload to code-scanning
-        uses: github/codeql-action/upload-sarif@v3
-        with:
-          sarif_file: results.sarif
diff --git a/.github/workflows/weekly_github_maintenance.yml b/.github/workflows/weekly_github_maintenance.yml
new file mode 100644
index 00000000..9de93ccb
--- /dev/null
+++ b/.github/workflows/weekly_github_maintenance.yml
@@ -0,0 +1,133 @@
+name: Weekly GitHub Maintenance
+
+on:
+  schedule:
+    # every Monday at 12:30 AM UTC
+    - cron:  "30 0 * * 1"
+  workflow_dispatch:
+
+jobs:
+  pre-commit-auto-update:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Checkout main
+        uses: actions/checkout@v4
+
+      - name: Setup Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - uses: browniebroke/pre-commit-autoupdate-action@v1.0.0
+
+      - if: always()
+        name: Create app token
+        uses: actions/create-github-app-token@v2
+        id: app-token
+        with:
+          app-id: ${{ vars.PR_APP_ID }}
+          private-key: ${{ secrets.PR_APP_KEY }}
+
+      - if: always()
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          commit-message: "Automated `pre-commit` hook update"
+          branch: pre-commit-hooks-update
+          title: "[MNT] Automated `pre-commit` hook update"
+          body: "Automated weekly update to `.pre-commit-config.yaml` hook versions."
+          labels: maintenance, full pre-commit, no changelog
+
+  teams-table-auto-update:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Checkout main
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/utilities
+
+      - name: Setup Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Create app token
+        uses: actions/create-github-app-token@v2
+        id: app-token
+        with:
+          app-id: ${{ vars.PR_APP_ID }}
+          private-key: ${{ secrets.PR_APP_KEY }}
+
+      - name: Process comment edit
+        id: label_out
+        run: python .github/utilities/generate_developer_tables.py
+        env:
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
+
+      - uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          commit-message: "Automated teams tables update"
+          branch: webpage-teams-update
+          title: "[DOC] Automated website teams tables update"
+          body: "Automated weekly update to the website teams tables."
+          labels: documentation, no changelog
+
+  github-security-scorecard:
+    name: Scorecard analysis
+    runs-on: ubuntu-24.04
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Run analysis
+        uses: ossf/scorecard-action@v2.4.1
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      - name: Upload to code-scanning
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif
+
+  stale_branches:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Create app token
+        uses: actions/create-github-app-token@v2
+        id: app-token
+        with:
+          app-id: ${{ vars.PR_APP_ID }}
+          private-key: ${{ secrets.PR_APP_KEY }}
+
+      - name: Stale Branches
+        uses: crs-k/stale-branches@v8.1.1
+        with:
+          repo-token: ${{ steps.app-token.outputs.token }}
+          days-before-stale: 180
+          days-before-delete: 210
+          comment-updates: true
+          tag-committer: true
+          stale-branch-label: "stale branch"
+          compare-branches: "info"
+          pr-check: true
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 62dab7f1..b438f853 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -29,7 +29,7 @@ repos:
         args: [ "--create", "--python-folders", "aeon" ]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.9
+    rev: v0.11.10
     hooks:
       - id: ruff
         args: [ "--fix"]
diff --git a/aeon/anomaly_detection/base.py b/aeon/anomaly_detection/base.py
index 2e333cf7..689c0188 100644
--- a/aeon/anomaly_detection/base.py
+++ b/aeon/anomaly_detection/base.py
@@ -79,6 +79,9 @@ class BaseAnomalyDetector(BaseSeriesEstimator):
         "X_inner_type": "np.ndarray",  # One of VALID_SERIES_INNER_TYPES
         "fit_is_empty": True,
         "requires_y": False,
+        "learning_type:unsupervised": False,
+        "learning_type:semi_supervised": False,
+        "learning_type:supervised": False,
     }
 
     def __init__(self, axis):
diff --git a/aeon/anomaly_detection/distance_based/_cblof.py b/aeon/anomaly_detection/distance_based/_cblof.py
index 18bb044c..e4470efc 100644
--- a/aeon/anomaly_detection/distance_based/_cblof.py
+++ b/aeon/anomaly_detection/distance_based/_cblof.py
@@ -81,6 +81,9 @@ class CBLOF(PyODAdapter):
         "capability:missing_values": False,
         "fit_is_empty": False,
         "python_dependencies": ["pyod"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/distance_based/_kmeans.py b/aeon/anomaly_detection/distance_based/_kmeans.py
index bb8f188a..e4e7cc42 100644
--- a/aeon/anomaly_detection/distance_based/_kmeans.py
+++ b/aeon/anomaly_detection/distance_based/_kmeans.py
@@ -81,6 +81,9 @@ class KMeansAD(BaseAnomalyDetector):
         "capability:multivariate": True,
         "capability:missing_values": False,
         "fit_is_empty": False,
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/distance_based/_left_stampi.py b/aeon/anomaly_detection/distance_based/_left_stampi.py
index 43078ce0..59c8d1be 100644
--- a/aeon/anomaly_detection/distance_based/_left_stampi.py
+++ b/aeon/anomaly_detection/distance_based/_left_stampi.py
@@ -69,6 +69,8 @@ class LeftSTAMPi(BaseAnomalyDetector):
         "fit_is_empty": False,
         "cant_pickle": True,
         "python_dependencies": ["stumpy"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/distance_based/_lof.py b/aeon/anomaly_detection/distance_based/_lof.py
index 2c3615d9..bc736902 100644
--- a/aeon/anomaly_detection/distance_based/_lof.py
+++ b/aeon/anomaly_detection/distance_based/_lof.py
@@ -75,6 +75,9 @@ class LOF(PyODAdapter):
         "capability:multithreading": True,
         "fit_is_empty": False,
         "python_dependencies": ["pyod"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/distance_based/_merlin.py b/aeon/anomaly_detection/distance_based/_merlin.py
index b63224ac..08cc6fff 100644
--- a/aeon/anomaly_detection/distance_based/_merlin.py
+++ b/aeon/anomaly_detection/distance_based/_merlin.py
@@ -51,6 +51,11 @@ class MERLIN(BaseAnomalyDetector):
            False, False, False, False, False, False, False])
     """
 
+    _tags = {
+        "anomaly_output_type": "binary",
+        "learning_type:unsupervised": True,
+    }
+
     def __init__(self, min_length=5, max_length=50, max_iterations=500):
         self.min_length = min_length
         self.max_length = max_length
diff --git a/aeon/anomaly_detection/distance_based/_one_class_svm.py b/aeon/anomaly_detection/distance_based/_one_class_svm.py
index 9e654ee3..c0e8f055 100644
--- a/aeon/anomaly_detection/distance_based/_one_class_svm.py
+++ b/aeon/anomaly_detection/distance_based/_one_class_svm.py
@@ -90,6 +90,8 @@ class OneClassSVM(BaseAnomalyDetector):
         "capability:multivariate": True,
         "capability:missing_values": False,
         "fit_is_empty": False,
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/distance_based/_stomp.py b/aeon/anomaly_detection/distance_based/_stomp.py
index 3f8be364..9b0f5510 100644
--- a/aeon/anomaly_detection/distance_based/_stomp.py
+++ b/aeon/anomaly_detection/distance_based/_stomp.py
@@ -61,6 +61,8 @@ class STOMP(BaseAnomalyDetector):
         "capability:missing_values": False,
         "fit_is_empty": True,
         "python_dependencies": ["stumpy"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/distribution_based/_copod.py b/aeon/anomaly_detection/distribution_based/_copod.py
index bd2af0e0..9a4fe0b6 100644
--- a/aeon/anomaly_detection/distribution_based/_copod.py
+++ b/aeon/anomaly_detection/distribution_based/_copod.py
@@ -37,6 +37,9 @@ class COPOD(PyODAdapter):
         "capability:multithreading": True,
         "fit_is_empty": False,
         "python_dependencies": ["pyod"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(self, n_jobs: int = 1, window_size: int = 10, stride: int = 1):
diff --git a/aeon/anomaly_detection/distribution_based/_dwt_mlead.py b/aeon/anomaly_detection/distribution_based/_dwt_mlead.py
index cb0de0c0..fed0de5f 100644
--- a/aeon/anomaly_detection/distribution_based/_dwt_mlead.py
+++ b/aeon/anomaly_detection/distribution_based/_dwt_mlead.py
@@ -91,6 +91,8 @@ class DWT_MLEAD(BaseAnomalyDetector):
         "capability:univariate": True,
         "capability:multivariate": False,
         "capability:missing_values": False,
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/outlier_detection/_iforest.py b/aeon/anomaly_detection/outlier_detection/_iforest.py
index f13152d0..b37696fc 100644
--- a/aeon/anomaly_detection/outlier_detection/_iforest.py
+++ b/aeon/anomaly_detection/outlier_detection/_iforest.py
@@ -81,6 +81,9 @@ class IsolationForest(PyODAdapter):
         "capability:multithreading": True,
         "fit_is_empty": False,
         "python_dependencies": ["pyod"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/outlier_detection/_pyodadapter.py b/aeon/anomaly_detection/outlier_detection/_pyodadapter.py
index 5a068857..bdde293a 100644
--- a/aeon/anomaly_detection/outlier_detection/_pyodadapter.py
+++ b/aeon/anomaly_detection/outlier_detection/_pyodadapter.py
@@ -75,6 +75,9 @@ class PyODAdapter(BaseAnomalyDetector):
         "capability:missing_values": False,
         "fit_is_empty": False,
         "python_dependencies": ["pyod"],
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/outlier_detection/_stray.py b/aeon/anomaly_detection/outlier_detection/_stray.py
index e7512e2d..bc4fd6dd 100644
--- a/aeon/anomaly_detection/outlier_detection/_stray.py
+++ b/aeon/anomaly_detection/outlier_detection/_stray.py
@@ -68,6 +68,8 @@ class STRAY(BaseAnomalyDetector):
         "capability:multivariate": True,
         "capability:missing_values": True,
         "X_inner_type": "np.ndarray",
+        "anomaly_output_type": "binary",
+        "learning_type:unsupervised": True,
     }
 
     def __init__(
diff --git a/aeon/anomaly_detection/whole_series/_rockad.py b/aeon/anomaly_detection/whole_series/_rockad.py
index 603a8732..55a3cad3 100644
--- a/aeon/anomaly_detection/whole_series/_rockad.py
+++ b/aeon/anomaly_detection/whole_series/_rockad.py
@@ -69,6 +69,8 @@ class ROCKAD(BaseAnomalyDetector):
         "capability:missing_values": False,
         "capability:multithreading": True,
         "fit_is_empty": False,
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(
diff --git a/aeon/base/_base.py b/aeon/base/_base.py
index 5a336c73..7f886952 100644
--- a/aeon/base/_base.py
+++ b/aeon/base/_base.py
@@ -1,4 +1,35 @@
-"""Base class template for aeon estimators."""
+"""
+Base class for Aeon estimators.
+
+Provides a framework for defining estimators in Aeon, managing state, cloning,
+and dynamic tagging.
+
+Class Name: BaseEstimator
+
+Main Methods:
+    - reset(keep) - Resets estimator while preserving attributes.
+    - clone(random_state) - Creates a copy of the estimator.
+    - get_class_tags() / get_class_tag(tag_name) - Retrieves static class tags.
+    - get_tags() / get_tag(tag_name) - Retrieves all or specific tags.
+    - set_tags(**tag_dict) - Modifies dynamic tags.
+    - get_fitted_params(deep) - Extracts fitted parameters.
+    - _check_is_fitted() - Ensures estimator is fitted before use.
+    - _create_test_instance() - Generates test instances.
+
+Attributes
+----------
+    - is_fitted - Indicates if `fit()` has been called.
+    - _tags - Static metadata dictionary.
+    - _tags_dynamic - Stores dynamic tag modifications.
+
+Sklearn Compatibility:
+    - Implements `__sklearn_is_fitted__()` for compatibility.
+    - `_validate_data()` and `get_metadata_routing()`
+      raise NotImplementedError.
+
+Helper Methods:
+    - _clone_estimator(base_estimator, random_state) - Clones an estimator.
+"""
 
 __maintainer__ = ["MatthewMiddlehurst", "TonyBagnall"]
 __all__ = ["BaseAeonEstimator"]
diff --git a/aeon/base/_base_series.py b/aeon/base/_base_series.py
index f4609114..e3a382f3 100644
--- a/aeon/base/_base_series.py
+++ b/aeon/base/_base_series.py
@@ -1,7 +1,31 @@
-"""Base class for estimators that fit single time series.
-
-This time series can be univariate or multivariate. The time series can potentially
-contain missing values.
+"""
+Base class for single time series estimators (univariate/multivariate).
+
+Class Name: BaseSeriesEstimator
+
+Methods
+-------
+    - _preprocess_series(X, axis, store_metadata)
+      Validates and converts input `X` before fitting.
+    - _check_X(X, axis)
+      Ensures `X` is a valid type and format.
+    - _convert_X(X, axis)
+      Converts `X` to the required internal format.
+
+Attributes
+----------
+    - metadata_
+      Stores input series metadata.
+    - axis
+      Defines time axis for input data.
+    - _tags
+      Specifies estimator capabilities (e.g., univariate, multivariate).
+
+Inherited Methods:
+    - get_params()
+      Returns hyperparameters.
+    - get_fitted_params()
+      Returns learned parameters.
 """
 
 __maintainer__ = ["TonyBagnall", "MatthewMiddlehurst"]
diff --git a/aeon/benchmarking/metrics/anomaly_detection/_continuous.py b/aeon/benchmarking/metrics/anomaly_detection/_continuous.py
index ce84ee33..ade8c102 100644
--- a/aeon/benchmarking/metrics/anomaly_detection/_continuous.py
+++ b/aeon/benchmarking/metrics/anomaly_detection/_continuous.py
@@ -18,12 +18,16 @@ import numpy as np
 from sklearn.metrics import auc, f1_score, precision_recall_curve
 from sklearn.metrics import roc_auc_score as _roc_auc_score
 
+from aeon.benchmarking.metrics.anomaly_detection._range_metrics import (
+    range_f_score,
+    range_precision,
+    range_recall,
+)
 from aeon.benchmarking.metrics.anomaly_detection._util import check_y
 from aeon.benchmarking.metrics.anomaly_detection.thresholding import (
     top_k_points_threshold,
     top_k_ranges_threshold,
 )
-from aeon.utils.validation._dependencies import _check_soft_dependencies
 
 
 def roc_auc_score(y_true: np.ndarray, y_score: np.ndarray) -> float:
@@ -142,9 +146,8 @@ def f_score_at_k_ranges(
     finding a threshold on the scoring that produces at least k anomalous ranges. If `k`
     is not specified, the number of anomalies within the ground truth is used as `k`.
 
-    This implementation uses the community package
-    `prts <https://pypi.org/project/prts/>`_ as a soft-dependency to compute the
-    range-based F-score.
+    This implementation uses the aeon's implementation from `_range_metrics.py` to
+    compute the range-based F-score.
 
     Parameters
     ----------
@@ -167,12 +170,6 @@ def f_score_at_k_ranges(
     aeon.benchmarking.metrics.anomaly_detection.thresholding.top_k_ranges_threshold
         Function used to find the threshold.
     """
-    _check_soft_dependencies(
-        "prts", obj="f_score_at_k_ranges", suppress_import_stdout=True
-    )
-
-    from prts import ts_fscore
-
     y_true, y_pred = check_y(y_true, y_score, force_y_pred_continuous=True)
     if np.unique(y_score).shape[0] == 1:
         warnings.warn(
@@ -183,7 +180,8 @@ def f_score_at_k_ranges(
 
     threshold = top_k_ranges_threshold(y_true, y_score, k)
     y_pred = y_score >= threshold
-    return ts_fscore(y_true, y_pred, p_alpha=1, r_alpha=1, cardinality="reciprocal")
+    # Corrected p_alpha to 1 to match original prts behavior expectation
+    return range_f_score(y_true, y_pred, p_alpha=1, r_alpha=1, cardinality="reciprocal")
 
 
 def rp_rr_auc_score(
@@ -199,8 +197,6 @@ def rp_rr_auc_score(
 
     Computes the area under the precision recall curve when using the range-based
     precision and range-based recall metric introduced by Tatbul et al. at NeurIPS 2018
-    [1]_. This implementation uses the community package
-    `prts <https://pypi.org/project/prts/>`_ as a soft-dependency.
 
     This metric only considers the top-k predicted anomaly ranges within the scoring by
     finding a threshold on the scoring that produces at least k anomalous ranges. If `k`
@@ -242,12 +238,6 @@ def rp_rr_auc_score(
        1920–30. 2018.
        http://papers.nips.cc/paper/7462-precision-and-recall-for-time-series.pdf.
     """
-    _check_soft_dependencies(
-        "prts", obj="f_score_at_k_ranges", suppress_import_stdout=True
-    )
-
-    from prts import ts_precision, ts_recall
-
     y_true, y_pred = check_y(y_true, y_score, force_y_pred_continuous=True)
     if np.unique(y_score).shape[0] == 1:
         warnings.warn(
@@ -279,10 +269,10 @@ def rp_rr_auc_score(
     precisions = np.zeros_like(thresholds)
     for i, threshold in enumerate(thresholds):
         y_pred = (y_score >= threshold).astype(np.int64)
-        recalls[i] = ts_recall(
+        recalls[i] = range_recall(
             y_true, y_pred, alpha=r_alpha, cardinality=cardinality, bias=bias
         )
-        precisions[i] = ts_precision(
+        precisions[i] = range_precision(
             y_true, y_pred, alpha=p_alpha, cardinality=cardinality, bias=bias
         )
     # first sort by recall, then by precision to break ties
diff --git a/aeon/benchmarking/metrics/anomaly_detection/_range_metrics.py b/aeon/benchmarking/metrics/anomaly_detection/_range_metrics.py
index 7143100c..6308cd9b 100644
--- a/aeon/benchmarking/metrics/anomaly_detection/_range_metrics.py
+++ b/aeon/benchmarking/metrics/anomaly_detection/_range_metrics.py
@@ -30,10 +30,6 @@ def range_precision(
     predicted continuous anomaly range the overlap size, position, and cardinality is
     considered. For more details, please refer to the paper [1]_.
 
-    The `alpha` parameter for the existence reward was removed. Because precision
-    emphasizes prediction quality, there is no need for an existence reward and this
-    value should always be set to 0.
-
     Parameters
     ----------
     y_true : np.ndarray
@@ -41,7 +37,7 @@ def range_precision(
     y_pred : np.ndarray
         Anomaly scores for each point of the time series of shape (n_instances,).
     alpha : float
-        DEPRECATED. Default is 0 = no existence reward.
+        Default is 0 = no existence reward.
     cardinality : {'reciprocal', 'one', 'udf_gamma'}
         Cardinality type.
     bias : {'flat', 'front', 'middle', 'back'}
@@ -60,13 +56,6 @@ def range_precision(
        1920–30. 2018.
        http://papers.nips.cc/paper/7462-precision-and-recall-for-time-series.pdf.
     """
-    if alpha != 0:
-        warnings.warn(
-            "The alpha parameter should not be used in range precision. This "
-            "parameter is removed in 1.3.0.",
-            stacklevel=2,
-            category=FutureWarning,
-        )
     y_true, y_pred = check_y(y_true, y_pred, force_y_pred_continuous=False)
     if np.unique(y_pred).shape[0] == 1:
         warnings.warn(
@@ -160,9 +149,6 @@ def range_f_score(
     its optimal value at 1 and its worst value at 0. This implementation uses the
     range-based precision and range-based recall as basis.
 
-    The `p_alpha` parameter for the potential existance reward in the calculation of
-    range-based precision was removed. `p_alpha` should always be set to 0, anyway.
-
     Parameters
     ----------
     y_true : np.ndarray
@@ -173,7 +159,7 @@ def range_f_score(
         F-score beta determines the weight of recall in the combined score.
         beta < 1 lends more weight to precision, while beta > 1 favors recall.
     p_alpha : float
-        DEPRECATED. Default is 0 = no existence reward for precision.
+        Default is 0 = no existence reward for precision.
     r_alpha : float
         Weight of the existence reward. If 0: no existence reward, if 1: only
         existence reward.
@@ -197,14 +183,6 @@ def range_f_score(
        1920–30. 2018.
        http://papers.nips.cc/paper/7462-precision-and-recall-for-time-series.pdf.
     """
-    if p_alpha != 0:
-        warnings.warn(
-            "The p_alpha parameter should not be used. This parameter is removed "
-            "in 1.3.0.",
-            stacklevel=2,
-            category=FutureWarning,
-        )
-
     y_true, y_pred = check_y(y_true, y_pred, force_y_pred_continuous=False)
     if np.unique(y_pred).shape[0] == 1:
         warnings.warn(
@@ -216,7 +194,9 @@ def range_f_score(
     y_pred_ranges = _binary_to_ranges(y_pred)
     y_true_ranges = _binary_to_ranges(y_true)
 
-    precision = _ts_precision(y_pred_ranges, y_true_ranges, cardinality, p_bias)
+    precision = _ts_precision(
+        y_pred_ranges, y_true_ranges, cardinality, p_bias, p_alpha
+    )
     recall = _ts_recall(y_pred_ranges, y_true_ranges, cardinality, r_bias, r_alpha)
 
     if precision + recall > 0:
diff --git a/aeon/benchmarking/metrics/anomaly_detection/_range_ts_metrics.py b/aeon/benchmarking/metrics/anomaly_detection/_range_ts_metrics.py
index 12ad2c0e..1791d367 100644
--- a/aeon/benchmarking/metrics/anomaly_detection/_range_ts_metrics.py
+++ b/aeon/benchmarking/metrics/anomaly_detection/_range_ts_metrics.py
@@ -233,7 +233,7 @@ def _binary_to_ranges(binary_sequence):
     "Please use range_precision instead.",
     category=FutureWarning,
 )
-def ts_precision(y_pred, y_real, gamma="one", bias_type="flat"):
+def ts_precision(y_pred, y_real, gamma="one", bias_type="flat", alpha=0.0):
     """
     Calculate Precision for time series anomaly detection.
 
@@ -317,10 +317,12 @@ def ts_precision(y_pred, y_real, gamma="one", bias_type="flat"):
     flat_y_pred = _flatten_ranges(y_pred_ranges)
     flat_y_real = _flatten_ranges(y_real_ranges)
 
-    return _ts_precision(flat_y_pred, flat_y_real, gamma, bias_type)
+    return _ts_precision(flat_y_pred, flat_y_real, gamma, bias_type, alpha=alpha)
 
 
-def _ts_precision(y_pred_ranges, y_real_ranges, gamma="one", bias_type="flat"):
+def _ts_precision(
+    y_pred_ranges, y_real_ranges, gamma="one", bias_type="flat", alpha=0.0
+):
     """
     Implement range-based precision for time series anomaly detection.
 
@@ -371,13 +373,20 @@ def _ts_precision(y_pred_ranges, y_real_ranges, gamma="one", bias_type="flat"):
         overlap_reward = _calculate_overlap_reward_precision(
             pred_range, overlap_set, bias_type
         )
+
+        existence_reward = 1.0 if overlap_set else 0.0
         gamma_value = _gamma_select(cardinality, gamma)
-        total_overlap_reward += gamma_value * overlap_reward
+
+        score_i = alpha * existence_reward + (1 - alpha) * (
+            gamma_value * overlap_reward
+        )
+
+        total_overlap_reward += score_i
+
         total_cardinality += 1
 
-    precision = (
-        total_overlap_reward / total_cardinality if total_cardinality > 0 else 0.0
-    )
+    precision = total_overlap_reward / total_cardinality if total_cardinality else 0.0
+
     return precision
 
 
@@ -609,7 +618,7 @@ def ts_fscore(
        Processing Systems (NeurIPS 2018), Montréal, Canada.
        http://papers.nips.cc/paper/7462-precision-and-recall-for-time-series.pdf
     """
-    precision = ts_precision(y_pred, y_real, gamma, p_bias)
+    precision = ts_precision(y_pred, y_real, gamma, p_bias, alpha=p_alpha)
     recall = ts_recall(y_pred, y_real, gamma, r_bias, r_alpha)
 
     if precision + recall > 0:
diff --git a/aeon/clustering/_kernel_k_means.py b/aeon/clustering/_kernel_k_means.py
index 062b06eb..311228c8 100644
--- a/aeon/clustering/_kernel_k_means.py
+++ b/aeon/clustering/_kernel_k_means.py
@@ -26,7 +26,7 @@ def _kdtw_lk(x, y, local_kernel):
     diagonal_weights = np.zeros(max(x_timepoints, y_timepoints))
 
     min_timepoints = min(x_timepoints, y_timepoints)
-    diagonal_weights[1] = 1.0
+    diagonal_weights[0] = 1.0
     for i in range(1, min_timepoints):
         diagonal_weights[i] = local_kernel[i - 1, i - 1]
 
@@ -34,12 +34,12 @@ def _kdtw_lk(x, y, local_kernel):
     cumulative_dp_diag[0, 0] = 1
 
     for i in range(1, x_timepoints):
-        cost_matrix[i, 1] = cost_matrix[i - 1, 1] * local_kernel[i - 1, 2]
-        cumulative_dp_diag[i, 1] = cumulative_dp_diag[i - 1, 1] * diagonal_weights[i]
+        cost_matrix[i, 0] = cost_matrix[i - 1, 0] * local_kernel[i - 1, 0]
+        cumulative_dp_diag[i, 0] = cumulative_dp_diag[i - 1, 0] * diagonal_weights[i]
 
     for j in range(1, y_timepoints):
-        cost_matrix[1, j] = cost_matrix[1, j - 1] * local_kernel[2, j - 1]
-        cumulative_dp_diag[1, j] = cumulative_dp_diag[1, j - 1] * diagonal_weights[j]
+        cost_matrix[0, j] = cost_matrix[0, j - 1] * local_kernel[0, j - 1]
+        cumulative_dp_diag[0, j] = cumulative_dp_diag[0, j - 1] * diagonal_weights[j]
 
     for i in range(1, x_timepoints):
         for j in range(1, y_timepoints):
diff --git a/aeon/segmentation/_ggs.py b/aeon/segmentation/_ggs.py
index 0a1bb615..85b08d27 100644
--- a/aeon/segmentation/_ggs.py
+++ b/aeon/segmentation/_ggs.py
@@ -503,12 +503,10 @@ class GreedyGaussianSegmenter(BaseSegmenter):
             dimension of X. The numerical values represent distinct segments
             labels for each of the data points.
         """
-        self.change_points_ = self.ggs.find_change_points(X)
+        change_points_ = self.ggs.find_change_points(X)
 
         labels = np.zeros(X.shape[0], dtype=np.int32)
-        for i, (start, stop) in enumerate(
-            zip(self.change_points_[:-1], self.change_points_[1:])
-        ):
+        for i, (start, stop) in enumerate(zip(change_points_[:-1], change_points_[1:])):
             labels[start:stop] = i
         return labels
 
diff --git a/aeon/segmentation/_igts.py b/aeon/segmentation/_igts.py
index 1bd673b3..dd9aa399 100644
--- a/aeon/segmentation/_igts.py
+++ b/aeon/segmentation/_igts.py
@@ -106,7 +106,7 @@ class _IGTS:
     """
     Information Gain based Temporal Segmentation (GTS).
 
-    GTS is a n unsupervised method for segmenting multivariate time series
+    GTS is an unsupervised method for segmenting multivariate time series
     into non-overlapping segments by locating change points that for which
     the information gain is maximized.
 
@@ -127,18 +127,13 @@ class _IGTS:
 
     Parameters
     ----------
-    k_max: int, default=10
+    k_max : int, default=10
         Maximum number of change points to find. The number of segments is thus k+1.
-    step: : int, default=5
+    step : int, default=5
         Step size, or stride for selecting candidate locations of change points.
         Fox example a `step=5` would produce candidates [0, 5, 10, ...]. Has the same
         meaning as `step` in `range` function.
 
-    Attributes
-    ----------
-    intermediate_results_: list of `ChangePointResult`
-        Intermediate segmentation results for each k value, where k=1, 2, ..., k_max
-
     Notes
     -----
     Based on the work from [1]_.
@@ -366,9 +361,9 @@ class InformationGainSegmenter(BaseSegmenter):
             The numerical values represent distinct segment labels for each of the
             data points.
         """
-        self.change_points_ = self._igts.find_change_points(X)
-        self.intermediate_results_ = self._igts.intermediate_results_
-        return self.to_clusters(self.change_points_[1:-1], X.shape[0])
+        change_points_ = self._igts.find_change_points(X)
+        # self.intermediate_results_ = self._igts.intermediate_results_
+        return self.to_clusters(change_points_[1:-1], X.shape[0])
 
     def __repr__(self) -> str:
         """Return a string representation of the estimator."""
diff --git a/aeon/similarity_search/series/_commons.py b/aeon/similarity_search/series/_commons.py
index 646c38e5..fa3346df 100644
--- a/aeon/similarity_search/series/_commons.py
+++ b/aeon/similarity_search/series/_commons.py
@@ -41,10 +41,10 @@ def fft_sliding_dot_product(X, q):
     Use FFT convolution to calculate the sliding window dot product.
 
     This function applies the Fast Fourier Transform (FFT) to efficiently compute
-    the sliding dot product between the input time series `X` and the query `q`.
+    the sliding dot product between the input time series ``X`` and the query ``q``.
     The dot product is computed for each channel individually. The sliding window
     approach ensures that the dot product is calculated for every possible subsequence
-    of `X` that matches the length of `q`
+    of ``X`` that matches the length of ``q``
 
     Parameters
     ----------
diff --git a/aeon/similarity_search/series/motifs/_stomp.py b/aeon/similarity_search/series/motifs/_stomp.py
index 0f43bbf4..e825903f 100644
--- a/aeon/similarity_search/series/motifs/_stomp.py
+++ b/aeon/similarity_search/series/motifs/_stomp.py
@@ -157,8 +157,8 @@ class StompMotif(BaseSeriesSimilaritySearch):
             A factor of the query length used to define the exclusion zone when
             ``allow_trivial_matches`` is set to False. For a given timestamp,
             the exclusion zone starts from
-            :math:`id_timestamp - floor(length*exclusion_factor)` and end at
-            :math:`id_timestamp + floor(length*exclusion_factor)`.
+            :math:``id_timestamp - floor(length*exclusion_factor)`` and end at
+            :math:``id_timestamp + floor(length*exclusion_factor)``.
         inverse_distance : bool
             If True, the matching will be made on the inverse of the distance, and thus,
             the farther neighbors will be returned instead of the closest ones.
@@ -241,8 +241,8 @@ class StompMotif(BaseSeriesSimilaritySearch):
             A factor of the query length used to define the exclusion zone when
             ``allow_trivial_matches`` is set to False. For a given timestamp,
             the exclusion zone starts from
-            :math:`id_timestamp - floor(length * exclusion_factor)` and end at
-            :math:`id_timestamp + floor(length * exclusion_factor)`.
+            :math:``id_timestamp - floor(length * exclusion_factor)`` and end at
+            :math:``id_timestamp + floor(length * exclusion_factor)``.
         is_self_computation : bool
             Wheter X is equal to the series X_ given during fit.
 
@@ -317,7 +317,8 @@ class StompMotif(BaseSeriesSimilaritySearch):
         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.
+            ``MyClass(**params)`` or ``MyClass(**params[i])`` creates a valid test
+            instance.
         """
         if parameter_set == "default":
             params = {"length": 3}
@@ -375,9 +376,9 @@ def _stomp_normalized(
         The size of the exclusion zone used to prevent returning as top k candidates
         the ones that are close to each other (for example i and i+1).
         It is used to define a region between
-        :math:`id_timestamp - exclusion_size` and
-        :math:`id_timestamp + exclusion_size` which cannot be returned
-        as best match if :math:`id_timestamp` was already selected. By default,
+        :math:``id_timestamp - exclusion_size`` and
+        :math:``id_timestamp + exclusion_size`` which cannot be returned
+        as best match if :math:``id_timestamp`` was already selected. By default,
         the value None means that this is not used.
     inverse_distance : bool
         If True, the matching will be made on the inverse of the distance, and thus, the
@@ -470,9 +471,9 @@ def _stomp(
         The size of the exclusion zone used to prevent returning as top k candidates
         the ones that are close to each other (for example i and i+1).
         It is used to define a region between
-        :math:`id_timestamp - exclusion_size` and
-        :math:`id_timestamp + exclusion_size` which cannot be returned
-        as best match if :math:`id_timestamp` was already selected. By default,
+        :math:``id_timestamp - exclusion_size`` and
+        :math:``id_timestamp + exclusion_size`` which cannot be returned
+        as best match if :math:``id_timestamp`` was already selected. By default,
         the value None means that this is not used.
     inverse_distance : bool
         If True, the matching will be made on the inverse of the distance, and thus, the
diff --git a/aeon/similarity_search/series/neighbors/_dummy.py b/aeon/similarity_search/series/neighbors/_dummy.py
index 399297b5..031f93bc 100644
--- a/aeon/similarity_search/series/neighbors/_dummy.py
+++ b/aeon/similarity_search/series/neighbors/_dummy.py
@@ -81,8 +81,8 @@ class DummySNN(BaseSeriesSimilaritySearch):
             A factor of the query length used to define the exclusion zone when
             ``allow_neighboring_matches`` is set to False. For a given timestamp,
             the exclusion zone starts from
-            :math:`id_timestamp - floor(length * exclusion_factor)` and end at
-            :math:`id_timestamp + floor(length * exclusion_factor)`.
+            :math:``id_timestamp - floor(length * exclusion_factor)`` and end at
+            :math:``id_timestamp + floor(length * exclusion_factor)``.
         X_index : int, optional
             If ``X`` is a subsequence of X_, specify its starting timestamp in ``X_``.
             If specified, neighboring subsequences of X won't be able to match as
@@ -158,7 +158,7 @@ class DummySNN(BaseSeriesSimilaritySearch):
         ----------
         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.
+            special parameters are defined for a value, will return ``"default"`` set.
             There are currently no reserved values for transformers.
 
         Returns
@@ -166,7 +166,8 @@ class DummySNN(BaseSeriesSimilaritySearch):
         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.
+            ``MyClass(**params)`` or ``MyClass(**params[i])`` creates a valid test
+            instance.
         """
         if parameter_set == "default":
             params = {"length": 20}
diff --git a/aeon/similarity_search/series/neighbors/_mass.py b/aeon/similarity_search/series/neighbors/_mass.py
index 695dce88..f060fe93 100644
--- a/aeon/similarity_search/series/neighbors/_mass.py
+++ b/aeon/similarity_search/series/neighbors/_mass.py
@@ -90,8 +90,8 @@ class MassSNN(BaseSeriesSimilaritySearch):
             A factor of the query length used to define the exclusion zone when
             ``allow_trivial_matches`` is set to False. For a given timestamp,
             the exclusion zone starts from
-            :math:`id_timestamp - floor(length * exclusion_factor)` and end at
-            :math:`id_timestamp + floor(length * exclusion_factor)`.
+            :math:``id_timestamp - floor(length * exclusion_factor)`` and end at
+            :math:``id_timestamp + floor(length * exclusion_factor)``.
         X_index : int, optional
             If ``X`` is a subsequence of X_, specify its starting timestamp in ``X_``.
             If specified, neighboring subsequences of X won't be able to match as
@@ -178,7 +178,7 @@ class MassSNN(BaseSeriesSimilaritySearch):
         ----------
         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.
+            special parameters are defined for a value, will return ``"default"`` set.
             There are currently no reserved values for transformers.
 
         Returns
@@ -186,7 +186,8 @@ class MassSNN(BaseSeriesSimilaritySearch):
         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.
+            ``MyClass(**params)`` or ``MyClass(**params[i])`` creates a valid test
+            instance.
         """
         if parameter_set == "default":
             params = {"length": 20}
diff --git a/aeon/transformations/collection/convolution_based/_hydra.py b/aeon/transformations/collection/convolution_based/_hydra.py
index 34ae1ced..75db8e3f 100644
--- a/aeon/transformations/collection/convolution_based/_hydra.py
+++ b/aeon/transformations/collection/convolution_based/_hydra.py
@@ -4,6 +4,7 @@ __maintainer__ = ["TonyBagnall"]
 __all__ = ["HydraTransformer"]
 
 import numpy as np
+import pandas as pd
 
 from aeon.transformations.collection import BaseCollectionTransformer
 from aeon.utils.validation import check_n_jobs
@@ -38,6 +39,12 @@ class HydraTransformer(BaseCollectionTransformer):
         If `RandomState` instance, random_state is the random number generator;
         If `None`, the random number generator is the `RandomState` instance used
         by `np.random`.
+    output_type : str, default='tensor'
+        The output type of the transformer.
+        Can be either 'tensor' or 'numpy' or 'dataframe'.
+        If 'tensor', the output will be a PyTorch tensor. If 'numpy', the output
+        will be a NumPy array. If 'dataframe', the output will be a pandas DataFrame.
+
 
     See Also
     --------
@@ -76,13 +83,20 @@ class HydraTransformer(BaseCollectionTransformer):
     }
 
     def __init__(
-        self, n_kernels=8, n_groups=64, max_num_channels=8, n_jobs=1, random_state=None
+        self,
+        n_kernels=8,
+        n_groups=64,
+        max_num_channels=8,
+        n_jobs=1,
+        random_state=None,
+        output_type="tensor",
     ):
         self.n_kernels = n_kernels
         self.n_groups = n_groups
         self.max_num_channels = max_num_channels
         self.n_jobs = n_jobs
         self.random_state = random_state
+        self.output_type = output_type
 
         super().__init__()
 
@@ -104,7 +118,12 @@ class HydraTransformer(BaseCollectionTransformer):
         )
 
     def _transform(self, X, y=None):
-        return self._hydra(torch.tensor(X).float())
+        transformed = self._hydra(torch.tensor(X).float())
+        if (self.output_type == "numpy") or (self.output_type == "dataframe"):
+            transformed = transformed.detach().numpy()
+        if self.output_type == "dataframe":
+            transformed = pd.DataFrame(transformed)
+        return transformed
 
 
 if _check_soft_dependencies("torch", severity="none"):
diff --git a/aeon/utils/tags/_tags.py b/aeon/utils/tags/_tags.py
index 2c132902..a4f9e041 100644
--- a/aeon/utils/tags/_tags.py
+++ b/aeon/utils/tags/_tags.py
@@ -169,4 +169,27 @@ ESTIMATOR_TAGS = {
         "unordered attributes are columns. Series indicates a single series output "
         "and collection indicates output is a collection of time series.",
     },
+    "anomaly_output_type": {
+        "class": "anomaly-detector",
+        "type": ("str", ["anomaly_scores", "binary"]),
+        "description": "The format of the anomaly detector output. anomaly_scores "
+        "estimators provide a numeric score on how anomalous the point/case is. binary"
+        "estimators provide a binary classification of whether the point/case is "
+        "anomalous or not.",
+    },
+    "learning_type:unsupervised": {
+        "class": "anomaly-detector",
+        "type": "bool",
+        "description": "Does the anomaly detector support unsupervised learning?",
+    },
+    "learning_type:semi_supervised": {
+        "class": "anomaly-detector",
+        "type": "bool",
+        "description": "Does the anomaly detector support semi-supervised learning?",
+    },
+    "learning_type:supervised": {
+        "class": "anomaly-detector",
+        "type": "bool",
+        "description": "Does the anomaly detector support supervised learning?",
+    },
 }
diff --git a/docs/about.md b/docs/about.md
index ca896658..798e6e8d 100644
--- a/docs/about.md
+++ b/docs/about.md
@@ -42,9 +42,18 @@ The release management workgroup is responsible for managing the project's relea
 ```{include} about/release_management_workgroup.md
 ```
 
+### Supporting Developers
+
+Supporting developers have been provided write access to the main repository to aid
+with package contributions and maintenance.
+
+```{include} about/supporting_developers.md
+```
+
 ### Core Developers
 
-The core developers push forward `aeon`'s development and maintain the package.
+Core developers push forward `aeon`'s development, maintain the package and build
+our community.
 
 ```{include} about/core_developers.md
 ```
diff --git a/docs/about/supporting_developers.md b/docs/about/supporting_developers.md
new file mode 100644
index 00000000..db9464c5
--- /dev/null
+++ b/docs/about/supporting_developers.md
@@ -0,0 +1,15 @@
+<!-- Generated by generate_developer_table.py -->
+<div class='aeon-teams-container'>
+<div>
+<a href='https://github.com/LinGinQiu'><img src='https://avatars.githubusercontent.com/u/80885865?v=4' class='avatar' /></a> <br />
+<p><a href='https://github.com/LinGinQiu'>Chuanhang Qiu </a></p>
+</div>
+<div>
+<a href='https://github.com/alexbanwell1'><img src='https://avatars.githubusercontent.com/u/31886108?v=4' class='avatar' /></a> <br />
+<p><a href='https://github.com/alexbanwell1'>alexbanwell1</a></p>
+</div>
+<div>
+<a href='https://github.com/pattplatt'><img src='https://avatars.githubusercontent.com/u/55019140?v=4' class='avatar' /></a> <br />
+<p><a href='https://github.com/pattplatt'>Patrick</a></p>
+</div>
+</div>
diff --git a/examples/segmentation/hidalgo_segmentation.ipynb b/examples/segmentation/hidalgo_segmentation.ipynb
index cfa22b8e..f4603fc3 100644
--- a/examples/segmentation/hidalgo_segmentation.ipynb
+++ b/examples/segmentation/hidalgo_segmentation.ipynb
@@ -2,46 +2,172 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "# Hidalgo segmentation"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+    "# Hidalgo Segmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hidalgo (Heterogeneous Intrinsic Dimensionality Algorithm) is a method for detecting change points in time series data. It identifies segments where statistical properties of the data shift, allowing for better understanding of structural changes in the series. It is particularly useful in applications like anomaly detection, financial market analysis, and sensor monitoring for discriminating regions with different local intrinsic dimensionality.\n",
+    "\n",
+    "Hidalgo Segmentation is used for\n",
+    "\n",
+    "- **Unsupervised Learning**: Hidalgo does not require labeled data for segmentation, making it suitable for exploratory data analysis.\n",
+    "- **High-Dimensional Data**: It can handle high-dimensional time series data effectively.\n",
+    "- **Intrinsic Dimensionality**: By focusing on local intrinsic dimensionality, Hidalgo can identify regions with different complexities within the data.\n",
+    "\n",
+    "Applications\n",
+    "\n",
+    "- **Change Point Detection**: Identifying points in time where the statistical properties of a time series change.\n",
+    "- **Anomaly Detection**: Detecting unusual patterns or outliers in time series data.\n",
+    "- **Feature Extraction**: Segmenting data to extract meaningful features for further analysis or modeling."
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "array([ 1,  1,  1,  1,  1, -1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,\n        1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,\n        1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, -1,\n        1, -1, -1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,\n        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],\n      dtype=int64)"
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "\n",
     "from aeon.segmentation import HidalgoSegmenter\n",
+    "from aeon.visualisation.learning_task._segmentation import (\n",
+    "    plot_series_with_change_points,\n",
+    ")\n",
+    "from aeon.visualisation.series._series import plot_series"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1. Generate Synthetic Data\n",
     "\n",
+    "We create a synthetic dataset with 100 time points, each having 3 channels. The data is constructed such that the first 60 time points have higher values in the second and third channels, and the remaining time points have lower values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "X = np.random.rand(100, 3)\n",
     "X[:60, 1:] += 10\n",
     "X[60:, 1:] = 0\n",
-    "hidalgo = HidalgoSegmenter(K=2, burn_in=0.8, n_iter=1000, seed=10)\n",
     "\n",
-    "hidalgo.fit_predict(X, axis=0)"
+    "time = np.arange(len(X))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Visualize Synthetic Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_ = plot_series(X.T, labels=[\"Channel 0\", \"Channel 1\", \"Channel 2\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Apply Hidalgo Segmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `HidalgoSegmenter` is initialized with various parameters that control the behavior of the algorithm. These parameters include the number of manifolds (`K`), local homogeneity level (`zeta`), number of points for local interaction (`q`), number of Gibbs sampling iterations (`n_iter`), and others. These parameters allow to customize the segmentation process according to data and requirements, while the `fit_predict` method is used to fit the Hidalgo model to the data and predict the segmentation labels using Neighborhood Calculation and Gibbs Sampling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found change points: [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
+      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
+      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n"
+     ]
+    }
+   ],
+   "source": [
+    "hidalgo = HidalgoSegmenter(K=2, q=3, n_iter=2000, burn_in=0.8, seed=10)\n",
+    "\n",
+    "labels = hidalgo.fit_predict(X, axis=0)\n",
+    "print(\"Found change points:\", labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1 Visualize Segmentation Output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
    ],
-   "metadata": {
-    "collapsed": false
-   }
+   "source": [
+    "_ = plot_series_with_change_points(\n",
+    "    X, np.where(np.diff(labels) != 0)[0], \"Segmentation Result\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "[1] Allegra, Michele, et al. \"Data segmentation based on the local intrinsic dimension.\" [Scientific reports 10.1 (2020): 1-12.](https://www.nature.com/articles/s41598-020-72222-0)"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.13 ('aeon-dev')",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -55,13 +181,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "3672c9971f48dc8b5371767a83a5c009b8758f695819d57d51811323dc5c559e"
-   }
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,


Test patch:
diff --git a/.github/workflows/pr_pytest.yml b/.github/workflows/pr_pytest.yml
index 4b5679f7..cf1baee9 100644
--- a/.github/workflows/pr_pytest.yml
+++ b/.github/workflows/pr_pytest.yml
@@ -5,8 +5,6 @@ on:
     branches:
       - main
   pull_request:
-    branches:
-      - main
     paths:
       - "aeon/**"
       - ".github/workflows/**"
diff --git a/aeon/benchmarking/metrics/anomaly_detection/tests/test_ad_metrics.py b/aeon/benchmarking/metrics/anomaly_detection/tests/test_ad_metrics.py
index fd14aa39..e2e5364e 100644
--- a/aeon/benchmarking/metrics/anomaly_detection/tests/test_ad_metrics.py
+++ b/aeon/benchmarking/metrics/anomaly_detection/tests/test_ad_metrics.py
@@ -20,9 +20,8 @@ from aeon.benchmarking.metrics.anomaly_detection._range_metrics import (
     range_recall,
 )
 from aeon.testing.data_generation import make_example_1d_numpy
-from aeon.utils.validation._dependencies import _check_soft_dependencies
 
-pr_metrics = [pr_auc_score]
+pr_metrics = [pr_auc_score, rp_rr_auc_score]
 range_metrics = [
     range_roc_auc_score,
     range_pr_auc_score,
@@ -32,6 +31,7 @@ range_metrics = [
 other_metrics = [
     roc_auc_score,
     f_score_at_k_points,
+    f_score_at_k_ranges,
 ]
 continuous_metrics = [*pr_metrics, *other_metrics, *range_metrics]
 binary_metrics = [
@@ -40,21 +40,6 @@ binary_metrics = [
     range_recall,
 ]
 
-if _check_soft_dependencies("prts", severity="none"):
-    pr_metrics.append(rp_rr_auc_score)
-    other_metrics.extend(
-        [
-            f_score_at_k_ranges,
-            rp_rr_auc_score,
-        ]
-    )
-    continuous_metrics.extend(
-        [
-            rp_rr_auc_score,
-            f_score_at_k_ranges,
-        ]
-    )
-
 metrics = [*pr_metrics, *range_metrics, *other_metrics]
 
 
@@ -148,10 +133,6 @@ def test_edge_cases_pr_metrics(metric):
     assert score <= 0.2, f"{metric.__name__}(y_true, y_inverted)={score} is not <= 0.2"
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_range_based_f1():
     """Test range-based F1 score."""
     y_pred = np.array([0, 1, 1, 0])
@@ -160,10 +141,6 @@ def test_range_based_f1():
     np.testing.assert_almost_equal(result, 0.66666, decimal=4)
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_range_based_precision():
     """Test range-based precision."""
     y_pred = np.array([0, 1, 1, 0])
@@ -172,10 +149,6 @@ def test_range_based_precision():
     assert result == 0.5
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_range_based_recall():
     """Test range-based recall."""
     y_pred = np.array([0, 1, 1, 0])
@@ -184,10 +157,6 @@ def test_range_based_recall():
     assert result == 1
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_rf1_value_error():
     """Test range-based F1 score raises ValueError on binary predictions."""
     y_pred = np.array([0, 0.2, 0.7, 0])
@@ -211,10 +180,6 @@ def test_pr_curve_auc():
 #     np.testing.assert_almost_equal(result, 0.8333, decimal=4)
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_range_based_p_range_based_r_curve_auc():
     """Test range-based precision-recall curve AUC."""
     y_pred = np.array([0, 0.1, 1.0, 0.5, 0.1, 0])
@@ -223,10 +188,6 @@ def test_range_based_p_range_based_r_curve_auc():
     np.testing.assert_almost_equal(result, 0.9792, decimal=4)
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_range_based_p_range_based_r_auc_perfect_hit():
     """Test range-based precision-recall curve AUC with perfect hit."""
     y_pred = np.array([0, 0, 0.5, 0.5, 0, 0])
@@ -235,10 +196,6 @@ def test_range_based_p_range_based_r_auc_perfect_hit():
     np.testing.assert_almost_equal(result, 1.0000, decimal=4)
 
 
-@pytest.mark.skipif(
-    not _check_soft_dependencies("prts", severity="none"),
-    reason="required soft dependency prts not available",
-)
 def test_f_score_at_k_ranges():
     """Test range-based F1 score at k ranges."""
     y_pred = np.array([0.4, 0.1, 1.0, 0.5, 0.1, 0, 0.4, 0.5])
diff --git a/aeon/clustering/feature_based/tests/__init__.py b/aeon/clustering/feature_based/tests/__init__.py
new file mode 100644
index 00000000..d6e8de22
--- /dev/null
+++ b/aeon/clustering/feature_based/tests/__init__.py
@@ -0,0 +1,1 @@
+"""Feature Based learning clustering tests."""
diff --git a/aeon/clustering/feature_based/tests/test_catch22.py b/aeon/clustering/feature_based/tests/test_catch22.py
new file mode 100644
index 00000000..e91ea019
--- /dev/null
+++ b/aeon/clustering/feature_based/tests/test_catch22.py
@@ -0,0 +1,88 @@
+"""Tests for Catch22 Clusterer."""
+
+import numpy as np
+from sklearn import metrics
+
+from aeon.clustering.feature_based import Catch22Clusterer
+from aeon.datasets import load_basic_motions, load_gunpoint
+
+
+def test_catch22_multivariate():
+    """Test Catch22 Clusterer with univariate data."""
+    X_train, y_train = load_basic_motions(split="train")
+    X_test, y_test = load_basic_motions(split="test")
+    num_points = 12
+
+    X_train = X_train[:num_points]
+    y_train = y_train[:num_points]
+    X_test = X_test[:num_points]
+    y_test = y_test[:num_points]
+
+    catach22 = Catch22Clusterer(
+        catch24=False,
+        random_state=1,
+    )
+    train_result = catach22.fit_predict(X_train)
+    train_score = metrics.rand_score(y_train, train_result)
+    test_result = catach22.predict(X_test)
+    test_score = metrics.rand_score(y_test, test_result)
+    ari_test = metrics.adjusted_rand_score(y_test, test_result)
+    ari_train = metrics.adjusted_rand_score(y_train, train_result)
+    predict_proba = catach22.predict_proba(X_test)
+
+    assert len(predict_proba) == 12
+    assert ari_test == 0.1927353595255745
+    assert ari_train == 0.09810791871058164
+    assert len(predict_proba) == 12
+    assert np.array_equal(
+        test_result,
+        [3, 4, 7, 7, 7, 7, 0, 7, 0, 4, 2, 2],
+    )
+    assert np.array_equal(
+        train_result,
+        [7, 3, 0, 5, 6, 4, 7, 7, 4, 7, 1, 2],
+    )
+    assert train_score == 0.4090909090909091
+    assert test_score == 0.5
+    assert test_result.shape == (12,)
+    assert train_result.shape == (12,)
+
+
+def test_catch22_univariate():
+    """Test Catch22 Clusterer with multivariate data."""
+    X_train, y_train = load_gunpoint(split="train")
+    X_test, y_test = load_gunpoint(split="test")
+    num_points = 8
+
+    X_train = X_train[:num_points]
+    y_train = y_train[:num_points]
+    X_test = X_test[:num_points]
+    y_test = y_test[:num_points]
+
+    catach22 = Catch22Clusterer(
+        catch24=False,
+        random_state=1,
+    )
+    train_result = catach22.fit_predict(X_train)
+    train_score = metrics.rand_score(y_train, train_result)
+    test_result = catach22.predict(X_test)
+    test_score = metrics.rand_score(y_test, test_result)
+    ari_test = metrics.adjusted_rand_score(y_test, test_result)
+    ari_train = metrics.adjusted_rand_score(y_train, train_result)
+    predict_proba = catach22.predict_proba(X_test)
+
+    assert len(predict_proba) == 8
+    assert ari_test == 0.023255813953488372
+    assert ari_train == 0.0
+    assert np.array_equal(
+        test_result,
+        [3, 0, 1, 3, 7, 5, 2, 2],
+    )
+    assert np.array_equal(
+        train_result,
+        [5, 0, 3, 7, 4, 6, 2, 1],
+    )
+    assert train_score == 0.42857142857142855
+    assert test_score == 0.5714285714285714
+    assert test_result.shape == (8,)
+    assert train_result.shape == (8,)
diff --git a/aeon/clustering/feature_based/tests/test_summary.py b/aeon/clustering/feature_based/tests/test_summary.py
new file mode 100644
index 00000000..75d93212
--- /dev/null
+++ b/aeon/clustering/feature_based/tests/test_summary.py
@@ -0,0 +1,48 @@
+"""Tests for Summary Clusterer."""
+
+import numpy as np
+
+from aeon.clustering.feature_based import SummaryClusterer
+from aeon.datasets import load_basic_motions, load_gunpoint
+
+
+def test_all_summary_stat_uni():
+    """Test Summary Clusterer with all summary stat."""
+    X_train, y_train = load_gunpoint(split="train")
+    X_test, y_test = load_gunpoint(split="test")
+    num_points = 8
+
+    X_train = X_train[:num_points]
+    X_test = X_test[:num_points]
+    summary_stats_options = ["default", "quantiles", "bowley", "tukey"]
+    for summary_stat in summary_stats_options:
+        summary = SummaryClusterer(random_state=1, summary_stats=summary_stat)
+        train_result = summary.fit_predict(X_train)
+        test_result = summary.predict(X_test)
+        predict_proba = summary.predict_proba(X_test)
+        assert len(predict_proba) == 8
+        assert not np.isnan(train_result).any()
+        assert not np.isnan(test_result).any()
+        assert test_result.shape == (8,)
+        assert train_result.shape == (8,)
+
+
+def test_all_summary_stat_multi():
+    """Test Summary Clusterer with all summary stat."""
+    X_train, y_train = load_basic_motions(split="train")
+    X_test, y_test = load_basic_motions(split="test")
+    num_points = 8
+
+    X_train = X_train[:num_points]
+    X_test = X_test[:num_points]
+    summary_stats_options = ["default", "quantiles", "bowley", "tukey"]
+    for summary_stat in summary_stats_options:
+        summary = SummaryClusterer(random_state=1, summary_stats=summary_stat)
+        train_result = summary.fit_predict(X_train)
+        test_result = summary.predict(X_test)
+        predict_proba = summary.predict_proba(X_test)
+        assert len(predict_proba) == 8
+        assert not np.isnan(train_result).any()
+        assert not np.isnan(test_result).any()
+        assert test_result.shape == (8,)
+        assert train_result.shape == (8,)
diff --git a/aeon/clustering/feature_based/tests/test_tsfresh.py b/aeon/clustering/feature_based/tests/test_tsfresh.py
new file mode 100644
index 00000000..4602b0bf
--- /dev/null
+++ b/aeon/clustering/feature_based/tests/test_tsfresh.py
@@ -0,0 +1,64 @@
+"""Tests for TSFresh Clusterer."""
+
+import numpy as np
+import pytest
+
+from aeon.clustering.feature_based import TSFreshClusterer
+from aeon.datasets import load_basic_motions, load_gunpoint
+from aeon.utils.validation._dependencies import _check_soft_dependencies
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies(["tsfresh"], severity="none"),
+    reason="TSFresh soft dependency unavailable.",
+)
+def test_all_fc_parameters_uni():
+    """Test TSFresh Clusterer with all FC parameters."""
+    X_train, y_train = load_gunpoint(split="train")
+    X_test, y_test = load_gunpoint(split="test")
+    num_points = 5
+
+    X_train = X_train[:num_points]
+    X_test = X_test[:num_points]
+    fc_parameters = ["minimal", "efficient", "comprehensive"]
+    for fc in fc_parameters:
+        tsfresh = TSFreshClusterer(
+            n_clusters=2, random_state=1, default_fc_parameters=fc
+        )
+
+        train_result = tsfresh.fit_predict(X_train)
+        test_result = tsfresh.predict(X_test)
+        predict_proba = tsfresh.predict_proba(X_test)
+        assert len(predict_proba) == 5
+        assert not np.isnan(train_result).any()
+        assert not np.isnan(test_result).any()
+        assert test_result.shape == (5,)
+        assert train_result.shape == (5,)
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies(["tsfresh"], severity="none"),
+    reason="TSFresh soft dependency unavailable.",
+)
+def test_all_fc_parameters_multi():
+    """Test TSFresh Clusterer with all FC parameters."""
+    X_train, y_train = load_basic_motions(split="train")
+    X_test, y_test = load_basic_motions(split="test")
+    num_points = 5
+
+    X_train = X_train[:num_points]
+    X_test = X_test[:num_points]
+    fc_parameters = ["minimal", "efficient", "comprehensive"]
+    for fc in fc_parameters:
+        tsfresh = TSFreshClusterer(
+            n_clusters=2, random_state=1, default_fc_parameters=fc
+        )
+
+        train_result = tsfresh.fit_predict(X_train)
+        test_result = tsfresh.predict(X_test)
+        predict_proba = tsfresh.predict_proba(X_test)
+        assert len(predict_proba) == 5
+        assert not np.isnan(train_result).any()
+        assert not np.isnan(test_result).any()
+        assert test_result.shape == (5,)
+        assert train_result.shape == (5,)
diff --git a/aeon/clustering/tests/test_kernel_k_means.py b/aeon/clustering/tests/test_kernel_k_means.py
index 36a761a4..dd765fca 100644
--- a/aeon/clustering/tests/test_kernel_k_means.py
+++ b/aeon/clustering/tests/test_kernel_k_means.py
@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from aeon.clustering._kernel_k_means import TimeSeriesKernelKMeans
+from aeon.clustering._kernel_k_means import TimeSeriesKernelKMeans, _kdtw
 from aeon.datasets import load_basic_motions
 from aeon.utils.validation._dependencies import _check_estimator_deps
 
@@ -19,18 +19,18 @@ expected_iters_kdtw = 2
 
 expected_results_kdtw = [0, 2, 0, 0, 0]
 
+max_train = 5
+
+X_train, y_train = load_basic_motions(split="train")
+X_test, y_test = load_basic_motions(split="test")
+
 
 @pytest.mark.skipif(
     not _check_estimator_deps(TimeSeriesKernelKMeans, severity="none"),
     reason="skip test if required soft dependencies not available",
 )
-def test_kernel_k_means():
-    """Test implementation of kernel k means."""
-    max_train = 5
-
-    X_train, y_train = load_basic_motions(split="train")
-    X_test, y_test = load_basic_motions(split="test")
-
+def test_kernel_k_means_gak():
+    """Test implementation of kernel k means with GAK kernel."""
     kernel_kmeans = TimeSeriesKernelKMeans(random_state=1, n_clusters=3)
     kernel_kmeans.fit(X_train[0:max_train])
     test_shape_result = kernel_kmeans.predict(X_test[0:max_train])
@@ -44,6 +44,13 @@ def test_kernel_k_means():
     for val in proba:
         assert np.count_nonzero(val == 1.0) == 1
 
+
+@pytest.mark.skipif(
+    not _check_estimator_deps(TimeSeriesKernelKMeans, severity="none"),
+    reason="skip test if required soft dependencies not available",
+)
+def test_kernel_k_means_kdtw():
+    """Test implementation of kernel k means with KDTW kernel."""
     kernel_kmeans_kdtw = TimeSeriesKernelKMeans(
         kernel="kdtw",
         random_state=1,
@@ -61,3 +68,17 @@ def test_kernel_k_means():
 
     for val in kdtw_proba:
         assert np.count_nonzero(val == 1.0) == 1
+
+
+def test_kdtw_kernel_univariate():
+    """Test kdtw kernel for univariate time series."""
+    # expected value created with the original (Matlab) code from:
+    # https://people.irisa.fr/Pierre-Francois.Marteau/REDK/KDTW/KDTW.html
+    x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.float64).reshape(-1, 1)
+    y = np.array([5, 6, 7, 8, 9, 1, 2], dtype=np.float64).reshape(-1, 1)
+    sigma = 0.125
+    epsilon = 1e-20
+    expected_distance = 1.2814e-102
+
+    distance = _kdtw(x, y, sigma=sigma, epsilon=epsilon)
+    np.testing.assert_allclose(expected_distance, distance, rtol=1e-4, atol=1e-106)
diff --git a/aeon/segmentation/tests/test_igts.py b/aeon/segmentation/tests/test_igts.py
index 7103dca3..0aaa0f2d 100644
--- a/aeon/segmentation/tests/test_igts.py
+++ b/aeon/segmentation/tests/test_igts.py
@@ -51,5 +51,3 @@ def test_InformationGainSegmenter(multivariate_mean_shift):
             [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3], dtype=int
         ),
     )
-    assert igts.change_points_ == [0, 5, 10, 15, 20]
-    assert len(igts.intermediate_results_) == 3
diff --git a/aeon/testing/estimator_checking/_yield_anomaly_detection_checks.py b/aeon/testing/estimator_checking/_yield_anomaly_detection_checks.py
index 5f2f05aa..363db48e 100644
--- a/aeon/testing/estimator_checking/_yield_anomaly_detection_checks.py
+++ b/aeon/testing/estimator_checking/_yield_anomaly_detection_checks.py
@@ -6,10 +6,7 @@ import numpy as np
 
 from aeon.base._base import _clone_estimator
 from aeon.base._base_series import VALID_SERIES_INNER_TYPES
-from aeon.testing.data_generation import (
-    make_example_1d_numpy,
-    make_example_2d_numpy_series,
-)
+from aeon.testing.testing_data import FULL_TEST_DATA_DICT
 
 
 def _yield_anomaly_detection_checks(estimator_class, estimator_instances, datatypes):
@@ -20,10 +17,19 @@ def _yield_anomaly_detection_checks(estimator_class, estimator_instances, dataty
     )
 
     # test class instances
-    for _, estimator in enumerate(estimator_instances):
-        # no data needed
-        yield partial(check_anomaly_detector_univariate, estimator=estimator)
-        yield partial(check_anomaly_detector_multivariate, estimator=estimator)
+    for i, estimator in enumerate(estimator_instances):
+        # data type irrelevant
+        yield partial(
+            check_anomaly_detector_learning_types,
+            estimator=estimator,
+            datatype=datatypes[i][0],
+        )
+
+        # test all data types
+        for datatype in datatypes[i]:
+            yield partial(
+                check_anomaly_detector_output, estimator=estimator, datatype=datatype
+            )
 
 
 def check_anomaly_detector_overrides_and_tags(estimator_class):
@@ -53,41 +59,44 @@ def check_anomaly_detector_overrides_and_tags(estimator_class):
     assert multi or uni
 
 
-labels = np.zeros(15, dtype=np.int_)
-labels[np.random.choice(15, 5)] = 1
-uv_series = make_example_1d_numpy(n_timepoints=15, random_state=0)
-uv_series[labels == 1] += 1
-mv_series = make_example_2d_numpy_series(n_timepoints=15, n_channels=2, random_state=0)
-mv_series[:, labels == 1] += 1
+def check_anomaly_detector_learning_types(estimator, datatype):
+    """Test anomaly detector learning types."""
+    unsupervised = estimator.get_tag("learning_type:unsupervised")
+    semisup = estimator.get_tag("learning_type:semi_supervised")
+    supervised = estimator.get_tag("learning_type:supervised")
 
+    assert (
+        unsupervised or semisup or supervised
+    ), "At least one learning type must be True"
 
-def check_anomaly_detector_univariate(estimator):
-    """Test the anomaly detector on univariate data."""
-    import pytest
 
+def check_anomaly_detector_output(estimator, datatype):
+    """Test the anomaly detector output on valid data."""
     estimator = _clone_estimator(estimator)
 
-    if estimator.get_tag(tag_name="capability:univariate"):
-        pred = estimator.fit_predict(uv_series, labels)
-        assert isinstance(pred, np.ndarray)
-        assert pred.shape == (15,)
-        assert issubclass(pred.dtype.type, (np.integer, np.floating, np.bool_))
-    else:
-        with pytest.raises(ValueError, match="Univariate data not supported"):
-            estimator.fit_predict(uv_series, labels)
-
-
-def check_anomaly_detector_multivariate(estimator):
-    """Test the anomaly detector on multivariate data."""
-    import pytest
-
-    estimator = _clone_estimator(estimator)
+    estimator.fit(
+        FULL_TEST_DATA_DICT[datatype]["train"][0],
+        FULL_TEST_DATA_DICT[datatype]["train"][1],
+    )
 
-    if estimator.get_tag(tag_name="capability:multivariate"):
-        pred = estimator.fit_predict(mv_series, labels)
-        assert isinstance(pred, np.ndarray)
-        assert pred.shape == (15,)
-        assert issubclass(pred.dtype.type, (np.integer, np.floating, np.bool_))
+    y_pred = estimator.predict(FULL_TEST_DATA_DICT[datatype]["test"][0])
+    assert isinstance(y_pred, np.ndarray)
+    assert len(y_pred) == FULL_TEST_DATA_DICT[datatype]["test"][0].shape[1]
+
+    ot = estimator.get_tag("anomaly_output_type")
+    if ot == "anomaly_scores":
+        assert np.issubdtype(y_pred.dtype, np.floating) or np.issubdtype(
+            y_pred.dtype, np.integer
+        ), "y_pred must be of floating point or int type"
+        assert not np.array_equal(
+            np.unique(y_pred), [0, 1]
+        ), "y_pred cannot contain only 0s and 1s"
+    elif ot == "binary":
+        assert np.issubdtype(y_pred.dtype, np.integer) or np.issubdtype(
+            y_pred.dtype, np.bool_
+        ), "y_pred must be of int or bool type for binary output"
+        assert all(
+            val in [0, 1] for val in np.unique(y_pred)
+        ), "y_pred must contain only 0s, 1s, True, or False"
     else:
-        with pytest.raises(ValueError, match="Multivariate data not supported"):
-            estimator.fit_predict(mv_series, labels)
+        raise ValueError(f"Unknown anomaly output type: {ot}")
diff --git a/aeon/testing/estimator_checking/_yield_classification_checks.py b/aeon/testing/estimator_checking/_yield_classification_checks.py
index 1ab7b484..0591119f 100644
--- a/aeon/testing/estimator_checking/_yield_classification_checks.py
+++ b/aeon/testing/estimator_checking/_yield_classification_checks.py
@@ -73,7 +73,7 @@ def _yield_classification_checks(estimator_class, estimator_instances, datatypes
             yield partial(
                 check_classifier_train_estimate,
                 estimator=estimator,
-                datatype=datatypes[0][0],
+                datatype=datatypes[i][0],
             )
 
         if isinstance(estimator, BaseDeepClassifier):
diff --git a/aeon/testing/estimator_checking/_yield_regression_checks.py b/aeon/testing/estimator_checking/_yield_regression_checks.py
index 73bba3af..06fe4796 100644
--- a/aeon/testing/estimator_checking/_yield_regression_checks.py
+++ b/aeon/testing/estimator_checking/_yield_regression_checks.py
@@ -68,7 +68,7 @@ def _yield_regression_checks(estimator_class, estimator_instances, datatypes):
             yield partial(
                 check_regressor_train_estimate,
                 estimator=estimator,
-                datatype=datatypes[0][0],
+                datatype=datatypes[i][0],
             )
 
         if isinstance(estimator, BaseDeepRegressor):
diff --git a/aeon/testing/mock_estimators/_mock_anomaly_detectors.py b/aeon/testing/mock_estimators/_mock_anomaly_detectors.py
index 4ec14d35..ed0ba248 100644
--- a/aeon/testing/mock_estimators/_mock_anomaly_detectors.py
+++ b/aeon/testing/mock_estimators/_mock_anomaly_detectors.py
@@ -19,6 +19,9 @@ class MockAnomalyDetector(BaseAnomalyDetector):
     _tags = {
         "capability:missing_values": True,
         "capability:multivariate": True,
+        "anomaly_output_type": "anomaly_scores",
+        "learning_type:unsupervised": True,
+        "learning_type:semi_supervised": True,
     }
 
     def __init__(self):
diff --git a/aeon/testing/testing_config.py b/aeon/testing/testing_config.py
index b17b9626..fe7f8d00 100644
--- a/aeon/testing/testing_config.py
+++ b/aeon/testing/testing_config.py
@@ -52,10 +52,9 @@ EXCLUDED_TESTS = {
     "SAST": ["check_fit_deterministic"],
     "RSAST": ["check_fit_deterministic"],
     "MatrixProfile": ["check_fit_deterministic", "check_persistence_via_pickle"],
+    "LeftSTAMPi": ["check_anomaly_detector_output"],
     # missed in legacy testing, changes state in predict/transform
     "FLUSSSegmenter": ["check_non_state_changing_method"],
-    "InformationGainSegmenter": ["check_non_state_changing_method"],
-    "GreedyGaussianSegmenter": ["check_non_state_changing_method"],
     "ClaSPSegmenter": ["check_non_state_changing_method"],
     "HMMSegmenter": ["check_non_state_changing_method"],
     "RSTSF": ["check_non_state_changing_method"],
diff --git a/aeon/testing/testing_data.py b/aeon/testing/testing_data.py
index 3337f83b..f3360d93 100644
--- a/aeon/testing/testing_data.py
+++ b/aeon/testing/testing_data.py
@@ -13,7 +13,6 @@ from aeon.segmentation import BaseSegmenter
 from aeon.similarity_search.collection import BaseCollectionSimilaritySearch
 from aeon.similarity_search.series import BaseSeriesSimilaritySearch
 from aeon.testing.data_generation import (
-    make_example_1d_numpy,
     make_example_2d_dataframe_collection,
     make_example_2d_numpy_collection,
     make_example_2d_numpy_series,
@@ -642,11 +641,14 @@ MISSING_VALUES_REGRESSION = {
 
 # Series testing data
 
-X_series = make_example_1d_numpy(
-    n_timepoints=40, random_state=data_rng.randint(np.iinfo(np.int32).max)
+X_series = make_example_2d_numpy_series(
+    n_timepoints=40,
+    n_channels=1,
+    axis=1,
+    random_state=data_rng.randint(np.iinfo(np.int32).max),
 )
-X_series2 = X_series[20:40]
-X_series = X_series[:20]
+X_series2 = X_series[:, 20:40]
+X_series = X_series[:, :20]
 UNIVARIATE_SERIES_NONE = {"train": (X_series, None), "test": (X_series2, None)}
 
 X_series_mv = make_example_2d_numpy_series(
@@ -662,13 +664,16 @@ MULTIVARIATE_SERIES_NONE = {
     "test": (X_series_mv2, None),
 }
 
-X_series_mi = make_example_1d_numpy(
-    n_timepoints=40, random_state=data_rng.randint(np.iinfo(np.int32).max)
+X_series_mi = make_example_2d_numpy_series(
+    n_timepoints=40,
+    n_channels=1,
+    axis=1,
+    random_state=data_rng.randint(np.iinfo(np.int32).max),
 )
-X_series_mi2 = X_series_mi[20:40]
-X_series_mi2[data_rng.choice(20, 1)] = np.nan
-X_series_mi = X_series_mi[:20]
-X_series_mi[data_rng.choice(20, 2)] = np.nan
+X_series_mi2 = X_series_mi[:, 20:40]
+X_series_mi2[:, data_rng.choice(20, 1)] = np.nan
+X_series_mi = X_series_mi[:, :20]
+X_series_mi[:, data_rng.choice(20, 2)] = np.nan
 MISSING_VALUES_SERIES_NONE = {
     "train": (X_series_mi, None),
     "test": (X_series_mi2, None),
diff --git a/aeon/transformations/collection/convolution_based/tests/test_hydra.py b/aeon/transformations/collection/convolution_based/tests/test_hydra.py
new file mode 100644
index 00000000..59da35a8
--- /dev/null
+++ b/aeon/transformations/collection/convolution_based/tests/test_hydra.py
@@ -0,0 +1,112 @@
+"""Hydra tests."""
+
+import numpy as np
+import pytest
+
+from aeon.transformations.collection.convolution_based._hydra import HydraTransformer
+from aeon.utils.validation._dependencies import _check_soft_dependencies
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("torch", severity="none"),
+    reason="Skip test if torch not available",
+)
+def test_hydra_output_types():
+    """Test HydraTransformer output_type parameter."""
+    # Create a simple dataset
+    X = np.random.random(size=(10, 3, 20))
+
+    # Test tensor output (default)
+    hydra_tensor = HydraTransformer(random_state=42)
+    hydra_tensor.fit(X)
+    tensor_output = hydra_tensor.transform(X)
+
+    # Check that output is a torch tensor
+    import torch
+
+    assert isinstance(tensor_output, torch.Tensor)
+
+    # Test numpy output
+    hydra_numpy = HydraTransformer(random_state=42, output_type="numpy")
+    hydra_numpy.fit(X)
+    numpy_output = hydra_numpy.transform(X)
+
+    # Check that output is a numpy array
+    assert isinstance(numpy_output, np.ndarray)
+
+    # Test dataframe output
+    hydra_df = HydraTransformer(random_state=42, output_type="dataframe")
+    hydra_df.fit(X)
+    df_output = hydra_df.transform(X)
+
+    # Check that output is a pandas DataFrame
+    import pandas as pd
+
+    assert isinstance(df_output, pd.DataFrame)
+
+    # Check that all outputs have the same shape
+    assert tensor_output.shape == numpy_output.shape
+    assert numpy_output.shape == df_output.shape
+
+    tensor_np = tensor_output.detach().cpu().numpy()
+    df_np = df_output.to_numpy()
+    assert np.allclose(tensor_np[:5], numpy_output[:5], atol=1e-6)
+    assert np.allclose(numpy_output[:5], df_np[:5], atol=1e-6)
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("torch", severity="none"),
+    reason="Skip test if torch not available",
+)
+def test_hydra_short_series():
+    """Test HydraTransformer with very short time series."""
+    # Create a dataset with short time series (less than kernel length)
+    X = np.random.random(size=(10, 2, 8))
+
+    hydra = HydraTransformer(random_state=42)
+    # Should still work with short series, but will use padding
+    hydra.fit(X)
+    output = hydra.transform(X)
+
+    # Check that output has the expected number of samples
+    assert output.shape[0] == 10
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("torch", severity="none"),
+    reason="Skip test if torch not available",
+)
+def test_hydra_parameter_values():
+    """Test HydraTransformer with different parameter values."""
+    X = np.random.random(size=(10, 3, 20))
+
+    # Test with different numbers of kernels and groups
+    hydra = HydraTransformer(n_kernels=4, n_groups=32, random_state=42)
+    hydra.fit(X)
+    output = hydra.transform(X)
+
+    # Expected feature count: num_dilations * divisor * h * k
+    # where divisor = min(2, g), h = g // divisor
+    # For a 20-length time series, num_dilations should be around 2-3
+    # With n_groups=32, divisor=2, h=16, n_kernels=4
+    # So expected features would be approximately 2 * 2 * 16 * 4 = 256
+    # But this is approximate since dilations depend on series length
+    assert output.shape[1] > 0
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("torch", severity="none"),
+    reason="Skip test if torch not available",
+)
+def test_hydra_univariate():
+    """Test HydraTransformer with univariate data."""
+    # Create a univariate dataset
+    X = np.random.random(size=(10, 1, 20))
+
+    hydra = HydraTransformer(random_state=42)
+    hydra.fit(X)
+    output = hydra.transform(X)
+
+    # Check that output has the expected number of samples
+    assert output.shape[0] == 10
+    assert output.shape[1] > 0