Una implementación de codificación para comprimir y comparar LLM ajustados por instrucciones con FP8, GPTQ y SmoothQuant Quantization usando llmcompressor

importar subproceso, sys def pip(*pkgs): subproceso.check_call([sys.executable, “-m”, “pip”, “install”, “-q”, *pkgs]) pip(“llmcompressor”, “compressed-tensors”, “transformers>=4.45”, “accelerate”, “datasets”) importar os, gc, time, json, math desde pathlib importar ruta importar antorcha desde transformadores importar AutoModelForCausalLM, AutoTokenizer desde conjuntos de datos importar load_dataset afirmar torch.cuda.is_available(), \ “Habilitar una GPU: Tiempo de ejecución > Cambiar tipo de tiempo de ejecución > GPU T4” print(“GPU:”, torch.cuda.get_device_name(0), “| CUDA:”, torch.version.cuda, “| torch:”, torch.__version__) MODEL_ID = “Qwen/Qwen2.5-0.5B-Instruct” WORKDIR = Path(“/content/quant_lab”); WORKDIR.mkdir(exist_ok=True) os.chdir(WORKDIR) def free_mem(): gc.collect(); torch.cuda.empty_cache() def dir_size_gb(ruta): total = 0 para raíz, _, archivos en os.walk(ruta): para f en archivos: total += os.path.getsize(os.path.join(root, f)) return total / 1e9 def time_generación(modelo, tok, aviso, max_new_tokens=64): “””Decodificación codiciosa; informa latencia & tokens/seg después de un breve calentamiento.””” inputs = tok(prompt, return_tensors=”pt”).to(model.device) _ = model.generate(**inputs, max_new_tokens=4, do_sample=False) torch.cuda.synchronize() t0 = time.time() out = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False, pad_token_id=tok.eos_token_id) torch.cuda.synchronize() dt = time.time() – t0 new_ids = out[0][inputs[“input_ids”].forma[1]:]return tok.decode(new_ids, skip_special_tokens=True), dt, max_new_tokens/dt @torch.no_grad() def wikitext_ppl(model, tok, seq_len=512, max_chunks=20, stride=512): “””Sonda de perplejidad ligera de WikiText-2 (rápida, indicativa).””” ds = load_dataset(“wikitext”, “wikitext-2-raw-v1″, split=”test”) texto = “\n\n”.join(t para t en ds[“text”][:400] if t.strip()) enc = tok(text, return_tensors=”pt”).input_ids.to(model.device) nll_sum, tok_count = 0.0, 0 para comenzar en range(0, enc.size(1) – seq_len, stride): fragmento = enc[:, begin:begin+seq_len]
out = model(chunk, etiquetas=chunk) nll_sum += out.loss.float().item() * seq_len tok_count += seq_len if tok_count // seq_len >= max_chunks: break return math.exp(nll_sum / tok_count) results = {} PROMPT = (“<|im_start|>user\nEn dos oraciones, explique por qué la cuantificación ” ” posterior al entrenamiento funciona para lenguajes grandes models.<|im_end|>\n” “<|im_start|>assistant\n”) def benchmark(label, model_path_or_id): free_mem() print(f”\n──── benchmarking: {label} ────”) tok = AutoTokenizer.from_pretrained(model_path_or_id) m = AutoModelForCausalLM.from_pretrained( model_path_or_id, torch_dtype=”auto”, device_map=”cuda”).eval() sample, dt, tps = time_generation(m, tok, PROMPT) ppl = wikitext_ppl(m, tok) size = dir_size_gb(model_path_or_id) if os.path.isdir(str(model_path_or_id)) else Ningunos resultados[label] = {“size_gb”: tamaño, “ppl”: round(ppl, 3), “latency_s”: round(dt, 3), “tok_per_s”: round(tps, 1), “sample”: sample.strip().replace(“\n”, ” “)[:180]} print(json.dumps(resultados[label]sangría=2)) del m; memoria_libre()