Vai al contenuto principale
ModelliIntermedio7 min di lettura

Ripple-65B: un dense da 64,8B in Apache-2.0, i conti per girarlo in locale

i
iaLocale Team
•
Ripple-65B: un dense da 64,8B in Apache-2.0, i conti per girarlo in locale

Un modello da 64,8 miliardi di parametri, denso (niente esperti, niente MoE), in licenza Apache 2.0, con un checkpoint progettato per girare su una singola workstation da 128 GB di memoria unificata: Ripple-65B Preview di Ricursive Intelligence è il primo modello di questa taglia che è stato disegnato fin dall'architettura per stare sull'hardware di consumo. È il classico passaggio dall'affitto alla proprietà: qualità da modello frontier, ma su una macchina che è tua, senza token a pagamento e senza dipendere da un data center.

Che cos'è Ripple-65B

Ripple-65B è un Transformer denso: ogni token attiva tutti e 64,8B i parametri, non una parte come nei MoE. La scheda completa è nella model card:

  • 64,8B parametri (129,5 GB in BF16), pretraining da zero su 12 trilioni di token
  • 1M di contesto: fino a 1.048.576 token
  • Architettura thin-and-deep: d_model 5120 e 80 layer, stile Gemma 3N, con un rapporto più alto di layer SWA rispetto al baseline Olmo 3
  • Apache 2.0, in tre varianti: instruct in BF16 e NVFP4, base in BF16

Nei numeri esatti: 129,5 GB di file BF16 diviso 2 byte per parametro fa 64,8B — il "65B" del nome è l'arrotondamento.

Perché denso e non MoE? La scelta è dichiarata nella model card: il modello è stato codesigned per essere addestrato e servito in modo semplice — 40% di MFU in pretraining, sharding standard, nessun kernel custom, nessuna quantizzazione durante l'addestramento (BF16 puro). Il risultato: un modello forte su reasoning e task agentici per la sua taglia, allenato da un team che è cresciuto da 1 a 5 persone.

I numeri: un 65B davanti a MoE dieci volte più grandi

Sui benchmark agentici dichiarati dal laboratorio, Ripple-65B batte modelli open-weight molto più grandi:

Ripple-65BNemotron 3 Ultra 550BMuse Spark Open 816BReflection Beam 501B
ArchitetturaDensoMoEMoEMoE
Parametri totali65B550B816B501B
Parametri attivi65B55B42B23B
TerminalBench 2.180.556.476.480.1
SWE-bench Verified76.571.978.781.6
SWE-bench Pro v2.0 Hard79.130.772.476.5
MMLU89.692.092.692.4

Matematica: AIME 2025 a 98,3. GPQA Diamond: 85,2.

Il punto da tenere a mente: nel denso i parametri attivi sono tutti i parametri. Nel MoE da 501B solo 23B sono attivi per token — quel modello legge circa 46 GB di pesi a token (23B × 2 byte in BF16), contro i 129,5 GB di Ripple. È il motivo per cui un MoE può essere più veloce a parità di banda, ma ha bisogno di 500 GB di memoria per i soli pesi. A 128 GB la scelta è fatta al posto tuo: o quantizzi il denso, o scendi di taglia.

I conti: su quale hardware ci sta

La domanda giusta non è "quanto è grande il modello", ma "quanti byte devo portare in memoria a ogni token e quanta memoria ho":

Checkpoint BF16 (129,5 GB)

  • DGX Spark (128 GB unificati): non ci sta, e non di poco — pesi di 129,5 GB più KV cache più spazio di lavoro. È esattamente per questo che il laboratorio ha pubblicato la variante NVFP4
  • Due GPU da 48 GB (96 GB totali): insufficienti; servono 160 GB, cioè 2 × 80 GB
  • Mac Studio M5 Ultra da 512 GB: ci sta con ampio margine, come per ogni grande modello BF16 — la guida al Mac Studio M5 Ultra vale anche qui

Checkpoint NVFP4 (MLP in 4 bit, attenzione in BF16)

  • Pesa circa 65 GB: sta nei 128 GB della Spark con 131.072 token di contesto, prefix caching attivo e fino a 4 richieste concorrenti
  • Velocità misurata dal laboratorio sulla Spark: ~19,5 tok/s con una richiesta, ~48 tok/s in totale con 4 concorrenti (uscite da 128 token)
  • Per gli ordini di grandezza su banda e memoria unificata, la guida alla memoria unificata è il riferimento

Il costo per token, in locale, è zero: l'unica voce di spesa è l'elettricità di una macchina già in funzione. Il trade-off è la velocità — sulla Spark stai a ~19,5 tok/s, mentre il laboratorio riporta 250 tok/s su 2×B200 in batch 8: con la workstation scambii velocità con proprietà, non il contrario.

Perché il criterio giusto è quello dei parametri attivi

Ripple è l'occasione per fissare il metodo con cui leggi le specifiche di un modello, la stessa della guida alla lettura delle specifiche:

  1. Parametri attivi — determinano la qualità per token e i byte letti a token. 65B attivi significa 129,5 GB letti a token in BF16; il MoE da 501B ne legge circa 46.
  2. Pesi totali contro la tua memoria — 129,5 GB totali in BF16; il NVFP4 è il ponte verso i 128 GB.
  3. La quantizzazione che il vendor ha progettato per il tuo chip — NVFP4 + decodifica speculativa DFlash2 + SGLang stock sul GB10 è un percorso progettato, non una quantizzazione applicata dopo: il laboratorio lo pubblica con i comandi pronti.
  4. Il contesto che il setup reale supporta — 1M è una spec di addestramento; il setup Spark gira a 131K.

