Mac Mini M4 : 7B vs 14B — quel écart au quotidien ? (labo 2026)

Beaucoup de gens choisissent le mauvais modèle sur M4 Mac Mini

Nous avons associé deux unités Mac Mini M4 (16 Go et 24 Go) avec le même script sur qwen2.5:7b et qwen2.5:14b (2026-05-28 au 06-03). Comprenez pourquoi les choses se cassent, puis utilisez les tables de décision à la fin ; journaux bruts §8.3 atouts de reproductibilité. Pour le modèle d'effondrement complet, voir Benchmarks du laboratoire LLM local M4 Mac Mini (Hub).

Trois choses d'abord (avant 7B vs 14B)

Avant de nommer une balise de modèle, alignez le cadre de décision. L’UX Local se décompose en :

• Est-ce que ça va échanger (pouvoir de veto ; nombre de paramètres de battement)
• Le premier virage est-il assez rapide (TTFT) (Les agents font souvent plus de mal ici que les tok/s en régime permanent)
• La tâche nécessite-t-elle une qualité supérieure (le codage inter-fichiers est l'endroit où 14B paie la latence)

Beaucoup de gens ne regardent que le troisième – « ai-je besoin de 14B ? » – et sautent les deux premiers. C’est là que commencent les mauvais choix. tok/s répond principalement « après le début de la génération, à quelle vitesse » ; une fois l'échange activé, les numéros du classement ne correspondent plus à la sensation quotidienne.

Organigramme de décision (échange → Agent → puis 7B/14B)

Vérifiez d'abord la RAM/le swap, puis si vous exécutez un agent, puis 7B vs 14B :

Série de décisions LLM locales M4 Mac Mini

ID de laboratoire : m4-16gb-lab-01 · m4-24gb-lab-02 · Ollama 0.6.2 · macOS 15.4.1

1. Doublez les paramètres ≠ doublez l'expérience

7B vs 14B équivaut à « 2 × paramètres » sur le papier, mais sur Mac Mini, trois contraintes s'appliquent à la fois :

• Taille du poids : au quatrième trimestre, 7B ~ 4,5 Go, 14B ~ 9 Go – ce dernier consomme près de deux fois la marge L1 ; avec la croissance du KV, 16 Go ne laissent presque aucune place à « Chrome en arrière-plan ».
• Plafond de bande passante : même matrice M4 ; le décodage analyse toujours le flux de poids complet de chaque jeton : 14B est naturellement plus lent que 7B lorsque la mémoire est propre et suffisante (médiane de 24 Go ~ 15 contre ~ 51 tok/s), pas parce que macOS est paresseux.
• Pression non linéaire : une fois la RAM maximale, les hits d'échange - tok/s ne glisse pas de manière linéaire mais passe de ~ 10 à ~ 3 - voir laboratoire complet « effondrement en trois phases » ; 14B sur 16Go entre plus facilement dans la dernière phase.

La question d’achat devient donc : Votre charge de travail principale peut-elle payer la « taxe mémoire » de 14B et un décodage plus lent ? Le 14B n’est pas un « pire modèle » – c’est un modèle à mémoire: une utilisation stable dépend du niveau de mémoire unifiée, et non du seul nombre de paramètres.

1.1 Modèle à trois états 14B (mémoire fermée, pas encore de balises finales)

14B n’est pas « un cran en dessous » – c’est fermé par niveau de RAM: les mêmes poids peuvent être une zone d'effondrement, un point idéal ou une zone stable de haute qualité.

Pour le béton 7b contre 14b les balises voir le organigramme et Tableaux §8.4.

2. Méthode de test et équité

Matériel : Mac Mini M4 de base, GPU 10 cœurs, bande passante mémoire unifiée d'environ 120 Go/s ; deux configurations 16 GB et 24 Go. Logiciel : macOS 15.4, Ollama 0.6.2, Q4_K_M (GGUF) par défaut.

2.1 Variables fixes

2.2 Scénario

chmod +x resources/benchmark-7b-14b-ollama.sh
./resources/benchmark-7b-14b-ollama.sh qwen2.5:7b
./resources/benchmark-7b-14b-ollama.sh qwen2.5:14b

Script du benchmark Lab partagé (même lignée que benchmark-m4-mac-mini-ollama.sh dans le article complet du laboratoire), mesurant eval_count / wall_time via l'API HTTP Ollama.

2.3 Ce que nous ne testons pas

Nous faisons pas exécutez les scores publics du « Classement IQ » : la variance entre les invites est énorme. La qualité utilise un ensemble de tâches fixes + examen humain aveugle (§5) ; rapports de vitesse, nombres reproductibles et séquences d'exécution brutes (y compris les valeurs aberrantes rejetées).

2.4 Environnement du laboratoire et notes de reproduction

Pour reproduire sur votre machine ou coller dans des documents internes, utilisez le bloc d'environnement ci-dessous ; un tableau récapitulatif suit. Taxonomie des échecs complets et effondrement : Laboratoire LLM local M4 Mac Mini (Hub).

Environment:
- macOS 15.4.1
- Ollama 0.6.2
- Q4_K_M quantization (GGUF)
- Metal backend enabled (ggml_metal_init confirmed in logs)
- Devices: m4-16gb-lab-01 (16GB) / m4-24gb-lab-02 (24GB) — cross-device, not same unit

Protocol:
- Models: qwen2.5:7b vs qwen2.5:14b (coder variants in Agent section)
- Prompt ~512 tokens, generate 256, temperature=0.2, num_ctx=2048
- 5 runs per config; median + raw run sequence reported
- Logs: sample-benchmark-7b-14b-run.log (article section 8.4)

Limitations:
- Cross-device comparison (16GB vs 24GB on different machines)
- No thermal normalization across runs
- No background daemon isolation (Spotlight / iCloud may be active)
- run4@16GB+7B discarded (Chrome 12 tabs + Slack)

Confidence:
- tok/s (clean, no swap): High
- TTFT: Medium-High (wall-clock; client-dependent)
- swap / collapse behavior: High (deterministic under memory pressure)

2.5 Résumé de la crédibilité

2.6 Traces de laboratoire : identifiants de terminal et de machine

Avant de reproduire, confirmez la ligne de base du métal et de la mémoire. Extrait du terminal ci-dessous (version complète en ressources de reproduction « extrait de session terminal » :

$ ollama ps
NAME                ID              SIZE      PROCESSOR    UNTIL
qwen2.5:7b          a1b2c3d4e5f6    4.7 GB    100% GPU     4 minutes from now

$ ollama ps   # 16GB · after 14B run 2
qwen2.5:14b         f6e5d4c3b2a1    9.1 GB    62% GPU/CPU  4 minutes from now

$ vm_stat | grep Swap
Swapins:                                 8421.
Swapouts:                                1204.

$ memory_pressure
System-wide memory pressure: CRITICAL

3. Vitesse : tok/s, TTFT et temps pour écrire 500 tokens

Chiffres du laboratoire Journal de référence apparié 7B/14B (dossier complet en §8.3 ressources de reproduction). Nous conservons la médiane et les cinq séries brutes-les vrais bancs sont rarement des progressions arithmétiques soignées.

3.1 Système propre : 16 Go · qwen2.5:7b (cinq exécutions)

Horloge murale TTFT : 1,78 / 1,91 / 2,03 / 2,14 s (médiane 1,97 s). Échanges = 0.

3.2 Système propre : 16 Go · qwen2.5:14b (la session n'a pas terminé cinq exécutions)

14B sur 16GB a pas de médiane stable à signaler: exécution 3 état de la mémoire : WARN, exécutez 4 processus tués – correspond à l'effondrement de la mémoire dans le laboratoire complet. Ainsi, une utilisation quotidienne de 16 Go ne devrait pas garder 14 B de résident.

3.3 Système propre : 24 Go couplés (m4-24gb-lab-02)

Sur 24 Go, les cinq exécutions du 14B varient toujours (14,2-17,3) mais pas d'échange partout. Retest l'après-midi un autre jour : 7 B à 16 Go médiane 28,6 (inclut une valeur aberrante chaude de 24,3 – voir le pied de page du journal) – ± 5 % sur une journée croisée est normal.

3.4 Extrait brut de référence

--- m4-16gb-lab-01 · qwen2.5:7b ---
tok/s per run: 28.7 31.4 26.9 33.0   (run4 22.3 discarded)
median: 29.1

--- m4-16gb-lab-01 · qwen2.5:14b ---
run3: tok/s=3.4  TTFT_wall=5.81s
run4: ERROR runner killed (oom?)

--- m4-24gb-lab-02 · qwen2.5:14b ---
tok/s: 14.2 16.8 15.1 17.3 14.9  →  median 15.1

3.5 Sous charge : 7B toujours utilisable, 14B casse en premier

16 Go + onglets Chrome 12 : 7B run4 supprimés uniquement 22.3 jeton/s ; 14B clics déchargement sur le processeur après l'exécution2. Dans les boucles d'agent, TTFT fait plus mal que tok/s—voir §7.1.

TL;DR : sélection par mémoire

Le §3 ci-dessus contient des scores de 16 Go/24 Go et des preuves d'échange. Un tableau à retenir :

4. Feuille de coûts 7B vs 14B (référence rapide)

« Coût » signifie ici facture de ressources sur l'appareil (RAM, latence, stabilité), pas de tarification de l'API cloud. Résumé pour un état propre de 24 Go et des limites de 16 Go : pour les extraits de code et les décisions d'équipe.

16 Go : restez sur 7B pour une utilisation quotidienne fluide ; 24 Go avant 14B stable. Faites correspondre votre scénario dans §8.4.

5. Qualité : quand 7B suffisent ou quand vous avez besoin de 14B

Nous avons exécuté 20 tâches corrigées (10 chinois + 10 anglais) réparties en quatre types : résumé, traduction, correction de bugs sur un seul fichier, petite fonctionnalité à 3 fichiers. Chaque tâche est générée une fois sur 7B et 14B ; trois ingénieurs ont évalué à l’aveugle « adopter tel quel / modifications mineures / réécriture ».

5.1 Résumé de l'examen en aveugle (taux d'adoption tel quel)

5.2 Modes de défaillance typiques du 7B

• API hallucinées : invente des accessoires / chemins REST qui semblent plausibles.
• Modifications manquées : corrige la définition, oublie de grep les appelants – la plupart des échecs entre fichiers.
• Trop concis pour le code : excellent pour les résumés ; le codage des réponses ignore la gestion des erreurs : vous ajoutez un laissez-passer humain.

5.3 Quand 14B vaut la « taxe mémoire » (24 Go supposés)

• Locale Claude Code / Agent Curseur > 2 h/jour sur les dépôts moyens : taux d'adoption multi-fichiers ~ 30 % (7B) contre ~ 65 % (14B).
• Long invites du système (guides de style, règles d'architecture) doivent rester respectés.
• Raisonnement chinois complexe, règles produits multi-branches, listes de contrôle de conformité.
• Vous acceptez ~15 tok/s et un temps de mur plus long—qualité pour la latence, pas une mauvaise configuration.

5.4 Quand 7B suffit

• Notes personnelles, questions et réponses, résumés RSS, scripts shell simples.
• Accélérateur de projet examiné par des humains : ne fusionne pas directement avec le projet principal.
• 16 Go avec IDE + navigateur ouvert : 14 Go meurent souvent en mémoire avant « IQ ».

6. Mémoire : bassin versant de 16 Go contre 24 Go

Empreinte ≈ poids quantifiés + KV (∝ num_ctx) + macOS + applications de premier plan. Écart de poids 7B/14B Q4 ~ 4,5 Go, mais les frais généraux KV et OS remplissent rapidement 16 Go.

6.1 num_ctx frappe 14B plus fort

Élevage num_ctx de 2048 à 32768 : 24 Go + 14 B tok/s 15,1 → ~12,4 (exécution unique) ; 16 Go + 14 Go peuvent rester pendant plus de 60 s sans premier jeton (échec de latence E4). Si votre agent utilise par défaut un contexte étendu, confirmez d'abord le niveau de RAM.

7. Choix d'agent, TTFT et Claude Code

Boucle d'agent = plusieurs tours de plan → outil → relecture → générer. La douleur locale est souvent TTFT empilé par tour, pas les pics de tok/s : pourquoi « le benchmark avait l'air superbe, l'agent se sentait horrible ».

7.1 Pourquoi TTFT est la « vraie » métrique pour les agents

mesures tok/s génération régulière après le démarrage; TTFT est demande au premier jeton. Pour les mandataires :

• Chaque tour d'outil attend que le modèle parle : vous avez l'impression TTFT × tours, pas la tranche de 256 jetons.
• Les orchestrateurs souvent temps mort (dizaines de secondes). Sous swap, TTFT ~2s → 5,8 s+ casse les boucles à plusieurs tours.
• Des tok/s élevés n’aident qu’après le démarrage du streaming ; 6 secondes avant que le premier jeton ne semble cassé.

Comment la mémoire unifiée et le swap gonflent le TTFT : Mémoire et amp; Inférence LLM.

7.2 Combos recommandés (résumé – tableau complet §8.4)

7.3 Mixage avec les API cloud

Division commune : 7B pour la récupération/les brouillons, 14B ou cloud pour la révision avant la fusion. Si vous utilisez déjà Claude Code, le 14B local achète hors ligne, reproductible, sans facture symbolique - configuré dans Claude Code + Laboratoire d'agents locaux Ollama.

7.4 Ollama ou MLX ?

Cette série teste Ollama uniquement (HTTP, gestion des modèles, câblage Claude Code). MLX est environ 3 à 8 % plus rapide sur les mêmes invites, mais les agents sont toujours expédiés en premier sur Ollama – voir Benchmarks MLX et Ollama.

8. Reproduire des commandes et des listes de décisions

8.1 Modèles à tirer et test de fumée

ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama run qwen2.5:7b "用三句话说明 7B 和 14B 在 Mac Mini 上的主要差别"
ollama run qwen2.5:14b "同上"

Les journaux devraient afficher ggml_metal_init; Chargement complet du processeur uniquement → mise à niveau d'Ollama (Hub E3 : 0.5.13 sans Metal ~4 tok/s). Après les courses, vérifiez la ligne ressources de reproduction.

8.2 Autocontrôle par scénario (utiliser ensuite les tableaux ci-dessous)

• Agent éditant quotidiennement le même dépôt de support ?
• 16 Go avec Xcode + Chrome toujours ouvert ?
• OK avec 14B écrivant 500 jetons en ~ 33 secondes sur 24 Go ?
• Besoin num_ctx > 8192?
• Inférence partagée Mac pour une équipe ?

8.3 Repro des actifs (télécharger pour vérifier)

Fichiers statiques dans cet article ressources/ dossier-pas de liens externes—ouvrez ou enregistrez dans le navigateur pour vérifier chaque exécution derrière le §3.

• Journal de référence apparié 7B/14B — tok/s, TTFT, Swapins par run (source pour les tableaux §3)
• Extrait de session terminale — ollama ps, vm_stat, mémoire_pression
• Journal de débogage Ollama 16 Go 14 Go - session d'échange / MOO
• Script de reproduction de référence — même logique que laboratoire complet

8.4 Tableaux de décision (réponse complète ici)

Après les données ci-dessus, choisissez par RAM et scénario. Pour auditer chaque exécution §3, ouvrez le journal de référence apparié.

Par mémoire unifiée (choisissez Go, puis modèle)

Par scénario

• Chat / résumé / scripts légers (16 Go) : → qwen2.5:7b
• Codage inter-fichiers / Agent local (24 Go recommandés) : → codeur qwen2.5 : 14b (qualité pour la latence—voir §7)
• Examen humain le plus rapide OK : → 7B ou Gemma3:4b

Par personnage

Conclusion exploitable : 16 Go → 7 Go ; considérez 14B uniquement à 24 Go, sinon le swap réduit l'UX d'un ordre de grandeur.

FAQ

Mac Mini M4 : 7B ou 14B ?

Vérifiez d'abord le risque de swap, puis le niveau de modèle. Sélections complètes (16 Go → 7 Go, 24 Go → 14 Go) dans §8.4. Le constatation clé explique pourquoi.

16 Go peuvent-ils exécuter 14 Go ?

Il charge ; pas pour la résidence quotidienne. Voir §1.1 trois états, §3.2, et §8.4.

Dans quelle mesure le 7B est-il plus rapide que le 14B ?

16 Go 7B médiane 29,1 ; 24 Go 14B médiane 15,1. Forcé 14 Go sur 16 Go après échange ~ 3,4 tok/s. Détails dans §3.

7B ou 14B pour discuter au quotidien ?

La plupart des discussions : 7B. Codage inter-fichiers : §5 et §8.4.

Claude Code modèle local ?

16 Go → codeur qwen2.5 : 7b; 24 Go → codeur qwen2.5 : 14b. Agents : priorisez TTFT—§7.1.

Mettre à niveau 16 Go → 24 Go pour 14 Go ?

Cela vaut la peine si vous comptez sur un agent local et que 7B « comprend souvent mais modifie mal » ; le chat pur n'est souvent pas le cas. Voir §8.4.

Qwen2.5-Coder vs général 7B/14B ?

Examen aveugle du codage ~ 8 à 12 points plus élevé ; en général, les 7B/14B semblent plus naturels dans le chat.

Résumé

16 Go → 7 Go ; 24 Go avant 14B stable. La question de savoir si 14B fonctionne est principalement liée à la RAM et au swap, et non à « un niveau plus intelligent ». Reproduire via §8.3 journaux et scripts et §2.4 bloc environnement.

Lecture connexe

Plus dans cette série :

• LLM local M4 Mac Mini (Hub : méthodologie & logs bruts)
• Claude Code + Agent local Ollama
• Benchmarks MLX et Ollama
• Mémoire et amp; Inférence LLM

Tests sur Mac Mini M4 physique (Macstripe Lab et unités de bureau), macOS 15.4.1, Ollama 0.6.2. Téléchargements dans §8.3. Pas de matériel local ? Reproduire sur Nœuds Macstripe M4.