7 TB de pesos: com saber si valen alguna cosa

Un model és, sobretot, una muntanya de nombres

Un model de llenguatge no desa frases, ni regles, ni una base de dades de respostes. Desa nombres: milions en un de petit i bilions en els més grans. Cada vegada que escriu una paraula fa amb ells una llarga cadena de multiplicacions i sumes, i d'aquí surt la següent.

Aquests nombres s'anomenen paràmetres, i els que s'aprenen, pesos. Quan es descarrega un model es baixen, sobretot, aquests nombres, més dos fitxers petits: la configuració, que diu com estan ordenats, i el tokenitzador, que trosseja el text en les peces amb què treballa el model.

Que siguin «només nombres» no és un detall tècnic. D'això depèn quant ocupa un model, en quin ordinador hi cap, com es pot comprovar sense executar-lo i què pot anar malament en obrir el fitxer. Tot s'entén millor amb un exemple real i petit, mesurat per nosaltres.

Un paràmetre és un nombre que es pot ajustar

Un paràmetre és com un dels milers de comandaments d'una taula de mescles: tot sol no vol dir res, però entre tots decideixen què sona. Entrenar un model és moure tots aquests comandaments alhora, una mica a cada pas, fins que el que surt s'assembla al que ha de sortir.

El nombre de paràmetres és la xifra que acompanya el nom de gairebé qualsevol model, i cal llegir-la amb compte. El 135M de SmolLM2-135M són uns 135 milions. Un model «de 14T» presumeix d'uns 14 bilions, i cada bilió és un milió de milions.

No és una xifra opaca: amb la configuració del model es pot calcular a mà. Ho vam fer el 2 de novembre de 2026 amb SmolLM2-135M.

SmolLM2: 134.515.008 nombres comptats a mà

SmolLM2-135M és un model de llenguatge petit publicat per HuggingFaceTB, un equip de Hugging Face, l'empresa nord-americana d'origen francès a la plataforma de la qual es publiquen la majoria dels models oberts. El seu repositori es va crear el 31 d'octubre de 2024, té llicència Apache 2.0 i s'ha descarregat 2.392.045 vegades en els darrers 30 dies. Són 10 fitxers, i el dels pesos, model.safetensors, ocupa 269.060.552 bytes.

El seu config.json en dona les mesures: un vocabulari de 49.152 peces, 576 nombres per descriure cadascuna, 30 capes i una mida intermèdia de 1.536. Amb això surt el compte. La taula de paraules té 49.152 × 576 = 28.311.552 nombres. Cada capa en suma 884.736 a la primera peça principal, 2.654.208 a la segona i 1.152 en dues normalitzacions: 3.540.096, que per 30 capes donen 106.202.880. Queda una normalització final de 576.

Total: 134.515.008 paràmetres. La taula de paraules es compta una sola vegada perquè el model la fa servir tant per llegir com per escriure, i així ho declara la seva configuració amb tie_word_embeddings. El nom arrodoneix: 135M.

Per què un model ocupa el que ocupa

Si un model és una llista de nombres, la seva mida és gairebé una multiplicació: nombre de paràmetres per bytes per nombre. A SmolLM2, 134.515.008 × 2 = 269.030.016 bytes. El fitxer real pesa 269.060.552. En sobren 30.536, i no són cap error: són la capçalera, 8 bytes que diuen quant mesura i 30.528 de text amb l'índex del que ve darrere.

La regla escala sense sorpreses. Un model d'un bilió de paràmetres a 2 bytes per nombre són 2 bilions de bytes, 2 TB, abans de comptar res més. Per això els models grans es reparteixen en centenars de fitxers i es mesuren en terabytes. I per això, per a un mateix model, la manera de fer que ocupi menys és desar cada nombre en menys bytes.

Els pesos van ordenats en tensors

Els 134.515.008 nombres de SmolLM2 no van solts: estan repartits en 272 tensors. El més gran, model.embed_tokens.weight, és la taula de paraules: 49.152 files, una per cada peça del vocabulari, i 576 columnes. D'altres són minúsculs: model.layers.0.input_layernorm.weight és un vector de 576 nombres.

El nom diu on va cadascun: layers.0 és la primera capa, i mlp, self_attn o layernorm, la peça d'aquella capa. La forma diu quants nombres té: només cal multiplicar-ne les dimensions. Sumant les formes dels 272 tensors torna a sortir 134.515.008, el mateix que el compte fet amb la configuració.

Què hi ha dins d'un fitxer safetensors

