# /// script # requires-python = ">=3.11" # dependencies = [ # "torch>=2.6", # "transformers>=5.0.0", # "huggingface-hub>=1.0", # "safetensors>=0.5", # "psutil>=6", # "nvidia-ml-py>=12; platform_system == 'Linux'", # ] # /// from __future__ import annotations import argparse import copy import json import math import os import threading import time from pathlib import Path from typing import Any import psutil import torch from huggingface_hub import HfApi, hf_hub_download from transformers import AutoConfig, AutoProcessor, AutoTokenizer class Telemetry: def __init__(self, interval: float = 2.0): self.interval = interval self.stop_event = threading.Event() self.thread = threading.Thread(target=self.run, daemon=True) def start(self): self.thread.start() return self def stop(self): self.stop_event.set() self.thread.join(timeout=3) def run(self): psutil.cpu_percent(interval=None) while not self.stop_event.wait(self.interval): memory = psutil.virtual_memory() payload: dict[str, Any] = { "event": "telemetry", "timestamp": time.time(), "cpu_percent": psutil.cpu_percent(interval=None), "ram_used_gb": round((memory.total - memory.available) / 1024**3, 3), "ram_total_gb": round(memory.total / 1024**3, 3), "ram_percent": memory.percent, "gpu_count": 0, "gpu_name": None, "gpu_util_percent": None, "vram_used_gb": None, "vram_total_gb": None, "vram_percent": None, "gpu_temperature_c": None, } try: import pynvml pynvml.nvmlInit() count = pynvml.nvmlDeviceGetCount() utils, used, total, temps, names = [], 0, 0, [], [] for index in range(count): handle = pynvml.nvmlDeviceGetHandleByIndex(index) util = pynvml.nvmlDeviceGetUtilizationRates(handle) mem = pynvml.nvmlDeviceGetMemoryInfo(handle) name = pynvml.nvmlDeviceGetName(handle) names.append(name.decode() if isinstance(name, bytes) else str(name)) utils.append(float(util.gpu)); used += int(mem.used); total += int(mem.total) try: temps.append(float(pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU))) except Exception: pass payload.update({ "gpu_count": count, "gpu_name": " + ".join(names) if names else None, "gpu_util_percent": round(sum(utils) / len(utils), 1) if utils else None, "vram_used_gb": round(used / 1024**3, 3) if total else None, "vram_total_gb": round(total / 1024**3, 3) if total else None, "vram_percent": round(100 * used / total, 1) if total else None, "gpu_temperature_c": round(sum(temps) / len(temps), 1) if temps else None, }) pynvml.nvmlShutdown() except Exception: pass print(json.dumps(payload), flush=True) def progress(percent: int, stage: str, message: str = "") -> None: print(json.dumps({"event": "progress", "percent": percent, "stage": stage, "message": message}), flush=True) print(f"{percent}% · {stage} · {message}", flush=True) def round_multiple(value: float, multiple: int, minimum: int) -> int: return max(minimum, int(round(value / multiple) * multiple)) def divisors(value: int) -> list[int]: result = [] for item in range(1, int(math.sqrt(value)) + 1): if value % item == 0: result.extend([item, value // item]) return sorted(set(result)) def best_head_count(hidden_size: int, original: int) -> int: choices = [value for value in divisors(hidden_size) if value <= max(1, original)] target = min(max(1, original), max(1, hidden_size // 64)) return min(choices or [1], key=lambda value: abs(value - target)) def resize_layer_sequence(values: list[Any], new_length: int) -> list[Any]: """Resize per-layer metadata while preserving its distribution and final layer.""" if new_length <= 0 or not values: return [] if len(values) == new_length: return list(values) if new_length == 1: return [values[-1]] last = len(values) - 1 indices = [round(index * last / (new_length - 1)) for index in range(new_length)] return [values[index] for index in indices] def scale_config_object(config: Any, ratio: float, overrides: dict[str, Any] | None = None) -> dict[str, Any]: """Scale common Transformer dimensions and keep architecture-coupled fields valid.""" overrides = overrides or {} layer_scale = max(0.18, min(1.0, ratio ** 0.40)) hidden_scale = max(0.22, min(1.0, ratio ** 0.30)) layer_keys = ["num_hidden_layers", "n_layer", "num_layers", "encoder_layers", "decoder_layers", "num_decoder_layers"] hidden_keys = ["hidden_size", "d_model", "n_embd", "model_dim"] ff_keys = ["intermediate_size", "d_ff", "ffn_dim", "encoder_ffn_dim", "decoder_ffn_dim"] head_keys = ["num_attention_heads", "n_head", "encoder_attention_heads", "decoder_attention_heads"] per_layer_keys = ["layer_types", "mlp_layer_types", "block_types", "attention_types"] original_layer_count = getattr(config, "num_hidden_layers", None) per_layer_values = { key: list(value) for key in per_layer_keys if isinstance((value := getattr(config, key, None)), (list, tuple)) } original_heads: dict[str, int] = {} for key in head_keys: value = getattr(config, key, None) if isinstance(value, int) and value > 0: original_heads[key] = value scaled_layer_counts: dict[str, int] = {} for key in layer_keys: value = getattr(config, key, None) if isinstance(value, int) and value > 1: scaled_layer_counts[key] = max(2, int(round(value * layer_scale))) for key, value in scaled_layer_counts.items(): setattr(config, key, value) new_layer_count = getattr(config, "num_hidden_layers", None) if isinstance(new_layer_count, int) and new_layer_count > 0: for key, values in per_layer_values.items(): setattr(config, key, resize_layer_sequence(values, new_layer_count)) max_window_layers = getattr(config, "max_window_layers", None) if isinstance(max_window_layers, int): setattr(config, "max_window_layers", min(max_window_layers, new_layer_count)) # Some hybrid architectures keep additional lists not known in advance. if isinstance(original_layer_count, int) and original_layer_count > 0: for key, value in list(getattr(config, "__dict__", {}).items()): if key in per_layer_keys: continue if isinstance(value, list) and len(value) == original_layer_count and ("layer" in key or "block" in key or "attention" in key): setattr(config, key, resize_layer_sequence(value, new_layer_count)) hidden_value = None for key in hidden_keys: value = getattr(config, key, None) if isinstance(value, int) and value >= 64: scaled = round_multiple(value * hidden_scale, 64, 128) setattr(config, key, scaled) hidden_value = scaled for key in ff_keys: value = getattr(config, key, None) if isinstance(value, int) and value >= 128: setattr(config, key, round_multiple(value * hidden_scale, 128, 256)) if hidden_value: for key, original in original_heads.items(): setattr(config, key, best_head_count(hidden_value, original)) kv = getattr(config, "num_key_value_heads", None) heads = getattr(config, "num_attention_heads", None) if isinstance(kv, int) and isinstance(heads, int): valid = [value for value in divisors(heads) if value <= kv] setattr(config, "num_key_value_heads", max(valid or [1])) head_dim = getattr(config, "head_dim", None) heads = getattr(config, "num_attention_heads", None) if isinstance(head_dim, int) and isinstance(heads, int) and heads: setattr(config, "head_dim", hidden_value // heads) for nested_name in ("text_config", "vision_config", "audio_config", "encoder", "decoder"): nested = getattr(config, nested_name, None) if nested is not None and hasattr(nested, "to_dict"): scale_config_object(nested, ratio, {}) for key, value in overrides.items(): if hasattr(config, key): setattr(config, key, value) # Re-run generic validators before publishing instead of discovering errors at load time. validator = getattr(config, "validate_layer_type", None) if callable(validator): validator() return config.to_dict() if hasattr(config, "to_dict") else {} def choose_loader(config: Any, tags: list[str]): import transformers if bool(getattr(config, "is_encoder_decoder", False)): return getattr(transformers, "AutoModelForSeq2SeqLM") tag_text = " ".join(tags).lower() if any(tag in tag_text for tag in ("image-text-to-text", "any-to-any", "vision-language")): for name in ("AutoModelForMultimodalLM", "AutoModelForImageTextToText", "AutoModelForVision2Seq"): loader = getattr(transformers, name, None) if loader is not None: return loader return getattr(transformers, "AutoModelForCausalLM") def copy_processor(source_model: str, output_dir: Path, token: str) -> str | None: for loader in (AutoProcessor, AutoTokenizer): try: processor = loader.from_pretrained(source_model, token=token, trust_remote_code=True) processor.save_pretrained(output_dir) return loader.__name__ except Exception: continue return None def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Create a compact initialized child model from a source config") parser.add_argument("--source-model", required=True) parser.add_argument("--output-repo", required=True) parser.add_argument("--target-parameters", type=int, required=True) parser.add_argument("--plan-path", default="training_adapter.json") parser.add_argument("--initialize-weights", action="store_true") parser.add_argument("--private", action="store_true") parser.add_argument("--dry-run", action="store_true") return parser.parse_args() def main() -> None: args = parse_args() token = os.environ["HF_TOKEN"] api = HfApi(token=token) telemetry = Telemetry().start() try: progress(3, "inventory", "Reading source and AI blueprint") info = api.model_info(args.source_model, token=token) source_params = None safetensors = getattr(info, "safetensors", None) if safetensors and isinstance(getattr(safetensors, "total", None), (int, float)): source_params = int(safetensors.total) try: plan_path = hf_hub_download(args.output_repo, args.plan_path, token=token) plan = json.loads(Path(plan_path).read_text(encoding="utf-8")) except Exception: plan = {} tags = list(info.tags or []) ratio = min(1.0, args.target_parameters / source_params) if source_params else 0.25 progress(15, "configuration", f"Target ratio {ratio:.3f}") api.create_repo(args.output_repo, repo_type="model", private=args.private, exist_ok=True, token=token) with __import__("tempfile").TemporaryDirectory() as tmp: output_dir = Path(tmp) / "child" output_dir.mkdir(parents=True) build: dict[str, Any] = { "source_model": args.source_model, "source_parameters": source_params, "target_parameters": args.target_parameters, "ratio": ratio, "initialized": False, "processor": None, "loader": None, "status": "scaffold", "errors": [], } config = None try: config = AutoConfig.from_pretrained(args.source_model, token=token, trust_remote_code=True) overrides = ((plan.get("child") or {}).get("config_overrides") or {}) if isinstance(plan, dict) else {} scaled = scale_config_object(config, ratio, overrides) config.save_pretrained(output_dir) (output_dir / "scaled_config.json").write_text(json.dumps(scaled, indent=2), encoding="utf-8") build["status"] = "configured" except Exception as exc: build["errors"].append(f"config: {exc}") (output_dir / "child_blueprint.json").write_text(json.dumps({ "source_model": args.source_model, "target_parameters": args.target_parameters, "plan": plan, "note": "Source does not expose a standard Transformers config. Use the generated TrainingAdapter/custom entrypoint.", }, indent=2), encoding="utf-8") progress(35, "processor", "Copying tokenizer/processor") build["processor"] = copy_processor(args.source_model, output_dir, token) if args.dry_run: progress(80, "dry-run", "Architecture validation complete") elif args.initialize_weights and config is not None: progress(45, "initialization", "Creating compact random-initialized weights") try: loader = choose_loader(config, tags) build["loader"] = loader.__name__ model = loader.from_config(config, trust_remote_code=True) model.save_pretrained(output_dir, safe_serialization=True, max_shard_size="3GB") build["initialized"] = True build["status"] = "initialized" del model if torch.cuda.is_available(): torch.cuda.empty_cache() except Exception as exc: build["errors"].append(f"weights: {exc}") build["status"] = "configured" (output_dir / "child_build.json").write_text(json.dumps(build, indent=2), encoding="utf-8") progress(88, "publish", "Uploading child architecture") api.upload_folder( folder_path=output_dir, repo_id=args.output_repo, repo_type="model", token=token, commit_message="Create distilled child architecture", ) progress(100, "completed", f"Child repository ready: {args.output_repo}") finally: telemetry.stop() if __name__ == "__main__": main()