# SINQ

[Sinkhorn-Normalized Quantization (SINQ)](https://github.com/huawei-csl/SINQ/tree/main) es una técnica de cuantización rápida, de uso inmediato e independiente del modelo, que ofrece un rendimiento de última generación para los Large Language Models sin sacrificar la precisión.

### 🔍 Lo que encontrarás aquí

- [1. Cuantizar (y guardar) cualquier LLM con SINQ](#1-quantize-any-llm-with-sinq)
- [2. Cómo citar este trabajo](#2-how-to-cite-this-work)
- [3. Limitaciones actuales](#3-current-limitations)

#### 📊 Comparación de características: SINQ frente a HQQ _(sin calibración)_ y A-SINQ frente a AWQ _(con calibración)_

| Característica | **SINQ** | **HQQ** | **A-SINQ** | **AWQ** |
|------------|:--------:|:--------:|:----------:|:-------:|
| 🎯 Calibración | Sin calibración | Sin calibración |  Calibrado | Calibrado |
| 🧮 Tipo de cuantización | Simétrico y asimétrico | Solo asimétrico | Simétrico y asimétrico | Simétrico y asimétrico |
| 📦 Soporte para NF4 | **Sí** | No | **Sí** | No |
| ⚡ Velocidad de cuantización | ~2× **más rápido** que HQQ | Más lento | ~4× **más rápido** que AWQ | Más lento |
| 📈 Calidad del modelo | **Mayor** | Inferior | **Mayor** | Inferior |

📄 **¿Quieres saber más?**
- Lee nuestro artículo en [**arXiv**](http://arxiv.org/abs/2509.22944)
- Consulte el repositorio de GitHub oficial de [**SINQ**](https://github.com/huawei-csl/SINQ/tree/main)

--- 

## 1. Cuantice cualquier LLM con SINQ

### Configuración y comienzo rápido

Primero, instale el paquete. Se puede hacer de dos maneras:
- Desde el código fuente usando el repositorio oficial de Github [**SINQ**](https://github.com/huawei-csl/SINQ/tree/main) **[Recomendado]**
- Usando el paquete pip:
```bash
pip install sinq
```

---

### Cuantiza en unas pocas líneas

Cuantizar cualquier modelo de 🤗 Hugging Face con SINQ es sencillo y requiere solo unas pocas líneas de código. Primero, crea un [SinqConfig](/docs/transformers/main/es/main_classes/quantization#transformers.SinqConfig) y especifica los siguientes parámetros:

| Flag | Descripción | Tipo | Opciones | Predeterminado |
|------|-------------|---------|---------|----------|
| `--nbits` | Ancho de bits para la cuantización de pesos | int | 2, 3, 4, 5, 6, 8 | 4 |
| `--tiling_mode` | Estrategia de teselado de la matriz de pesos | str | 1D, 2D | 1D |
| `--group_size` | Pesos por grupo de cuantización | int | 64, 128 | 64 |
| `--method` | Método de cuantización | str | sinq, asinq | sinq |
| `--modules_to_not_convert` | Lista de las capas que NO se cuantizan | Lista de str | [lm_head, ...] | [lm_head] |

Luego, especifique el modelo que desea cuantizar y pase SinqConfig como opción de configuración de cuantización

```python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, SinqConfig

model_name = "Qwen/Qwen3-1.7B"

cfg = SinqConfig(
    nbits=4,
    group_size=64,
    tiling_mode="1D",
    method="sinq",
    modules_to_not_convert=["lm_head"]
)

tok = AutoTokenizer.from_pretrained(model_name)
qmodel = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=cfg,
    dtype=torch.bfloat16
)

```

✅ Listo. Tu modelo ahora está cuantizado con **SINQ** y está listo para inferencia o para guardarse.

> ¡Consulta nuestro repositorio oficial de GitHub [**SINQ**](https://github.com/huawei-csl/SINQ/tree/main) para mantenerte al día!

---

### Guardar y recargar

Si deseas reutilizar un modelo cuantizado más adelante, guárdalo en el disco o súbelo al HuggingFace Hub y recárgalo sin necesidad de los pesos base FP. Si instalaste SINQ desde el código fuente, debes llamar a la función *patch_hf_pretrained_io* al recargar un modelo cuantizado:
```python
# Save sinq quantized model
model.save_pretrained("/path/to/save/qwen3-1.7B-sinq-4bit")
model.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")
tokenizer.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")
```
```python
from sinq.hf_io import patch_hf_pretrained_io
patch_hf_pretrained_io()
# Reload a sinq quantized model
hf_hub_model = "HF_Hub_username/qwen3-1.7B-sinq-4bit"
tokenizer  = AutoTokenizer.from_pretrained(hf_hub_model)
model = AutoModelForCausalLM.from_pretrained(hf_hub_model)
```
En caso contrario, si instalaste SINQ a través de pip, puedes usar simplemente las funciones integradas de HF:

```python
# --- Save to a folder (sharded safetensors) ---

# 'model' must already be SINQ-quantized
# Locally save
qmodel.save_pretrained("/path/to/save/qwen3-1.7B-sinq-4bit")
# Push to the Hub
qmodel.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")
tok.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")

# --- Reload later--

save_dir = "/path/to/save/qwen3-1.7B-sinq-4bit"
hf_hub_model = "HF_Hub_username/qwen3-1.7B-sinq-4bit"

# From local directory
tok = AutoTokenizer.from_pretrained(save_dir)
qmodel = AutoModelForCausalLM.from_pretrained(save_dir)

# From HF Hub
tok = AutoTokenizer.from_pretrained(hf_hub_model)
qmodel = AutoModelForCausalLM.from_pretrained(hf_hub_model)

```

✅ ¡Tu modelo ya está cargado y listo para la inferencia!

> Nota: Si el modelo ha sido cuantizado en 4 bits y se ha instalado la biblioteca `gemlite`, se utiliza el kernel más rápido de gemlite para ejecutar la inferencia.

---

### Compatible con el marco de evaluación [`lm-eval`](https://github.com/EleutherAI/lm-evaluation-harness)

A continuación se muestra un ejemplo mínimo que ilustra cómo evaluar un modelo cuantizado con SINQ en un conjunto de datos de referencia:

```python
import torch
from lm_eval import evaluator
from lm_eval.models.huggingface import HFLM

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

# Wrap the already quantized model and tokenizer with HFLM
lm = HFLM(pretrained=qmodel, tokenizer=tok, device=device)

# Evaluate (many tasks available on lm-eval such as MMLU and HellaSwag)
results = evaluator.simple_evaluate(
    model=lm,
    tasks=["wikitext"],  # small and fast benchmark
    device=device
)
```

## 2. Cómo citar este trabajo

Si encuentras que **SINQ** es útil en tus investigaciones o aplicaciones
- Apoya nuestro proyecto añadiendo una estrella ⭐️ en el repositorio de github de [**SINQ**](https://github.com/huawei-csl/SINQ/tree/main)
- Cite nuestro artículo:

```bibtex
@misc{muller2025sinq,
      title={SINQ: Sinkhorn-Normalized Quantization for Calibration-Free Low-Precision LLM Weights}, 
      author={Lorenz K. Muller and Philippe Bich and Jiawei Zhuang and Ahmet Celik and Luca Benfenati and Lukas Cavigelli},
      year={2025},
      eprint={2509.22944},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={http://arxiv.org/abs/2509.22944}
}
```

## 3. Limitaciones actuales

Actualmente, el método A-SINQ no está soportado en Hugging Face. Consulte el [repositorio oficial de SINQ](https://github.com/huawei-csl/SINQ/tree/main) para cuantizar un modelo con esta estrategia. Por el momento, la estrategia de cuantización SINQ y los modelos cuantizados con SINQ no admiten la opción Multi-GPU, por lo que si su sistema cuenta con varias GPU, especifique cuál debe utilizarse.