Cuántica de modelos

Integración de bitsandbytes

Accelerate incorpora la cuantización de bitsandbytes a tu modelo. Ahora puedes cargar cualquier modelo de pytorch en 8 bits o 4 bits con unas pocas líneas de código.

Si deseas usar modelos de Transformers con bitsandbytes, debes seguir esta documentación.

Para saber más sobre cómo funciona la cuantización de bitsandbytes, consulta las publicaciones de blog sobre cuantización de 8 bits y cuantización de 4 bits.

Prerrequisitos

Deberá instalar los siguientes requisitos:

• Instala la biblioteca bitsandbytes

pip install bitsandbytes

Para dispositivos que no son cuda, puede consultar la guía de instalación de bitsandbytes aquí.

• Instala la última versión de accelerate desde el código fuente

pip install git+https://github.com/huggingface/accelerate.git

• Instale minGPT y huggingface_hub para ejecutar los ejemplos

git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
pip install huggingface_hub

Cómo funciona

Primero, necesitamos inicializar nuestro modelo. Para ahorrar memoria, podemos inicializar un modelo vacío usando el gestor de contexto init_empty_weights().

Tomemos el modelo GPT2 de la biblioteca minGPT.

from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    empty_model = GPT(model_config)

Luego, necesitamos obtener la ruta de los pesos de tu modelo. La ruta puede ser el archivo state_dict (p. ej., “pytorch_model.bin”) o una carpeta que contenga los checkpoints fragmentados.

from huggingface_hub import snapshot_download
weights_location = snapshot_download(repo_id="marcsun13/gpt2-xl-linear-sharded")

Por último, debes configurar tu configuración de cuantización con BnbQuantizationConfig.

Aquí hay un ejemplo de cuantización de 8 bits:

from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_8bit=True, llm_int8_threshold = 6)

Aquí hay un ejemplo de cuantización de 4 bits:

from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4")

Para cuantizar tu modelo vacío con la configuración seleccionada, debes usar load_and_quantize_model().

from accelerate.utils import load_and_quantize_model
quantized_model = load_and_quantize_model(empty_model, weights_location=weights_location, bnb_quantization_config=bnb_quantization_config)

Guardar y cargar un modelo de 8 bits

Puedes guardar tu modelo de 8 bits con accelerate usando save_model().

from accelerate import Accelerator
accelerate = Accelerator()
new_weights_location = "path/to/save_directory"
accelerate.save_model(quantized_model, new_weights_location)

quantized_model_from_saved = load_and_quantize_model(empty_model, weights_location=new_weights_location, bnb_quantization_config=bnb_quantization_config, device_map = "auto")

Tenga en cuenta que la serialización de modelos de 4 bits no está soportada actualmente.

Descarga los módulos a la cpu y al disco

Puedes descargar algunos módulos a la cpu/disco si no tienes suficiente espacio en la GPU para almacenar el modelo completo en tus GPUs. Esto utiliza la inferencia de modelos grandes por debajo. Consulta esta documentación para más detalles.

Para la cuantización de 8 bits, los módulos seleccionados se convertirán a una precisión de 8 bits.

Para la cuantización de 4 bits, los módulos seleccionados se mantendrán en torch_dtype que el usuario pasó en BnbQuantizationConfig. Añadiremos soporte para convertir estos módulos descargados a 4 bits cuando la serialización de 4 bits sea posible.

Solo necesitas pasar un device_map personalizado para descargar módulos en cpu/disco. Los módulos descargados se enviarán a la GPU cuando sea necesario. Aquí tienes un ejemplo:

device_map = {
    "transformer.wte": 0,
    "transformer.wpe": 0,
    "transformer.drop": 0,
    "transformer.h": "cpu",
    "transformer.ln_f": "disk",
    "lm_head": "disk",
}

Ajustar un modelo cuantizado

No es posible realizar un entrenamiento puro en 8 bits o 4 bits en estos modelos. Sin embargo, puedes entrenar estos modelos aprovechando métodos de ajuste fino eficientes en parámetros (PEFT) y, por ejemplo, entrenar adaptadores sobre ellos. Consulta la biblioteca peft para obtener más detalles.

Actualmente, no se pueden añadir adaptadores sobre ningún modelo cuantizado. Sin embargo, con el soporte oficial de adaptadores en los modelos de Transformers, es posible realizar el ajuste fino de modelos cuantizados. Si deseas realizar el ajuste fino de un modelo de Transformers, sigue esta documentación en su lugar. Consulta esta demostración sobre cómo realizar el ajuste fino de un modelo de Transformers de 4 bits.

Tenga en cuenta que no es necesario pasar device_map al cargar el modelo para el entrenamiento. Cargará automáticamente su modelo en su GPU. Tenga en cuenta que device_map=auto debe usarse solo para inferencia.

Demo de ejemplo: ejecución de GPT2 1.5b en Google Colab

Mira la demo de Google Colab para ejecutar modelos cuantizados en un modelo GPT2. El checkpoint del modelo GPT2-1.5B está en FP32 y utiliza 6 GB de memoria. Después de la cuantización, utiliza 1,6 GB con módulos de 8 bits y 1,2 GB con módulos de 4 bits.