[Bug][Keras 3 OpenVINO Backend]: Negative `seed` values are being generated(integer overflow)

[daehyun99]

Hi, devs.

I believe I have found a bug in the Keras 3 OpenVINO backend.

While working on issue openvinotoolkit/openvino#34308 , I attempted to implement a Beta distribution random number generator. To achieve this, I called the Gamma random number generator twice.

def beta(shape, alpha, beta, dtype=None, seed=None):
    from keras.src import backend

    dtype = dtype or floatx()

    seed1 = seed
    seed2 = seed
    # ...

    x = backend.random.gamma(shape, alpha, dtype=dtype, seed=seed1)
    y = backend.random.gamma(shape, beta, dtype=dtype, seed=seed2)

This resulted in the following example error(Negative seed values are being generated.):

When calling the gamma function for the first time with seed=None, seed1 is consistently generated as a positive value. However, when the gamma function is called multiple times, seed1 occasionally results in a negative value.

I believe this issue occurs not only in gamma but also in other functions like randint.

My proposed solution is as follows:

(1) Add code within the randint and gamma functions to convert seed1 to a positive value if it is negative.
This is a very intuitive approach and allows for a quick fix.

    if seed1 < 0:
        seed1 = -1 * seed1
    if seed2 < 0:
        seed2 = -1 * seed2

However, we might need to apply this logic to each of the other functions individually.

(2) In search of a better approach, I conducted further debugging and I believe I have identified the root cause.
The execution enters draw_seed(seed=None) -> global_seed_generator().

def randint(shape, minval, maxval, dtype="int32", seed=None):
    dtype = dtype or "int32"
    ov_dtype = OPENVINO_DTYPES[dtype]
    seed_val = draw_seed(seed)

Initially, it enters SeedGenerator() via the if gen is None condition.

During the initialization process, it executes the make_default_seed() function, which consistently generates a positive random seed.

However, starting from the second execution, it generates random numbers without calling make_default_seed(). During this process, negative random seeds can occur.

I believe (speculating that) the fundamental solution might be to ensure that global_seed_generator() does not generate negative seed values.

What do you think would be the best way to resolve this?

Please let me know if there is anything I have misunderstood or if you have a better solution in mind.

Thanks.

[goyaladitya05]

Hi @daehyun99,

I cross-verified this, the bug is legit. It's contained only to this file keras/src/backend/openvino/random.py, because this is the only file in the Keras OpenVINO Backend that pulls from keras.src.random.seed_generator.draw_seed().

However, we should not be making any changes to draw_seed:

• It is a core Keras function located in keras.src.random.seed_generator. It is used by all backends (TensorFlow, JAX, PyTorch, NumPy, and OpenVINO), and the bug only exists in this particular backend( I verified this ).
• The uint32 overflow bug is exclusively an artifact of how the OpenVINO Python C++ bindings parse large Python integers.

Therefore, handling this must be done strictly within the OpenVINO backend implementation.

From what I concluded,
Any operation within this file that uses the random_uniform op is susceptible to this crash once the internal seed generator counter reaches a high enough value.

Pinpointing Source of the Bug

The bug lies in the interface between Keras's unsigned seeds and OpenVINO's signed validation checks.

The actual exception : Check 'validate::out_et(out_e)' failed... Python integer -664758 out of bounds for uint32,
originates directly from the OpenVINO C++ source code during Python binding interpretation.

When Keras unpacks the seed to pass it to the OpenVINO operation:

# keras/src/backend/openvino/random.py (Line 329 for instance)
u = ov_opset.random_uniform(
    shape, zero, one, ov_dtype, iter_seed + 500, seed2
).output(0)

1. The Seed: iter_seed and seed2 are originally generated by Keras as numpy.uint32.
2. In Python, when this exceeds 2147483647, it continues growing as a positive number. But when passed into openvino.opset15.random_uniform(), OpenVINO's PyBind11 layer interprets these large Python integers into signed 32-bit integers (int32) (would persist even if it's interpreted as int64). The sign bit flips, creating a massive negative number (like -664758). OpenVINO likely expects a signed 32-bit integer in its C++ validation check, whereas Keras provides an unsigned 32-bit integer.
3. The underlying OpenVINO C++ constructor for random_uniform sees a negative global_seed or op_seed and throws the validation exception, preventing the graph from building.

Example of the C++ code causing this

void ov::op::v8::RandomUniform::validate_and_infer_types() {
    // ... other validation ...

    auto global_seed = get_global_seed();
    auto op_seed = get_op_seed();

    NODE_VALIDATION_CHECK(this,
                          global_seed >= 0,
                          "global_seed should be positive or 0. Got: ",
                          global_seed);

    NODE_VALIDATION_CHECK(this,
                          op_seed >= 0,
                          "op_seed should be positive or 0. Got: ",
                          op_seed);

    // ... shape inference ...
}

When Keras builds the OpenVINO graph (using ov_opset.random_uniform), it calls this validate_and_infer_types() function. The check global_seed >= 0 fails because global_seed is now -664758, and the NODE_VALIDATION_CHECK macro throws a RuntimeError which bubbles back up to Python.

I will look into a fix for this, and resolve it soon.

[daehyun99]

Hi, @goyaladitya05

That's really insightful!!

I was wondering if it could be an overflow, and it turns out you were spot on.

Coudl you please mention me when you open the PR to fix it?
I’m curious to see how you solve it.

Thanks.