import torch

# 4D matmul with mismatched dtypes
a = torch.randn(2, 4, 8, 8, device="cuda", dtype=torch.float16)
b = torch.randn(2, 4, 8, 64, device="cuda", dtype=torch.float32)

# Eager: raises RuntimeError
try:
    out_eager = torch.matmul(a, b)
    print(f"eager: OK dtype={out_eager.dtype}")
except RuntimeError as e:
    print(f"eager: ERROR — {e}")
# Output: eager: ERROR — expected scalar type Half but found Float

# Compiled with inductor: silently succeeds
torch._dynamo.reset()

@torch.compile(backend="inductor", fullgraph=True)
def compiled_matmul(x, y):
    return torch.matmul(x, y)

try:
    out_compiled = compiled_matmul(a, b)
    print(f"compile: OK dtype={out_compiled.dtype}")
except Exception as e:
    print(f"compile: ERROR — {e}")
# Output: compile: OK dtype=torch.float32

# Verify the compiled output is an implicit fp16→fp32 promotion
ref = torch.matmul(a.float(), b)
print(f"max diff vs explicit promotion: {(out_compiled - ref).abs().max().item()}")
# Output: max diff vs explicit promotion: 0.0

---

import torch
import torch.nn as nn
import math

class SingleHeadAttention(nn.Module):
    def __init__(self, embed_dim=512, num_embeddings=10000):
        super().__init__()
        self.embed_dim = embed_dim
        self.embedding = nn.Embedding(num_embeddings, embed_dim)
        self.query_proj = nn.Linear(embed_dim, embed_dim)
        self.key_proj = nn.Linear(embed_dim, embed_dim)
        self.value_proj = nn.Linear(embed_dim, embed_dim)
        self.out_proj = nn.Linear(embed_dim, embed_dim)

    def forward(self, x):
        x_emb = self.embedding(x)
        query = self.query_proj(x_emb)
        key = self.key_proj(x_emb)
        value = self.value_proj(x_emb)
        batch_size, seq_len, embed_dim = query.shape
        query = query.view(batch_size, seq_len, 1, embed_dim).permute(0, 2, 1, 3)
        key = key.view(batch_size, seq_len, 1, embed_dim).permute(0, 2, 1, 3)
        value = value.view(batch_size, seq_len, 1, embed_dim).permute(0, 2, 1, 3)
        query = query / math.sqrt(query.size(-1))
        attn_scores = query @ key.transpose(-2, -1)
        attn_scores = attn_scores.float()         # upcast to float32 for stable softmax
        attn_weights = torch.softmax(attn_scores, dim=-1)
        attn_weights = attn_weights.half()         # downcast back to float16
        context = attn_weights @ value             # half @ float => error in eager, OK in compile
        context = context.permute(0, 2, 1, 3).reshape(batch_size, seq_len, embed_dim)
        return self.out_proj(context)

model = SingleHeadAttention().cuda()  # model weights are float32
x = torch.randint(0, 10000, (2, 16), dtype=torch.long, device="cuda")

# Eager: RuntimeError
try:
    model(x)
    print("eager: OK")
except RuntimeError as e:
    print(f"eager: ERROR — {e}")

# Compiled: silently succeeds
torch._dynamo.reset()
compiled_model = torch.compile(model, backend="inductor", fullgraph=True)
try:
    out = compiled_model(x)
    print(f"compile: OK dtype={out.dtype}")
except Exception as e:
    print(f"compile: ERROR — {e}")

---

RuntimeError: expected scalar type Half but found Float

---

(no error — silently returns torch.float32 tensor of shape [2, 4, 8, 64])

---

Collecting environment information...
PyTorch version: 2.12.0.dev20260316+cu126
Is debug build: False
CUDA used to build PyTorch: 12.6
ROCM used to build PyTorch: N/A

OS: Ubuntu 22.04.5 LTS (x86_64)
GCC version: (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0
Clang version: Could not collect
CMake version: Could not collect
Libc version: glibc-2.35

Python version: 3.10.12 (main, Nov  4 2025, 08:48:33) [GCC 11.4.0] (64-bit runtime)
Python platform: Linux-6.6.87.2-microsoft-standard-WSL2-x86_64-with-glibc2.35
Is CUDA available: True
CUDA runtime version: Could not collect
CUDA_MODULE_LOADING set to:
GPU models and configuration: GPU 0: NVIDIA GeForce RTX 3060 Laptop GPU
Nvidia driver version: 546.30
cuDNN version: Could not collect
Is XPU available: False
HIP runtime version: N/A
MIOpen runtime version: N/A
Is XNNPACK available: True

Versions of relevant libraries:
[pip3] numpy==2.2.6
[pip3] torch==2.12.0.dev20260316+cu126
[pip3] triton==3.6.0+git9844da95