⚡️ Speed up function model_keypoints_to_response by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for model_keypoints_to_response in inference/core/models/utils/keypoints.py

⏱️ Runtime : 1.72 milliseconds → 1.59 milliseconds (best of 236 runs)

📝 Explanation and details

The optimized version achieves an 8% speedup by eliminating redundant computations and bounds checking within the main loop:

Key optimizations:

1. Pre-computed loop bounds: Uses min(len(keypoint_id2name), len(keypoints) // 3) to determine the exact number of iterations upfront, eliminating the per-iteration keypoint_id >= len(keypoint_id2name) check that appeared in 2,942 iterations in the original code.

2. Eliminated repeated index calculations: Replaces keypoints[3 * keypoint_id], keypoints[3 * keypoint_id + 1], keypoints[3 * keypoint_id + 2] with direct slicing (keypoints[0::3], keypoints[1::3], keypoints[2::3]) and zip iteration, removing costly multiplication operations performed 5,181 times in the original.

3. Improved data access pattern: The zip() approach provides direct variable access (x, y, confidence) instead of repeated list indexing, reducing memory access overhead.

Performance characteristics by test case:

• Large datasets with many valid keypoints (500+ keypoints above threshold): 9-13% faster due to elimination of index calculations
• Large datasets with mostly invalid keypoints: Up to 57% faster because the optimized bounds checking avoids unnecessary iterations entirely
• Small datasets: Slightly slower (15-20%) due to overhead of slice creation, but this is negligible in absolute terms (microseconds)

The optimization is most effective for production workloads with substantial keypoint data, where the computational savings from eliminating redundant arithmetic and bounds checking compound significantly.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
inference/unit_tests/core/models/utils/test_keypoints.py::test_model_keypoints_to_response	9.84μs	11.2μs	-11.8%⚠️
inference/unit_tests/core/models/utils/test_keypoints.py::test_model_keypoints_to_response_padded_points	12.5μs	14.0μs	-10.7%⚠️

🌀 Generated Regression Tests and Runtime

from typing import List

# imports
import pytest
from inference.core.models.utils.keypoints import model_keypoints_to_response

# --- Mocked dependencies for testing ---

class ModelArtefactError(Exception):
    pass

class Keypoint:
    def __init__(self, x, y, confidence, class_id, **kwargs):
        self.x = x
        self.y = y
        self.confidence = confidence
        self.class_id = class_id
        self.class_ = kwargs.get("class")
    def __eq__(self, other):
        if not isinstance(other, Keypoint):
            return False
        return (
            self.x == other.x
            and self.y == other.y
            and self.confidence == other.confidence
            and self.class_id == other.class_id
            and self.class_ == other.class_
        )
    def __repr__(self):
        return f"Keypoint(x={self.x}, y={self.y}, conf={self.confidence}, class_id={self.class_id}, class_={self.class_})"
from inference.core.models.utils.keypoints import model_keypoints_to_response

# unit tests

# -------------------- BASIC TEST CASES --------------------

def test_basic_single_keypoint_above_threshold():
    # Single keypoint, confidence above threshold
    keypoints_metadata = {0: ["nose"]}
    keypoints = [10.0, 20.0, 0.9]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 4.86μs -> 5.91μs (17.9% slower)
    expected = [Keypoint(x=10.0, y=20.0, confidence=0.9, class_id=0, **{"class": "nose"})]

def test_basic_single_keypoint_below_threshold():
    # Single keypoint, confidence below threshold
    keypoints_metadata = {0: ["nose"]}
    keypoints = [10.0, 20.0, 0.3]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 1.21μs -> 2.23μs (45.9% slower)

def test_basic_multiple_keypoints_mixed_confidence():
    # Multiple keypoints, some above and some below threshold
    keypoints_metadata = {0: ["nose", "eye"]}
    keypoints = [10.0, 20.0, 0.9, 30.0, 40.0, 0.4]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 5.35μs -> 6.31μs (15.1% slower)
    expected = [Keypoint(x=10.0, y=20.0, confidence=0.9, class_id=0, **{"class": "nose"})]

def test_basic_multiple_keypoints_all_above_threshold():
    # Multiple keypoints, all above threshold
    keypoints_metadata = {0: ["nose", "eye"]}
    keypoints = [1.0, 2.0, 0.6, 3.0, 4.0, 0.7]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 6.16μs -> 6.94μs (11.3% slower)
    expected = [
        Keypoint(x=1.0, y=2.0, confidence=0.6, class_id=0, **{"class": "nose"}),
        Keypoint(x=3.0, y=4.0, confidence=0.7, class_id=1, **{"class": "eye"}),
    ]

def test_basic_multiple_keypoints_all_below_threshold():
    # Multiple keypoints, all below threshold
    keypoints_metadata = {0: ["nose", "eye"]}
    keypoints = [1.0, 2.0, 0.1, 3.0, 4.0, 0.2]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 1.42μs -> 2.39μs (40.5% slower)

# -------------------- EDGE TEST CASES --------------------


def test_edge_empty_keypoints_list():
    # Empty keypoints list should return empty list
    keypoints_metadata = {0: ["nose"]}
    keypoints = []
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 1.39μs -> 2.87μs (51.4% slower)

def test_edge_no_keypoints_for_class():
    # keypoints_metadata exists but no keypoints for the class
    keypoints_metadata = {0: []}
    keypoints = [1.0, 2.0, 0.9]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 1.15μs -> 2.27μs (49.1% slower)

def test_edge_keypoints_length_not_multiple_of_3():
    # Keypoints list length not a multiple of 3 (should ignore extra values)
    keypoints_metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, 0.9, 5.0]  # Extra value at the end
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    # Only the first triplet should be processed
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 7.99μs -> 9.36μs (14.6% slower)
    expected = [Keypoint(x=1.0, y=2.0, confidence=0.9, class_id=0, **{"class": "nose"})]

