Vergelijk payload, bestandsidentiteit en apparaatprofielen

import numpy as np

import math

import hashlib

import json

import numbers

import re

# Jouw functies

def tensor_payload(parameters,weight_bits,tokens,layers,kv_heads,head_dim,cache_bits=16):
    parameters=_dev_int(parameters,1,10**9);weight_bits=_dev_int(weight_bits,4,32)
    if weight_bits not in (4,8,16,32):raise ValueError('Ondersteunde oefenbitbreedte vereist')
    tokens=_dev_int(tokens,0,32768);layers=_dev_int(layers,1,128);kv_heads=_dev_int(kv_heads,1,128);head_dim=_dev_int(head_dim,1,256)
    cache_bits=_dev_int(cache_bits,16,32)
    if cache_bits not in (16,32):raise ValueError('De oefencache gebruikt 16 of 32 bits')
    weights=(parameters*weight_bits+7)//8;cache=(2*tokens*layers*kv_heads*head_dim*cache_bits+7)//8
    return {'weight_payload_bytes':weights,'kv_payload_bytes':cache,'minimum_bytes':weights+cache,'minimum_mib':(weights+cache)/2**20}

def verify_artifacts(manifest,blobs):
    if type(manifest) is not dict or set(manifest)!={'model_id','revision','dtype','files'}:raise ValueError('Een volledig vast manifest vereist')
    model=manifest['model_id'];revision=manifest['revision'];dtype=manifest['dtype'];files=manifest['files']
    if type(model) is not str or re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_.-]{0,63}/[A-Za-z0-9][A-Za-z0-9_.-]{0,63}',model) is None:raise ValueError('Een vaste modeleigenaar en modelnaam vereist')
    if type(revision) is not str or re.fullmatch('[0-9a-f]{40}',revision) is None:raise ValueError('Een volledige vaste revisie vereist')
    if type(dtype) is not str or dtype not in ('q4','q8','fp16','fp32'):raise ValueError('Een ondersteunde variant vereist')
    if type(files) is not list or not 1<=len(files)<=8 or type(blobs) is not dict:raise ValueError('Een tot acht lokale bestandjes vereist')
    rows=[];names=set();total=0
    for row in files:
        if type(row) is not dict or set(row)!={'name','bytes','sha256'}:raise ValueError('Bestandsnaam, grootte en hash vereist')
        name=_dev_id(row['name']);size=_dev_int(row['bytes'],1,65536);expected=row['sha256']
        if name in names or type(expected) is not str or re.fullmatch('[0-9a-f]{64}',expected) is None:raise ValueError('Unieke namen en volledige SHA-256 vereist')
        names.add(name);total+=size;rows.append({'name':name,'bytes':size,'sha256':expected})
    if total>262144 or set(blobs)!=names:raise ValueError('Begrensde complete bestandenset vereist')
    for row in rows:
        value=blobs[row['name']]
        if type(value) not in (bytes,bytearray) or len(value)!=row['bytes']:raise ValueError('Werkelijke grootte wijkt af')
        if hashlib.sha256(value).hexdigest()!=row['sha256']:raise ValueError('Werkelijke hash wijkt af')
    canonical={'model_id':model,'revision':revision,'dtype':dtype,'files':sorted(rows,key=lambda row:row['name'])}
    key=hashlib.sha256(json.dumps(canonical,sort_keys=True,separators=(',',':')).encode('utf-8')).hexdigest()
    return {'model_id':model,'revision':revision,'dtype':dtype,'verified_bytes':total,'files':sorted(names),'cache_key':key}

