diffusers/main/tr/quantization/modelopt.md

NVIDIA ModelOpt

NVIDIA-ModelOpt, kuantizasyon, budama, damıtma, spekülatif çözümleme gibi son teknoloji model optimizasyon tekniklerini bir araya getiren birleşik bir kütüphanedir. TensorRT-LLM veya TensorRT gibi aşağı akış dağıtım çerçeveleri için derin öğrenme modellerini sıkıştırarak çıkarım hızını optimize eder.

Başlamadan önce, nvidia_modelopt'un yüklü olduğundan emin olun.

pip install -U "nvidia_modelopt[hf]"

NVIDIAModelOptConfig nesnesini from_pretrained() fonksiyonuna geçirerek bir modeli kuantize edin (önceden kuantize edilmiş modelleri de yükleyebilirsiniz). Bu yöntem, Accelerate ile yüklemeyi destekleyen ve torch.nn.Linear katmanları içeren herhangi bir modalitedeki herhangi bir model için geçerlidir.

Aşağıdaki örnek yalnızca ağırlıkları FP8'e kuantize eder.

import torch
from diffusers import AutoModel, SanaPipeline, NVIDIAModelOptConfig

model_id = "Efficient-Large-Model/Sana_600M_1024px_diffusers"
dtype = torch.bfloat16

quantization_config = NVIDIAModelOptConfig(quant_type="FP8", quant_method="modelopt")
transformer = AutoModel.from_pretrained(
    model_id,
    subfolder="transformer",
    quantization_config=quantization_config,
    dtype=dtype,
)
pipe = SanaPipeline.from_pretrained(
    model_id,
    transformer=transformer,
    dtype=dtype,
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

print(f"Pipeline memory usage: {torch.cuda.max_memory_reserved() / 1024**3:.3f} GB")

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt, num_inference_steps=50, guidance_scale=4.5, max_sequence_length=512
).images[0]
image.save("output.png")

Not:

NVIDIA-ModelOpt'taki kuantizasyon yöntemleri, model performansını korurken çeşitli QAT (Quantization-Aware Training) ve PTQ (Post-Training Quantization) tekniklerini kullanarak model ağırlıklarının bellek ayak izini azaltmak üzere tasarlanmıştır. Ancak, çıkarım sırasında elde edilen gerçek performans artışı, dağıtım çerçevesine (ör. TRT-LLM, TensorRT) ve belirli donanım yapılandırmasına bağlıdır.

Daha fazla ayrıntı burada bulunabilir.

NVIDIAModelOptConfig

NVIDIAModelOptConfig sınıfı üç parametre kabul eder:

• quant_type: Aşağıdaki kuantizasyon türlerinden birini belirten bir dize değeri.
• modules_to_not_convert: Kuantizasyonun uygulanmaması gereken modül tam/kısmi modül adlarının listesi. Örneğin, SD3Transformer2DModel'in pos_embed projeksiyon bloklarında herhangi bir kuantizasyon uygulanmaması için şu şekilde belirtilebilir: modules_to_not_convert=["pos_embed.proj.weight"].
• disable_conv_quantization: Modeldeki tüm konvolüsyon katmanları için kuantizasyonu devre dışı bırakmak için True olarak ayarlanabilen bir boole değeri. Kanal ve blok kuantizasyonu genellikle konvolüsyon katmanlarıyla (INT4, NF4, NVFP4 ile kullanılır) iyi çalışmadığından bu özellik faydalıdır. Belirli konvolüsyon katmanları için kuantizasyonu devre dışı bırakmak istiyorsanız bunun yerine modules_to_not_convert kullanın.
• algorithm: Ölçek belirlemek için kullanılacak algoritma, varsayılan olarak "max"'dır. Daha fazla algoritma ve detay için modelopt dokümantasyonunu kontrol edebilirsiniz.
• forward_loop: Kuantizasyon sırasında aktivasyonların kalibre edilmesi için kullanılacak ileri döngü işlevi. Sağlanmazsa, yalnızca ağırlıklar kullanılarak hesaplanan statik ölçek değerlerine dayanır.
• kwargs: quant_type'ye göre çağrılacak olan altta yatan kuantizasyon yöntemine iletilecek anahtar kelime argümanlarının sözlüğü.

