File size: 5,968 Bytes
23ce76a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | # /// script
# requires-python = ">=3.11"
# dependencies = [
# "torch>=2.1,<2.7",
# "transformers>=4.46,<4.50",
# "datasets",
# "hqq>=0.2.8",
# "accelerate",
# "tqdm",
# "huggingface_hub",
# ]
# ///
"""
HSAQ-quantize the LoRA-merged guardian model for swarm serving.
Source: mxguru1/master-chief-guardian-8b-v1 (bf16 merged, 16 GB)
Output: HSAQ-quantized state_dict + tokenizer + config in
mxguru1/master-chief-guardian-8b-v1-hsaq (HF dataset)
This is Phase 1A of the wargame thesis-test. The artifact is then loaded
by a local FastAPI shim (Phase 1B) that mimics Ollama's endpoints, so the
wargame can route to it via LOCAL_HF_SHIMS in adversarial_wargame_swarm.py.
Cost: ~$1.50, ~30 min on A100 80GB.
"""
from __future__ import annotations
import json, logging, os, subprocess, sys, time
from datetime import UTC, datetime
from pathlib import Path
import torch
if not torch.cuda.is_available():
subprocess.check_call([sys.executable, "-m", "pip", "install", "torch", "--force-reinstall",
"--index-url", "https://download.pytorch.org/whl/cu124"])
import importlib; importlib.reload(torch)
if not torch.cuda.is_available(): sys.exit(1)
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s | %(message)s")
logger = logging.getLogger("GuardianHSAQ")
sys.path.insert(0, "/opt/hsaq")
from quantization.hsaq.config import HSAQConfig
from quantization.hsaq.pipeline import HSAQPipeline
MODEL_ID = "mxguru1/master-chief-guardian-8b-v1"
HF_TOKEN = os.environ.get("HF_TOKEN")
RUN_TAG = datetime.now(UTC).strftime("%Y%m%d_%H%M%S")
OUT = Path("/tmp/guardian_hsaq"); OUT.mkdir(parents=True, exist_ok=True)
def main():
start = time.time()
report = {"run_tag": RUN_TAG, "approach": "hsaq_quantize_for_serving", "model_id": MODEL_ID}
try:
cfg = HSAQConfig(
model_id=MODEL_ID,
output_dir=str(OUT.parent),
hf_token=HF_TOKEN,
gpu_budget_gb=11.2,
enable_2bit=False,
enable_pruning=False,
train_lora=False, # already LoRA-merged
calibration_samples=128,
)
pipe = HSAQPipeline(cfg)
logger.info("Stage 1: load + profile %s", MODEL_ID)
model, tokenizer = pipe._load_model()
model = model.to("cuda:0")
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
sensitivity = pipe.profiler.profile(model)
candidates = pipe._build_layer_candidates(sensitivity, model)
from quantization.hsaq.assignment import assign_bit_widths
weight_budget_gb = pipe._compute_weight_budget()
assignment = assign_bit_widths(candidates, weight_budget_gb)
name_to_bits = {a.component: a.chosen.bits for a in assignment.assignments}
logger.info("Stage 2: HQQ apply to all 281 Linears")
n_hqq = pipe._apply_per_module_hqq(model, name_to_bits, device="cuda:0")
logger.info("HQQ applied to %d Linears", n_hqq)
# Save model artifact
artifact_dir = OUT / "guardian-hsaq"
artifact_dir.mkdir(parents=True, exist_ok=True)
try:
from hqq.models.hf.base import AutoHQQHFModel
AutoHQQHFModel.save_quantized(model, str(artifact_dir))
save_method = "AutoHQQHFModel.save_quantized"
except Exception as exc:
logger.warning("AutoHQQHFModel.save_quantized failed (%s); falling back to state_dict", exc)
torch.save(model.state_dict(), artifact_dir / "pytorch_model.bin")
save_method = "state_dict"
tokenizer.save_pretrained(str(artifact_dir))
model.config.save_pretrained(str(artifact_dir))
# Per-layer bits manifest for the shim
manifest = {
"model_id": MODEL_ID,
"save_method": save_method,
"n_linears_quantized": n_hqq,
"name_to_bits": name_to_bits,
"group_size": 64,
"axis": 0,
"compute_dtype": "bfloat16",
"total_weight_gb": round(assignment.total_weights_gb, 3),
}
(artifact_dir / "hsaq_manifest.json").write_text(json.dumps(manifest, indent=2))
report["artifact"] = manifest
report["artifact_size_bytes"] = sum(p.stat().st_size for p in artifact_dir.rglob("*") if p.is_file())
logger.info("Artifact saved: %s (%.2f GB)", artifact_dir, report["artifact_size_bytes"] / 1e9)
# Upload as dataset (HQQ artifacts aren't standard HF model format; dataset is fine)
from huggingface_hub import HfApi
repo_id = "mxguru1/master-chief-guardian-8b-v1-hsaq"
api = HfApi(token=HF_TOKEN)
api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True)
for p in artifact_dir.rglob("*"):
if p.is_file():
api.upload_file(
path_or_fileobj=str(p),
path_in_repo=p.name,
repo_id=repo_id,
repo_type="dataset",
)
logger.info("Uploaded artifact to https://huggingface.co/datasets/%s", repo_id)
report["status"] = "success"
report["artifact_repo"] = repo_id
except Exception as e:
logger.exception("Run failed")
report["status"] = "failed"
report["error"] = repr(e)
finally:
report["elapsed_s"] = round(time.time() - start, 1)
# Always upload the report
from huggingface_hub import HfApi
api = HfApi(token=HF_TOKEN)
rid = f"mxguru1/guardian-hsaq-job-{RUN_TAG}"
try:
api.create_repo(repo_id=rid, repo_type="dataset", exist_ok=True)
p = OUT / "report.json"; p.write_text(json.dumps(report, indent=2))
api.upload_file(path_or_fileobj=str(p), path_in_repo="report.json", repo_id=rid, repo_type="dataset")
except Exception:
pass
if __name__ == "__main__":
main()
|