MoEDiet: codice e parametri del Job

requests/4af9bd4213d54162b4aec991fb2a55a7/fidelity.py

@@ -0,0 +1,69 @@
+"""Compare next-token distributions on held-out, original-model greedy continuations."""
+
+from dataclasses import dataclass
+
+import torch
+
+from routing import continuation, encode
+
+
+@dataclass
+class Trace:
+    group: str
+    prefix: torch.Tensor  # Input through the penultimate token, on CPU.
+    original: torch.Tensor  # Log probabilities for the generated positions, on CPU.
+
+
+@torch.inference_mode()
+def log_probs(model, prefix, steps):
+    out = model(input_ids=prefix.to(model.get_input_embeddings().weight.device), use_cache=False,
+                output_router_logits=False, logits_to_keep=steps, return_dict=True)
+    logp = out.logits[0].float().log_softmax(-1).cpu()
+    if logp.shape[0] != steps or not torch.isfinite(logp).all():
+        raise ValueError('Log-probabilità mancanti o non finite.')
+    return logp
+
+
+@torch.inference_mode()
+def make_traces(model, tokenizer, groups, steps):
+    traces = []
+    for group, prompts in groups.items():
+        for prompt in prompts:
+            ids = encode(model, tokenizer, prompt, reserve=steps)
+            sequence = continuation(model, tokenizer, ids, steps)
+            used = sequence.shape[1] - ids.shape[1]  # EOS may shorten the reference.
+            if used < 1:
+                raise ValueError('Il modello di riferimento ha generato una continuazione vuota.')
+            prefix = sequence[:, :-1].cpu()
+            traces.append(Trace(group, prefix, log_probs(model, prefix, used)))
+    return traces
+
+
+def replay(model, traces):
+    return [log_probs(model, trace.prefix, len(trace.original)) for trace in traces]
+
+
+def compare(traces, candidate, reference=None):
+    if reference is None:
+        reference = [t.original for t in traces]
+    totals = {}
+    for trace, base, new in zip(traces, reference, candidate, strict=True):
+        # Sum over vocab then positions; per-group means use the number of generated positions.
+        base, new = base.double().log_softmax(-1), new.double().log_softmax(-1)
+        difference = base - new
+        delta = (base.exp() * difference).sum().item()
+        hits = (base.argmax(-1) == new.argmax(-1)).sum().item()
+        row = totals.setdefault(trace.group, {'prompts': 0, 'tokens': 0, 'kl_sum': 0.0, 'hits': 0, 'peak': 0.0})
+        row['prompts'] += 1
+        row['tokens'] += len(base)
+        row['kl_sum'] += delta
+        row['hits'] += hits
+        row['peak'] = max(row['peak'], difference.abs().max().item())
+    return {name: {'prompts': row['prompts'], 'tokens': row['tokens'],
+                   'kl_nats_per_token': max(0.0, row['kl_sum'] / row['tokens']),
+                   'top1_agreement': row['hits'] / row['tokens'],
+                   'max_abs_logp_delta': row['peak']} for name, row in totals.items()}
+
+
+def passes(metrics, limit):
+    return bool(metrics) and all(m['kl_nats_per_token'] <= limit for m in metrics.values())

requests/4af9bd4213d54162b4aec991fb2a55a7/gguf_export.py