def test_edge_more_keypoints_than_metadata():
    # More keypoints in input than names in metadata; should stop at metadata length
    keypoints_metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, 0.9, 3.0, 4.0, 0.8]  # Two keypoints, one name
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 5.32μs -> 6.57μs (19.1% slower)
    expected = [Keypoint(x=1.0, y=2.0, confidence=0.9, class_id=0, **{"class": "nose"})]

def test_edge_class_id_not_in_metadata():
    # predicted_object_class_id not in keypoints_metadata
    keypoints_metadata = {1: ["eye"]}
    keypoints = [1.0, 2.0, 0.9]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    with pytest.raises(KeyError):
        model_keypoints_to_response(
            keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
        ) # 790ns -> 805ns (1.86% slower)

def test_edge_zero_confidence_keypoint():
    # Confidence is exactly zero
    keypoints_metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, 0.0]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.0
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 6.25μs -> 7.46μs (16.3% slower)
    # Zero is not less than threshold, so should be included
    expected = [Keypoint(x=1.0, y=2.0, confidence=0.0, class_id=0, **{"class": "nose"})]

def test_edge_threshold_equals_confidence():
    # Confidence exactly equals threshold
    keypoints_metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, 0.5]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 5.10μs -> 6.29μs (18.9% slower)
    expected = [Keypoint(x=1.0, y=2.0, confidence=0.5, class_id=0, **{"class": "nose"})]

def test_edge_negative_confidence():
    # Negative confidence value
    keypoints_metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, -0.1]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.0
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 1.18μs -> 2.27μs (48.1% slower)

def test_edge_empty_metadata_dict():
    # keypoints_metadata is empty dict
    keypoints_metadata = {}
    keypoints = [1.0, 2.0, 0.9]
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    with pytest.raises(KeyError):
        model_keypoints_to_response(
            keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
        ) # 762ns -> 839ns (9.18% slower)

def test_edge_metadata_with_extra_names():
    # Metadata has more names than keypoints
    keypoints_metadata = {0: ["nose", "eye", "ear"]}
    keypoints = [1.0, 2.0, 0.9, 3.0, 4.0, 0.8]  # Only two keypoints
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 8.28μs -> 9.58μs (13.6% slower)
    expected = [
        Keypoint(x=1.0, y=2.0, confidence=0.9, class_id=0, **{"class": "nose"}),
        Keypoint(x=3.0, y=4.0, confidence=0.8, class_id=1, **{"class": "eye"}),
    ]

# -------------------- LARGE SCALE TEST CASES --------------------

def test_large_scale_many_keypoints():
    # Test with a large number of keypoints (e.g., 500 keypoints)
    num_keypoints = 500
    keypoints_metadata = {0: [f"kp_{i}" for i in range(num_keypoints)]}
    keypoints = []
    # Alternate confidence above and below threshold
    for i in range(num_keypoints):
        keypoints.extend([float(i), float(i+1), 0.6 if i % 2 == 0 else 0.4])
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 243μs -> 213μs (13.9% faster)
    # Only even-indexed keypoints should be included
    expected = [
        Keypoint(x=float(i), y=float(i+1), confidence=0.6, class_id=i, **{"class": f"kp_{i}"})
        for i in range(0, num_keypoints, 2)
    ]

def test_large_scale_metadata_shorter_than_keypoints():
    # Test with more keypoints than metadata names (should stop at metadata length)
    num_metadata = 100
    num_keypoints = 200  # 200 keypoints, but only 100 names
    keypoints_metadata = {0: [f"kp_{i}" for i in range(num_metadata)]}
    keypoints = []
    for i in range(num_keypoints):
        keypoints.extend([float(i), float(i+1), 0.7])
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 89.6μs -> 85.4μs (4.93% faster)
    # Only first 100 keypoints should be included
    expected = [
        Keypoint(x=float(i), y=float(i+1), confidence=0.7, class_id=i, **{"class": f"kp_{i}"})
        for i in range(num_metadata)
    ]

