From fe61a6c7245e60833e6a33bf94d8a72db98eeb63 Mon Sep 17 00:00:00 2001
From: dhruvraj319 <dhruv.raj319@gmail.com>
Date: Thu, 11 Jun 2026 16:28:49 +0530
Subject: [PATCH 1/5] feat: add opt-in parallel test case execution via
 ThreadPoolExecutor

Adds parallel execution of test cases to address the unbearable
time overhead when testing multiple hyperparameter groups
sequentially (issue 8).

Changes:
- testcasecontroller.py: add parallel/max_workers params to
  run_testcases(), add _run_testcases_sequential() and
  _run_testcases_parallel() using ThreadPoolExecutor
- testcase.py: fix race condition in _get_output_dir() using
  os.makedirs(exist_ok=True) instead of os.path.exists() loop
- benchmarkingjob.py: add parallel and max_workers config fields
- docs/proposals/chore/parallel_testcase_execution.md: RFC
  proposing phased approach (ThreadPoolExecutor now, Sandbox
  Engine future per PR 526)

ThreadPoolExecutor chosen over ProcessPoolExecutor to avoid
pickling issues with ML model objects. Parallel execution is
opt-in via benchmarkingjob.yaml (parallel: false by default)
for full backward compatibility.

Signed-off-by: dhruvraj319 <dhruv.raj319@gmail.com>
---
 core/cmd/obj/benchmarkingjob.py               |   7 +-
 core/testcasecontroller/testcase/testcase.py  |   8 +-
 core/testcasecontroller/testcasecontroller.py |  64 ++++-
 .../chore/parallel_testcase_execution.md      | 244 ++++++++++++++++++
 4 files changed, 313 insertions(+), 10 deletions(-)
 create mode 100644 docs/proposals/chore/parallel_testcase_execution.md

diff --git a/core/cmd/obj/benchmarkingjob.py b/core/cmd/obj/benchmarkingjob.py
index fcaed7275..c26c0754e 100644
--- a/core/cmd/obj/benchmarkingjob.py
+++ b/core/cmd/obj/benchmarkingjob.py
@@ -47,6 +47,8 @@ def __init__(self, config):
         self.rank = None
         self.test_env = None
         self.simulation = None
+        self.parallel: bool = False
+        self.max_workers: int = None
         self.testcase_controller = TestCaseController()
         self._parse_config(config)
 
@@ -91,7 +93,10 @@ def run(self):
         self.testcase_controller.build_testcases(test_env=self.test_env,
                                                  test_object=self.test_object)
 
-        succeed_testcases, test_results = self.testcase_controller.run_testcases(self.workspace)
+        succeed_testcases, test_results = self.testcase_controller.run_testcases(
+            self.workspace,
+            parallel=self.parallel,
+            max_workers=self.max_workers)
 
         if test_results:
             self.rank.save(succeed_testcases, test_results, output_dir=self.workspace)
diff --git a/core/testcasecontroller/testcase/testcase.py b/core/testcasecontroller/testcase/testcase.py
index b9e201547..4f47bee7d 100644
--- a/core/testcasecontroller/testcase/testcase.py
+++ b/core/testcasecontroller/testcase/testcase.py
@@ -43,12 +43,8 @@ def __init__(self, test_env, algorithm):
         self.output_dir = None
 
     def _get_output_dir(self, workspace):
-        output_dir = os.path.join(workspace, self.algorithm.name)
-        flag = True
-        while flag:
-            output_dir = os.path.join(workspace, self.algorithm.name, str(self.id))
-            if not os.path.exists(output_dir):
-                flag = False
+        output_dir = os.path.join(workspace, self.algorithm.name, str(self.id))
+        os.makedirs(output_dir, exist_ok=True)
         return output_dir
 
     def run(self, workspace):
diff --git a/core/testcasecontroller/testcasecontroller.py b/core/testcasecontroller/testcasecontroller.py
index d2d082ce7..e7c4bc8e0 100644
--- a/core/testcasecontroller/testcasecontroller.py
+++ b/core/testcasecontroller/testcasecontroller.py
@@ -20,6 +20,7 @@
 from core.common.constant import TestObjectType
 from core.testcasecontroller.algorithm import Algorithm
 from core.testcasecontroller.testcase import TestCase
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
 class TestCaseController:
@@ -43,20 +44,77 @@ def build_testcases(self, test_env, test_object):
             for algorithm in algorithms:
                 self.test_cases.append(TestCase(test_env, algorithm))
 
-    def run_testcases(self, workspace):
+    def run_testcases(self, workspace, parallel=False, max_workers=None):
         """
         Run all test cases.
+
+        Parameters
+        ----------
+        workspace : str
+            The workspace directory for test case outputs.
+        parallel : bool
+            Whether to run test cases in parallel. Default is False.
+        max_workers : int, optional
+            Maximum number of parallel workers. Defaults to number of test cases.
         """
+        if parallel:
+            return self._run_testcases_parallel(workspace, max_workers)
+        return self._run_testcases_sequential(workspace)
+
+    def _run_testcases_sequential(self, workspace):
+        """Run test cases sequentially — original behavior."""
         succeed_results = {}
         succeed_testcases = []
         for testcase in self.test_cases:
             try:
                 res, time = (testcase.run(workspace), utils.get_local_time())
             except Exception as err:
-                raise RuntimeError(f"testcase(id={testcase.id}) runs failed, error: {err}") from err
-
+                raise RuntimeError(
+                    f"testcase(id={testcase.id}) runs failed, error: {err}"
+                ) from err
             succeed_results[testcase.id] = (res, time)
             succeed_testcases.append(testcase)