Come farlo girare (NVFP4 su DGX Spark)

Setup ufficiale dalla repo NVFP4 — servono Python 3.12 e il toolkit CUDA 13:

hf download ricursiveAI/Ripple-65B-Preview-NVFP4 --include "inference/local/*" --include chat_template.jinja --local-dir ripple
cd ripple/inference/local
python3.12 -m venv .venv && .venv/bin/pip install -r requirements.txt
CUDA_HOME=/usr/local/cuda-13.0 PATH="$PWD/.venv/bin:/usr/local/cuda-13.0/bin:$PATH" python spark.py

spark.py scarica i checkpoint e alza un server OpenAI-compatible su http://127.0.0.1:8000/v1 con modello ripple, con streaming, tool calling e reasoning_content. Verifica che funzioni:

curl http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"ripple","messages":[{"role":"user","content":"Scrivi una binary search in Python."}],"max_tokens":256}'

Se non va: senza chip GB10 (DGX Spark) il percorso NVFP4 non è il tuo — SGLang stock e i kernel Triton deterministici sono costruiti per quello stack. La tua strada è il BF16: servono 140 GB o più di memoria unificata, cioè 2 × 80 GB di GPU o un Mac da 512 GB.

E i limiti?

  • La quantizzazione costa qualcosa: NVFP4 scende da 80,5 a 76,0 su TerminalBench 2.1 e da 89,6 a 89,2 su MMLU. Non è gratis, ma è la quantizzazione più leggera che il laboratorio certifica.
  • 1M di contesto è una spec di addestramento: il setup Spark gira a 131.072 token.
  • È un Preview: post-training relativamente leggero, concentrato sull'agentic coding. Il modello finale potrà cambiare.
  • Addestrato su 12 trilioni di token prevalentemente in inglese e codice: per l'italiano e il francese parti con le aspettative giuste, come spieghiamo in cosa aspettarsi dall'italiano nei modelli locali.
  • 19,5 tok/s non è "veloce" come i modelli da laptop: è il prezzo della qualità frontier su 128 GB. Se il tuo caso d'uso è una chat reattiva, un 7-14B quantizzato su una GPU da 16 GB resta più scattante.

In sintesi

Ripple-65B Preview è il primo modello denso da 64,8B che un laboratorio ha progettato per l'hardware di consumo: Apache 2.0, 1M di contesto, e su TerminalBench 2.1 davanti a MoE con dieci volte i parametri. In locale si gira nella pratica con il checkpoint NVFP4 su una workstation da 128 GB, a ~19,5 tok/s e 131K di contesto: si scambiano velocità e qualche punto di benchmark con la proprietà del modello e dei dati. Il criterio da portarti a casa: leggi i parametri attivi, confronta i pesi totali con la tua memoria e preferisci la quantizzazione che il vendor ha progettato per il tuo chip.

Fonti

Articolo generato con IA

Condividi:

Ti è piaciuto questo articolo?

Iscriviti alla newsletter per ricevere nuovi tutorial e guide.

Dopo l'iscrizione ricevi una email di conferma (double opt-in). Senza conferma non inviamo nulla. Nessuno spam, ti promettiamo.

Articoli Correlati

Risorse correlate

Strumenti e risorse dell'archivio iaLocale pertinenti a questo contenuto.

🌊

Ripple-65B Preview

Modelli

Modello denso da 64,8B parametri di Ricursive Intelligence, Apache 2.0: pretraining da zero su 12T di token, contesto fino a 1M, architettura thin-and-deep (d_model 5120, 80 layer). Puntato all'agentic coding: 80,5 su TerminalBench 2.1 davanti a MoE open-weight fino a 10x più grandi. Checkpoint NVFP4 (MLP 4-bit, attenzione BF16) pensato per una singola workstation da 128 GB unificati (DGX Spark), ~19,5 tok/s single request.

🖥️

AMD Ryzen AI Max+ 395 (Strix Halo)

Hardware

La APU AMD con la massima memoria unificata su x86: fino a 128GB di LPDDR5X condivisa tra CPU (16 core Zen 5), GPU integrata (40 CU RDNA 3.5) e NPU. Fino a 96GB allocabili alla GPU: modelli fino a 100B+ a 4 bit senza GPU dedicata, su mini-PC o laptop. Bandwidth 256 GB/s.

🖥️

Mac Studio (M5 Max)

Hardware

La workstation Apple di fascia alta: M5 Max con 18 core CPU, GPU fino a 40 core con Neural Accelerator e fino a 128GB di memoria unificata a 614 GB/s. Modelli fino a ~120B in 4 bit (e i MoE a bassa attivazione come gpt-oss-120b in tempo quasi reale), con MLX e llama.cpp. 10GbE di serie, Thunderbolt 5, fino a 8 display.

🖥️

Mac Studio (M5 Ultra)

Hardware

Il Mac più potente di Apple: M5 Ultra, primo chip a quattro die (due M5 Max uniti da UltraFusion), fino a 36 core CPU, 80 core GPU e 512GB di memoria unificata a 1,2 TB/s. Pensato per modelli frontier-class in locale: MoE da centinaia di miliardi di parametri e RAG su corpora enormi, senza cloud. Il clustering RDMA di più unità porta fino a 3× l'inferenza distribuita.