Merge branch 'master' into openvino-nn-functions

Author: danielenricocahall

.github/workflows/nightly.yml

@@ -69,9 +69,9 @@ jobs:
       PYTHON: ${{ matrix.python-version }}
       KERAS_BACKEND: ${{ matrix.backend }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Get pip cache dir

.github/workflows/scorecard.yml

@@ -48,14 +48,14 @@ jobs:
       # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
       # format to the repository Actions tab.
       - name: "Upload artifact"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: SARIF file
           path: results.sarif
           retention-days: 5
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.29.5
+        uses: github/codeql-action/upload-sarif@0499de31b99561a6d14a36a5f662c2a54f91beee # v3.29.5
         with:
           sarif_file: results.sarif

CONTRIBUTING.md

@@ -4,7 +4,7 @@ Contributions can be made in a variety of ways, including coding, enriching docu
 
 
 ## Current items open for contributions
-At [this link](https://github.com/keras-team/keras/issues/18442), you'll find a list of items where you help is needed!
+At [this link](https://github.com/keras-team/keras/issues/18442), you'll find a list of items where your help is needed!
 
 
 ## How to contribute code

keras/src/backend/jax/nn.py

@@ -355,7 +355,7 @@ def conv(
     feature_group_count = channels // kernel_in_channels
     kernel = convert_to_tensor(kernel)
     inputs = convert_to_tensor(inputs, dtype=kernel.dtype)
-    return jax.lax.conv_general_dilated(
+    result = jax.lax.conv_general_dilated(
         inputs,
         kernel,
         strides,
@@ -364,6 +364,14 @@ def conv(
         dimension_numbers=dimension_numbers,
         feature_group_count=feature_group_count,
     )
+    if result.size == 0:
+        raise ValueError(
+            "The convolution operation resulted in an empty output. "
+            "This can happen if the input is too small for the given "
+            "kernel size, strides, dilation rate, and padding mode. "
+            "Please check the input shape and convolution parameters."
+        )
+    return result
 
 
 def depthwise_conv(

keras/src/backend/jax/numpy.py

@@ -1196,6 +1196,8 @@ def take(x, indices, axis=None):
 
 
 def take_along_axis(x, indices, axis=None):
+    x = convert_to_tensor(x)
+    indices = convert_to_tensor(indices, sparse=False)
     return jnp.take_along_axis(x, indices, axis=axis)
 
 

keras/src/backend/numpy/nn.py

@@ -404,7 +404,7 @@ def conv(
             f"kernel in_channels {kernel_in_channels}. "
         )
     feature_group_count = channels // kernel_in_channels
-    return np.array(
+    result = np.array(
         jax.lax.conv_general_dilated(
             inputs,
             kernel if is_tensor(kernel) else kernel.numpy(),
@@ -415,6 +415,14 @@ def conv(
             feature_group_count=feature_group_count,
         )
     )
+    if result.size == 0:
+        raise ValueError(
+            "The convolution operation resulted in an empty output. "
+            "This can happen if the input is too small for the given "
+            "kernel size, strides, dilation rate, and padding mode. "
+            "Please check the input shape and convolution parameters."
+        )
+    return result
 
 
 def depthwise_conv(

keras/src/backend/openvino/excluded_concrete_tests.txt

@@ -19,7 +19,6 @@ NumpyDtypeTest::test_correlate
 NumpyDtypeTest::test_cross
 NumpyDtypeTest::test_cumprod
 NumpyDtypeTest::test_diag
-NumpyDtypeTest::test_digitize
 NumpyDtypeTest::test_einsum
 NumpyDtypeTest::test_exp2
 NumpyDtypeTest::test_flip
@@ -76,13 +75,6 @@ NumpyOneInputOpsCorrectnessTest::test_floor_divide
 NumpyOneInputOpsCorrectnessTest::test_imag
 NumpyOneInputOpsCorrectnessTest::test_isreal
 NumpyOneInputOpsCorrectnessTest::test_logaddexp2
-NumpyOneInputOpsCorrectnessTest::test_pad_float16_constant_2
-NumpyOneInputOpsCorrectnessTest::test_pad_float32_constant_2
-NumpyOneInputOpsCorrectnessTest::test_pad_float64_constant_2
-NumpyOneInputOpsCorrectnessTest::test_pad_int16_constant_2
-NumpyOneInputOpsCorrectnessTest::test_pad_int8_constant_2
-NumpyOneInputOpsCorrectnessTest::test_pad_uint8_constant_2
-NumpyOneInputOpsCorrectnessTest::test_pad_int32_constant_2
 NumpyOneInputOpsCorrectnessTest::test_real
 NumpyOneInputOpsCorrectnessTest::test_reshape
 NumpyOneInputOpsCorrectnessTest::test_roll
@@ -92,15 +84,12 @@ NumpyOneInputOpsCorrectnessTest::test_select
 NumpyOneInputOpsCorrectnessTest::test_signbit
 NumpyOneInputOpsCorrectnessTest::test_size
 NumpyOneInputOpsCorrectnessTest::test_slogdet
-NumpyOneInputOpsCorrectnessTest::test_std
 NumpyOneInputOpsCorrectnessTest::test_swapaxes
 NumpyOneInputOpsCorrectnessTest::test_tile
 NumpyOneInputOpsCorrectnessTest::test_trace
-NumpyOneInputOpsCorrectnessTest::test_transpose
 NumpyOneInputOpsCorrectnessTest::test_trapezoid
 NumpyOneInputOpsCorrectnessTest::test_trunc
 NumpyOneInputOpsCorrectnessTest::test_unravel_index
-NumpyOneInputOpsCorrectnessTest::test_var
 NumpyOneInputOpsCorrectnessTest::test_vectorize
 NumpyOneInputOpsCorrectnessTest::test_vstack
 NumpyOneInputOpsCorrectnessTest::test_view
@@ -110,11 +99,9 @@ NumpyTwoInputOpsCorrectnessTest::test_bitwise_or
 NumpyTwoInputOpsCorrectnessTest::test_bitwise_right_shift
 NumpyTwoInputOpsCorrectnessTest::test_bitwise_xor
 NumpyTwoInputOpsCorrectnessTest::test_cross
-NumpyTwoInputOpsCorrectnessTest::test_digitize
 NumpyTwoInputOpsCorrectnessTest::test_divide_no_nan
 NumpyTwoInputOpsCorrectnessTest::test_einsum
 NumpyTwoInputOpsCorrectnessTest::test_gcd
-NumpyTwoInputOpsCorrectnessTest::test_heaviside
 NumpyTwoInputOpsCorrectnessTest::test_hypot
 NumpyTwoInputOpsCorrectnessTest::test_inner
 NumpyTwoInputOpsCorrectnessTest::test_isin
@@ -130,23 +117,19 @@ NumpyOneInputOpsDynamicShapeTest::test_cbrt
 NumpyOneInputOpsDynamicShapeTest::test_corrcoef
 NumpyOneInputOpsDynamicShapeTest::test_hamming
 NumpyOneInputOpsDynamicShapeTest::test_hanning
-NumpyOneInputOpsDynamicShapeTest::test_isposinf
 NumpyOneInputOpsDynamicShapeTest::test_isreal
 NumpyOneInputOpsDynamicShapeTest::test_kaiser
 NumpyOneInputOpsDynamicShapeTest::test_view
 NumpyOneInputOpsStaticShapeTest::test_angle
 NumpyOneInputOpsStaticShapeTest::test_cbrt
-NumpyOneInputOpsStaticShapeTest::test_isposinf
 NumpyOneInputOpsStaticShapeTest::test_isreal
 NumpyOneInputOpsStaticShapeTest::test_view
 NumpyTwoInputOpsDynamicShapeTest::test_gcd
-NumpyTwoInputOpsDynamicShapeTest::test_heaviside
 NumpyTwoInputOpsDynamicShapeTest::test_hypot
 NumpyTwoInputOpsDynamicShapeTest::test_isin
 NumpyTwoInputOpsDynamicShapeTest::test_kron
 NumpyTwoInputOpsDynamicShapeTest::test_lcm
 NumpyTwoInputOpsStaticShapeTest::test_gcd
-NumpyTwoInputOpsStaticShapeTest::test_heaviside
 NumpyTwoInputOpsStaticShapeTest::test_hypot
 NumpyTwoInputOpsStaticShapeTest::test_isin
 NumpyTwoInputOpsStaticShapeTest::test_kron

keras/src/backend/openvino/numpy.py

@@ -557,9 +557,21 @@ def hamming(x):
 
 
 def heaviside(x1, x2):
-    raise NotImplementedError(
-        "`heaviside` is not supported with openvino backend"
-    )
+    x1 = get_ov_output(x1)
+    x_type = x1.get_element_type()
+    x2 = get_ov_output(x2, x_type)
+
+    zero_scalar = ov_opset.constant(0, x_type).output(0)
+    one_scalar = ov_opset.constant(1, x_type).output(0)
+
+    neg = ov_opset.less(x1, zero_scalar).output(0)
+    pos = ov_opset.greater(x1, zero_scalar).output(0)
+    eq = ov_opset.equal(x1, zero_scalar).output(0)
+
+    x = ov_opset.select(neg, zero_scalar, x1).output(0)
+    x = ov_opset.select(pos, one_scalar, x).output(0)
+    x = ov_opset.select(eq, x2, x).output(0)
+    return OpenVINOKerasTensor(x)
 
 
 def kaiser(x, beta):
@@ -699,15 +711,9 @@ def count_nonzero(x, axis=None):
     zero_constant = ov_opset.convert_like(zero_constant, x)
     x = ov_opset.not_equal(x, zero_constant).output(0)
     x = ov_opset.convert(x, Type.i32).output(0)
-    if axis is None:
-        flatten_shape = ov_opset.constant([-1], Type.i32).output(0)
-        x = ov_opset.reshape(x, flatten_shape, False).output(0)
-        axis = 0
-    if isinstance(axis, tuple):
-        axis = list(axis)
-    if axis == []:
+    x, axis = _resolve_axis(x, axis)
+    if not axis:
         return OpenVINOKerasTensor(x)
-    axis = ov_opset.constant(axis, Type.i32).output(0)
     return OpenVINOKerasTensor(ov_opset.reduce_sum(x, axis, False).output(0))
 
 
@@ -726,11 +732,7 @@ def cumsum(x, axis=None, dtype=None):
     if dtype is not None:
         ov_type = OPENVINO_DTYPES[standardize_dtype(dtype)]
         x = ov_opset.convert(x, ov_type).output(0)
-    if axis is None:
-        flatten_shape = ov_opset.constant([-1], Type.i32).output(0)
-        x = ov_opset.reshape(x, flatten_shape, False).output(0)
-        axis = 0
-    axis = ov_opset.constant(axis, Type.i32).output(0)
+    x, axis = _resolve_axis(x, axis)
     if x.get_element_type() == Type.boolean:
         x = ov_opset.convert(x, Type.i32).output(0)
     return OpenVINOKerasTensor(ov_opset.cumsum(x, axis).output(0))
@@ -841,9 +843,30 @@ def diff(a, n=1, axis=-1):
 
 
 def digitize(x, bins):
-    raise NotImplementedError(
-        "`digitize` is not supported with openvino backend"
-    )
+    x_node = get_ov_output(x)
+
+    if isinstance(bins, OpenVINOKerasTensor):
+        bins_node = get_ov_output(bins)
+    else:
+        bins_np = np.asarray(bins)
+        if bins_np.ndim != 1:
+            raise ValueError("`bins` must be 1-D array-like")
+        bins_node = ov_opset.constant(bins_np).output(0)
+
+    x_node, bins_node = _align_operand_types(x_node, bins_node, "digitize()")
+
+    if x_node.get_element_type() == Type.boolean:
+        x_node = ov_opset.convert(x_node, Type.f32).output(0)
+        bins_node = ov_opset.convert(bins_node, Type.f32).output(0)
+
+    result = ov_opset.bucketize(
+        x_node,
+        bins_node,
+        output_type=Type.i32,
+        with_right_bound=False,
+    ).output(0)
+
+    return OpenVINOKerasTensor(result)
 
 
 def dot(x1, x2):
@@ -1765,7 +1788,9 @@ def pad(x, pad_width, mode="constant", constant_values=None):
             "`pad` operation supports only scalar pad value "
             "in constant mode by openvino backend"
         )
-        pad_value = constant_values
+        pad_value = ov_opset.constant(
+            constant_values, x.get_element_type()
+        ).output(0)
 
     # split pad_width into two tensors pads_begin and pads_end
     pads_begin = []
@@ -2061,22 +2086,9 @@ def stack(x, axis=0):
 
 
 def std(x, axis=None, keepdims=False):
-    x = get_ov_output(x)
-    if axis is None:
-        flatten_shape = ov_opset.constant([-1], Type.i32).output(0)
-        x = ov_opset.reshape(x, flatten_shape, False).output(0)
-        axis = 0
-    axis = ov_opset.constant(axis, Type.i32).output(0)
-    # The variance is computed using $Var = E[|x|^2] - |E[x]|^2$, It is faster
-    # but less numerically stable.
-    mean = ov_opset.reduce_mean(x, axis, keepdims).output(0)
-    const_two = ov_opset.constant(2, x.get_element_type()).output(0)
-    squared_x = ov_opset.power(x, const_two).output(0)
-    squared_mean = ov_opset.power(mean, const_two).output(0)
-    squared_x_mean = ov_opset.reduce_mean(squared_x, axis, keepdims)
-    variance = ov_opset.subtract(squared_x_mean, squared_mean).output(0)
-    std_var = OpenVINOKerasTensor(ov_opset.sqrt(variance).output(0))
-    return std_var
+    var_x = var(x, axis, keepdims)
+    std_dev = ov_opset.sqrt(var_x).output(0)
+    return OpenVINOKerasTensor(std_dev)
 
 
 def swapaxes(x, axis1, axis2):
@@ -2441,18 +2453,26 @@ def trapezoid(y, x=None, dx=1.0, axis=-1):
 
 def var(x, axis=None, keepdims=False):
     x = get_ov_output(x)
+    x_type = x.get_element_type()
+    x, axis = _resolve_axis(x, axis)
+
+    work_dtype = Type.f64 if x_type.is_integral() else x.get_element_type()
+    if x_type.is_integral():
+        x = ov_opset.convert(x, work_dtype).output(0)
     if axis is None:
-        flatten_shape = ov_opset.constant([-1], Type.i32).output(0)
-        x = ov_opset.reshape(x, flatten_shape, False).output(0)
-        axis = 0
-    axis = ov_opset.constant(axis, Type.i32).output(0)
+        const_zero = ov_opset.constant(0, dtype=work_dtype).output(0)
+        return OpenVINOKerasTensor(
+            ov_opset.broadcast(const_zero, ov_opset.shape_of(x)).output(0)
+        )
     # The variance is computed using $Var = E[|x|^2] - |E[x]|^2$, It is faster
     # but less numerically stable.
     mean = ov_opset.reduce_mean(x, axis, keepdims).output(0)
-    const_two = ov_opset.constant(2, x.get_element_type()).output(0)
+    const_two = ov_opset.constant(2, work_dtype).output(0)
+
     squared_x = ov_opset.power(x, const_two).output(0)
     squared_mean = ov_opset.power(mean, const_two).output(0)
-    squared_x_mean = ov_opset.reduce_mean(squared_x, axis, keepdims)
+
+    squared_x_mean = ov_opset.reduce_mean(squared_x, axis, keepdims).output(0)
     variance = OpenVINOKerasTensor(
         ov_opset.subtract(squared_x_mean, squared_mean).output(0)
     )

keras/src/backend/tensorflow/nn.py

@@ -310,14 +310,28 @@ def conv(
 ):
     def _conv():
         tf_data_format = _convert_data_format(data_format, len(inputs.shape))
-        return tf.nn.convolution(
+        result = tf.nn.convolution(
             inputs,
             kernel,
             strides,
             padding.upper(),
             data_format=tf_data_format,
             dilations=dilation_rate,
         )
+        result_shape = result.shape
+        if (
+            result_shape.is_fully_defined()
+            and math.prod(result_shape.as_list()) == 0
+        ):
+            raise ValueError(
+                "The convolution operation resulted in an empty output. "
+                "Output shape:"
+                f" {result_shape}. This can happen if the input is too small "
+                "for the given kernel size, strides, dilation rate, and "
+                "padding mode. Please check the input shape and convolution "
+                "parameters."
+            )
+        return result
 
     # Certain ops are are broken in Tensorflow on CPU only.
     # We can work around by compiling the op with XLA.