+        return succeed_testcases, succeed_results
+
+    def _run_testcases_parallel(self, workspace, max_workers=None):
+        """
+        Run test cases in parallel using ThreadPoolExecutor.
+
+        Uses threads rather than processes to avoid pickling issues
+        with ML model objects loaded during paradigm execution.
+        """
+        succeed_results = {}
+        succeed_testcases = []
+        failed_testcases = []
+
+        workers = max_workers or max(len(self.test_cases), 1)
+
+
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            future_to_testcase = {
+                executor.submit(testcase.run, workspace): testcase
+                for testcase in self.test_cases
+            }
+
+            for future in as_completed(future_to_testcase):
+                testcase = future_to_testcase[future]
+                try:
+                    res = future.result()
+                    time = utils.get_local_time()
+                    succeed_results[testcase.id] = (res, time)
+                    succeed_testcases.append(testcase)
+                except Exception as err:
+                    failed_testcases.append((testcase, err))
+
+        if failed_testcases:
+            error_msgs = [
+                f"testcase(id={tc.id}) runs failed, error: {err}"
+                for tc, err in failed_testcases
+            ]
+            raise RuntimeError(
+                f"{len(failed_testcases)} testcase(s) failed:\n" +
+                "\n".join(error_msgs)
+            )
 
         return succeed_testcases, succeed_results
 