@@ -0,0 +1,131 @@
+"""Export an accepted MoEDiet run to a quantized GGUF using native llama.cpp."""
+
+import argparse
+from collections import Counter
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+import tempfile
+
+from llama_tools import get_tools, sha256
+
+QTYPES = ('Q4_K_M', 'Q4_0')
+
+
+def model_config(run, report):
+    cfg = json.loads((run / 'checkpoint' / 'config.json').read_text(encoding='utf-8'))
+    native = report['routing']
+    if (not report.get('checkpoint') or not report.get('checkpoint_audit', {}).get('passed')
+            or cfg.get('model_type') != 'olmoe' or cfg['num_experts'] != report['retained_per_layer']
+            or cfg['num_experts_per_tok'] != native['experts_per_token']
+            or cfg['num_hidden_layers'] != native['num_layers']
+            or not cfg['num_experts_per_tok'] <= cfg['num_experts'] < native['experts_per_layer']):
+        raise ValueError('Il checkpoint non corrisponde al taglio accettato nel report.')
+    # The pinned native OLMoE graph has these semantics. Refuse variants it would silently change.
+    if (cfg.get('norm_topk_prob', False) or cfg.get('clip_qkv') is not None or cfg.get('attention_bias', False)
+            or cfg.get('rope_scaling') or cfg.get('hidden_act', 'silu') != 'silu'
+            or cfg.get('rms_norm_eps', 1e-5) != 1e-5
+            or cfg.get('num_key_value_heads', cfg['num_attention_heads']) != cfg['num_attention_heads']):
+        raise ValueError('Configurazione OLMoE fuori dal profilo GGUF verificato (AllenAI 0125).')
+    return cfg
+
+
+def check_gguf(file, source, cfg, qtype):
+    sys.path.insert(0, str(source / 'gguf-py'))
+    try:
+        from gguf import GGUFReader, LlamaFileType
+    finally:
+        sys.path.pop(0)
+    reader = GGUFReader(str(file))
+    expected = {'general.architecture': 'olmoe', 'general.file_type': int(getattr(LlamaFileType, 'MOSTLY_' + qtype)),
+                'olmoe.block_count': cfg['num_hidden_layers'], 'olmoe.expert_count': cfg['num_experts'],
+                'olmoe.expert_used_count': cfg['num_experts_per_tok']}
+    for key, value in expected.items():
+        if key not in reader.fields or reader.fields[key].contents() != value:
+            raise ValueError(f'Metadato GGUF errato o mancante: {key}')
+    names = {f'blk.{i}.ffn_{axis}_exps.weight' for i in range(cfg['num_hidden_layers'])
+             for axis in ('gate', 'up', 'down')}
+    experts = {tensor.name: tensor for tensor in reader.tensors if '_exps.weight' in tensor.name}
+    if set(experts) != names or any(len(t.shape) != 3 or t.shape[2] != cfg['num_experts'] for t in experts.values()):
+        raise ValueError('Tensori degli esperti mancanti o dimensione errata nel GGUF.')
+    counts = Counter(t.tensor_type.name for t in experts.values())
+    if counts['Q4_K' if qtype == 'Q4_K_M' else 'Q4_0'] == 0:
+        raise ValueError(f'Nessuna matrice degli esperti quantizzata realmente in {qtype}.')
+    return dict(counts)
+
+
+def export_run(run, qtype='Q4_K_M', llama_dir=None, bin_dir=None):
+    run = Path(os.path.expandvars(str(run))).expanduser().resolve()
+    if llama_dir:
+        llama_dir = Path(os.path.expandvars(str(llama_dir))).expanduser()
+    if bin_dir:
+        bin_dir = Path(os.path.expandvars(str(bin_dir))).expanduser()
+    if qtype not in QTYPES:
+        raise ValueError(f'Quantizzazione sconosciuta: {qtype}')
+    report = json.loads((run / 'report.json').read_text(encoding='utf-8'))
+    if report['status'] != 'pruned':
+        if report['status'] not in ('mask_only', 'mask_only_checkpoint_audit_failed',
+                                    'unchanged_audit_failed', 'unchanged_no_candidate'):
+            raise ValueError(f"Stato della build sconosciuto: {report['status']}")
+        print(f"GGUF saltato: {report['status']}. Nessun checkpoint fisico accettato.", flush=True)
+        return None
+    cfg = model_config(run, report)
+    dest = run / 'gguf' / qtype
+    if dest.exists():
+        raise ValueError(f'Esiste già un export {qtype}: {dest}')
+    tools = get_tools(llama_dir, bin_dir)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix='.convert-', dir=dest.parent) as tmp:
+        work = Path(tmp)
+        stage = work / 'publish'
+        stage.mkdir()
+        fp16, result = work / 'intermediate-f16.gguf', stage / f'model-{qtype}.gguf'
+        env = os.environ.copy()
+        env.pop('NO_LOCAL_GGUF', None)
+        print(f'Conversione del checkpoint in F16, poi {qtype}...', flush=True)
+        subprocess.run([sys.executable, str(tools.source / 'convert_hf_to_gguf.py'), str(run / 'checkpoint'),
+                        '--outtype', 'f16', '--outfile', str(fp16)], env=env, check=True)
+        subprocess.run([str(tools.quantize), str(fp16), str(result), qtype], check=True)
+        counts = check_gguf(result, tools.source, cfg, qtype)
+        smoke_cmd = [str(tools.cli), '-m', str(result), '-ngl', '0',
+                     '--no-warmup', '--no-display-prompt', '--check-tensors', '--ignore-eos', '-c', '64',
+                     '-t', '2', '-n', '2', '--temp', '0', '-p', 'print(1)']
+        smoke = subprocess.run(smoke_cmd, stdin=subprocess.DEVNULL, capture_output=True, timeout=600)
+        logs = smoke.stderr.decode('utf-8', errors='replace')
+        out = smoke.stdout.decode('utf-8', errors='replace')
+        prefill = re.search(r'prompt eval time\s*=[^\n/]+/\s*([1-9]\d*)\s+tokens?', logs)
+        decode = re.search(r':\s*eval time\s*=[^\n/]+/\s*([1-9]\d*)\s+(?:runs?|tokens?)', logs)
+        if not prefill or not decode:
+            m = re.search(r'Prompt:\s*([0-9.]+)\s*t/s\s*\|\s*Generation:\s*([0-9.]+)\s*t/s', out)
+            if m:
+                prefill = (None, '2')
+                decode = (None, '2')
+        if smoke.returncode or not prefill or not decode:
+            raise ValueError('Smoke test llama-cli fallito.\n' + (logs + '\n' + out)[-2200:])
+        record = {'file': result.name, 'quantization': qtype, 'bytes': result.stat().st_size,
+                  'sha256': sha256(result), 'llama_cpp_revision': tools.revision,
+                  'layers': cfg['num_hidden_layers'], 'experts_per_layer': cfg['num_experts'],
+                  'experts_per_token': cfg['num_experts_per_tok'], 'expert_tensor_types': counts,
+                  'smoke': {'backend': 'llama.cpp/CPU', 'requested_tokens': 2, 'passed': True,
+                            'prompt_tokens_evaluated': int(prefill[1]), 'decode_steps': int(decode[1])},
+                  'post_quantization_task_quality_measured': False}
+        (stage / 'conversion.json').write_text(json.dumps(record, indent=2) + '\n', encoding='utf-8')
+        stage.rename(dest)
+    print(f'GGUF verificato: {dest / result.name}', flush=True)
+    return dest
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--run', required=True, type=Path)
+    parser.add_argument('--qtype', choices=QTYPES, default=QTYPES[0])
+    parser.add_argument('--llama-dir', type=Path)
+    parser.add_argument('--bin-dir', type=Path)
+    args = parser.parse_args()
+    try:
+        export_run(args.run, args.qtype, args.llama_dir, args.bin_dir)
+    except (ValueError, OSError, ImportError, subprocess.SubprocessError) as error:
+        sys.exit(f'Errore: {error}')

requests/4af9bd4213d54162b4aec991fb2a55a7/hf_jobs.py

