Dix-sept modèles téléchargés, un processeur graphique intégré, 14 Go de mémoire partagée avec
le système. Pas de GPU dédié, pas de serveur, pas de facture à la requête.
Beaucoup la décriraient comme insuffisante, et elle l'est en effet pour certaines choses. Mais
elle tourne tous les jours, et sur une partie de mes tâches elle est plus utile qu'une API.
La question n'est pas « est-ce que ça marche », mais « à quoi ça sert, et jusqu'à quand ».
Ce que 14 Go veulent dire pour un modèle
Un modèle occupe de la mémoire pour trois raisons, et il faut les trois.
- Les poids. Sept milliards de paramètres en 4 bits, environ 4,5 Go. En 8 bits, le double. En 16 bits, quatre fois plus.
- Le cache de contexte. Chaque token occupe de la mémoire, pour chaque couche. Il croît avec la longueur du contexte, et c'est souvent lui qui fait déborder, pas les poids.
- Le runtime. Quelques centaines de mégaoctets, plus ce que le système utilise déjà.
Sur un iGPU, il n'y a pas de VRAM séparée : le graphique intégré prend sa mémoire dans les
14 Go systèmes. Un modèle de 7B en 4 bits laisse de quoi respirer. Un 14B en 4 bits frôle la
limite et ne supporte pas un contexte long. Au-delà de 30B, ce n'est pas une question de
patience : ça ne rentre pas.
La taille du modèle est une contrainte dure, pas un réglage : aucun paramètre d'Ollama ne fera
tenir 40 Go dans 14.
Dix-sept modèles sur le disque, un seul en mémoire
Avoir dix-sept modèles ne veut pas dire en faire tourner dix-sept. Ollama charge un modèle quand
une requête arrive, le garde quelques minutes, puis le décharge quand un autre arrive.
ollama list # ce qui est sur le disque
ollama ps # ce qui est réellement chargé, et pour combien de temps
ollama ps est la commande que je regarde le plus : elle explique pourquoi une requête
« rapide » prend parfois quinze secondes. Le modèle était froid.
Deux conséquences. Un modèle à la fois : deux 7B chargés ensemble, et la machine échange sur le
disque, avec un ralentissement d'un facteur dix, pas deux. Et le premier token coûte cher : sur
un usage interactif, la latence de chargement se sent ; sur un lot de deux cents documents, elle
est amortie.
Là où le local gagne, sans discussion
Les données qui ne sortent pas. Un document client, un export de base, un journal
d'incident : tout ça part chez un fournisseur dès qu'on appelle une API. En local, ça reste sur
le disque. Ce n'est pas une opinion sur la confidentialité, c'est une différence de nature.
Le volume régulier. Classer deux mille lignes, extraire des champs de trois cents factures,
reformater du texte : le coût par appel, multiplié par le volume, devient un budget. En local,
le coût marginal est de l'électricité.
L'absence de limite de débit. Pas de quota, pas de 429, pas de fenêtre de tokens à
surveiller. Un script qui traite toute la nuit ne s'arrête pas au bout de cent requêtes.
La reproductibilité. Le même modèle, la même version, le même fichier de poids dans six
mois. Une API change de modèle derrière son nom sans prévenir, et une sortie qui marchait cesse
de marcher sans qu'une ligne de code ait bougé.
Là où l'API gagne, et il faut le dire
Le contexte long. Un document de cent pages, une base de code entière : sur 14 Go, le cache
de contexte devient le facteur limitant bien avant la qualité du modèle.
Le raisonnement difficile. Un petit modèle produit des réponses plausibles et fausses sur
les problèmes à plusieurs étapes. Il n'échoue pas bruyamment : il échoue avec assurance.
La vision et l'audio. Ceux qui tiennent dans 14 Go existent, mais leur qualité n'est pas
comparable : pour lire un graphique ou transcrire une réunion, l'API reste devant.
La latence sur les gros modèles. Un 70B sur une API répond en quelques secondes ; le même en
local ne rentre pas.
La maintenance. Un modèle local, c'est plusieurs gigaoctets à télécharger et une version à
figer. Une API, c'est une clé.
Router selon la tâche
Le code ne fait pas de magie : il choisit un modèle selon la tâche et appelle Ollama en HTTP
local.
import json, urllib.request
def local(prompt: str, modele: str, contexte: int = 4096) -> str:
req = urllib.request.Request(
"http://127.0.0.1:11434/api/generate",
data=json.dumps({
"model": modele,
"prompt": prompt,
"stream": False,
"keep_alive": "10m", # le modèle chaud reste 10 min en mémoire
"options": {"num_ctx": contexte, "temperature": 0.2},
}).encode(),
headers={"Content-Type": "application/json"},
)
with urllib.request.urlopen(req, timeout=300) as r:
return json.loads(r.read())["response"]
TACHES = {
"classer": ("petit-modele-3b", 2048),
"extraire": ("petit-modele-3b", 4096),
"resumer": ("moyen-modele-7b", 8192),
}
Deux réglages comptent plus que le choix du modèle. num_ctx explicite : la valeur par défaut
peut être plus grande que nécessaire, et le cache de contexte est ce qui fait planter une
machine à 14 Go. keep_alive à dix minutes : sur un lot de deux cents documents, ça évite de
recharger le modèle entre chaque appel ; sur un usage sporadique, ça libère la mémoire.
Ce que la mesure tranche
Je ne publie pas de tokens par seconde, parce que le chiffre ne veut rien dire sans le modèle,
la quantification, la longueur de contexte et la machine. Je mesure trois choses.
- Est-ce que ça tient dans une conversation interactive ? Une réponse après vingt secondes sur une question courte fait du local un outil batch, pas un assistant.
- Est-ce que la mémoire reste sous le plafond ? Une machine qui échange sur le disque ment sur ses performances.
- Est-ce que la qualité passe sur vingt cas réels ? Mes documents, mes erreurs, comparés à la main. Pas un benchmark public.
Sur ces trois critères, la répartition est simple : le local prend le volume et la
confidentialité, l'API prend le raisonnement et le multimédia. Le choix se fait par une ligne
dans un dictionnaire.
Dix-sept modèles sur un disque et 14 Go de RAM, ce n'est pas une performance : c'est un poste de
travail qui fait ce qu'il peut faire. Le local ne remplace pas une API, il la complète là où
payer n'a pas de sens et où envoyer les données n'en a pas non plus. La seule erreur serait de
trancher par principe — ça se tranche par tâche, avec une mesure.
Top comments (0)