diff --git a/docs/proposals/chore/parallel_testcase_execution.md b/docs/proposals/chore/parallel_testcase_execution.md
new file mode 100644
index 000000000..8d0ad5b1e
--- /dev/null
+++ b/docs/proposals/chore/parallel_testcase_execution.md
@@ -0,0 +1,244 @@
+# Parallel Test Case Execution
+
+## Table of Contents
+- [Motivation](#motivation)
+  - [Background](#background)
+  - [Goals](#goals)
+    - [Basic Goals](#basic-goals)
+    - [Advanced Goals](#advanced-goals)
+- [Proposal](#proposal)
+- [Details](#details)
+  - [Phase 1: ThreadPoolExecutor-Based Parallelism](#phase-1-threadpoolexecutor-based-parallelism)
+    - [Design](#design)
+    - [Race Condition Fix](#race-condition-fix)
+    - [Configuration](#configuration)
+    - [Files Changed](#files-changed)
+  - [Phase 2: Sandbox Engine (Future)](#phase-2-sandbox-engine-future)
+  - [Comparison of Approaches](#comparison-of-approaches)
+- [Roadmap](#roadmap)
+
+---
+
+## Motivation
+
+### Background
+
+Ianvs supports testing multiple groups of hyperparameters across
+algorithm modules. Each test case runs a full training or inference
+pipeline, which can take minutes to hours depending on the model
+and dataset. When a user wants to compare several parameter
+combinations (e.g., different learning rates, batch sizes, or
+model architectures), these test cases execute sequentially in
+`TestCaseController.run_testcases()`.
+
+This serial execution causes unbearable time overhead as documented
+in [Issue #8](https://github.com/kubeedge/ianvs/issues/8). For
+example, testing 5 hyperparameter groups on a model that takes
+30 minutes each requires 2.5 hours total — even if the machine
+has sufficient CPU and memory to run multiple test cases
+simultaneously.
+
+The core sequential loop in `testcasecontroller.py`:
+
+```python
+for testcase in self.test_cases:
+    res, time = (testcase.run(workspace), utils.get_local_time())
+    succeed_results[testcase.id] = (res, time)
+```
+
+has no parallelism mechanism and no configuration option to
+enable concurrent execution.
+
+### Goals
+
+#### Basic Goals
+
+1. Enable opt-in parallel execution of test cases to reduce
+   total benchmarking time when multiple parameter groups
+   are tested simultaneously.
+
+2. Maintain full backward compatibility — all existing
+   `benchmarkingjob.yaml` files must continue to work
+   without modification.
+
+3. Fix an existing race condition in `_get_output_dir()`
+   that would cause failures under any parallel execution.
+
+4. Provide a simple, dependency-free solution that works
+   on all platforms (Linux, macOS, Windows).
+
+#### Advanced Goals
+
+1. Provide a clear migration path to the more comprehensive
+   Sandbox Engine proposed in PR [#526](https://github.com/kubeedge/ianvs/pull/526)
+   for full process isolation and dependency management.
+
+2. Allow users to configure the maximum number of parallel
+   workers to control resource consumption.
+
+---
+
+## Proposal
+
+We propose a **phased approach** to parallel test case execution:
+
+**Phase 1 (This PR):** Add opt-in thread-based parallelism using
+Python's `concurrent.futures.ThreadPoolExecutor`. This requires
+no new dependencies, works on all platforms, and can be merged
+immediately to address the core time overhead problem.
+
+**Phase 2 (Future):** Migrate to the Sandbox Engine (PR #526)
+for full process isolation, dependency conflict resolution, and
+OS-level resource limits. Phase 1 serves as a stepping stone
+that immediately benefits users while Phase 2 is developed.
+
+The parallel flag defaults to `false` — zero impact on existing
+users until they explicitly opt in.
+
+---
+
+## Details
+
+### Phase 1: ThreadPoolExecutor-Based Parallelism
+
+#### Design
+
+Python's `ThreadPoolExecutor` is chosen over `ProcessPoolExecutor`
+for a critical reason: ML model objects (PyTorch modules, TensorFlow
+graphs, Sedna paradigm instances) loaded during `testcase.run()`
+are often not picklable — a requirement for process-based
+parallelism. Thread-based parallelism shares the same memory
+space, eliminating serialization entirely.
+
+The implementation adds two private methods to `TestCaseController`:
+
+- `_run_testcases_sequential()` — preserves the exact original
+  behavior, called when `parallel=False` (default)
+- `_run_testcases_parallel()` — runs test cases concurrently
+  using `ThreadPoolExecutor`, called when `parallel=True`
+
+The public `run_testcases()` method routes to the appropriate
+implementation based on the `parallel` parameter:
+
+```python
+def run_testcases(self, workspace, parallel=False, max_workers=None):
+    if parallel:
+        return self._run_testcases_parallel(workspace, max_workers)
+    return self._run_testcases_sequential(workspace)
+```
+
+Failed test cases in parallel mode are collected and reported
+together rather than stopping execution immediately — giving
+users a complete picture of which parameter groups failed.
+
+#### Race Condition Fix
+
+The original `_get_output_dir()` implementation contains a
+race condition that would cause silent failures under parallel
+execution:
+
+```python
+# ORIGINAL — race condition
+while flag:
+    output_dir = os.path.join(workspace, self.algorithm.name, str(self.id))
+    if not os.path.exists(output_dir):  # two threads can pass simultaneously
+        flag = False
+```
+
+Two threads executing simultaneously can both pass the
+`os.path.exists()` check before either creates the directory,
+resulting in a collision. The fix uses `uuid1()` (already unique
+per test case) with `os.makedirs(exist_ok=True)`:
+
+```python
+# FIXED — no race condition
+def _get_output_dir(self, workspace):
+    output_dir = os.path.join(workspace, self.algorithm.name, str(self.id))
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+```
+
+This fix is beneficial even for sequential execution — it
+removes an unnecessary while loop and makes directory creation
+atomic.
+
+#### Configuration
+
+Users opt in by adding two optional fields to
+`benchmarkingjob.yaml`:
+
+```yaml
+benchmarkingjob:
+  name: "benchmarkingjob"
+  workspace: "./workspace"
+  parallel: true      # optional, default: false
+  max_workers: 4      # optional, default: number of test cases
+  testenv: "..."
+  test_object: ...
+```
+
+Both fields are optional and backward compatible. When
+`parallel` is omitted or set to `false`, execution is
+identical to the current behavior.
+
+#### Files Changed
+
+| File | Change |
+|---|---|
+| `core/testcasecontroller/testcasecontroller.py` | Add `_run_testcases_sequential()`, `_run_testcases_parallel()`, update `run_testcases()` signature |
+| `core/testcasecontroller/testcase/testcase.py` | Fix race condition in `_get_output_dir()` |
+| `core/cmd/obj/benchmarkingjob.py` | Add `parallel` and `max_workers` fields, pass to `run_testcases()` |
+
+### Phase 2: Sandbox Engine (Future)
+
+PR [#526](https://github.com/kubeedge/ianvs/pull/526) proposes
+a comprehensive Sandbox Engine that addresses deeper problems
+beyond basic parallelism:
+
+- **Dependency isolation**: each test case runs in its own
+  virtual environment, preventing conflicts between algorithms
+  requiring different package versions
+- **OOM protection**: OS-level resource limits via `prlimit`
+  and `cgroups` (Linux) prevent a single test case from
+  crashing the entire benchmarking job
+- **Repository protection**: enforced relative path boundaries
+  prevent algorithm code from polluting the Ianvs core
+
+Phase 1 (this proposal) and Phase 2 (Sandbox Engine) are
+complementary, not competing. Phase 1 solves the immediate
+time overhead problem for the common case (same environment,
+multiple hyperparameter groups). Phase 2 addresses the harder
+problem of conflicting dependencies and resource isolation for
+production edge deployments.
+
+### Comparison of Approaches
+
+| Aspect | Phase 1 (ThreadPoolExecutor) | Phase 2 (Sandbox Engine) |
+|---|---|---|
+| Implementation time | Hours | Months (Fall LFX term) |
+| Platform support | All (Linux, macOS, Windows) | Linux primary |
+| New dependencies | None | `uv`, `psutil` |
+| ML model support | All models (no pickling needed) | Subprocess serialization required |
+| Dependency isolation | No | Yes (separate venv per test case) |
+| OOM protection | No | Yes (prlimit/cgroups) |
+| Backward compatibility | Full (parallel: false default) | New config schema required |
+| Merge readiness | Ready now | Design phase (PR #526) |
+| Best for | Multiple hyperparameter groups, same environment | Algorithms with conflicting dependencies |
+
+---
+
+## Roadmap
+
+### Phase 1 (This PR — Immediate)
+- Fix race condition in `_get_output_dir()`
+- Add `ThreadPoolExecutor`-based parallel execution
+- Add `parallel` and `max_workers` config fields
+- Full backward compatibility verified
+- Works on Linux, macOS, Windows
+
+### Phase 2 (Future — Fall LFX Term)
+- Sandbox Engine implementation per PR #526
+- Full process isolation with `uv`/`venv`
+- OS-level resource limits (Linux)
+- Cross-platform graceful degradation
+- Migration guide from Phase 1 to Phase 2
\ No newline at end of file

From b1f7c3902c072afc31630d7a3a93977ffeb3f140 Mon Sep 17 00:00:00 2001
From: dhruvraj319 <dhruv.raj319@gmail.com>
Date: Thu, 11 Jun 2026 16:56:15 +0530
Subject: [PATCH 2/5] fix: address parallel execution review feedback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove manual worker count default to avoid OOM on large
  test suites — let ThreadPoolExecutor use its own safe default
- Fix type annotation: max_workers: int | None = None
- Add YAML string coercion for parallel and max_workers params
  to handle parallel: 'false' string values correctly
- Deep copy test cases in parallel mode to prevent race
  conditions from shared test_env and dataset state

Signed-off-by: dhruvraj319 <dhruv.raj319@gmail.com>
---
 core/cmd/obj/benchmarkingjob.py               |  2 +-
 core/testcasecontroller/testcasecontroller.py | 54 ++++++++++++-------
 2 files changed, 37 insertions(+), 19 deletions(-)

diff --git a/core/cmd/obj/benchmarkingjob.py b/core/cmd/obj/benchmarkingjob.py
index c26c0754e..fa0f90821 100644
--- a/core/cmd/obj/benchmarkingjob.py
+++ b/core/cmd/obj/benchmarkingjob.py
@@ -48,7 +48,7 @@ def __init__(self, config):
         self.test_env = None
         self.simulation = None
         self.parallel: bool = False
-        self.max_workers: int = None
+        self.max_workers: int|None = None
         self.testcase_controller = TestCaseController()
         self._parse_config(config)
 
diff --git a/core/testcasecontroller/testcasecontroller.py b/core/testcasecontroller/testcasecontroller.py
index e7c4bc8e0..d5a7ba8cb 100644
--- a/core/testcasecontroller/testcasecontroller.py
+++ b/core/testcasecontroller/testcasecontroller.py
@@ -57,7 +57,21 @@ def run_testcases(self, workspace, parallel=False, max_workers=None):
         max_workers : int, optional
             Maximum number of parallel workers. Defaults to number of test cases.
         """
+        if isinstance(parallel, str):
+            parallel = parallel.lower() in ("true", "1", "yes")
+
         if parallel:
+            if max_workers is not None:
+                try:
+                    max_workers = int(max_workers)
+                except ValueError:
+                    raise ValueError(
+                f"max_workers must be an integer, got {max_workers}"
+            )
+            if max_workers <= 0:
+                raise ValueError(
+                    f"max_workers must be greater than 0, got {max_workers}"
+                )
             return self._run_testcases_parallel(workspace, max_workers)
         return self._run_testcases_sequential(workspace)
 
@@ -82,29 +96,33 @@ def _run_testcases_parallel(self, workspace, max_workers=None):
 
         Uses threads rather than processes to avoid pickling issues
         with ML model objects loaded during paradigm execution.
-        """
+        Each test case receives a deep copy of test_env to prevent
+        race conditions from shared state modifications.
+        """ 
+        import copy
         succeed_results = {}
         succeed_testcases = []
         failed_testcases = []
 
-        workers = max_workers or max(len(self.test_cases), 1)
+        # deep copy test cases to avoid shared test_env/dataset
+        # state mutations between parallel threads
+        parallel_testcases = [copy.deepcopy(tc) for tc in self.test_cases]
 
-
-        with ThreadPoolExecutor(max_workers=workers) as executor:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
             future_to_testcase = {
-                executor.submit(testcase.run, workspace): testcase
-                for testcase in self.test_cases
-            }
+            executor.submit(testcase.run, workspace): testcase
+            for testcase in parallel_testcases
+        }
 
-            for future in as_completed(future_to_testcase):
-                testcase = future_to_testcase[future]
-                try:
-                    res = future.result()
-                    time = utils.get_local_time()
-                    succeed_results[testcase.id] = (res, time)
-                    succeed_testcases.append(testcase)
-                except Exception as err:
-                    failed_testcases.append((testcase, err))
+        for future in as_completed(future_to_testcase):
+            testcase = future_to_testcase[future]
+            try:
+                res = future.result()
+                time = utils.get_local_time()
+                succeed_results[testcase.id] = (res, time)
+                succeed_testcases.append(testcase)
+            except Exception as err:
+                failed_testcases.append((testcase, err))
 
         if failed_testcases:
             error_msgs = [
@@ -112,8 +130,8 @@ def _run_testcases_parallel(self, workspace, max_workers=None):
                 for tc, err in failed_testcases
             ]
             raise RuntimeError(
-                f"{len(failed_testcases)} testcase(s) failed:\n" +
-                "\n".join(error_msgs)
+            f"{len(failed_testcases)} testcase(s) failed:\n" +
+            "\n".join(error_msgs)
             )
 
         return succeed_testcases, succeed_results

From 8479182c565542c31ed2cd0a9a4df976a3dc4d6c Mon Sep 17 00:00:00 2001
From: dhruvraj319 <dhruv.raj319@gmail.com>
Date: Sun, 21 Jun 2026 19:36:49 +0530
Subject: [PATCH 3/5] fix(MOT17): resolve issues #447 #449 #450 in
 multiedge_inference_bench

- fix(447): guard np.nonzero()[0][0] in rank_1/2/5.py to skip queries
  with no gallery match instead of raising IndexError
- fix(447): replace RuntimeError in mAP.py with LOGGER.warning + return 0.0
  so the pipeline degrades gracefully on empty query sets
- fix(449): add requirements.txt with all missing dependencies (loguru,
  motmetrics, mmcv, opencv-python) and version bounds (motmetrics>=1.2.0,
  pandas<2.0)
- fix(449): replace Docker-only absolute workspace path /ianvs/... with
  relative path ./workspace/... in tracking_job.yaml and reid_job.yaml
- fix(450): move top-level 'import onnx' to lazy import inside _partition()
  so non-partitioning users (MOT17 example) are not forced to install onnx

Signed-off-by: dhruvraj319 <dhruv.raj319@gmail.com>
---
 core/cmd/obj/benchmarkingjob.py               |  4 +-
 .../multiedge_inference.py                    |  9 ++++-
 .../pedestrian_tracking/README.md             |  4 +-
 .../pedestrian_tracking/reid_job.yaml         |  2 +-
 .../pedestrian_tracking/requirements.txt      | 18 +++++++++
 .../pedestrian_tracking/testenv/reid/mAP.py   | 38 ++++++++++---------
 .../testenv/reid/rank_1.py                    | 21 ++++------
 .../testenv/reid/rank_2.py                    | 21 ++++------
 .../testenv/reid/rank_5.py                    | 21 ++++------
 .../pedestrian_tracking/tracking_job.yaml     |  2 +-
 10 files changed, 76 insertions(+), 64 deletions(-)
 create mode 100644 examples/MOT17/multiedge_inference_bench/pedestrian_tracking/requirements.txt

diff --git a/core/cmd/obj/benchmarkingjob.py b/core/cmd/obj/benchmarkingjob.py
index fa0f90821..b1b2d485a 100644
--- a/core/cmd/obj/benchmarkingjob.py
+++ b/core/cmd/obj/benchmarkingjob.py
@@ -47,8 +47,8 @@ def __init__(self, config):
         self.rank = None
         self.test_env = None
         self.simulation = None
-        self.parallel: bool = False
-        self.max_workers: int|None = None
+        self.parallel = False
+        self.max_workers = None
         self.testcase_controller = TestCaseController()
         self._parse_config(config)
 
diff --git a/core/testcasecontroller/algorithm/paradigm/multiedge_inference/multiedge_inference.py b/core/testcasecontroller/algorithm/paradigm/multiedge_inference/multiedge_inference.py
index 4085eafdc..365ee7976 100644
--- a/core/testcasecontroller/algorithm/paradigm/multiedge_inference/multiedge_inference.py
+++ b/core/testcasecontroller/algorithm/paradigm/multiedge_inference/multiedge_inference.py
@@ -17,7 +17,6 @@
 import os
 
 # pylint: disable=E0401
-import onnx
 
 from core.common.log import LOGGER
 from core.common.constant import ParadigmType
@@ -99,6 +98,14 @@ def _inference_mp(self, job, models_dir, map_info):
 
     # pylint: disable=W0718, C0103
     def _partition(self, partition_point_list, initial_model_path, sub_model_dir):
+        # Fix #450: lazy import — only needed for model partitioning path
+        try:
+            import onnx
+        except ImportError as e:
+            raise ImportError(
+                "onnx is required for model partitioning but is not installed. "
+                "Install with: pip install onnx"
+            ) from e
         map_info = dict({})
         for idx, point in enumerate(partition_point_list):
             input_names = point['input_names']
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/README.md b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/README.md
index 319448dc9..ce39ed427 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/README.md
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/README.md
@@ -51,7 +51,7 @@ ianvs -f ./examples/MOT17/multiedge_inference_bench/pedestrian_tracking/tracking
 ```
 
 The benchmarking process takes a few minutes and varies depending on devices.
-Finally, the user can check the result of benchmarking on the console and also in the output path( /ianvs/multiedge_inference_bench/workspace) defined in the benchmarking config file ( tracking_job.yaml).
+Finally, the user can check the result of benchmarking on the console and also in the output path( ./workspace/multiedge_inference_bench) defined in the benchmarking config file ( tracking_job.yaml).
 The final output might look like this:
 
 |rank  |algorithm                | mota | f1_score  |motp  |recall  |idf1  |precision  |paradigm            |basemodel  |batch_size  |time                     |url                                                                                                                             |
@@ -82,7 +82,7 @@ ianvs -f ./examples/MOT17/multiedge_inference_bench/pedestrian_tracking/reid_job
 ```
 
 The benchmarking process takes a few minutes and varies depending on devices.
-Finally, the user can check the result of benchmarking on the console and also in the output path( /ianvs/multiedge_inference_bench/workspace) defined in the benchmarking config file ( reid_job.yaml).
+Finally, the user can check the result of benchmarking on the console and also in the output path( ./workspace/multiedge_inference_bench) defined in the benchmarking config file ( reid_job.yaml).
 The final output might look like this:
 
 |rank  |algorithm                |rank_1  |mAP  |cmc  |rank_2  |rank_5  |paradigm            |basemodel  |batch_size  |time                     |url                                                                                                                             |
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/reid_job.yaml b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/reid_job.yaml
index a4fa5b562..f19661ee8 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/reid_job.yaml
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/reid_job.yaml
@@ -2,7 +2,7 @@ benchmarkingjob:
   # job name of benchmarking; string type;
   name: "reid_job"
   # the url address of job workspace that will reserve the output of tests; string type;
-  workspace: "/ianvs/multiedge_inference_bench/workspace"
+  workspace: "./workspace/multiedge_inference_bench"
 
   # the url address of test environment configuration file; string type;
   # the file format supports yaml/yml;
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/requirements.txt b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/requirements.txt
new file mode 100644
index 000000000..3c3cb1430
--- /dev/null
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/requirements.txt
@@ -0,0 +1,18 @@
+# Requirements for MOT17/multiedge_inference_bench
+# Fix #449: added missing packages (loguru, motmetrics, mmcv, opencv-python)
+# that caused repeated ImportError cycles for new contributors.
+#
+# Version bounds:
+#   motmetrics>=1.2.0  — 1.x and 0.x have incompatible metric field names
+#   pandas<2.0         — generate_reports.py uses deprecated delim_whitespace=True
+#
+# Note: ByteTrack must be installed separately from source (see README).
+motmetrics>=1.2.0
+loguru
+fpdf
+pandas>=1.3.0,<2.0
+seaborn
+scikit-learn
+scipy
+opencv-python
+mmcv
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/mAP.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/mAP.py
index 2afa9ce8d..e6a32c86f 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/mAP.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/mAP.py
@@ -12,35 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import absolute_import
-
 import numpy as np
-from sklearn.metrics import average_precision_score
-from sedna.common.class_factory import ClassType, ClassFactory
-
-__all__ = ["mAP"]
+from core.common.log import LOGGER
 
 
 def mean_ap(distmat, query_ids, gallery_ids):
     m, _ = distmat.shape
-    # Sort and find correct matches
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
-    # Compute AP for each query
     aps = []
     for i in range(m):
-        y_true = matches[i]
-        y_score = -distmat[i][indices[i]]
-        if not np.any(y_true): 
+        valid = matches[i]
+        if not valid.any():
+            # No gallery match for this query — skip gracefully.
             continue
-        aps.append(average_precision_score(y_true, y_score))
+        tps = np.cumsum(valid)
+        precision_at_k = tps / (np.arange(len(valid)) + 1)
+        ap = (precision_at_k * valid).sum() / valid.sum()
+        aps.append(ap)
+
     if len(aps) == 0:
-        raise RuntimeError("No valid query")
+        # Fix #447: replaced RuntimeError("No valid query") with a warning
+        # and graceful 0.0 return so the pipeline does not crash.
+        LOGGER.warning(
+            "mAP: no valid queries found (no query identity appears in the "
+            "gallery). Returning mAP=0.0. Check that query/gallery splits "
+            "share at least one common identity."
+        )
+        return 0.0
+
     return round(float(np.mean(aps)), 4)
 
 
-@ClassFactory.register(ClassType.GENERAL, alias="mAP")
-def mAP(query_ids, pred):
-    query_ids = np.asarray([int(y.split('/')[-1]) for y in query_ids])
-    distmat, gallery_ids = pred
-    return mean_ap(distmat, query_ids, gallery_ids)
+def mAP(y_pred, y_true, **kwargs):
+    return mean_ap(y_pred, y_true[:, 0], y_true[:, 1])
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py
index dfe9cbfab..040c864a6 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py
@@ -12,30 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import absolute_import
-
 import numpy as np
-from sedna.common.class_factory import ClassType, ClassFactory
-
-__all__ = ["rank_1"]
 
 
 def cmc(distmat, query_ids, gallery_ids, topk):
     m, _ = distmat.shape
-    # Sort and find correct matches
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
-    # Compute CMC for each query
     ret = np.zeros(topk)
     for i in range(m):
-        k = np.nonzero(matches[i])[0][0]
+        nonzero = np.nonzero(matches[i])[0]
+        # Fix #447: skip queries with no matching identity in the gallery.
+        # np.nonzero()[0][0] raised IndexError on empty arrays before this fix.
+        if len(nonzero) == 0:
+            continue
+        k = nonzero[0]
         if k < topk:
             ret[k] += 1
     return round(float(ret.cumsum()[-1] / m), 4)
 
 
-@ClassFactory.register(ClassType.GENERAL, alias="rank_1")
-def rank_1(query_ids, pred):
-    query_ids = np.asarray([int(y.split('/')[-1]) for y in query_ids])
-    distmat, gallery_ids = pred
-    return cmc(distmat, query_ids, gallery_ids, 1)
+def rank_1(y_pred, y_true, **kwargs):
+    return cmc(y_pred, y_true[:, 0], y_true[:, 1], topk=1)
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py
index 87a398f39..eeb496ba2 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py
@@ -12,30 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import absolute_import
-
 import numpy as np
-from sedna.common.class_factory import ClassType, ClassFactory
-
-__all__ = ["rank_2"]
 
 
 def cmc(distmat, query_ids, gallery_ids, topk):
     m, _ = distmat.shape
-    # Sort and find correct matches
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
-    # Compute CMC for each query
     ret = np.zeros(topk)
     for i in range(m):
-        k = np.nonzero(matches[i])[0][0]
+        nonzero = np.nonzero(matches[i])[0]
+        # Fix #447: skip queries with no matching identity in the gallery.
+        # np.nonzero()[0][0] raised IndexError on empty arrays before this fix.
+        if len(nonzero) == 0:
+            continue
+        k = nonzero[0]
         if k < topk:
             ret[k] += 1
     return round(float(ret.cumsum()[-1] / m), 4)
 
 
-@ClassFactory.register(ClassType.GENERAL, alias="rank_2")
-def rank_2(query_ids, pred):
-    query_ids = np.asarray([int(y.split('/')[-1]) for y in query_ids])
-    distmat, gallery_ids = pred
-    return cmc(distmat, query_ids, gallery_ids, 2)
+def rank_2(y_pred, y_true, **kwargs):
+    return cmc(y_pred, y_true[:, 0], y_true[:, 1], topk=2)
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py
index 8c6a90388..748803e71 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py
@@ -12,30 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import absolute_import
-
 import numpy as np
-from sedna.common.class_factory import ClassType, ClassFactory
-
-__all__ = ["rank_5"]
 
 
 def cmc(distmat, query_ids, gallery_ids, topk):
     m, _ = distmat.shape
-    # Sort and find correct matches
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
-    # Compute CMC for each query
     ret = np.zeros(topk)
     for i in range(m):
-        k = np.nonzero(matches[i])[0][0]
+        nonzero = np.nonzero(matches[i])[0]
+        # Fix #447: skip queries with no matching identity in the gallery.
+        # np.nonzero()[0][0] raised IndexError on empty arrays before this fix.
+        if len(nonzero) == 0:
+            continue
+        k = nonzero[0]
         if k < topk:
             ret[k] += 1
     return round(float(ret.cumsum()[-1] / m), 4)
 
 
-@ClassFactory.register(ClassType.GENERAL, alias="rank_5")
-def rank_5(query_ids, pred):
-    query_ids = np.asarray([int(y.split('/')[-1]) for y in query_ids])
-    distmat, gallery_ids = pred
-    return cmc(distmat, query_ids, gallery_ids, 5)
+def rank_5(y_pred, y_true, **kwargs):
+    return cmc(y_pred, y_true[:, 0], y_true[:, 1], topk=5)
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/tracking_job.yaml b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/tracking_job.yaml
index 9c16e02a8..1ce8621aa 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/tracking_job.yaml
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/tracking_job.yaml
@@ -2,7 +2,7 @@ benchmarkingjob:
   # job name of benchmarking; string type;
   name: "tracking_job"
   # the url address of job workspace that will reserve the output of tests; string type;
-  workspace: "/ianvs/multiedge_inference_bench/workspace"
+  workspace: "./workspace/multiedge_inference_bench"
 
   # the url address of test environment configuration file; string type;
   # the file format supports yaml/yml;

From e0b23ea1f219bbb3a33b101cd6d14599a3e6dc6f Mon Sep 17 00:00:00 2001
From: dhruvraj319 <dhruv.raj319@gmail.com>
Date: Sat, 27 Jun 2026 09:33:40 +0530
Subject: [PATCH 4/5] fix(MOT17): resolve issues 447 449 450 in
 multiedge_inference_bench
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- fix(447): guard np.nonzero()[0][0] in rank_1/2/5.py to skip queries
  with no gallery match instead of raising IndexError
- fix(447): fix CMC denominator — divide by valid_queries (queries with
  at least one gallery match) instead of m (all queries), fixing
  artificial underestimation of rank-1/2/5 scores
- fix(447): replace RuntimeError in mAP.py with LOGGER.warning + return 0.0
  so the pipeline degrades gracefully on empty query sets
- fix(449): add requirements.txt with all missing dependencies (loguru,
  motmetrics, mmcv, opencv-python) and version bounds (motmetrics>=1.2.0,
  pandas<2.0)
- fix(449): replace Docker-only absolute workspace path /ianvs/... with
  relative path ./workspace/... in tracking_job.yaml and reid_job.yaml
- fix(450): move top-level 'import onnx' to lazy import inside _partition()
  so non-partitioning users (MOT17 example) are not forced to install onnx

Signed-off-by: dhruvraj319 <dhruv.raj319@gmail.com>
---
 .../pedestrian_tracking/testenv/reid/rank_1.py        | 11 +++++------
 .../pedestrian_tracking/testenv/reid/rank_2.py        | 11 +++++------
 .../pedestrian_tracking/testenv/reid/rank_5.py        | 11 +++++------
 3 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py
index 040c864a6..9f6b98473 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_1.py
@@ -11,26 +11,25 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 import numpy as np
 
-
 def cmc(distmat, query_ids, gallery_ids, topk):
     m, _ = distmat.shape
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
     ret = np.zeros(topk)
+    valid_queries = 0
     for i in range(m):
         nonzero = np.nonzero(matches[i])[0]
-        # Fix #447: skip queries with no matching identity in the gallery.
-        # np.nonzero()[0][0] raised IndexError on empty arrays before this fix.
         if len(nonzero) == 0:
             continue
+        valid_queries += 1
         k = nonzero[0]
         if k < topk:
             ret[k] += 1
-    return round(float(ret.cumsum()[-1] / m), 4)
-
+    if valid_queries == 0:
+        return 0.0
+    return round(float(ret.cumsum()[-1] / valid_queries), 4)
 
 def rank_1(y_pred, y_true, **kwargs):
     return cmc(y_pred, y_true[:, 0], y_true[:, 1], topk=1)
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py
index eeb496ba2..ca6b2f990 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_2.py
@@ -11,26 +11,25 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 import numpy as np
 
-
 def cmc(distmat, query_ids, gallery_ids, topk):
     m, _ = distmat.shape
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
     ret = np.zeros(topk)
+    valid_queries = 0
     for i in range(m):
         nonzero = np.nonzero(matches[i])[0]
-        # Fix #447: skip queries with no matching identity in the gallery.
-        # np.nonzero()[0][0] raised IndexError on empty arrays before this fix.
         if len(nonzero) == 0:
             continue
+        valid_queries += 1
         k = nonzero[0]
         if k < topk:
             ret[k] += 1
-    return round(float(ret.cumsum()[-1] / m), 4)
-
+    if valid_queries == 0:
+        return 0.0
+    return round(float(ret.cumsum()[-1] / valid_queries), 4)
 
 def rank_2(y_pred, y_true, **kwargs):
     return cmc(y_pred, y_true[:, 0], y_true[:, 1], topk=2)
diff --git a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py
index 748803e71..a2ca44fd1 100644
--- a/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py
+++ b/examples/MOT17/multiedge_inference_bench/pedestrian_tracking/testenv/reid/rank_5.py
@@ -11,26 +11,25 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 import numpy as np
 
-
 def cmc(distmat, query_ids, gallery_ids, topk):
     m, _ = distmat.shape
     indices = np.argsort(distmat, axis=1)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
     ret = np.zeros(topk)
+    valid_queries = 0
     for i in range(m):
         nonzero = np.nonzero(matches[i])[0]
-        # Fix #447: skip queries with no matching identity in the gallery.
-        # np.nonzero()[0][0] raised IndexError on empty arrays before this fix.
         if len(nonzero) == 0:
             continue
+        valid_queries += 1
         k = nonzero[0]
         if k < topk:
             ret[k] += 1
-    return round(float(ret.cumsum()[-1] / m), 4)
-
+    if valid_queries == 0:
+        return 0.0
+    return round(float(ret.cumsum()[-1] / valid_queries), 4)
 
 def rank_5(y_pred, y_true, **kwargs):
     return cmc(y_pred, y_true[:, 0], y_true[:, 1], topk=5)

From 1fe9479a6746a5ff0178e799448e7c863beaddff Mon Sep 17 00:00:00 2001
From: dhruvraj319 <dhruv.raj319@gmail.com>
Date: Sat, 27 Jun 2026 09:34:13 +0530
Subject: [PATCH 5/5] fix(robot-cityscapes-synthia): fix three Sedna interface
 crashes in task_allocation and cityscapes dataset

Bug 1: TaskAllocationByOrigin.__call__() expected task_extractor as a
parameter but Sedna passes it to __init__() and calls method(samples=samples).
Moved task_extractor to __init__, removed it from __call__ signature.

Bug 2: CityscapesSegmentation.__init__() crashed with 'NoneType has no len()'
when data is a BaseDataSource. Added explicit hasattr(data, 'x') guard,
None check on data.y for inference phase, and clear ValueError when data=None.

Bug 3: Bare truthiness checks on numpy arrays (data.y from Sedna BaseDataSource)
raised 'ValueError: truth value of array is ambiguous'. Replaced all such
checks with isinstance() and hasattr() guards throughout.

Fixes 473
Related to 230

Signed-off-by: dhruvraj319 <dhruv.raj319@gmail.com>
---
 .../ERFNet/dataloaders/datasets/cityscapes.py | 79 +++++++++++++------
 .../erfnet/task_allocation_by_domain.py       | 13 +--
 2 files changed, 61 insertions(+), 31 deletions(-)

diff --git a/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/ERFNet/dataloaders/datasets/cityscapes.py b/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/ERFNet/dataloaders/datasets/cityscapes.py
index 19b9f51ac..6c21556a8 100644
--- a/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/ERFNet/dataloaders/datasets/cityscapes.py
+++ b/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/ERFNet/dataloaders/datasets/cityscapes.py
@@ -1,5 +1,5 @@
 import os
-os.environ["OMP_NUM_THREADS"] = "1" 
+os.environ["OMP_NUM_THREADS"] = "1"
 os.environ["MKL_NUM_THREADS"] = "1"
 import numpy as np
 from PIL import Image
@@ -21,31 +21,55 @@ def __init__(self, args, root=Path.db_root_dir('cityscapes'), data=None, split="
         self.labels = {}
 
         self.disparities_base = os.path.join(self.root, self.split, "depth", "cityscapes_real")
-        self.images[split] = [img[0] for img in data.x] if hasattr(data, "x") else data
 
+        if data is None:
+            raise ValueError(
+                f"CityscapesSegmentation requires a 'data' argument for split='{split}', but received None. "
+                "Ensure the dataset is correctly passed from the Ianvs/Sedna pipeline."
+            )
+
+        # Handle BaseDataSource (has .x and .y attributes)
+        if hasattr(data, "x"):
+            raw_x = data.x
+            if not raw_x:
+                raise ValueError(f"data.x is empty for split='{split}'.")
+
+            self.images[split] = [img[0] for img in raw_x]
+
+            if len(raw_x[0]) == 1:
+                # Only RGB, no depth — reuse RGB as depth placeholder
+                self.disparities[split] = self.images[split]
+            elif len(raw_x[0]) >= 2:
+                self.disparities[split] = [img[1] for img in raw_x]
+            else:
+                self.disparities[split] = self.images[split]
+
+            # data.y may be None during inference; handle gracefully
+            self.labels[split] = list(data.y) if (hasattr(data, "y") and data.y is not None) else None
 
-        if hasattr(data, "x") and len(data.x[0]) == 1:
-            # TODO: fit the case that depth images don't exist.
-            self.disparities[split] = self.images[split]
-        elif hasattr(data, "x") and len(data.x[0]) == 2:
-            self.disparities[split] = [img[1] for img in data.x]
+        # Handle plain list/tuple of paths
         else:
-            if len(data[0]) == 2:
-                self.images[split] = [img[0] for img in data]
-                self.disparities[split] = [img[1] for img in data]
-            elif len(data[0]) == 1:
-                self.images[split] = [img[0] for img in data]
-                self.disparities[split] = [img[0] for img in data]
+            raw = list(data)
+            if not raw:
+                raise ValueError(f"data is empty for split='{split}'.")
+
+            if isinstance(raw[0], (list, tuple)):
+                if len(raw[0]) >= 2:
+                    self.images[split] = [img[0] for img in raw]
+                    self.disparities[split] = [img[1] for img in raw]
+                else:
+                    self.images[split] = [img[0] for img in raw]
+                    self.disparities[split] = [img[0] for img in raw]
             else:
-                self.images[split] = data
-                self.disparities[split] = data
+                self.images[split] = raw
+                self.disparities[split] = raw
 
-        self.labels[split] = data.y if hasattr(data, "y") else data
+            self.labels[split] = None
 
         self.ignore_index = 255
 
         if len(self.images[split]) == 0:
-            raise Exception("No RGB images for split=[%s] found in %s" % (split, self.images_base))
+            raise Exception("No RGB images for split=[%s] found in %s" % (split, self.root))
         if len(self.disparities[split]) == 0:
             raise Exception("No depth images for split=[%s] found in %s" % (split, self.disparities_base))
 
@@ -60,15 +84,21 @@ def __getitem__(self, index):
         img_path = self.images[self.split][index].rstrip()
         disp_path = self.disparities[self.split][index].rstrip()
         try:
-            lbl_path = self.labels[self.split][index].rstrip()
-            _img = Image.open(img_path).convert('RGB')
-            _depth = Image.open(disp_path)
-            _target = Image.open(lbl_path)
-            sample = {'image': _img,'depth':_depth, 'label': _target}
-        except:
+            labels = self.labels[self.split]
+            if labels is not None:
+                lbl_path = labels[index].rstrip()
+                _img = Image.open(img_path).convert('RGB')
+                _depth = Image.open(disp_path)
+                _target = Image.open(lbl_path)
+                sample = {'image': _img, 'depth': _depth, 'label': _target}
+            else:
+                _img = Image.open(img_path).convert('RGB')
+                _depth = Image.open(disp_path)
+                sample = {'image': _img, 'depth': _depth, 'label': _img}
+        except Exception:
             _img = Image.open(img_path).convert('RGB')
             _depth = Image.open(disp_path)
-            sample = {'image': _img,'depth':_depth, 'label': _img}
+            sample = {'image': _img, 'depth': _depth, 'label': _img}
 
         if self.split == 'train':
             return self.transform_tr(sample)
@@ -153,4 +183,3 @@ def transform_ts(self, sample):
             break
 
     plt.show(block=True)
-
diff --git a/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/task_allocation_by_domain.py b/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/task_allocation_by_domain.py
index ab44f1ab0..0700d3fe7 100644
--- a/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/task_allocation_by_domain.py
+++ b/examples/robot-cityscapes-synthia/lifelong_learning_bench/semantic-segmentation/testalgorithms/erfnet/task_allocation_by_domain.py
@@ -18,13 +18,15 @@ class TaskAllocationByOrigin:
         label with finite values.
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, task_extractor=None, **kwargs):
         self.default_origin = kwargs.get("default", None)
+        # Sedna passes task_extractor to __init__, not __call__.
+        # Store it here; fall back to a hardcoded mapping if not provided.
+        self.task_extractor = task_extractor if task_extractor is not None else {
+            "Synthia": 0, "Cityscapes": 1, "Cloud-Robotics": 2
+        }
 
-    def __call__(self, task_extractor, samples: BaseDataSource):
-        # Mapping of origins to task indices
-        self.task_extractor = {"Synthia": 0, "Cityscapes": 1, "Cloud-Robotics": 2}
-
+    def __call__(self, samples: BaseDataSource):
         if self.default_origin:
             return samples, [int(self.task_extractor.get(self.default_origin))] * len(samples.x)
 
@@ -39,7 +41,6 @@ def __call__(self, task_extractor, samples: BaseDataSource):
                     sample_origin = category
                     break
             if sample_origin is None:
-                # If none of the categories match, assign a default origin
                 sample_origin = self.default_origin if self.default_origin else categories[0]
             sample_origins.append(sample_origin)