⚡️ Speed up method RoboflowMultiLabelClassificationModelBlockV2.run_remotely by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for RoboflowMultiLabelClassificationModelBlockV2.run_remotely in inference/core/workflows/core_steps/models/roboflow/multi_label_classification/v2.py

⏱️ Runtime : 52.4 microseconds → 49.9 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup through two key micro-optimizations in the post-processing logic:

What was optimized:

1. Single-loop processing: The _post_process_result method was restructured to combine metadata attachment and result dict creation into one loop, eliminating the separate list comprehension pass.

2. Conditional list coercion: Added a type check before converting predictions to a list, avoiding unnecessary list creation when the inference already returns a list.

Key changes:

• Combined operations: Instead of first attaching metadata to predictions in one loop, then creating result dictionaries in a separate list comprehension, both operations now happen in a single iteration.
• In-place updates: Metadata is attached directly to prediction dictionaries during the same loop that builds the final result list.
• Smarter type handling: Only converts predictions to a list when it's actually a single dict, not when it's already a list.

Why this improves performance:

• Reduced iteration overhead: Eliminates one complete pass through the predictions list, reducing loop setup/teardown costs.
• Better memory locality: Processing each prediction completely before moving to the next improves cache efficiency.
• Fewer intermediate operations: Combines what were previously two separate operations (metadata attachment + result building) into one.

Best suited for: Workloads processing multiple predictions in batch, where the reduced iteration overhead and improved memory access patterns provide measurable benefits. The optimization is most effective when processing moderate to large batches of inference results.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 26 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	90.9%

🌀 Generated Regression Tests and Runtime

from typing import Any, List, Optional

# imports
import pytest
from inference.core.workflows.core_steps.models.roboflow.multi_label_classification.v2 import \
    RoboflowMultiLabelClassificationModelBlockV2

# --- Minimal stubs for dependencies ---

# Constants
INFERENCE_ID_KEY = "inference_id"
PARENT_ID_KEY = "parent_id"
ROOT_PARENT_ID_KEY = "root_parent_id"
PREDICTION_TYPE_KEY = "prediction_type"

# Dummy InferenceConfiguration
class InferenceConfiguration:
    def __init__(
        self,
        confidence_threshold: Optional[float] = None,
        disable_active_learning: Optional[bool] = None,
        active_learning_target_dataset: Optional[str] = None,
        max_batch_size: int = 1,
        max_concurrent_requests: int = 1,
        source: Optional[str] = None,
    ):
        self.confidence_threshold = confidence_threshold
        self.disable_active_learning = disable_active_learning
        self.active_learning_target_dataset = active_learning_target_dataset
        self.max_batch_size = max_batch_size
        self.max_concurrent_requests = max_concurrent_requests
        self.source = source

    @classmethod
    def init_default(cls):
        return cls()

# Dummy attach_prediction_type_info
def attach_prediction_type_info(predictions, prediction_type, key=PREDICTION_TYPE_KEY):
    for result in predictions:
        result[key] = prediction_type
    return predictions

# Dummy WorkflowImageData and parent metadata
class Metadata:
    def __init__(self, parent_id):
        self.parent_id = parent_id

class WorkflowImageData:
    def __init__(self, base64_image, parent_id, root_parent_id):
        self.base64_image = base64_image
        self.parent_metadata = Metadata(parent_id)
        self.workflow_root_ancestor_metadata = Metadata(root_parent_id)

# Dummy Batch type alias
Batch = list

# --- Function under test: run_remotely ---

def run_remotely(
    images: Batch[Optional[WorkflowImageData]],
    model_id: str,
    confidence: Optional[float],
    disable_active_learning: Optional[bool],
    active_learning_target_dataset: Optional[str],
) -> List[dict]:
    # Simulate environment variables/constants
    LOCAL_INFERENCE_API_URL = "http://localhost:9001"
    HOSTED_CLASSIFICATION_URL = "http://hosted.roboflow.com"
    WORKFLOWS_REMOTE_API_TARGET = "local"  # or "hosted"
    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_BATCH_SIZE = 32
    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS = 4

    api_url = (
        LOCAL_INFERENCE_API_URL
        if WORKFLOWS_REMOTE_API_TARGET != "hosted"
        else HOSTED_CLASSIFICATION_URL
    )
    client = InferenceHTTPClient(
        api_url=api_url,
        api_key="dummy_key",
    )
    if WORKFLOWS_REMOTE_API_TARGET == "hosted":
        client.select_api_v0()
    client_config = InferenceConfiguration(
        confidence_threshold=confidence,
        disable_active_learning=disable_active_learning,
        active_learning_target_dataset=active_learning_target_dataset,
        max_batch_size=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_BATCH_SIZE,
        max_concurrent_requests=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
        source="workflow-execution",
    )
    client.configure(inference_configuration=client_config)
    non_empty_inference_images = [i.base64_image for i in images]
    predictions = client.infer(
        inference_input=non_empty_inference_images,
        model_id=model_id,
    )
    if not isinstance(predictions, list):
        predictions = [predictions]
    # Attach prediction type info and parent/root ids
    predictions = attach_prediction_type_info(
        predictions=predictions,
        prediction_type="classification",
    )
    for prediction, image in zip(predictions, images):
        prediction[PARENT_ID_KEY] = image.parent_metadata.parent_id
        prediction[ROOT_PARENT_ID_KEY] = (
            image.workflow_root_ancestor_metadata.parent_id
        )
    return [
        {
            "inference_id": prediction.get(INFERENCE_ID_KEY),
            "predictions": prediction,
            "model_id": model_id,
        }
        for prediction in predictions
    ]

# --- Unit tests for run_remotely ---

# ---- Basic Test Cases ----












#------------------------------------------------
from dataclasses import dataclass, field
from typing import Any, List, Optional

# imports
import pytest
from inference.core.workflows.core_steps.models.roboflow.multi_label_classification.v2 import \
    RoboflowMultiLabelClassificationModelBlockV2

PARENT_ID_KEY = "parent_id"
ROOT_PARENT_ID_KEY = "root_parent_id"
PREDICTION_TYPE_KEY = "prediction_type"

# Dummy Batch and WorkflowImageData for test
@dataclass
class ParentMetadata:
    parent_id: Any

@dataclass
class WorkflowRootAncestorMetadata:
    parent_id: Any

@dataclass
class WorkflowImageData:
    base64_image: str
    parent_metadata: ParentMetadata
    workflow_root_ancestor_metadata: WorkflowRootAncestorMetadata

# --- Unit Tests ---

# Helper to create WorkflowImageData
def make_image(base64_image: str, parent_id: Any, root_parent_id: Any) -> WorkflowImageData:
    return WorkflowImageData(
        base64_image=base64_image,
        parent_metadata=ParentMetadata(parent_id=parent_id),
        workflow_root_ancestor_metadata=WorkflowRootAncestorMetadata(parent_id=root_parent_id),
    )

# BASIC TEST CASES

To edit these changes git checkout codeflash/optimize-RoboflowMultiLabelClassificationModelBlockV2.run_remotely-mh9mgyvi and push.