⚡️ Speed up function make_span_finder_scorer by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for make_span_finder_scorer in spacy/pipeline/span_finder.py

⏱️ Runtime : 11.1 microseconds → 9.94 microseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves an 11% speedup by reducing overhead from Python's setdefault() calls and optimizing key computations:

Key optimizations:

1. Eliminated redundant dict(kwargs) copy - The original code unnecessarily copied the kwargs dictionary, which creates overhead for every function call.

2. Replaced setdefault() with direct assignment for complex values - For attr, getter, and has_annotation, the code now uses kwargs.get() followed by direct assignment. This avoids the overhead of setdefault() which must evaluate the default value (including lambda creation) even when the key already exists.

3. Pre-computed string slicing - The suffix key[len(attr_prefix):] is calculated once and captured in the closure, rather than being computed on every call to the getter lambda.

4. Optimized dictionary removal - Changed from scores.pop(f"{kwargs['attr']}_per_type", None) to a conditional del operation, which is more direct when you know the key exists.

Why this speeds up the code:

• setdefault() has to evaluate its default argument even when the key exists, creating unnecessary lambda objects
• String slicing inside lambdas gets repeated for every span evaluation
• The dict(kwargs) copy creates unnecessary memory allocation and copying overhead

Performance impact by test case:
The optimization shows consistent 7-25% improvements across test cases, with particularly strong gains in:

• Empty or small span scenarios (up to 31% faster) where setup overhead dominates
• Cases with missing spans keys (17-24% faster) where the has_annotation logic is frequently called
• Single span exact matches (25% faster) where the getter function overhead is most apparent

The optimization maintains identical behavior while reducing Python interpreter overhead, making it especially beneficial for span evaluation pipelines that process many documents.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Dict, Iterable, List

# imports
import pytest  # used for our unit tests
from spacy.pipeline.span_finder import make_span_finder_scorer


# Minimal mocks for spacy objects
class Span:
    def __init__(self, doc, start, end, label_):
        self.doc = doc
        self.start = start
        self.end = end
        self.label_ = label_

class Doc:
    def __init__(self, text, spans=None):
        self.text = text
        self.spans = spans or {}

class Example:
    def __init__(self, predicted, reference):
        self.predicted = predicted
        self.reference = reference

    def get_aligned_spans_x2y(self, spans, allow_overlap):
        # For testing, just return the spans as-is
        return spans
from spacy.pipeline.span_finder import make_span_finder_scorer

# -------------------- UNIT TESTS --------------------

# Helper to create docs with spans
def make_doc(text, spans_dict):
    # spans_dict: {key: [Span(...), ...]}
    doc = Doc(text)
    doc.spans = spans_dict
    return doc

# Basic Test Cases