Un safetensors té tres parts i cap sorpresa. Els primers 8 bytes són un nombre: la longitud de la capçalera. Després ve la capçalera, un text en format JSON amb una entrada per tensor: el nom, el tipus de nombre, la forma i en quin byte comença i acaba. I darrere, tots els nombres seguits, sense res més.

A SmolLM2 la capçalera mesura 30.528 bytes, de manera que els nombres comencen al byte 30.536. La primera entrada diu que model.embed_tokens.weight és BF16, té forma 49.152 × 576 i ocupa de la posició 0 a la 56.623.104 de la zona de dades. I 8 + 30.528 + 269.030.016 dona la mida exacta del fitxer: no queda ni un byte per explicar.

Que no hi hagi codi és la gràcia del format. La documentació de Transformers, la biblioteca de Hugging Face per fer servir models, ho resumeix així: els pesos de PyTorch s'han desat tradicionalment amb pickle, «que se sap que és insegur», i els fitxers safetensors «són més segurs i més ràpids de carregar».

El mateix model en GGUF

Hi ha una versió de SmolLM2 en GGUF: la Instruct, la variant preparada per conversar, que bartowski, un usuari de Hugging Face, ha convertit i publicat amb la mateixa llicència. El fitxer en Q4_K_M ocupa 105 MB, davant dels 269 de l'original.

La seva capçalera també es llegeix sense baixar tot el fitxer: en vam demanar els primers 4 MB i en van bastar 1.785.944 bytes. Diu: magic GGUF, que és la signatura del format; versió 3; 272 tensors, els mateixos que el safetensors; 37 claus de metadades; arquitectura llama, i file_type 15, que segons l'especificació vol dir Q4_K_M.

105 MB en lloc de 269: menys bits per nombre

La diferència entre 269 i 105 MB és la quantització, i Q4_K_M és el nom d'una de les seves receptes en GGUF. El nom enganya una mica: la capçalera mostra que no tot va amb el mateix nombre de bits. La recepta barreja diversos tipus, i deixa sense comprimir, en F32, els vectors petits, com els de normalització.

El principi no canvia: la mida és, més o menys, el nombre de paràmetres per allò que ocupa cadascun. La quantització només toca el segon factor.

Après o a l'atzar: es nota en la forma dels nombres

Un model comença amb nombres a l'atzar i l'entrenament els dona estructura. Es nota mirant només els nombres? Ho vam comprovar amb SmolLM2: al costat de cada tensor real hi vam posar soroll generat amb NumPy, la biblioteca de càlcul numèric de Python, amb la mateixa forma i la mateixa desviació típica. Mateixa mida, mateixa dispersió; només canvia si hi ha aprenentatge al darrere.

La primera diferència és als extrems. El soroll és una campana ben rodona. Una matriu real de la capa 15 (q_proj) també concentra els valors a prop del zero, però en té molts més de molt allunyats: els seus extrems arriben a més del doble de distància que els del soroll. Són cues pesades, i la taula de la secció següent les mesura.

La segona és a les normalitzacions, les peces que reajusten l'escala dels nombres entre un pas i el següent amb un vector de pesos propi. En aquestes peces, 1 és el valor neutre, el que deixa l'escala tal com està. A SmolLM2 vam mesurar els de les capes 0, 7, 15, 22 i 29, i cap no té tots els valors a 1. Els de les capes 7, 15, 22 i 29 tenen mitjanes d'entre 0,31 i 0,42; el de la 15, 0,34. L'excepció és la capa 0: el seu vector surt amb mitjana 0,001, centrat en el zero com el soroll.

El significat també deixa empremta

La prova més intuïtiva és a la taula de paraules. Amb el tokenitzador de SmolLM2 vam buscar quina fila correspon a cada paraula i vam mesurar la semblança entre parells, en el model real i en la seva còpia de soroll. En el real, els parells relacionats, com king i queen o Paris i France, surten per damunt dels que no ho són, com king i banana. En el de soroll, tots voregen el zero.

Un avís honest: a SmolLM2, dos tokens qualssevol ja s'assemblen un +0,45 de mitjana, perquè tots comparteixen una direcció comuna. Els parells sense relació que vam triar, de +0,18 a +0,22, queden per sota d'aquesta mitjana, i per això el +0,62 de king i queen no es pot llegir tot sol. El que compta és que, a la còpia de soroll, tots els parells, relacionats o no, donen pràcticament zero.

Amb un model de 269 MB, tot això triga 3,2 segons. Un de 7,72 TB no es pot baixar sencer per provar-lo, però sí que se'n poden mirar fragments.