def select_profile(profiles,budget):
    if type(profiles) not in (list,tuple) or not 1<=len(profiles)<=16:raise ValueError('Een tot zestien oefenprofielen vereist')
    cleaned=[_dev_profile(profile) for profile in profiles]
    if len({row['id'] for row in cleaned})!=len(cleaned):raise ValueError('Unieke profiel-IDs vereist')
    if type(budget) is not dict or set(budget)!={'device','context','available_backends','limits'}:raise ValueError('Een volledig apparaatbudget vereist')
    device=_dev_id(budget['device']);context=_dev_context(budget['context']);backends=budget['available_backends'];limits=budget['limits']
    if type(backends) not in (list,tuple) or not 1<=len(backends)<=2 or any(type(value) is not str or value not in ('wasm','webgpu') for value in backends) or len(set(backends))!=len(backends):raise ValueError('Beschikbare bekende backends vereist')
    if type(limits) is not dict or set(limits)!={'max_download_bytes','max_peak_bytes','max_ttft_ms','min_tokens_per_second','min_quality'}:raise ValueError('Expliciete bovengrenzen en ondergrenzen vereist')
    caps={'max_download_bytes':_dev_int(limits['max_download_bytes'],0,10**12),'max_peak_bytes':_dev_int(limits['max_peak_bytes'],0,10**12),
        'max_ttft_ms':_dev_number(limits['max_ttft_ms'],0,10**9),'min_tokens_per_second':_dev_number(limits['min_tokens_per_second'],0,10**6),'min_quality':_dev_number(limits['min_quality'],0,1)}
    eligible=[];reasons={}
    for row in cleaned:
        m=row['measurements'];failed=[]
        for name,condition in [('device',row['device']!=device),('context',row['context']!=context),('backend',row['backend'] not in backends),
            ('download',m['download_bytes']>caps['max_download_bytes']),('memory',m['peak_bytes']>caps['max_peak_bytes']),
            ('ttft',m['ttft_ms']>caps['max_ttft_ms']),('throughput',m['tokens_per_second']<caps['min_tokens_per_second']),('quality',m['quality']<caps['min_quality'])]:
            if condition:failed.append(name)
        if failed:reasons[row['id']]=failed
        else:eligible.append(row)
    eligible.sort(key=lambda row:(-row['measurements']['quality'],-row['measurements']['tokens_per_second'],row['measurements']['ttft_ms'],row['id']))
    return {'chosen_id':eligible[0]['id'] if eligible else None,'eligible_ids':sorted(row['id'] for row in eligible),'rejected':reasons}

# Gegeven helpers

def _dev_int(value,low,high):
    if type(value) is not int or not low<=value<=high:raise ValueError('Begrensde Python-int vereist')
    return value

def _dev_number(value,low,high):
    if isinstance(value,bool) or not isinstance(value,numbers.Real):raise ValueError('Begrensde reële scalar vereist')
    try:number=float(value)
    except (OverflowError,ValueError,TypeError):raise ValueError('Begrensde reële scalar vereist') from None
    if not math.isfinite(number) or not low<=number<=high:raise ValueError('Begrensde reële scalar vereist')
    return number

def _dev_id(value):
    if type(value) is not str or re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_.-]{0,63}',value) is None:raise ValueError('Korte vaste identificatie vereist')
    return value

def _dev_context(context):
    if type(context) is not dict or set(context)!={'input_tokens','output_tokens','cold'} or type(context['cold']) is not bool:raise ValueError('Gelijke gemeten prompt-, generatie- en cachecondities vereist')
    return {'input_tokens':_dev_int(context['input_tokens'],1,32768),'output_tokens':_dev_int(context['output_tokens'],1,4096),'cold':context['cold']}

def _dev_profile(profile):
    if type(profile) is not dict or set(profile)!={'id','device','backend','context','measurements'}:raise ValueError('Een volledig gemeten oefenprofiel vereist')
    name=_dev_id(profile['id']);device=_dev_id(profile['device']);backend=profile['backend'];context=_dev_context(profile['context']);m=profile['measurements']
    if type(backend) is not str or backend not in ('wasm','webgpu'):raise ValueError('Een bekende backend vereist')
    if type(m) is not dict or set(m)!={'download_bytes','peak_bytes','ttft_ms','tokens_per_second','quality'}:raise ValueError('Alle vijf waarnemingen vereist')
    measurements={'download_bytes':_dev_int(m['download_bytes'],0,10**12),'peak_bytes':_dev_int(m['peak_bytes'],1,10**12),
        'ttft_ms':_dev_number(m['ttft_ms'],0,10**9),'tokens_per_second':_dev_number(m['tokens_per_second'],.000001,10**6),'quality':_dev_number(m['quality'],0,1)}
    return {'id':name,'device':device,'backend':backend,'context':context,'measurements':measurements}

Voer de code uit en verklaar voor jezelf waarom elke stap werkt.