Fix torch.randint generating values equal to the upper bound (#2568) (#2714)

* Fix torch.randint producing values equal to the upper bound (#2568)

torch.randint is documented as returning integers in [low, high), but the
lowering used mb.random_uniform whose upper bound is inclusive — and
cast-to-int truncates toward zero, so a sample exactly at high stays at
high after casting. The reporter saw torch.randint(0, 100, ...) produce
values up to 100.

Clamp the cast result to high - 1 with mb.minimum so the converted graph
matches torch's exclusive upper bound. Adds a regression test that asserts
the lowered MIL graph contains the clamp op.

* Check randint upper bound via prediction instead of MIL op-type walk

Author: john-rocky

coremltools/converters/mil/frontend/torch/ops.py

@@ -5654,7 +5654,14 @@ def _parse_positional_args(context, node) -> Tuple[Var]:
 
     low, high, shape = _parse_positional_args(context, node)
     rand_uniform = mb.random_uniform(shape=shape, low=low, high=high)
-    rand_int = mb.cast(x=rand_uniform, dtype="int32", name=node.name)
+    # torch.randint yields integers in [low, high) — the upper bound is exclusive.
+    # mb.random_uniform's upper bound is inclusive, so cast-to-int can yield
+    # exactly `high`. Clamp the result to `high - 1` to match torch's semantics
+    # (issue #2568).
+    rand_int_unclipped = mb.cast(x=rand_uniform, dtype="int32")
+    high_int = mb.cast(x=high, dtype="int32")
+    high_minus_one = mb.sub(x=high_int, y=1)
+    rand_int = mb.minimum(x=rand_int_unclipped, y=high_minus_one, name=node.name)
     context.add(rand_int)
 
 @register_torch_op

coremltools/converters/mil/frontend/torch/test/test_torch_ops.py

@@ -4748,6 +4748,41 @@ def forward(self, x):
         inputs = [ct.TensorType(shape=x.shape)] if frontend == TorchFrontend.TORCHSCRIPT else None
         ct.convert(torch_model, inputs=inputs)
 
+    @pytest.mark.parametrize("frontend", frontends)
+    def test_upper_bound_is_exclusive(self, frontend):
+        # Regression test for issue #2568. torch.randint produces integers in
+        # [low, high) — the upper bound is exclusive. random_uniform's upper
+        # bound is inclusive, so before the clamp cast-to-int could emit exactly
+        # `high`. The converted model must never produce a value >= `high`.
+        if frontend == TorchFrontend.EXECUTORCH:
+            pytest.skip("torch._ops.aten.randint.low is not Aten Canonical")
+
+        class TestModel(nn.Module):
+            def forward(self, x):
+                return torch.randint(0, 100, (1000, 100), dtype=torch.int64) + x
+
+        model = TestModel().eval()
+        x = torch.zeros((1000, 100), dtype=torch.int64)
+        torch_model = export_torch_model_to_frontend(model, (x,), frontend)
+        # TorchScript needs explicit input types; exported programs carry them.
+        inputs = (
+            [ct.TensorType(shape=x.shape, dtype=np.int32)]
+            if frontend == TorchFrontend.TORCHSCRIPT
+            else None
+        )
+        mlmodel = ct.convert(torch_model, inputs=inputs)
+
+        # Over a 100k-element draw the prediction must stay within [0, high).
+        # Before the clamp, the cast could emit exactly `high` (== 100).
+        input_name = mlmodel.get_spec().description.input[0].name
+        prediction = list(
+            mlmodel.predict({input_name: x.numpy().astype(np.int32)}).values()
+        )[0]
+        assert (
+            prediction.max() < 100
+        ), f"randint emitted {prediction.max()}, must be < high (100)"
+        assert prediction.min() >= 0
+
 
 class TestRand(TorchBaseTest):
     @pytest.mark.parametrize(