fix(randn_tensor): compare device.type, not torch.device to str, when suppressing MPS info log

When a CPU generator is passed with an MPS target, randn_tensor intentionally skips
the 'generator was on cpu, tensor will be moved to <device>' info log — MPS doesn't
support device-side generators, so the suggestion to create one on MPS would be
misleading. The guard was written as `if device != "mps"`, but a few lines
earlier `device` is coerced to a `torch.device` object, and
`torch.device("mps") == "mps"` is False (torch.device's __eq__ with a string
returns NotImplemented, falling back to identity — they're different types).

Result: the guard is effectively always True, so MPS users get the spurious log
whenever they pass a CPU generator — the opposite of the documented intent.

Fix: compare `device.type` (a str) against "mps". Added a regression test in
tests/others/test_utils.py that exercises both the MPS and non-MPS paths via
`assertLogs` on the diffusers logger.

Author: Ricardo-M-L

src/diffusers/utils/torch_utils.py

@@ -173,7 +173,7 @@ def randn_tensor(
         gen_device_type = generator.device.type if not isinstance(generator, list) else generator[0].device.type
         if gen_device_type != device.type and gen_device_type == "cpu":
             rand_device = "cpu"
-            if device != "mps":
+            if device.type != "mps":
                 logger.info(
                     f"The passed generator was created on 'cpu' even though a tensor on {device} was expected."
                     f" Tensors will be created on 'cpu' and then moved to {device}. Note that one can probably"

tests/others/test_utils.py

@@ -204,6 +204,56 @@ def test_deprecate_testing_utils_module(self):
         ), f"Expected deprecation message substring not found, got: {messages}"
 
 
+class RandnTensorTester(unittest.TestCase):
+    """Tests for :func:`diffusers.utils.torch_utils.randn_tensor`."""
+
+    def test_mps_suppresses_cpu_generator_info_log(self):
+        """
+        When a CPU generator targets MPS, the informational log about falling back to CPU
+        should be suppressed — MPS does not support device-side generators, so the message
+        would be misleading. Prior to fixing the ``device != "mps"`` string/``torch.device``
+        comparison this log fired on every device, including MPS.
+        """
+        import logging as py_logging
+
+        import torch
+
+        from diffusers.utils import logging as diffusers_logging
+        from diffusers.utils import torch_utils
+
+        gen = torch.Generator(device="cpu")
+
+        diffusers_logging.set_verbosity_info()
+        prev_level = torch_utils.logger.level
+        torch_utils.logger.setLevel(py_logging.INFO)
+
+        def _capture(target_device):
+            with self.assertLogs(torch_utils.logger, level="INFO") as cm:
+                torch_utils.logger.info("sentinel")
+                try:
+                    torch_utils.randn_tensor((1, 2), generator=gen, device=target_device, dtype=torch.float32)
+                except (AssertionError, RuntimeError):
+                    # Accelerator may be unavailable in the test env; we only care about the log path
+                    # before tensor materialization.
+                    pass
+            return [m for m in cm.output if "sentinel" not in m]
+
+        try:
+            mps_logs = _capture("mps")
+            self.assertFalse(
+                any("moved to" in m and "generator" in m for m in mps_logs),
+                f"MPS target should not emit the CPU-fallback info log, got: {mps_logs}",
+            )
+
+            cuda_logs = _capture("cuda")
+            self.assertTrue(
+                any("moved to" in m and "generator" in m for m in cuda_logs),
+                f"Non-MPS target should still emit the CPU-fallback info log, got: {cuda_logs}",
+            )
+        finally:
+            torch_utils.logger.setLevel(prev_level)
+
+
 # Copied from https://github.com/huggingface/transformers/blob/main/tests/utils/test_expectations.py
 class ExpectationsTester(unittest.TestCase):
     def test_expectations(self):