⚡️ Speed up function bincount by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for bincount in keras/src/backend/openvino/numpy.py

⏱️ Runtime : 20.2 milliseconds → 16.7 milliseconds (best of 30 runs)

📝 Explanation and details

The optimization achieves a 21% speedup by introducing LRU caching for frequently created OpenVINO constants in the bincount function, which is the primary performance bottleneck.

Key optimizations applied:

1. Constant Caching with LRU Cache: Added three cached helper functions (_ov_const, _ov_const_notype, _ov_const_empty) that cache the results of ov_opset.constant() calls. This eliminates repeated creation of identical OpenVINO constant tensors for scalar values like -1, 0, 1, and empty shapes.

2. Combined Type Checking in get_ov_output: Merged the separate isinstance(x, float) and isinstance(x, int) checks into a single isinstance(x, (float, int)) check, reducing redundant type checking overhead.

Why this leads to speedup:

The line profiler reveals that constant creation (ov_opset.constant().output(0)) was consuming significant time in the original code:

• scalar_shape = ov_opset.constant([], x_type).output(0) took 11.5% of total time
• const_minus_one = ov_opset.constant(-1, x_type).output(0) took 5.4% of total time
• Similar overhead for const_one and const_zero creation

With caching, these expensive constant creation operations are reduced from multiple calls per function invocation to just cache lookups after the first creation. The optimized version shows these operations now take significantly less time (0.9% for scalar_shape, 1.1% for const_minus_one).

Test case performance benefits:

The optimization particularly benefits test cases that involve multiple calls to bincount or operations with repeated scalar constants, as evidenced by the 6-20% improvements in various edge case tests. The caching is most effective when the same data types are used repeatedly across function calls, which is common in machine learning workloads where tensors often share consistent dtypes.

This optimization is especially valuable in ML pipelines where bincount may be called frequently with similar input types, maximizing the benefit of the cached constants.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from keras.src.backend.openvino.numpy import bincount

# --- Minimal stubs for OpenVINO and Keras backend types/classes for testing ---

class DummyOutput:
    """A dummy class to mimic ov.Output for test purposes."""
    def __init__(self, data):
        self._data = data

    def get_element_type(self):
        # Just return a string for type; not used in our stub logic
        return type(self._data[0]) if isinstance(self._data, list) and self._data else int

    def __getitem__(self, idx):
        return self._data[idx]

    def __eq__(self, other):
        return self._data == other._data

    def __repr__(self):
        return f"DummyOutput({self._data})"

    def output(self, idx=0):
        return self

    @property
    def data(self):
        return self._data

class OpenVINOKerasTensor:
    """A dummy class to mimic OpenVINOKerasTensor for test purposes."""
    def __init__(self, output):
        self.output = output

    @property
    def value(self):
        return self

    @property
    def data(self):
        return self.output.data

    def __eq__(self, other):
        if isinstance(other, OpenVINOKerasTensor):
            return self.data == other.data
        return False

    def __repr__(self):
        return f"OpenVINOKerasTensor({self.data})"

# --- Minimal stubs for ov_opset operations ---