def test_large_scale_all_below_threshold():
    # All confidences below threshold, should return empty list
    num_keypoints = 200
    keypoints_metadata = {0: [f"kp_{i}" for i in range(num_keypoints)]}
    keypoints = []
    for i in range(num_keypoints):
        keypoints.extend([float(i), float(i+1), 0.1])
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 12.6μs -> 9.37μs (34.6% faster)

def test_large_scale_all_above_threshold():
    # All confidences above threshold, all should be included
    num_keypoints = 300
    keypoints_metadata = {0: [f"kp_{i}" for i in range(num_keypoints)]}
    keypoints = []
    for i in range(num_keypoints):
        keypoints.extend([float(i), float(i+1), 0.99])
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    codeflash_output = model_keypoints_to_response(
        keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
    ); result = codeflash_output # 261μs -> 238μs (9.66% faster)
    expected = [
        Keypoint(x=float(i), y=float(i+1), confidence=0.99, class_id=i, **{"class": f"kp_{i}"})
        for i in range(num_keypoints)
    ]

def test_large_scale_empty_metadata_and_keypoints():
    # Both metadata and keypoints are empty
    keypoints_metadata = {}
    keypoints = []
    predicted_object_class_id = 0
    keypoint_confidence_threshold = 0.5
    with pytest.raises(KeyError):
        model_keypoints_to_response(
            keypoints_metadata, keypoints, predicted_object_class_id, keypoint_confidence_threshold
        ) # 838ns -> 876ns (4.34% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import List

# imports
import pytest
from inference.core.models.utils.keypoints import model_keypoints_to_response

# --- Minimal stubs for dependencies ---

class ModelArtefactError(Exception):
    pass

class Keypoint:
    def __init__(self, x, y, confidence, class_id, **kwargs):
        self.x = x
        self.y = y
        self.confidence = confidence
        self.class_id = class_id
        self.class_ = kwargs.get("class")
    def __eq__(self, other):
        if not isinstance(other, Keypoint):
            return False
        return (
            self.x == other.x and
            self.y == other.y and
            self.confidence == other.confidence and
            self.class_id == other.class_id and
            self.class_ == other.class_
        )
    def __repr__(self):
        return f"Keypoint(x={self.x}, y={self.y}, confidence={self.confidence}, class_id={self.class_id}, class_={self.class_})"
from inference.core.models.utils.keypoints import model_keypoints_to_response

# --- UNIT TESTS ---

# Basic Test Cases

def test_basic_single_keypoint_above_threshold():
    # One keypoint, confidence above threshold
    metadata = {0: ["nose"]}
    keypoints = [10.0, 20.0, 0.9]
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 5.20μs -> 6.42μs (19.1% slower)

def test_basic_single_keypoint_below_threshold():
    # One keypoint, confidence below threshold
    metadata = {0: ["nose"]}
    keypoints = [10.0, 20.0, 0.3]
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 1.31μs -> 2.34μs (43.9% slower)

def test_basic_multiple_keypoints_mixed_confidence():
    # Multiple keypoints, some above, some below threshold
    metadata = {0: ["nose", "eye"]}
    keypoints = [1.0, 2.0, 0.8, 3.0, 4.0, 0.2]
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 5.81μs -> 6.89μs (15.7% slower)
    expected = [Keypoint(1.0, 2.0, 0.8, 0, **{"class": "nose"})]

def test_basic_all_keypoints_above_threshold():
    # All keypoints above threshold
    metadata = {0: ["nose", "eye"]}
    keypoints = [1.0, 2.0, 0.7, 3.0, 4.0, 0.8]
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 6.45μs -> 7.18μs (10.1% slower)
    expected = [
        Keypoint(1.0, 2.0, 0.7, 0, **{"class": "nose"}),
        Keypoint(3.0, 4.0, 0.8, 1, **{"class": "eye"}),
    ]

def test_basic_no_keypoints():
    # No keypoints present
    metadata = {0: ["nose", "eye"]}
    keypoints = []
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 962ns -> 2.28μs (57.8% slower)

# Edge Test Cases


def test_edge_empty_metadata_dict():
    # keypoints_metadata is empty dict
    metadata = {}
    # Should raise KeyError since predicted_object_class_id not present
    with pytest.raises(KeyError):
        model_keypoints_to_response(metadata, [1.0, 2.0, 0.9], 0, 0.5) # 916ns -> 886ns (3.39% faster)