def test_perfect_match_single_span():
    # One span, predicted matches gold exactly
    span = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": [span]})
    doc_gold = make_doc("Google is cool", {"ents": [span]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 311ns -> 290ns (7.24% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_no_predicted_spans():
    # Gold has spans, prediction is empty
    span = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": []})
    doc_gold = make_doc("Google is cool", {"ents": [span]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 302ns -> 257ns (17.5% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_no_gold_spans():
    # Prediction has spans, gold is empty
    span = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": [span]})
    doc_gold = make_doc("Google is cool", {"ents": []})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 276ns -> 255ns (8.24% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_partial_overlap():
    # Prediction partially overlaps with gold
    span_gold = Span(None, 0, 2, "ORG")
    span_pred = Span(None, 1, 3, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": [span_pred]})
    doc_gold = make_doc("Google is cool", {"ents": [span_gold]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 286ns -> 254ns (12.6% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_multiple_spans_some_match():
    # Multiple spans, some match, some don't
    span_gold1 = Span(None, 0, 2, "ORG")
    span_gold2 = Span(None, 3, 5, "PERSON")
    span_pred1 = Span(None, 0, 2, "ORG")  # correct
    span_pred2 = Span(None, 2, 4, "ORG")  # wrong
    span_pred3 = Span(None, 3, 5, "PERSON")  # correct
    doc_pred = make_doc("Google hires John Doe", {"ents": [span_pred1, span_pred2, span_pred3]})
    doc_gold = make_doc("Google hires John Doe", {"ents": [span_gold1, span_gold2]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 268ns -> 240ns (11.7% faster)
    result = scorer([ex], spans_key="spans_ents")

# Edge Test Cases

def test_empty_examples():
    # No examples provided
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 283ns -> 228ns (24.1% faster)
    result = scorer([], spans_key="spans_ents")

def test_missing_spans_key_in_gold():
    # Gold doc missing the spans key
    span_pred = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": [span_pred]})
    doc_gold = make_doc("Google is cool", {})  # no 'ents'
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 285ns -> 258ns (10.5% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_missing_spans_key_in_pred():
    # Pred doc missing the spans key, gold has it
    span_gold = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {})  # no 'ents'
    doc_gold = make_doc("Google is cool", {"ents": [span_gold]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 293ns -> 264ns (11.0% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_multiple_span_keys():
    # Multiple span keys in doc.spans, only one used
    span_gold = Span(None, 0, 2, "ORG")
    span_pred = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": [span_pred], "other": [Span(None, 1, 2, "LOC")]})
    doc_gold = make_doc("Google is cool", {"ents": [span_gold], "other": [Span(None, 1, 2, "LOC")]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 281ns -> 260ns (8.08% faster)
    result = scorer([ex], spans_key="spans_ents")

def test_overlapping_spans_allowed():
    # Overlapping spans, allow_overlap True
    span_gold1 = Span(None, 0, 3, "ORG")
    span_gold2 = Span(None, 1, 4, "ORG")
    span_pred1 = Span(None, 0, 3, "ORG")
    span_pred2 = Span(None, 1, 4, "ORG")
    doc_pred = make_doc("Google Inc.", {"ents": [span_pred1, span_pred2]})
    doc_gold = make_doc("Google Inc.", {"ents": [span_gold1, span_gold2]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 309ns -> 287ns (7.67% faster)
    # Should match both
    result = scorer([ex], spans_key="spans_ents", allow_overlap=True)

def test_overlapping_spans_disallowed():
    # Overlapping spans, allow_overlap False (should still match both for this test mock)
    span_gold1 = Span(None, 0, 3, "ORG")
    span_gold2 = Span(None, 1, 4, "ORG")
    span_pred1 = Span(None, 0, 3, "ORG")
    span_pred2 = Span(None, 1, 4, "ORG")
    doc_pred = make_doc("Google Inc.", {"ents": [span_pred1, span_pred2]})
    doc_gold = make_doc("Google Inc.", {"ents": [span_gold1, span_gold2]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 308ns -> 276ns (11.6% faster)
    result = scorer([ex], spans_key="spans_ents", allow_overlap=False)

def test_span_label_ignored_when_labeled_false():
    # Spans with different labels, but same start/end, labeled=False
    span_gold = Span(None, 0, 2, "ORG")
    span_pred = Span(None, 0, 2, "PERSON")
    doc_pred = make_doc("Google is cool", {"ents": [span_pred]})
    doc_gold = make_doc("Google is cool", {"ents": [span_gold]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 314ns -> 256ns (22.7% faster)
    # Should match because labeled=False
    result = scorer([ex], spans_key="spans_ents", labeled=False)

def test_span_label_considered_when_labeled_true():
    # Spans with different labels, labeled=True
    span_gold = Span(None, 0, 2, "ORG")
    span_pred = Span(None, 0, 2, "PERSON")
    doc_pred = make_doc("Google is cool", {"ents": [span_pred]})
    doc_gold = make_doc("Google is cool", {"ents": [span_gold]})
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 305ns -> 262ns (16.4% faster)
    # Should not match because labeled=True (default in score_spans)
    result = scorer([ex], spans_key="spans_ents", labeled=True)

def test_has_annotation_skips_unannotated():
    # has_annotation skips examples with no annotation
    span_pred = Span(None, 0, 2, "ORG")
    doc_pred = make_doc("Google is cool", {"ents": [span_pred]})
    doc_gold = make_doc("Google is cool", {})  # no 'ents'
    ex = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 286ns -> 250ns (14.4% faster)
    # Should skip scoring, so scores are None
    result = scorer([ex], spans_key="spans_ents")

# Large Scale Test Cases

def test_large_number_of_examples_and_spans():
    # Many examples, each with many spans
    num_examples = 50
    num_spans = 20
    examples = []
    for i in range(num_examples):
        spans = [Span(None, j, j+2, "LABEL") for j in range(num_spans)]
        doc_pred = make_doc("x" * 100, {"ents": spans})
        doc_gold = make_doc("x" * 100, {"ents": spans})
        ex = Example(doc_pred, doc_gold)
        examples.append(ex)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 318ns -> 319ns (0.313% slower)
    result = scorer(examples, spans_key="spans_ents")

def test_large_number_of_examples_some_partial_match():
    # Many examples, half of spans match
    num_examples = 30
    num_spans = 10
    examples = []
    for i in range(num_examples):
        gold_spans = [Span(None, j, j+2, "LABEL") for j in range(num_spans)]
        pred_spans = [Span(None, j, j+2, "LABEL") for j in range(num_spans//2)] + \
                     [Span(None, j+100, j+102, "LABEL") for j in range(num_spans//2)]
        doc_pred = make_doc("x" * 100, {"ents": pred_spans})
        doc_gold = make_doc("x" * 100, {"ents": gold_spans})
        ex = Example(doc_pred, doc_gold)
        examples.append(ex)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 282ns -> 281ns (0.356% faster)
    result = scorer(examples, spans_key="spans_ents")

def test_large_number_of_examples_no_match():
    # Many examples, none match
    num_examples = 40
    num_spans = 15
    examples = []
    for i in range(num_examples):
        gold_spans = [Span(None, j, j+2, "LABEL") for j in range(num_spans)]
        pred_spans = [Span(None, j+100, j+102, "LABEL") for j in range(num_spans)]
        doc_pred = make_doc("x" * 100, {"ents": pred_spans})
        doc_gold = make_doc("x" * 100, {"ents": gold_spans})
        ex = Example(doc_pred, doc_gold)
        examples.append(ex)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 336ns -> 292ns (15.1% faster)
    result = scorer(examples, spans_key="spans_ents")

def test_large_number_of_examples_empty_spans():
    # Many examples, all empty spans
    num_examples = 100
    examples = []
    for i in range(num_examples):
        doc_pred = make_doc("x" * 100, {"ents": []})
        doc_gold = make_doc("x" * 100, {"ents": []})
        ex = Example(doc_pred, doc_gold)
        examples.append(ex)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 298ns -> 288ns (3.47% faster)
    result = scorer(examples, spans_key="spans_ents")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from collections import namedtuple
from typing import Any, Dict, Iterable

# imports
import pytest
from spacy.pipeline.span_finder import make_span_finder_scorer

# --- Minimal mock classes for spacy objects ---

class Span:
    """Minimal mock of spacy.tokens.Span"""
    def __init__(self, start, end, label_):
        self.start = start
        self.end = end
        self.label_ = label_

class Doc:
    """Minimal mock of spacy.tokens.Doc"""
    def __init__(self, text, spans=None):
        self.text = text
        self.spans = spans if spans is not None else {}

class Example:
    """Minimal mock of spacy.training.Example"""
    def __init__(self, predicted, reference):
        self.predicted = predicted
        self.reference = reference

    def get_aligned_spans_x2y(self, spans, allow_overlap):
        # For simplicity, just return the spans as-is
        return spans
from spacy.pipeline.span_finder import make_span_finder_scorer

# --- Unit tests ---

# Basic Test Cases

def test_basic_exact_match_single_span():
    # Both predicted and gold have the same span, unlabeled
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 312ns -> 248ns (25.8% faster)
    result = scorer([example], spans_key="spans_ents")

def test_basic_partial_match_single_span():
    # Predicted span does not match gold span
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 1, "PERSON")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 289ns -> 246ns (17.5% faster)
    result = scorer([example], spans_key="spans_ents")

def test_basic_multiple_spans_some_match():
    # Some predicted spans match gold, some do not
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON"), Span(2, 3, "ORG")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON"), Span(1, 3, "ORG")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 297ns -> 250ns (18.8% faster)
    result = scorer([example], spans_key="spans_ents")

def test_basic_empty_predicted():
    # No predicted spans, but gold has spans
    doc_pred = Doc("Hello world", spans={"ents": []})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 289ns -> 234ns (23.5% faster)
    result = scorer([example], spans_key="spans_ents")

def test_basic_empty_gold():
    # Predicted spans exist, but gold has none
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    doc_gold = Doc("Hello world", spans={"ents": []})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 273ns -> 260ns (5.00% faster)
    result = scorer([example], spans_key="spans_ents")

def test_basic_empty_both():
    # Both predicted and gold have no spans
    doc_pred = Doc("Hello world", spans={"ents": []})
    doc_gold = Doc("Hello world", spans={"ents": []})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 275ns -> 210ns (31.0% faster)
    result = scorer([example], spans_key="spans_ents")

# Edge Test Cases

def test_edge_missing_spans_key_in_gold():
    # Gold doc does not have the spans key
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    doc_gold = Doc("Hello world", spans={})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 255ns -> 263ns (3.04% slower)
    result = scorer([example], spans_key="spans_ents")

def test_edge_missing_spans_key_in_pred():
    # Predicted doc does not have the spans key, gold does
    doc_pred = Doc("Hello world", spans={})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 265ns -> 226ns (17.3% faster)
    result = scorer([example], spans_key="spans_ents")

def test_edge_overlapping_spans():
    # Overlapping spans in both predicted and gold
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON"), Span(1, 3, "PERSON")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON"), Span(1, 3, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 327ns -> 285ns (14.7% faster)
    result = scorer([example], spans_key="spans_ents")

def test_edge_allow_overlap_false():
    # Overlapping spans, allow_overlap=False
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON"), Span(1, 3, "ORG")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON"), Span(1, 3, "ORG")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 317ns -> 310ns (2.26% faster)
    # Should still match both
    result = scorer([example], spans_key="spans_ents", allow_overlap=False)

def test_edge_labeled_true():
    # Labeled scoring, labels must match
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "ORG")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 311ns -> 294ns (5.78% faster)
    # With labeled=True, labels must match, so no match
    result = scorer([example], spans_key="spans_ents", labeled=True)

def test_edge_labeled_false():
    # Labeled scoring off, so only start/end must match
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "ORG")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 290ns -> 283ns (2.47% faster)
    # With labeled=False, match on start/end only
    result = scorer([example], spans_key="spans_ents", labeled=False)

def test_edge_custom_getter_and_has_annotation():
    # Custom getter and has_annotation functions
    def custom_getter(doc, key):
        # Always return all spans for the key, regardless of prefix
        return doc.spans.get("ents", [])
    def custom_has_annotation(doc):
        return "ents" in doc.spans
    doc_pred = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    doc_gold = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 280ns -> 264ns (6.06% faster)
    result = scorer(
        [example],
        spans_key="spans_ents",
        getter=custom_getter,
        has_annotation=custom_has_annotation,
    )

def test_edge_multiple_examples():
    # Multiple examples, aggregate scores
    doc_pred1 = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    doc_gold1 = Doc("Hello world", spans={"ents": [Span(0, 2, "PERSON")]})
    doc_pred2 = Doc("Hello world", spans={"ents": [Span(0, 1, "ORG")]})
    doc_gold2 = Doc("Hello world", spans={"ents": [Span(0, 1, "ORG"), Span(1, 2, "ORG")]})
    example1 = Example(doc_pred1, doc_gold1)
    example2 = Example(doc_pred2, doc_gold2)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 294ns -> 263ns (11.8% faster)
    result = scorer([example1, example2], spans_key="spans_ents")

# Large Scale Test Cases

def test_large_scale_many_spans():
    # Large number of spans, all match
    N = 500
    spans = [Span(i, i+1, "TYPE") for i in range(N)]
    doc_pred = Doc("X"*N, spans={"ents": spans})
    doc_gold = Doc("X"*N, spans={"ents": spans})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 328ns -> 300ns (9.33% faster)
    result = scorer([example], spans_key="spans_ents")

def test_large_scale_partial_match():
    # Large number of spans, half match
    N = 500
    spans_pred = [Span(i, i+1, "TYPE") for i in range(N//2)]
    spans_gold = [Span(i, i+1, "TYPE") for i in range(N)]
    doc_pred = Doc("X"*N, spans={"ents": spans_pred})
    doc_gold = Doc("X"*N, spans={"ents": spans_gold})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 324ns -> 276ns (17.4% faster)
    result = scorer([example], spans_key="spans_ents")

def test_large_scale_no_match():
    # Large number of spans, none match
    N = 500
    spans_pred = [Span(i, i+1, "TYPE") for i in range(N)]
    spans_gold = [Span(i+1000, i+1001, "TYPE") for i in range(N)]
    doc_pred = Doc("X"*N, spans={"ents": spans_pred})
    doc_gold = Doc("X"*N, spans={"ents": spans_gold})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 320ns -> 300ns (6.67% faster)
    result = scorer([example], spans_key="spans_ents")

def test_large_scale_multiple_examples():
    # Multiple examples with many spans
    N = 100
    examples = []
    for i in range(10):
        spans_pred = [Span(j, j+1, "TYPE") for j in range(N)]
        spans_gold = [Span(j, j+1, "TYPE") for j in range(N)]
        doc_pred = Doc("X"*N, spans={"ents": spans_pred})
        doc_gold = Doc("X"*N, spans={"ents": spans_gold})
        examples.append(Example(doc_pred, doc_gold))
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 331ns -> 308ns (7.47% faster)
    result = scorer(examples, spans_key="spans_ents")

def test_large_scale_label_mismatch():
    # Large number of spans, labels differ
    N = 500
    spans_pred = [Span(i, i+1, "ORG") for i in range(N)]
    spans_gold = [Span(i, i+1, "PERSON") for i in range(N)]
    doc_pred = Doc("X"*N, spans={"ents": spans_pred})
    doc_gold = Doc("X"*N, spans={"ents": spans_gold})
    example = Example(doc_pred, doc_gold)
    codeflash_output = make_span_finder_scorer(); scorer = codeflash_output # 347ns -> 299ns (16.1% faster)
    # Labeled: no matches
    result = scorer([example], spans_key="spans_ents", labeled=True)
    # Unlabeled: all match
    result_unlabeled = scorer([example], spans_key="spans_ents", labeled=False)
# 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-make_span_finder_scorer-mhmi5ymg and push.