class ov_opset:
    @staticmethod
    def constant(value, dtype=None):
        # dtype is ignored for our stub
        if isinstance(value, DummyOutput):
            return value
        if isinstance(value, (list, tuple)):
            return DummyOutput(list(value))
        return DummyOutput([value])

    @staticmethod
    def shape_of(x, dtype=None):
        # Return shape as DummyOutput
        if isinstance(x, DummyOutput):
            shape = [len(x.data)]
        elif isinstance(x, list):
            shape = [len(x)]
        else:
            shape = [1]
        return DummyOutput(shape)

    @staticmethod
    def convert(x, dtype):
        # Just return x for stub
        return x

    @staticmethod
    def reshape(x, shape, special_zero):
        # Flatten or reshape as needed
        if isinstance(x, DummyOutput):
            if shape.data == []:
                # Scalar
                return DummyOutput([x.data[0]])
            elif shape.data == [-1, 1]:
                # Reshape to column vector
                return DummyOutput([[v] for v in x.data])
        return x

    @staticmethod
    def add(x, y):
        # Elementwise add
        if isinstance(x, DummyOutput) and isinstance(y, DummyOutput):
            return DummyOutput([a + b for a, b in zip(x.data, y.data)])
        elif isinstance(x, DummyOutput):
            return DummyOutput([a + y.data[0] for a in x.data])
        elif isinstance(y, DummyOutput):
            return DummyOutput([x.data[0] + b for b in y.data])
        else:
            return DummyOutput([x.data[0] + y.data[0]])

    @staticmethod
    def reduce_max(x, axis, keep_dims=False):
        # Return max value as DummyOutput
        if isinstance(x, DummyOutput):
            return DummyOutput([max(x.data)])
        return x

    @staticmethod
    def maximum(x, y):
        # Elementwise maximum
        if isinstance(x, DummyOutput) and isinstance(y, DummyOutput):
            return DummyOutput([max(a, b) for a, b in zip(x.data, y.data)])
        elif isinstance(x, DummyOutput):
            return DummyOutput([max(a, y.data[0]) for a in x.data])
        elif isinstance(y, DummyOutput):
            return DummyOutput([max(x.data[0], b) for b in y.data])
        else:
            return DummyOutput([max(x.data[0], y.data[0])])

    @staticmethod
    def one_hot(x, depth, on_value, off_value, axis=-1):
        # x: DummyOutput([indices]), depth: DummyOutput([scalar]), on_value/off_value: DummyOutput([scalar])
        indices = x.data
        depth_val = depth.data[0]
        onv = on_value.data[0]
        offv = off_value.data[0]
        result = []
        for idx in indices:
            row = [onv if i == idx else offv for i in range(depth_val)]
            result.append(row)
        return DummyOutput(result)

    @staticmethod
    def multiply(x, y):
        # x: DummyOutput([[...], ...]), y: DummyOutput([[w], ...])
        xdata = x.data
        ydata = y.data
        # x: shape (n, m), y: shape (n, 1)
        result = []
        for row, wrow in zip(xdata, ydata):
            if isinstance(wrow, list):
                w = wrow[0]
            else:
                w = wrow
            result.append([v * w for v in row])
        return DummyOutput(result)

    @staticmethod
    def reduce_sum(x, axis, keep_dims=False):
        # x: DummyOutput([[...], ...]), axis: DummyOutput([scalar])
        xdata = x.data
        if isinstance(xdata[0], list):
            # Sum over last axis
            return DummyOutput([sum(row) for row in xdata])
        else:
            # Already reduced
            return DummyOutput([sum(xdata)])

# --- Minimal stubs for Type ---

class Type:
    f32 = 'float32'
    i32 = 'int32'
from keras.src.backend.openvino.numpy import bincount

# --- Unit tests ---

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

def test_bincount_input_none():
    # Edge: input x is None
    with pytest.raises(ValueError):
        bincount(None) # 1.09μs -> 1.02μs (6.78% faster)

def test_bincount_sparse_true():
    # Edge: sparse=True is not supported
    with pytest.raises(ValueError):
        bincount([1, 2, 3], sparse=True) # 1.31μs -> 1.29μs (1.86% faster)

def test_bincount_weights_length_mismatch():
    # Edge: weights length mismatch
    with pytest.raises(Exception):
        # Our stub doesn't check, but let's simulate
        def get_ov_output_weights(x, ov_type=None):
            return DummyOutput(x)
        orig = globals()['get_ov_output']
        globals()['get_ov_output'] = get_ov_output_weights
        try:
            bincount([1, 2], weights=[1.0])
        finally:
            globals()['get_ov_output'] = orig

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

import pytest
from keras.src.backend.openvino.numpy import bincount

# Minimal stubs for OpenVINOKerasTensor and OpenVINO ops to allow testing without OpenVINO
class OpenVINOKerasTensor:
    def __init__(self, data):
        self.data = data