Abans de descarregar: fitxa, mida i capçalera

Abans de baixar un model gran hi ha comprovacions que costen segons i no obliguen a descarregar els pesos. La primera és la fitxa i l'API pública del Hub de Hugging Face: qui el publica, quan es va crear, amb quina llicència, quantes descàrregues té i la llista de fitxers amb la seva mida. Allà es veu si hi ha fitxers .py, que són codi, i si hi ha fitxers pickle (.bin, .pt, .pkl). A SmolLM2: 10 fitxers, ni codi ni pickle, en mig segon.

La segona és el compte de la mida: paràmetres per bytes per nombre ha de donar, gairebé exactament, el que ocupen els pesos. Si un repositori promet una xifra de paràmetres i els fitxers no hi quadren, hi ha alguna cosa per explicar.

La tercera és llegir només la capçalera del safetensors amb una petició HTTP de rang, la que demana un tros concret d'un fitxer en lloc del fitxer sencer. La documentació de Hugging Face ho proposa: és «molt senzill i eficient» obtenir la llista de tensors, els seus tipus i les seves formes «amb petites peticions HTTP de rang». Es demanen els bytes 0 a 7, es llegeixen com un enter de 64 bits sense signe en ordre little-endian, que dona la longitud de la capçalera, i es demana el tram següent fins a completar-la. A SmolLM2 van ser uns 30 KB i 1,2 segons, en lloc de 269 MB.

Queden dues comprovacions sobre el que es pot executar en carregar el model —el codi i el format pickle— i una última sobre els nombres: mesurar si semblen apresos, com a les dues seccions anteriors, i, si algú publica una recepta per generar-los, reproduir-la.

Si demana trust_remote_code, executarà codi de l'autor

La documentació de Transformers ho diu sense embuts: cal anar amb «precaució extra» en carregar un model personalitzat, perquè, encara que el Hub analitza cada repositori a la recerca de programari maliciós, convé anar amb compte per «evitar executar sense voler codi maliciós». I proposa una capa més de seguretat: carregar-lo «des d'una revisió concreta», per no rebre codi que hagi canviat.

A la pràctica són dos gestos. Llegir els .py com a text abans de carregar res, per veure si obren connexions, llancen processos o executen text com si fos codi. I fixar la revisió: l'identificador de la versió exacta del repositori que s'ha llegit, per carregar aquesta i no la que hi hagi demà.

Pickle, el format que pot executar codi en obrir-se

La documentació del Hub ho adverteix: «hi ha atacs perillosos d'execució arbitrària de codi que es poden perpetrar en carregar un fitxer pickle». Hugging Face analitza els pickles que s'hi pugen i el que importen, però reconeix que això «no és infal·lible al cent per cent» i que comprovar si alguna cosa és segura «és responsabilitat de l'usuari». La sortida és preferir safetensors.

El seu escàner de programari maliciós té, a més, un límit escrit: «passem per un escàner de programari maliciós tots els fitxers dels vostres repositoris de menys de 2 GB». És una dada que convé tenir a mà en mirar el cas següent.

numbat: 7,72 TB que diuen ser d'Anthropic

burner22/numbat és un repositori de Hugging Face que, segons el seu README —el text de presentació del repositori—, conté un punt de control filtrat d'un model d'Anthropic —l'empresa que desenvolupa Claude— d'uns 14 bilions de paràmetres i amb «numbat» com a nom en clau. No consta cap pronunciament d'Anthropic. El seu fitxer de metadades declara el pas d'entrenament 1.830.000 i unes puntuacions que no hem verificat.

L'API, consultada el 2 de novembre a les 10:31, en dona el retrat: autor burner22; creat el 23 d'octubre de 2026 i modificat per última vegada el 24; 5.846 descàrregues i 248 «m'agrada»; 784 fitxers, dels quals 772 són fragments .safetensors que sumen 7,72 TB, cadascun d'entre 5,8 i 10,4 GB. Hi ha 2 fitxers .py, cap pickle, i el README proposa, com a alternativa de càrrega, trust_remote_code=True.

Quadren els 14 bilions? Les metadades del Hub compten 6,83 bilions de nombres de 8 bits (U8) i 16.900 milions en BF16. El repositori declara el format NVFP4, de 4 bits: si cada U8 empaqueta dos nombres de 4 bits, en surten uns 13,7 bilions. És una interpretació nostra, no verificada.

I la dada d'abans, posada al costat: segons la seva documentació, el Hub passa per l'escàner de programari maliciós els fitxers de menys de 2 GB, i els de numbat pesen entre 5,8 i 10,4 GB. Què suposa això per a aquest repositori no ho hem comprovat.