@@ -0,0 +1,88 @@
+"""Private, revision-pinned code submission and durable outputs for HF Jobs."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import tempfile
+from uuid import uuid4
+
+from huggingface_hub import HfApi, get_token
+
+HERE = Path(__file__).resolve().parent
+IMAGE = 'pytorch/pytorch:2.8.0-cuda12.8-cudnn9-devel@sha256:a7103283ea7113e10ae5d014bd2342acebda0bc53164b2f7b1dd6eb7a766bdb6'
+SOURCES = ('moediet.py', 'probes.py', 'routing.py', 'fidelity.py', 'gguf_export.py', 'llama_tools.py',
+           'run.py', 'hf_jobs.py', 'requirements.txt', 'requirements-q4.txt')
+# No model, token, local commands, or user-supplied values are interpolated into this program.
+BOOTSTRAP = '''
+import os, sys, subprocess, tempfile
+from pathlib import Path
+subprocess.run([sys.executable, '-m', 'pip', 'install', 'huggingface_hub==0.36.2'], check=True)
+from huggingface_hub import snapshot_download
+repo, prefix = os.environ['MOEDIET_REPO'], os.environ['MOEDIET_CODE']
+with tempfile.TemporaryDirectory() as job:
+    snapshot_download(repo, revision=os.environ['MOEDIET_COMMIT'], allow_patterns=[prefix + '/*'],
+                      local_dir=job, token=os.environ['HF_TOKEN'])
+    code = Path(job) / prefix
+    import json
+    cfg = json.loads((code / 'request.json').read_text())
+    deps = ['-r', str(code / 'requirements-q4.txt'), 'cmake>=3.28,<4'] if cfg['quantization'] else ['-r', str(code / 'requirements.txt')]
+    subprocess.run([sys.executable, '-m', 'pip', 'install', *deps], check=True)
+    subprocess.run([sys.executable, str(code / 'hf_jobs.py')], cwd=job, check=True)
+'''
+
+
+def submit(cfg):
+    token = get_token()
+    if not token:
+        raise ValueError('Autenticarsi con hf auth login oppure impostare HF_TOKEN.')
+    api = HfApi(token=token)
+    repo = cfg['output_repo']
+    # Check access and resolve the input before submitting billable compute.
+    source = api.model_info(cfg['model'], revision=cfg['build'].get('revision'))
+    if not source.sha:
+        raise ValueError('Commit del modello sorgente non disponibile.')
+    api.create_repo(repo_id=repo, private=True, exist_ok=True)
+    if api.model_info(repo).private is not True:
+        raise ValueError('La destinazione esiste ed è pubblica. Scegliere un repository privato.')
+    prefix = 'requests/' + uuid4().hex
+    with tempfile.TemporaryDirectory(prefix='moediet-job-') as tmp:
+        stage = Path(tmp)
+        for name in SOURCES:
+            shutil.copyfile(HERE / name, stage / name)
+        payload = {'model': cfg['model'], 'tags': cfg['tags'], 'quantization': cfg['quantization'],
+                   'build': {**cfg['build'], 'revision': source.sha}}
+        if cfg.get('corpus'):
+            shutil.copyfile(cfg['corpus'], stage / 'corpus.json')
+            payload['corpus'] = 'corpus.json'
+        (stage / 'request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
+        commit = api.upload_folder(repo_id=repo, folder_path=stage, path_in_repo=prefix,
+                                   commit_message='MoEDiet: codice e parametri del Job')
+    job = api.run_job(image=IMAGE, command=['python', '-c', BOOTSTRAP], flavor=cfg['flavor'],
+                      timeout=cfg['timeout'], secrets={'HF_TOKEN': token},
+                      env={'MOEDIET_REPO': repo, 'MOEDIET_CODE': prefix, 'MOEDIET_COMMIT': commit.oid})
+    print(f'Job: {job.url}\nOutput dopo il salvataggio: https://huggingface.co/{repo}/tree/main/runs/{job.id}')
+    return job
+
+
+def worker():
+    from run import execute
+    cfg = json.loads((HERE / 'request.json').read_text(encoding='utf-8'))
+    if 'corpus' in cfg:
+        cfg['corpus'] = str(HERE / 'corpus.json')
+    repo = os.environ['MOEDIET_REPO']
+    api = HfApi(token=os.environ['HF_TOKEN'])
+    prefix = 'runs/' + os.environ['JOB_ID']
+
+    def persist(folder, suffix):
+        remote_path = prefix + ('/' + suffix if suffix else '')
+        commit = api.upload_folder(repo_id=repo, folder_path=folder, path_in_repo=remote_path,
+                                   commit_message=f'MoEDiet: {remote_path}')
+        print(f'Salvato: https://huggingface.co/{repo}/tree/{commit.oid}/{remote_path}', flush=True)
+
+    with tempfile.TemporaryDirectory(prefix='moediet-result-') as tmp:
+        execute(cfg, Path(tmp) / 'result', publish=persist)
+
+
+if __name__ == '__main__':
+    worker()

requests/4af9bd4213d54162b4aec991fb2a55a7/llama_tools.py

@@ -0,0 +1,95 @@
+"""Pinned CPU tools for GGUF conversion and validation, also on Windows ARM64."""
+
+import hashlib
+import os
+import platform
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+
+COMMIT = 'a7a98e0fffed794396b3fbad4dcdbbc184963645'  # llama.cpp b6500
+ARCHIVE_SHA256 = '4d78e6aa4a9124b58dff994416525294fbab2990fe905a640d4cbd26bf563a31'
+TARGETS = ('llama-quantize', 'llama-cli')
+
+
+def sha256(path):
+    digest = hashlib.sha256()
+    with path.open('rb') as stream:
+        while block := stream.read(4 << 20):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+@dataclass(frozen=True)
+class Tools:
+    source: Path
+    quantize: Path
+    cli: Path
+    revision: str
+
+
+def installed(source, binary_dir=None, revision='user-supplied'):
+    source = Path(os.path.expandvars(str(source))).expanduser().resolve()
+    if not (source / 'convert_hf_to_gguf.py').is_file() or not (source / 'gguf-py' / 'gguf').is_dir():
+        raise ValueError(f'Checkout llama.cpp incompleto: {source}')
+    dirs = [Path(os.path.expandvars(str(binary_dir))).expanduser().resolve()] if binary_dir else [
+        source / 'build/bin/Release', source / 'build/bin', source / 'bin']
+    suffix = '.exe' if os.name == 'nt' else ''
+    for directory in dirs:
+        bins = [directory / (name + suffix) for name in TARGETS]
+        if all(file.is_file() for file in bins):
+            return Tools(source, *bins, revision)
+    raise ValueError('Servono llama-quantize e llama-cli della stessa build. Verificare bin_dir.')
+
+
+def get_tools(source=None, binary_dir=None):
+    if source:
+        return installed(source, binary_dir)
+    if binary_dir:
+        raise ValueError('bin_dir richiede llama_dir.')
+    tools_cache = os.environ.get('MOEDIET_TOOLS_CACHE')
+    if tools_cache:
+        root = Path(os.path.expandvars(str(tools_cache))).expanduser().resolve()
+    else:
+        root = (Path.home() / '.cache' / 'moediet').resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    target = root / f'llama-{COMMIT[:12]}-{platform.system()}-{platform.machine()}'
+    if target.exists():
+        return installed(target, revision=COMMIT)
+    if not shutil.which('cmake'):
+        raise ValueError('Installare CMake e un compilatore C++, oppure configurare llama_dir e bin_dir.')
+    print('Preparazione una tantum degli strumenti llama.cpp b6500...', flush=True)
+    with tempfile.TemporaryDirectory(prefix='.tools-', dir=root) as tmp:
+        work = Path(tmp)
+        archive = work / 'llama.tar.gz'
+        url = f'https://codeload.github.com/ggml-org/llama.cpp/tar.gz/{COMMIT}'
+        with urllib.request.urlopen(url, timeout=120) as response, archive.open('wb') as output:
+            shutil.copyfileobj(response, output)
+        if sha256(archive) != ARCHIVE_SHA256:
+            raise ValueError('SHA-256 inatteso per i sorgenti llama.cpp.')
+        with tarfile.open(archive) as tar:
+            tar.extractall(work, filter='data')
+        src, build = work / ('llama.cpp-' + COMMIT), work / 'build'
+        flags = ['-DCMAKE_BUILD_TYPE=Release', '-DGGML_NATIVE=OFF', '-DGGML_CUDA=OFF', '-DLLAMA_CURL=OFF',
+                 '-DLLAMA_BUILD_TESTS=OFF', '-DLLAMA_BUILD_EXAMPLES=OFF', '-DLLAMA_BUILD_SERVER=OFF',
+                 '-DBUILD_SHARED_LIBS=OFF']
+        if os.name == 'nt' and platform.machine().upper() in ('ARM64', 'AARCH64'):
+            flags += ['-G', 'Visual Studio 17 2022', '-A', 'ARM64']
+        subprocess.run(['cmake', '-S', str(src), '-B', str(build), *flags], check=True)
+        subprocess.run(['cmake', '--build', str(build), '--config', 'Release', '--parallel', '4',
+                        '--target', *TARGETS], check=True)
+        compiled = build / 'bin'
+        if (compiled / 'Release').is_dir():
+            compiled = compiled / 'Release'
+        shutil.copytree(compiled, src / 'bin', dirs_exist_ok=True)
+        installed(src)
+        try:
+            src.rename(target)
+        except OSError:
+            if not target.is_dir():  # Two first runs may finish installing simultaneously.
+                raise
+    return installed(target, revision=COMMIT)

requests/4af9bd4213d54162b4aec991fb2a55a7/moediet.py

@@ -0,0 +1,303 @@
+"""MoEDiet MVP: build an OLMoE expert mask and a standard compact HF checkpoint."""
+
+import argparse
+import gc
+import hashlib
+import json
+import math
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import torch
+import transformers
+from transformers import AutoConfig, AutoTokenizer, OlmoeForCausalLM
+
+from fidelity import compare, make_traces, passes, replay
+from probes import clean_tags, make_probes
+from routing import blocks, compact_in_place, continuation, encode, masked, profile, select_experts, validate_rows
+
+DEFAULT_MODEL = 'allenai/OLMoE-1B-7B-0125-Instruct'
+FORMAT = 'moediet.olmoe.mask.v1'
+
+
+def write_json(path, data):
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2, allow_nan=False) + '\n', encoding='utf-8')
+
+
+def local_signature(path):
+    # Check local model identity even when a training run overwrites the same directory.
+    names = ('config.json', 'generation_config.json', 'model.safetensors.index.json', 'tokenizer.json',
+             'tokenizer_config.json', 'special_tokens_map.json', 'added_tokens.json', 'vocab.json',
+             'vocab.txt', 'merges.txt', 'chat_template.jinja')
+    files = sorted({*path.glob('*.safetensors'), *path.glob('*.model'),
+                    *(path / name for name in names if (path / name).is_file())})
+    hashes = hashlib.sha256()
+    for file in files:
+        digest = hashlib.sha256()
+        with file.open('rb') as stream:
+            while chunk := stream.read(4 << 20):
+                digest.update(chunk)
+        hashes.update(file.name.encode('utf-8') + b'\x00' + digest.digest())
+    return hashes.hexdigest()
+
+
+def resolve_source(name, revision, fingerprint):
+    if transformers.__version__ != '4.55.4':
+        raise ValueError('Questo adattatore richiede transformers==4.55.4 (layout del router verificato).')
+    name = os.path.expandvars(str(name))
+    path = Path(name).expanduser()
+    local = path.is_dir()
+    if local and revision:
+        raise ValueError('--revision si applica solo a un modello sullo Hub.')
+    name = str(path.resolve()) if local else name
+    cfg = AutoConfig.from_pretrained(name, revision=revision, trust_remote_code=False)
+    if cfg.model_type != 'olmoe' or getattr(cfg, 'quantization_config', None):
+        raise ValueError('Il MVP richiede pesi OLMoE non quantizzati in formato HF/safetensors.')
+    source = {'kind': 'local' if local else 'hub', 'id': name}
+    if local and fingerprint:
+        source['sha256'] = local_signature(path)
+    if not local:
+        source['revision'] = getattr(cfg, '_commit_hash', None)
+        if not source['revision']:
+            raise ValueError('Impossibile determinare il commit del checkpoint sullo Hub.')
+    return cfg, source
+
+
+def load_model(source, device, dtype):
+    tp = 'auto' if dtype == 'auto' else getattr(torch, dtype)
+    model, info = OlmoeForCausalLM.from_pretrained(
+        source['id'], revision=source.get('revision'), torch_dtype=tp, use_safetensors=True,
+        attn_implementation='eager', output_loading_info=True,
+    )
+    if any(info.get(key) for key in ('missing_keys', 'unexpected_keys', 'mismatched_keys', 'error_msgs')):
+        raise ValueError(f'Pesi incompatibili con il modello: {info}')
+    model.to(device).eval()
+    blocks(model)
+    return model
+
+
+def load_tokenizer(source):
+    return AutoTokenizer.from_pretrained(source['id'], revision=source.get('revision'), trust_remote_code=False)
+
+
+def budgets_for(total, top_k, requested):
+    if not 1 <= top_k <= total:
+        raise ValueError('Numero di esperti o top-k del modello non valido.')
+    if requested is None:
+        requested = []
+        value = top_k
+        while value < total:
+            requested.append(value)
+            value *= 2
+    if any(not top_k <= x <= total for x in requested):
+        raise ValueError(f'Ogni budget deve essere fra {top_k} (routing nativo) e {total}.')
+    return sorted(set(requested) | {total})
+
+
+def topology(cfg):
+    return {'num_layers': cfg.num_hidden_layers, 'experts_per_layer': cfg.num_experts,
+            'experts_per_token': cfg.num_experts_per_tok, 'norm_topk_prob': cfg.norm_topk_prob}
+
+
+def size_of(model):
+    return {'parameters': sum(p.numel() for p in model.parameters()),
+            'parameter_bytes': sum(p.numel() * p.element_size() for p in model.parameters())}
+
+
+def verify_manifest(meta, model, source):
+    if meta.get('format') != FORMAT or meta.get('source') != source or meta.get('routing') != topology(model.config):
+        raise ValueError('La maschera non corrisponde alla sorgente, alla revisione o al routing del modello.')
+    rows = meta.get('expert_mask')
+    validate_rows(model, rows)
+    if meta.get('retained_per_layer') != len(rows[0]):
+        raise ValueError('Il budget dichiarato non corrisponde agli ID nella maschera.')
+
+
+@torch.inference_mode()
+def build(args, work, device):
+    if not (math.isfinite(args.penalty) and args.penalty >= 0 and math.isfinite(args.max_kl) and args.max_kl >= 0):
+        raise ValueError('Lambda e soglia KL devono essere finite e non negative.')
+    if args.eval_tokens < 1:
+        raise ValueError('--eval-tokens deve essere positivo.')
+    tags = clean_tags(args.tags)
+    corpus = make_probes(tags, args.corpus)
+    cfg, source = resolve_source(args.model, args.revision, fingerprint=True)
+    total = cfg.num_experts
+    budgets = budgets_for(total, cfg.num_experts_per_tok, args.budgets)
+    tok = load_tokenizer(source)
+    model = load_model(source, device, args.dtype or 'auto')
+    native = topology(model.config)
+    dtype = str(model.get_input_embeddings().weight.dtype).split('.')[-1]
+    print('Profilazione dei router...', flush=True)
+    score, tokens = profile(model, tok, corpus['profile'], tags, args.penalty)
+    full_size = size_of(model)
+    report = {'source': source, 'routing': native, 'dtype': dtype, 'device': str(device),
+              'torch': str(torch.__version__), 'transformers': transformers.__version__, 'probes': corpus,
+              'profile_tokens_per_layer_by_group': tokens, 'score_by_layer': score.tolist(),
+              'lambda': args.penalty, 'budgets': budgets, 'max_kl_nats_per_token': args.max_kl,
+              'max_continuation_tokens': args.eval_tokens, 'selection': [], 'audit': None,
+              'full_model': full_size, 'checkpoint': None}
+    keep = total
+    status = 'unchanged_no_candidate'
+    if budgets[0] < total:
+        selection = make_traces(model, tok, corpus['select'], args.eval_tokens)
+        for budget in budgets:
+            if budget == total:
+                break   # The identity fallback has KL = 0 by construction.
+            with masked(model, select_experts(score, budget)):
+                metrics = compare(selection, replay(model, selection))
+            passed = passes(metrics, args.max_kl)
+            report['selection'].append({'keep': budget, 'passed': passed, 'groups': metrics})
+            print(f'Budget {budget}/{total}: {"accettato" if passed else "respinto"}', flush=True)
+            if passed:
+                keep = budget
+                break
+        del selection
+    report['selected_before_audit'] = keep
+    rows = select_experts(score, keep)
+    if keep < total:
+        audit = make_traces(model, tok, corpus['audit'], args.eval_tokens)
+        with masked(model, rows):
+            masked_logp = replay(model, audit)
+        metrics = compare(audit, masked_logp)
+        passed = passes(metrics, args.max_kl)
+        report['audit'] = {'keep': keep, 'passed': passed, 'groups': metrics}
+        if passed:
+            status = 'mask_only' if args.mask_only else 'pruned'
+        else:
+            status, keep = 'unchanged_audit_failed', total
+            rows = select_experts(score, total)
+    manifest = {'format': FORMAT, 'source': source, 'routing': native, 'profile_dtype': dtype,
+                'target_tags': tags, 'retained_per_layer': keep, 'expert_mask': rows}
+    verify_manifest(manifest, model, source)
+    if status == 'pruned':
+        print('Esportazione e ricaricamento del checkpoint...', flush=True)
+        path = work / 'checkpoint'
+        compact_in_place(model, rows)
+        model.save_pretrained(path, safe_serialization=True, max_shard_size='2GB')
+        tok.save_pretrained(path)
+        del model
+        gc.collect()
+        compact = load_model({'id': str(path)}, device, dtype)
+        compact_logp = replay(compact, audit)
+        actual = compare(audit, compact_logp)
+        passed = passes(actual, args.max_kl)
+        report['checkpoint_audit'] = {'passed': passed, 'vs_original': actual,
+                                      'vs_mask': compare(audit, compact_logp, masked_logp)}
+        if passed:
+            report['checkpoint'] = {**size_of(compact), 'safetensors_bytes': sum(
+                file.stat().st_size for file in path.glob('*.safetensors'))}
+        else:
+            status = 'mask_only_checkpoint_audit_failed'
+        del compact
+        gc.collect()
+        if not passed:
+            shutil.rmtree(path)  # Only this run's unpublished temporary export.
+    report.update(status=status, retained_per_layer=keep, expert_fraction_removed=1 - keep / total)
+    write_json(work / 'mask.json', manifest)
+    write_json(work / 'report.json', report)
+    return report
+
+
+@torch.inference_mode()
+def generate(args, device):
+    if args.max_new_tokens < 1 or not args.prompt.strip():
+        raise ValueError('Servono un prompt non vuoto e un numero di token positivo.')
+    meta = None
+    if args.mask:
+        if args.revision:
+            raise ValueError('La revisione è già fissata nella maschera.')
+        meta = json.loads(Path(args.mask).read_text(encoding='utf-8'))
+        if meta.get('format') != FORMAT:
+            raise ValueError('Formato maschera non riconosciuto.')
+        original = meta['source']
+        if original['kind'] == 'local' and not Path(original['id']).is_dir():
+            raise ValueError('La directory locale originale registrata nella maschera non è disponibile.')
+        _, source = resolve_source(original['id'], original.get('revision'), fingerprint=True)
+        if source != original:
+            raise ValueError('Il checkpoint originale è cambiato dalla profilazione.')
+    else:
+        _, source = resolve_source(args.model, args.revision, fingerprint=False)
+    dtype = args.dtype or (meta['profile_dtype'] if meta else 'auto')
+    model, tok = load_model(source, device, dtype), load_tokenizer(source)
+    ids = encode(model, tok, args.prompt, reserve=args.max_new_tokens)
+    if meta:
+        verify_manifest(meta, model, source)
+        with masked(model, meta['expert_mask']):
+            seq = continuation(model, tok, ids, args.max_new_tokens)
+    else:
+        seq = continuation(model, tok, ids, args.max_new_tokens)
+    return tok.decode(seq[0, ids.shape[1]:].tolist(), skip_special_tokens=True)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    subs = parser.add_subparsers(dest='command', required=True)
+    builder = subs.add_parser('build', help='Profilazione, selezione, audit ed export')
+    builder.add_argument('--model', default=DEFAULT_MODEL, help='ID Hub o directory OLMoE locale')
+    builder.add_argument('--tags', nargs='+', required=True)
+    builder.add_argument('--out', type=Path, required=True, help='Nuova directory dei risultati')
+    builder.add_argument('--budgets', nargs='+', type=int, help='Esperti conservati per strato, fallback intero automatico')
+    builder.add_argument('--lambda', dest='penalty', type=float, default=0.5)
+    builder.add_argument('--max-kl', type=float, default=0.10, help='Soglia per ogni gruppo, in nat/token')
+    builder.add_argument('--eval-tokens', type=int, default=8)
+    builder.add_argument('--corpus', type=Path, help='JSON di sonde personalizzate')
+    builder.add_argument('--mask-only', action='store_true')
+    builder.add_argument('--gguf', choices=['Q4_K_M', 'Q4_0'], help='Esporta anche il checkpoint in GGUF Q4')
+    builder.add_argument('--llama-dir', type=Path, help='Checkout llama.cpp per --gguf')
+    builder.add_argument('--bin-dir', type=Path, help='Directory degli eseguibili della stessa build')
+    gen = subs.add_parser('generate', help='Inferenza greedy con maschera o checkpoint HF')
+    sources = gen.add_mutually_exclusive_group(required=True)
+    sources.add_argument('--model', help='Checkpoint HF completo o compatto')
+    sources.add_argument('--mask', type=Path, help='Maschera JSON con riferimento al checkpoint originale')
+    gen.add_argument('--prompt', required=True)
+    gen.add_argument('--max-new-tokens', type=int, default=48)
+    for sub in (builder, gen):
+        sub.add_argument('--device', choices=['auto', 'cpu', 'cuda'], default='auto')
+        sub.add_argument('--dtype', choices=['auto', 'float32', 'float16', 'bfloat16'])
+        sub.add_argument('--revision', help='Commit o ref del modello sullo Hub')
+    args = parser.parse_args(argv)
+    device = ('cuda' if torch.cuda.is_available() else 'cpu') if args.device == 'auto' else args.device
+    if args.command == 'generate':
+        if args.mask:
+            args.mask = Path(os.path.expandvars(str(args.mask))).expanduser()
+        if args.model:
+            args.model = os.path.expandvars(str(args.model))
+        print(generate(args, device))
+        return
+    if args.corpus:
+        args.corpus = Path(os.path.expandvars(str(args.corpus))).expanduser()
+    if args.llama_dir:
+        args.llama_dir = Path(os.path.expandvars(str(args.llama_dir))).expanduser()
+    if args.bin_dir:
+        args.bin_dir = Path(os.path.expandvars(str(args.bin_dir))).expanduser()
+    if args.mask_only and args.gguf:
+        raise ValueError('--gguf richiede il checkpoint fisico: non si combina con --mask-only.')
+    if (args.llama_dir or args.bin_dir) and not args.gguf:
+        raise ValueError('--llama-dir e --bin-dir richiedono --gguf.')
+    if args.bin_dir and not args.llama_dir:
+        raise ValueError('--bin-dir richiede --llama-dir.')
+    out = Path(os.path.expandvars(str(args.out))).expanduser().resolve()
+    if out.exists():
+        raise ValueError(f'La destinazione esiste già: {out}. Scegliere una nuova directory.')
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix='.moediet-', dir=out.parent) as temp:
+        stage = Path(temp) / 'result'
+        stage.mkdir()
+        report = build(args, stage, device)
+        stage.rename(out)
+    print(f"{report['status']} | {report['retained_per_layer']}/{report['routing']['experts_per_layer']} esperti/strato | {out}")
+    if args.gguf:
+        from gguf_export import export_run
+        export_run(out, args.gguf, args.llama_dir, args.bin_dir)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except (ValueError, OSError, ImportError, subprocess.SubprocessError) as error:
+        sys.exit(f'Errore: {error}')

requests/4af9bd4213d54162b4aec991fb2a55a7/probes.py

@@ -0,0 +1,90 @@
+"""Small, inspectable probe bank. No generator model or network calls."""
+
+import json
+from pathlib import Path
+
+CONTROL = "__control__"
+SPLITS = ("profile", "select", "audit")
+# Two distinct situations per split. The same stems are used for target and control.
+STEMS = (
+    "Explain the mechanism involved.", "Give a concrete solution and justify it.",
+    "What would you check first, and why?", "Work through a small example.",
+    "Explain what happens next and why.", "Show how you would verify your answer.",
+)
+CASES = {
+    "python": ("A mutable default list accumulates items between calls.", "Read a large CSV lazily using a generator.",
+               "A closure in a loop returns the last index every time.", "Group log entries using collections.defaultdict.",
+               "Two names refer to the same nested list after a shallow copy.", "Test an asynchronous context manager."),
+    "c++": ("A std::vector reallocation invalidates an iterator.", "Transfer sole ownership using std::unique_ptr.",
+            "A lambda captures a local variable by reference and escapes.", "Implement a move constructor for a buffer.",
+            "A std::string_view outlives its backing string.", "Test destruction through a polymorphic base pointer."),
+    "devops": ("A rolling deployment serves traffic before readiness checks pass.", "Roll back a failed deployment without losing logs.",
+               "A deployment succeeds in staging but fails its production health check.", "Choose a threshold for a canary rollback.",
+               "A Kubernetes pod is repeatedly OOMKilled.", "Restore a backup in isolation and verify the restored data."),
+    "docker": ("A source change invalidates every Docker build layer.", "Produce a small runtime image with a multi-stage Dockerfile.",
+               "A file copied into an image disappears under a bind mount.", "Configure a container health check.",
+               "A PID 1 shell does not forward SIGTERM to its child.", "Verify that a named volume survives container replacement."),
+    "postgresql": ("An index is ignored on a low-selectivity column.", "Inspect a slow query with EXPLAIN ANALYZE.",
+                   "Two transactions acquire row locks in opposite order.", "Build a partial index for unprocessed jobs.",
+                   "An old transaction prevents VACUUM from reclaiming tuples.", "Verify a retry after a serialization failure."),
+    "sql": ("A LEFT JOIN loses unmatched rows after a WHERE filter.", "Rank sales totals within each region.",
+            "A join duplicates each invoice total.", "Find customers with no orders using NOT EXISTS.",
+            "COUNT(column) skips NULL values in a grouped query.", "Test a running total when two rows share a date."),
+    "gardening": ("Leaves yellow after overwatering.", "Prepare soil for planting carrots.", "Seedlings bend toward a window.",
+                  "Choose a watering schedule for a clay pot.", "A late frost damages new shoots.", "Check whether stored seeds will germinate."),
+    "navigation": ("A compass bearing differs from true north.", "Estimate walking time using a contour map.", "Two map landmarks seem misaligned.",
+                   "Convert a map scale into walking distance.", "Wind pushes a boat away from its intended bearing.", "Check a position using two bearings."),
+    "music": ("Two strings produce beats when played together.", "Transpose a melody to a new key.", "A chord sounds unstable before resolving.",
+              "Count the pulses in six-eight time.", "Shortening a vibrating string raises its pitch.", "Check whether a recording is in tune."),
+}
+ALIASES = {"cpp": "c++", "postgres": "postgresql"}
+GENERAL = ("gardening", "navigation", "music")
+NEUTRAL = ("A calendar spans a leap day.", "Divide a grocery bill between three friends.",
+           "Two clocks disagree after a battery change.", "Find the median of five distances.",
+           "A queue is served in arrival order.", "Check a temperature conversion by reversing it.")
+GENERIC = ("Introduce a basic concept with a worked example.", "Correct a common beginner mistake.",
+           "Diagnose an unexpected outcome on a typical task.", "Compare two methods for a familiar problem.",
+           "Predict an edge case in a realistic scenario.", "Design a reproducible check for a subtle error.")
+
+
+def clean_tags(tags):
+    names = [t.strip().casefold() for t in tags]
+    names = list(dict.fromkeys(ALIASES.get(t, t) for t in names))
+    if not names or any(t in ('', CONTROL) for t in names):
+        raise ValueError(f"Serve almeno un tag non vuoto. {CONTROL} è riservato.")
+    return names
+
+
+def prompts_for(topic, split_index):
+    cases = CASES.get(topic, GENERIC)
+    return [f"Topic: {topic}. {cases[i]} {STEMS[i]}" for i in range(2 * split_index, 2 * split_index + 2)]
+
+
+def make_probes(tags, custom=None):
+    if custom:
+        corpus = json.loads(Path(custom).read_text(encoding="utf-8"))
+    else:
+        controls = [topic for topic in GENERAL if topic not in tags]
+        corpus = {}
+        for i, split in enumerate(SPLITS):
+            groups = {tag: prompts_for(tag, i) for tag in tags}
+            groups[CONTROL] = [prompt for topic in controls for prompt in prompts_for(topic, i)] or [
+                f"{NEUTRAL[j]} {STEMS[j]}" for j in range(2 * i, 2 * i + 2)]
+            corpus[split] = groups
+    if not isinstance(corpus, dict) or set(corpus) != set(SPLITS):
+        raise ValueError(f"Il corpus richiede esattamente questi split: {SPLITS}")
+    seen = set()
+    for split, groups in corpus.items():
+        if not isinstance(groups, dict) or set(groups) != {*tags, CONTROL}:
+            raise ValueError(f"Gruppi errati in {split}. Servono tutti i tag e {CONTROL}.")
+        for group, prompts in groups.items():
+            if not isinstance(prompts, list) or not prompts:
+                raise ValueError(f"Nessuna sonda in {split}/{group}. Fornire un corpus con esempi distinti.")
+            for prompt in prompts:
+                if not isinstance(prompt, str) or not prompt.strip():
+                    raise ValueError(f"Sonda vuota o non testuale in {split}/{group}.")
+                key = ' '.join(prompt.casefold().split())
+                if key in seen:
+                    raise ValueError(f"Sonda duplicata nel corpus: {prompt!r}")
+                seen.add(key)
+    return corpus

requests/4af9bd4213d54162b4aec991fb2a55a7/request.json

@@ -0,0 +1 @@
+{"model": "allenai/OLMoE-1B-7B-0125-Instruct", "tags": ["python", "c++", "devops"], "quantization": "Q4_K_M", "build": {"device": "cuda", "dtype": "bfloat16", "revision": "b89a7c4bc24fb9e55ce2543c9458ce0ca5c4650e"}}

requests/4af9bd4213d54162b4aec991fb2a55a7/requirements-q4.txt

@@ -0,0 +1,6 @@
+-r requirements.txt
+# Imports used by the pinned upstream GGUF converter.
+mistral-common==1.8.5
+sentencepiece>=0.2,<0.3
+protobuf>=4.25,<8
+PyYAML>=6,<7

requests/4af9bd4213d54162b4aec991fb2a55a7/requirements.txt

@@ -0,0 +1,4 @@
+# Install a PyTorch build for your platform before this file if necessary.
+torch>=2.6,<3
+transformers==4.55.4
+safetensors>=0.4.3,<1

requests/4af9bd4213d54162b4aec991fb2a55a7/routing.py

@@ -0,0 +1,129 @@
+"""OLMoE adapter for Transformers 4.55.4, with native top-k preserved."""
+
+from contextlib import ExitStack, contextmanager
+
+import torch
+from torch import nn
+
+
+def blocks(model):
+    cfg = model.config
+    if cfg.model_type != 'olmoe' or not 1 <= cfg.num_experts_per_tok <= cfg.num_experts:
+        raise ValueError('Richiesto un checkpoint OLMoE con top-k valido.')
+    layers = [layer.mlp for layer in model.model.layers]
+    if not layers or len(layers) != cfg.num_hidden_layers:
+        raise ValueError('Numero di strati OLMoE incoerente.')
+    for block in layers:
+        if not (isinstance(block.gate, nn.Linear) and block.gate.bias is None
+                and isinstance(block.experts, nn.ModuleList)
+                and block.num_experts == block.gate.out_features == len(block.experts) == cfg.num_experts
+                and block.top_k == cfg.num_experts_per_tok):
+            raise ValueError('Layout del router non supportato. Usare la versione Transformers in requirements.txt.')
+    return layers
+
+
+def encode(model, tokenizer, prompt, reserve=0):
+    if tokenizer.chat_template:
+        ids = tokenizer.apply_chat_template([{'role': 'user', 'content': prompt}], tokenize=True,
+                                            add_generation_prompt=True, return_tensors='pt')
+    else:
+        ids = tokenizer(prompt, return_tensors='pt')['input_ids']
+    if not ids.shape[1] or ids.shape[1] + reserve > model.config.max_position_embeddings:
+        raise ValueError(f'Sonda vuota o oltre il contesto: {ids.shape[1]} token + {reserve} riservati.')
+    return ids.to(model.get_input_embeddings().weight.device)
+
+
+def continuation(model, tokenizer, ids, count):
+    pad_id = tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id
+    return model.generate(input_ids=ids, attention_mask=torch.ones_like(ids), max_new_tokens=count,
+                          do_sample=False, num_beams=1, use_cache=True, pad_token_id=pad_id,
+                          return_dict_in_generate=False, output_router_logits=False)
+
+
+@torch.inference_mode()
+def profile(model, tokenizer, groups, tags, penalty):
+    from probes import CONTROL
+
+    layers = blocks(model)
+    experts = model.config.num_experts
+    means, counts = {}, {}
+    for group, prompts in groups.items():
+        sums = torch.zeros(len(layers), experts, dtype=torch.float64)
+        counts[group] = 0
+        for prompt in prompts:
+            ids = encode(model, tokenizer, prompt)
+            # Single unpadded prompt. The backbone returns logits without the LM head or auxiliary loss.
+            routers = model.model(input_ids=ids, use_cache=False, output_router_logits=True,
+                                  return_dict=True).router_logits
+            count = ids.numel()
+            if len(routers) != len(layers):
+                raise ValueError('Logit di uno o più router mancanti.')
+            for i, (block, logits) in enumerate(zip(layers, routers)):
+                if tuple(logits.shape) != (count, experts):
+                    raise ValueError(f'Forma inattesa dei logit del router {i}: {tuple(logits.shape)}')
+                probs = logits.float().softmax(-1)
+                weights, chosen = probs.topk(block.top_k, dim=-1)
+                if block.norm_topk_prob:
+                    weights = weights / weights.sum(-1, keepdim=True)
+                mass = torch.zeros_like(probs).scatter_(-1, chosen, weights)
+                sums[i] += mass.sum(dim=0, dtype=torch.float64).cpu()
+            counts[group] += count   # Every layer has seen these same tokens exactly once.
+        means[group] = sums / counts[group]
+    target = torch.stack([means[tag] for tag in tags]).mean(0)
+    score = target - penalty * means[CONTROL]
+    if not torch.isfinite(score).all():
+        raise ValueError('Lo score contiene valori non finiti.')
+    return score, counts
+
+
+def select_experts(score, keep):
+    # Stable sort resolves equal scores in favour of the lower original ID.
+    ranked = torch.argsort(score, dim=1, descending=True, stable=True)
+    return ranked[:, :keep].sort(dim=1).values.tolist()
+
+
+def validate_rows(model, rows):
+    layers = blocks(model)
+    cfg = model.config
+    if not isinstance(rows, list) or len(rows) != len(layers):
+        raise ValueError('La maschera deve contenere una lista per ogni strato, in ordine.')
+    for row in rows:
+        if (not isinstance(row, list) or not cfg.num_experts_per_tok <= len(row) <= cfg.num_experts
+                or any(type(i) is not int or not 0 <= i < cfg.num_experts for i in row)
+                or row != sorted(set(row)) or len(row) != len(rows[0])):
+            raise ValueError('Maschera non valida: servono ID unici ordinati e un budget uniforme >= top-k.')
+    return layers
+
+
+@contextmanager
+def masked(model, rows):
+    layers = validate_rows(model, rows)
+    with ExitStack() as stack:
+        for block, ids in zip(layers, rows):
+            if len(ids) == block.num_experts:
+                continue
+            excluded = torch.ones(block.num_experts, device=block.gate.weight.device, dtype=torch.bool)
+            excluded[ids] = False
+
+            def mask_logits(module, args, logits, excluded=excluded):
+                return logits.masked_fill(excluded, -torch.inf)
+
+            handle = block.gate.register_forward_hook(mask_logits)
+            stack.callback(handle.remove)
+        yield
+
+
+def compact_in_place(model, rows):
+    # This consumes the original model. Only gate rows are copied, retained MLPs are reused.
+    layers = validate_rows(model, rows)
+    keep = len(rows[0])
+    for block, ids in zip(layers, rows):
+        old = block.gate
+        index = torch.tensor(ids, device=old.weight.device)
+        gate = nn.Linear(old.in_features, keep, bias=False, device=old.weight.device, dtype=old.weight.dtype)
+        gate.weight = nn.Parameter(old.weight.index_select(0, index), requires_grad=old.weight.requires_grad)
+        block.gate = gate
+        block.experts = nn.ModuleList([block.experts[i] for i in ids])
+        block.num_experts = keep
+    model.num_experts = model.config.num_experts = keep
+    model.eval()

requests/4af9bd4213d54162b4aec991fb2a55a7/run.py

@@ -0,0 +1,144 @@
+"""Launch the same MoEDiet pipeline locally or on Hugging Face Jobs."""
+
+import argparse
+import json
+import math
+import os
+import re
+from pathlib import Path
+import subprocess
+import sys
+
+from gguf_export import QTYPES, export_run
+from probes import clean_tags, make_probes
+
+HERE = Path(__file__).resolve().parent
+DEFAULT_MODEL = 'allenai/OLMoE-1B-7B-0125-Instruct'
+BUILD_FLAGS = {'budgets': '--budgets', 'lambda': '--lambda', 'max_kl': '--max-kl',
+               'eval_tokens': '--eval-tokens', 'dtype': '--dtype', 'device': '--device', 'revision': '--revision'}
+
+
+def path_from(base, value):
+    expanded = os.path.expandvars(str(value))
+    path = Path(expanded).expanduser()
+    if path.is_absolute():
+        return str(path.resolve())
+    return str((base / path).resolve())
+
+
+def load_config(filename, tags=None, repo=None):
+    filename = Path(os.path.expandvars(str(filename))).expanduser().resolve()
+    raw = json.loads(filename.read_text(encoding='utf-8-sig'))
+    if not isinstance(raw, dict) or raw.get('mode') not in ('local', 'hf'):
+        raise ValueError('Il profilo JSON richiede mode uguale a local o hf.')
+    local = raw['mode'] == 'local'
+    common = {'mode', 'model', 'tags', 'quantization', 'build', 'corpus'}
+    extra = {'out', 'llama_dir', 'bin_dir'} if local else {'output_repo', 'flavor', 'timeout'}
+    if unknown := set(raw) - common - extra:
+        raise ValueError(f'Chiavi di configurazione sconosciute: {sorted(unknown)}')
+    names = raw.get('tags') if tags is None else tags
+    if not isinstance(names, list) or not all(isinstance(name, str) for name in names):
+        raise ValueError('tags deve essere una lista di stringhe.')
+    cfg = {'mode': raw['mode'], 'tags': clean_tags(names), 'model': raw.get('model', DEFAULT_MODEL),
+           'quantization': raw.get('quantization', 'Q4_K_M'), 'build': raw.get('build', {})}
+    if cfg['quantization'] not in (*QTYPES, None):
+        raise ValueError(f'quantization deve essere null oppure uno tra {QTYPES}.')
+    if not isinstance(cfg['model'], str) or not cfg['model'].strip():
+        raise ValueError('model deve contenere un ID Hub o una cartella locale.')
+    build = cfg['build']
+    if not isinstance(build, dict) or set(build) - set(BUILD_FLAGS):
+        raise ValueError(f'Parametri build consentiti: {list(BUILD_FLAGS)}')
+    for key in ('lambda', 'max_kl'):
+        value = build.get(key, 0)
+        if type(value) not in (int, float) or not math.isfinite(value) or value < 0:
+            raise ValueError(f'Valore non valido per {key}.')
+    if type(build.get('eval_tokens', 8)) is not int or build.get('eval_tokens', 8) < 1:
+        raise ValueError('eval_tokens deve essere un intero positivo.')
+    if 'budgets' in build and (not isinstance(build['budgets'], list) or not build['budgets'] or
+                               any(type(n) is not int or n < 1 for n in build['budgets'])):
+        raise ValueError('budgets deve essere una lista di interi positivi.')
+    if build.get('device', 'auto') not in ('auto', 'cpu', 'cuda') or build.get('dtype', 'auto') not in (
+            'auto', 'float32', 'bfloat16', 'float16'):
+        raise ValueError('device o dtype non valido.')
+    if 'revision' in build and (not isinstance(build['revision'], str) or not build['revision'].strip()):
+        raise ValueError('revision deve essere una stringa non vuota.')
+    if raw.get('corpus'):
+        cfg['corpus'] = path_from(filename.parent, raw['corpus'])
+        make_probes(cfg['tags'], cfg['corpus'])
+    if local:
+        if repo:
+            raise ValueError('--repo si usa con mode=hf.')
+        if not isinstance(raw.get('out'), str) or not raw['out'].strip():
+            raise ValueError('Indicare una nuova cartella out.')
+        cfg['out'] = path_from(filename.parent, raw['out'])
+        local_model = Path(path_from(filename.parent, cfg['model']))
+        if local_model.is_dir():
+            cfg['model'] = str(local_model)
+        for key in ('llama_dir', 'bin_dir'):
+            if raw.get(key):
+                cfg[key] = path_from(filename.parent, raw[key])
+        if cfg.get('bin_dir') and not cfg.get('llama_dir'):
+            raise ValueError('bin_dir richiede llama_dir.')
+    else:
+        from huggingface_hub.utils import validate_repo_id
+        cfg['output_repo'] = repo or raw.get('output_repo')
+        for name in (cfg['model'], cfg['output_repo']):
+            if not isinstance(name, str) or name.count('/') != 1:
+                raise ValueError('HF richiede ID nome/modello. Specificare --repo nome/repo-privato per il risultato.')
+            validate_repo_id(name)
+        if cfg['output_repo'].casefold() == cfg['model'].casefold():
+            raise ValueError('Sorgente e repository di destinazione devono essere distinti.')
+        cfg.update(flavor=raw.get('flavor', 'l4x1'), timeout=raw.get('timeout', '90m'))
+        if not isinstance(cfg['timeout'], str) or not re.fullmatch(r'[1-9]\d*[smhd]', cfg['timeout']):
+            raise ValueError('Timeout non valido (per esempio 90m).')
+        if not isinstance(cfg['flavor'], str) or not re.fullmatch(r'[a-z0-9-]+', cfg['flavor']):
+            raise ValueError('Flavor HF non valido.')
+    return cfg
+
+
+def build_command(cfg, out):
+    cmd = [sys.executable, str(HERE / 'moediet.py'), 'build', '--model', cfg['model'],
+           '--tags', *cfg['tags'], '--out', str(out)]
+    for name, flag in BUILD_FLAGS.items():
+        if name in cfg['build']:
+            value = cfg['build'][name]
+            values = value if isinstance(value, list) else [value]
+            cmd.extend([flag, *map(str, values)])
+    if cfg.get('corpus'):
+        cmd.extend(['--corpus', cfg['corpus']])
+    return cmd
+
+
+def execute(cfg, out, publish=None):
+    subprocess.run(build_command(cfg, out), check=True)
+    if publish:
+        publish(out, '')  # Keep the audited result even if the subsequent conversion fails.
+    if cfg['quantization']:
+        folder = export_run(out, cfg['quantization'], cfg.get('llama_dir'), cfg.get('bin_dir'))
+        if folder and publish:
+            publish(folder, folder.relative_to(out).as_posix())
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--config', type=lambda p: Path(os.path.expandvars(p)).expanduser(), required=True)
+    parser.add_argument('--tags', nargs='+', help='Sostituisce i tag del profilo')
+    parser.add_argument('--repo', help='Repository HF privato di destinazione, nome/repo')
+    parser.add_argument('--dry-run', action='store_true', help='Convalida il piano senza download, upload o Job')
+    args = parser.parse_args(argv)
+    cfg = load_config(args.config, args.tags, args.repo)
+    if args.dry_run:
+        print(json.dumps(cfg, ensure_ascii=False, indent=2))
+        return
+    if cfg['mode'] == 'local':
+        execute(cfg, Path(cfg['out']))
+    else:
+        from hf_jobs import submit
+        submit(cfg)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except (ValueError, OSError, ImportError, subprocess.SubprocessError) as error:
+        sys.exit(f'Errore: {error}')