Desteklenen kuantizasyon türleri

ModelOpt, int8, fp8, int4, nf4 ve nvfp4 için yalnızca ağırlık, kanal ve blok kuantizasyonunu destekler. Kuantizasyon yöntemleri, modelin çıkarım sırasında performansını korurken model ağırlıklarının bellek ayak izini azaltmak üzere tasarlanmıştır.

Sadece ağırlık kuantizasyonu, model ağırlıklarını belirli bir düşük bit veri türünde saklar ancak bfloat16 gibi daha yüksek hassasiyetli bir veri türüyle hesaplama yapar. Bu, model ağırlıklarından kaynaklanan bellek gereksinimini azaltır ancak aktivasyon hesaplama için bellek zirvelerini korur.

Desteklenen kuantizasyon yöntemleri aşağıdaki gibidir:

Kantizasyon Türü	Desteklenen Şemalar	Zorunlu Kwargs	Ek Notlar
INT8	int8 weight only, int8 channel quantization, int8 block quantization	quant_type, quant_type + channel_quantize, quant_type + channel_quantize + block_quantize
FP8	fp8 weight only, fp8 channel quantization, fp8 block quantization	quant_type, quant_type + channel_quantize, quant_type + channel_quantize + block_quantize
INT4	int4 weight only, int4 block quantization	quant_type, quant_type + channel_quantize + block_quantize	channel_quantize = -1 is only supported for now
NF4	nf4 weight only, nf4 double block quantization	quant_type, quant_type + channel_quantize + block_quantize + scale_channel_quantize + scale_block_quantize	channel_quantize = -1 and scale_channel_quantize = -1 are only supported for now
NVFP4	nvfp4 weight only, nvfp4 block quantization	quant_type, quant_type + channel_quantize + block_quantize	channel_quantize = -1 is only supported for now

Mevcut kuantizasyon yöntemlerini ve kullanılabilen kapsamlı yapılandırma seçenekleri listesini daha iyi anlamak için resmi modelopt belgelerine başvurun.

Kantize modellerin seri hale getirilmesi ve dizide çıkarılması

Belirtilen bir dtype ile kuantize edilmiş bir modeli serialize etmek için, önce modeli istenen kuantizasyon dtype'i ile yükleyin ve ardından save_pretrained() yöntemini kullanarak kaydedin.

import torch
from diffusers import AutoModel, NVIDIAModelOptConfig
from modelopt.torch.opt import enable_huggingface_checkpointing

enable_huggingface_checkpointing()

model_id = "Efficient-Large-Model/Sana_600M_1024px_diffusers"
quant_config_fp8 = {"quant_type": "FP8", "quant_method": "modelopt"}
quant_config_fp8 = NVIDIAModelOptConfig(**quant_config_fp8)
model = AutoModel.from_pretrained(
    model_id,
    subfolder="transformer",
    quantization_config=quant_config_fp8,
    dtype=torch.bfloat16,
)
model.save_pretrained('path/to/sana_fp8', safe_serialization=False)

Serileştirilmiş bir kuantize modeli yüklemek için from_pretrained() yöntemini kullanın.

import torch
from diffusers import AutoModel, NVIDIAModelOptConfig, SanaPipeline
from modelopt.torch.opt import enable_huggingface_checkpointing

enable_huggingface_checkpointing()

quantization_config = NVIDIAModelOptConfig(quant_type="FP8", quant_method="modelopt")
transformer = AutoModel.from_pretrained(
    "path/to/sana_fp8",
    subfolder="transformer",
    quantization_config=quantization_config,
    dtype=torch.bfloat16,
)
pipe = SanaPipeline.from_pretrained(
    "Efficient-Large-Model/Sana_600M_1024px_diffusers",
    transformer=transformer,
    dtype=torch.bfloat16,
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"
prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt, num_inference_steps=50, guidance_scale=4.5, max_sequence_length=512
).images[0]
image.save("output.png")