Una recepta reprodueix part dels seus nombres

L'1 de novembre, l'usuari FloxUnder va obrir al repositori la discussió «43 complete tensors exactly match name-seeded NumPy RNG output»: 43 tensors complets coincideixen exactament amb el que dona el generador aleatori de NumPy quan se li dona com a llavor el seu nom. La recepta que publica és aquesta: es calcula l'empremta SHA-256 del nom del tensor, els seus 8 primers bytes es llegeixen com un enter big-endian sense signe i aquest nombre és la llavor del generador PCG64 de NumPy; es treuen nombres d'una normal en float32, s'aplica exp(0,06·z) a les normalitzacions i z/6 a les convolucions, i es passa a BF16.

Segons el seu autor, 43 tensors complets, 730.368 valors, surten idèntics bit a bit, i n'havia predit 21 més abans de llegir-los. Ell mateix hi posa el límit: «Aquestes coincidències per si soles no poden excloure lògicament un entrenament que hagués mantingut congelats expressament tots aquests paràmetres. Tampoc no autentiquen el suposat origen a Anthropic».

La nostra reproducció va fer servir la revisió fixada 6b7f8fc i va baixar 295 KB per rang en 6,9 segons. La recepta, aplicada a 5 tensors complets del primer fitxer —tres normalitzacions de 12.288 valors i dos filtres de convolució de 24.576 i 49.152—, coincideix byte a byte en tots 5, i les empremtes de dos d'ells són les que publica la discussió. Com a control, la mateixa recepta amb la llavor d'un altre nom no coincideix. I el vector de normalització surt amb mitjana 1,003; el de SmolLM2 tenia 0,34.

Les matrius grans i els dos fitxers de codi

La recepta no ho explica tot. En els primers 4.096 valors de quatre matrius grans (embed_tokens, down_proj, q_proj i o_proj), la semblança amb la sèrie generada amb el seu nom com a llavor és la mateixa que amb la d'un altre nom: pràcticament nul·la. Tres tenen cues pesades, com una matriu entrenada; la taula de paraules surt amb forma de campana en aquest fragment.

Això no demostra ni que siguin autèntiques ni que siguin falses. Vam mirar els primers 4.096 valors de matrius d'entre 75,5 i 1.610 milions de valors i no vam comprovar els tensors de 4 bits, que són gairebé tot el model. El que sí que queda provat és més modest: almenys una part dels tensors de numbat surt d'un generador de nombres aleatoris que fa servir com a llavor el seu propi nom.

Els dos .py, llegits només com a text, defineixen la configuració i l'arquitectura del model. Importen math, typing, torch i transformers, i no hi apareixen os.system, subprocess, requests, eval, exec, open ni pickle. Que avui siguin innocus no canvia la regla: el que s'ha examinat és una revisió concreta, el repositori pot canviar i trust_remote_code=True executa el que hi hagi a la revisió que es carregui.

Els passos de la prova

Tot es va fer el 2 de novembre entre les 10:29 i les 10:33, amb Python 3.12 i NumPy, sense PyTorch ni Transformers. No es va carregar cap model ni es va executar cap codi descarregat, i de numbat no se'n va baixar cap fitxer de pesos sencer. Cost: 0 euros.

Cada pas fa servir un script propi i petit que consulta l'API pública del Hub o demana per rang un tros de fitxer, i calcula amb NumPy; les descàrregues es fan amb curl. Els scripts de Python s'executen amb python -I, el mode aïllat, que impedeix que Python importi per sorpresa fitxers de la carpeta de treball; la cerca de text, amb sh.

El que aquesta prova no diu

No diu d'on surt numbat. El seu README afirma que és d'Anthropic, no consta cap pronunciament de l'empresa, i la discussió 13, que hem reproduït en part, apunta a soroll sintètic com a mínim en les normalitzacions i les convolucions. Res d'això no en determina l'origen.

Tampoc no diu si el model funciona ni com: no es va carregar ni executar, i les puntuacions del seu fitxer de metadades continuen sent les que declara el repositori. Vam reproduir 5 dels 43 tensors de la discussió i cap dels 21 predits, i de cada matriu gran en vam mirar un fragment. La lectura dels .py val per a la revisió 6b7f8fc, no per a la que hi hagi demà.

I no és una invitació a descarregar-lo. Qui ho faci, com a mínim, n'hauria de llegir abans el codi, fixar la revisió i tenir present que són 7,72 TB.