# Minimal stubs for ops used in bincount
class DummyOpset:
    @staticmethod
    def constant(x, dtype=None):
        # Just wrap value and dtype for testing
        return DummyTensor(x)

    @staticmethod
    def shape_of(x, dtype=None):
        # For our dummy tensor, return shape as tensor
        if isinstance(x, DummyTensor):
            shape = [len(x.data)] if isinstance(x.data, list) else []
            return DummyTensor(shape)
        return DummyTensor([])

    @staticmethod
    def convert(x, dtype):
        return DummyTensor(x.data)

    @staticmethod
    def reshape(x, shape, special_zero):
        return DummyTensor(x.data)

    @staticmethod
    def add(x, y):
        return DummyTensor(x.data + y.data)

    @staticmethod
    def reduce_max(x, axis, keep_dims=False):
        if isinstance(x.data, list) and x.data:
            return DummyTensor(max(x.data))
        elif isinstance(x.data, int):
            return DummyTensor(x.data)
        else:
            return DummyTensor(0)

    @staticmethod
    def maximum(x, y):
        return DummyTensor(max(x.data, y.data))

    @staticmethod
    def one_hot(x, depth, on_value, off_value, axis=-1):
        # Create one-hot encoding for each value in x.data up to depth.data
        depth_val = depth.data
        arr = x.data if isinstance(x.data, list) else [x.data]
        result = []
        for val in arr:
            row = [on_value.data if i == val else off_value.data for i in range(depth_val)]
            result.append(row)
        return DummyTensor(result)

    @staticmethod
    def multiply(x, y):
        # x: one-hot, y: weights reshaped
        arr_x = x.data
        arr_y = y.data
        # arr_x: shape [N, depth], arr_y: shape [N, 1]
        result = []
        for i, row in enumerate(arr_x):
            result.append([row[j] * arr_y[i][0] for j in range(len(row))])
        return DummyTensor(result)

    @staticmethod
    def reduce_sum(x, axis, keep_dims=False):
        # x: shape [N, depth], sum over axis=-1 (depth)
        arr = x.data
        if isinstance(arr[0], list):
            # sum over last axis
            summed = [sum(row) for row in arr]
            # For bincount, we need sum over all rows for each column
            depth = len(arr[0])
            result = [sum(row[j] for row in arr) for j in range(depth)]
            return DummyTensor(result)
        else:
            # Just a list of numbers
            return DummyTensor(sum(arr))

class DummyTensor:
    def __init__(self, data):
        self.data = data
    def output(self, idx):
        return self
    def get_element_type(self):
        return "i32"
from keras.src.backend.openvino.numpy import bincount

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

# 1. Basic Test Cases

def test_bincount_edge_negative_values():
    # Edge: negative values, should raise or ignore
    with pytest.raises(Exception):
        bincount([-1, 0, 1])

def test_bincount_edge_weights_length_mismatch():
    # Edge: weights length mismatch
    with pytest.raises(Exception):
        bincount([0, 1], weights=[1.0])

def test_bincount_edge_weights_empty():
    # Edge: weights empty with non-empty x
    with pytest.raises(Exception):
        bincount([1, 2], weights=[]) # 510μs -> 424μs (20.0% faster)

def test_bincount_edge_none_input():
    # Edge: x is None
    with pytest.raises(ValueError):
        bincount(None) # 1.17μs -> 1.09μs (7.73% faster)

def test_bincount_edge_sparse_true():
    # Edge: sparse=True not supported
    with pytest.raises(ValueError):
        bincount([1, 2], sparse=True) # 1.26μs -> 1.25μs (0.879% faster)

def test_bincount_edge_non_integer_input():
    # Edge: non-integer input
    with pytest.raises(Exception):
        bincount([0.5, 1.2, 2.8]) # 190μs -> 158μs (20.2% faster)

def test_bincount_edge_non_list_input():
    # Edge: input is a string
    with pytest.raises(Exception):
        bincount("abc") # 16.7μs -> 17.2μs (2.79% slower)

To edit these changes git checkout codeflash/optimize-bincount-mir4sqtm and push.