Silent corruption: FP8 compressed-tensors "frozen" checkpoints load without applying weight_scale
Author: kvcache670
Pull request: no
Labels: name: bug

### System Info



```text
- `transformers` version: 5.13.0
- Platform: Linux-6.8.0-111-generic-x86_64-with-glibc2.35
- Python version: 3.12.13
- Huggingface_hub version: 1.22.0
- Safetensors version: 0.8.0
- Accelerate version: not installed
- Accelerate config: not found
- DeepSpeed version: not installed
- PyTorch version (accelerator?): 2.11.0+cu130 (CUDA)
- GPU type: NVIDIA GeForce RTX 4090
- Using distributed or parallel set-up in script?: no
- Using GPU in script?: no (CPU-only repro)
```

### Who can help?

@SunMarc @MekkCyber (quantization)


### Information

- [ ] The official example scripts
- [x] My own modified scripts

### Tasks

- [ ] An officially supported task in the `examples` folder (such as GLUE/SQuAD, ...)
- [x] My own task or dataset (give details below)

### Reproduction

```python
import torch
from transformers import AutoModelForCausalLM
m = AutoModelForCausalLM.from_pretrained(
    "RedHatAI/Llama-3.2-1B-Instruct-FP8", dtype=torch.float32)
w = m.model.layers[0].self_attn.q_proj.weight
print(w.abs().max())   # tensor(448.)  -- raw fp8 max; correct dequantized ~0.68
```


### Expected behavior

I think so every Linear layer is wrong by ~1/scale. I tried to ask question like:  "The capital of France is"  and the answer is  `\n Vandback retainingthouse나agemfacesauxdosulanattachment...`

Comments:
Hi! I looked into this and could reproduce it.

The root cause seems to be that `CompressedTensorsConfig.is_quantization_compressed` keys off `quantization_status == COMPRESSED`, but this checkpoint is saved with `format="float-quantized"` and `quantization_status="frozen"`. The weights are stored as fp8 with a separate `weight_scale`, so since the status isn't `compressed`, decompression gets skipped and `weight_scale` is never applied. That's why `q_proj.weight.abs().max()` comes out as 448 (raw fp8) instead of ~0.68.

status and format seem like separate things, so I think the check should look at `format` (non-`dense`) instead of the status. That's also how compressed_tensors' own `decompress_model` decides what to decompress. I tried a small change along those lines and it fixed the load in my quick tests, and the `compressed` / `int-quantized` / `pack-quantized` / `dense` paths still seemed fine.

Happy to open a PR if that sounds like the right direction. Or would it be better to handle this in `CompressedTensorsHfQuantizer` instead?

cc @SunMarc @MekkCyber


@subin9 I just opened PR #47152 for this. I've been deep in the source for the last 4-5 hours working on this locally and didn't even see your comment until I pushed. Glad we're on the same page about the status vs format issue. The PR is already verified against the RedHat FP8 checkpoint and is ready to go. 

Hey @kvcache670, once the recent changes are merged, you can use the following snippet to verify the fix:
```Python

from transformers import AutoModelForCausalLM, CompressedTensorsConfig
import torch

# 1. Define the config with run_compressed=False
quant_config = CompressedTensorsConfig(run_compressed=False)

# 2. Pass it to from_pretrained
m = AutoModelForCausalLM.from_pretrained(
    "RedHatAI/Llama-3.2-1B-Instruct-FP8",
    device_map="cpu",
    torch_dtype=torch.float32,
    quantization_config=quant_config
)

w = m.model.layers[0].self_attn.q_proj.weight
# Should now be ~0.68 instead of the raw FP8 max (448.0)
print(f"Max value: {w.to(torch.float32).abs().max()}") 
```
I will update the reproduction script if any further changes occur.