def test_edge_class_id_not_in_metadata():
    # keypoints_metadata does not contain the class id
    metadata = {1: ["nose"]}
    with pytest.raises(KeyError):
        model_keypoints_to_response(metadata, [1.0, 2.0, 0.9], 0, 0.5) # 747ns -> 759ns (1.58% slower)

def test_edge_keypoints_shorter_than_metadata():
    # Fewer keypoints than metadata names
    metadata = {0: ["nose", "eye", "ear"]}
    keypoints = [1.0, 2.0, 0.9, 3.0, 4.0, 0.8]  # only 2 keypoints, 3 metadata
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 10.4μs -> 11.9μs (13.1% slower)
    expected = [
        Keypoint(1.0, 2.0, 0.9, 0, **{"class": "nose"}),
        Keypoint(3.0, 4.0, 0.8, 1, **{"class": "eye"}),
    ]

def test_edge_keypoints_longer_than_metadata():
    # More keypoints than metadata names, should stop at metadata length
    metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, 0.9, 3.0, 4.0, 0.8]  # 2 keypoints, only 1 name
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 5.11μs -> 6.34μs (19.5% slower)
    # Only the first keypoint should be used
    expected = [Keypoint(1.0, 2.0, 0.9, 0, **{"class": "nose"})]

def test_edge_keypoints_exactly_zero_length():
    # keypoints is empty, should return empty list
    metadata = {0: []}
    keypoints = []
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 1.02μs -> 2.29μs (55.3% slower)

def test_edge_threshold_exactly_equal_confidence():
    # confidence exactly equal to threshold, should be included
    metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, 0.5]
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 5.67μs -> 6.88μs (17.5% slower)
    expected = [Keypoint(1.0, 2.0, 0.5, 0, **{"class": "nose"})]

def test_edge_negative_confidence():
    # negative confidence, should be excluded
    metadata = {0: ["nose"]}
    keypoints = [1.0, 2.0, -0.1]
    class_id = 0
    threshold = 0.0
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 1.27μs -> 2.34μs (45.9% slower)

def test_edge_keypoints_not_multiple_of_three():
    # keypoints list not multiple of 3, should ignore trailing incomplete
    metadata = {0: ["nose", "eye"]}
    keypoints = [1.0, 2.0, 0.9, 3.0]  # incomplete second keypoint
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 5.65μs -> 7.12μs (20.6% slower)
    # Only the first keypoint is complete and above threshold
    expected = [Keypoint(1.0, 2.0, 0.9, 0, **{"class": "nose"})]

def test_edge_empty_metadata_names():
    # metadata list for class is empty
    metadata = {0: []}
    keypoints = [1.0, 2.0, 0.9]
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 1.05μs -> 2.10μs (49.9% slower)

# Large Scale Test Cases

def test_large_all_keypoints_above_threshold():
    # Large number of keypoints, all above threshold
    n = 500
    metadata = {0: [f"kp{i}" for i in range(n)]}
    keypoints = []
    for i in range(n):
        keypoints.extend([float(i), float(i+1), 0.99])
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 440μs -> 399μs (10.5% faster)
    for i in range(n):
        pass

def test_large_all_keypoints_below_threshold():
    # Large number of keypoints, all below threshold
    n = 500
    metadata = {0: [f"kp{i}" for i in range(n)]}
    keypoints = []
    for i in range(n):
        keypoints.extend([float(i), float(i+1), 0.1])
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 33.0μs -> 21.0μs (57.3% faster)

def test_large_mixed_keypoints():
    # Large number of keypoints, alternating above and below threshold
    n = 500
    metadata = {0: [f"kp{i}" for i in range(n)]}
    keypoints = []
    for i in range(n):
        conf = 0.6 if i % 2 == 0 else 0.3
        keypoints.extend([float(i), float(i+1), conf])
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 244μs -> 215μs (13.8% faster)
    for idx, i in enumerate(range(0, n, 2)):
        pass

def test_large_keypoints_longer_than_metadata():
    # More keypoints than metadata, should stop at metadata length
    n = 200
    m = 150
    metadata = {0: [f"kp{i}" for i in range(m)]}
    keypoints = []
    for i in range(n):
        keypoints.extend([float(i), float(i+1), 0.99])
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 130μs -> 122μs (6.61% faster)
    for i in range(m):
        pass

def test_large_keypoints_shorter_than_metadata():
    # Fewer keypoints than metadata, should process all keypoints
    n = 150
    m = 200
    metadata = {0: [f"kp{i}" for i in range(m)]}
    keypoints = []
    for i in range(n):
        keypoints.extend([float(i), float(i+1), 0.99])
    class_id = 0
    threshold = 0.5
    codeflash_output = model_keypoints_to_response(metadata, keypoints, class_id, threshold); resp = codeflash_output # 129μs -> 121μs (7.24% faster)
    for i in range(n):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-model_keypoints_to_response-mh9tsmmd and push.