De combien de bits une IA a-t-elle besoin ?

Vous décidez de télécharger un modèle d’IA de huit milliards de paramètres.

Vous avez un ordinateur, quelques tâches en tête et la conviction optimiste que télécharger quelque chose est une activité avec un début et une fin.

Puis vous arrivez sur la page du modèle.

Il existe une version FP16. Une version à huit bits. Une à six. Une à cinq. Plusieurs à quatre. Et quelque chose nommé Q4_K_M, qui ressemble à une référence de pièce détachée à photographier avant d’aller à la quincaillerie.

Ce sont toutes des versions du même modèle entraîné. Elles contiennent, pour l’essentiel, le même ensemble de paramètres appris. Leurs besoins en mémoire sont pourtant très différents.

Votre premier réflexe est compréhensible : choisir la plus grosse. Elle contient sûrement davantage de ce qui rend le modèle utile.

Votre carte graphique, avec ses huit gigaoctets de VRAM, aimerait participer à cette décision.

La différence entre ces versions vient surtout de la quantification des poids : représenter les poids numériques appris par le modèle avec moins de bits, grâce à des approximations soigneusement choisies.

Réduire la précision de ces nombres peut considérablement diminuer la mémoire qu’ils occupent.

Cela ressemble à une bonne affaire, immédiatement suivie d’une raison de se méfier.

Qu’a-t-on perdu ? Le modèle comprendra-t-il encore vos documents ? Pourra-t-il toujours aider à programmer ? Un modèle à quatre bits sait-il que Boston est dans le Massachusetts, ou a-t-on supprimé la géographie pour faire de la place à la grammaire ?

Aucun service ne décide quelles villes survivront à la compression.

Ce qui change, c’est la fidélité avec laquelle les nombres appris sont conservés. Ces nombres influencent les calculs : les modifier peut donc affecter la manière dont le modèle utilise ce qu’il a appris.

Mais préserver chaque bit disponible a un coût. Et pour le travail que vous voulez réellement accomplir, la précision supplémentaire peut justifier davantage de mémoire vidéo — ou pas.

Voilà la question qui se cache derrière tout le menu de téléchargement :

De quelle part de la précision numérique du modèle original ai-je besoin — et que puis-je faire avec la VRAM économisée ?

Le modèle a déjà fait ses études

Avant de comparer quatre bits à seize, séparons l’apprentissage du stockage de ce qui a été appris.

Pendant l’entraînement, un modèle ajuste d’immenses ensembles de valeurs numériques appelées poids. Ensemble, elles influencent sa manière de reconnaître des régularités, de suivre des instructions et de produire des réponses.

Quand vous téléchargez un modèle préentraîné ordinaire, cet entraînement a déjà eu lieu.

La version à quatre bits n’a pas fréquenté l’école quatre ans tandis que celle à seize bits y serait restée seize ans. Ce sont des représentations numériques différentes du même modèle entraîné.

L’éducation est venue d’abord. La quantification change la façon d’en conserver les résultats.

Imaginons que l’entraînement ait produit ce poids :

Pour comprendre la précision numérique, comparons ces représentations :

Elles décrivent à peu près la même valeur, mais n’en conservent pas autant de détails.

La première garde tous les chiffres de notre exemple. La deuxième arrondit à deux décimales. La troisième est une approximation plus grossière.

C’est le sens courant de la précision numérique : dans quelle mesure le nombre stocké reste proche de la valeur que nous voulions conserver.

En représentant les mêmes poids avec moins de bits, nous acceptons généralement des approximations plus grossières en échange d’une consommation de mémoire réduite.

L’exemple décimal est une illustration. Les ordinateurs utilisent des formats binaires : quatre bits ne signifient donc pas quatre décimales. Les formats répartissent leurs bits différemment, et la quantification réelle est plus élaborée que la simple suppression des derniers chiffres.

Mais le compromis de fond existe bien.

Plus de bits offrent davantage de possibilités de préserver fidèlement les nombres appris. Moins de bits économisent de la mémoire, mais abandonnent certains détails numériques.

Puisque les capacités du modèle dépendent de ces nombres, perdre des détails peut affecter sa capacité à exploiter ce qu’il a appris.

Parfois, la différence est difficile à remarquer. Parfois, elle compte.

Il faut déterminer quel cas correspond à votre travail.

Votre carte graphique a un appartement plus petit

Votre SSD peut avoir de la place pour plusieurs versions d’un modèle. Un disque de deux téraoctets accueille une assez belle collection.

Votre carte graphique est une propriétaire moins généreuse.

Pour les exemples suivants, supposons que vous souhaitiez exécuter le modèle entièrement sur un GPU dédié. Ses poids doivent tenir dans la mémoire vidéo, ou VRAM, de cette carte, avec de la place supplémentaire pour traiter vos demandes.

C’est ce budget mémoire qui nous intéresse ici.

Un bit a deux états possibles : zéro ou un. Plusieurs bits réunis offrent davantage de combinaisons :

Quatre bits offrent seize combinaisons. Six en offrent soixante-quatre. Huit en offrent 256.

Un format numérique utilise ces combinaisons pour représenter des valeurs. Davantage de possibilités de représentation coûtent davantage de mémoire réelle.

Huit bits forment un octet. Seize bits en forment deux.

Prenons un modèle simplifié contenant exactement huit milliards de poids. À seize bits par poids, les seules données des poids nécessitent environ :

Soit environ 16 GB de données de poids à loger dans la VRAM, avant d’ajouter la mémoire de travail.

Une carte graphique de 8 GB ne peut pas fournir cet espace. Lui expliquer que le modèle a d’excellentes critiques ne la rendra pas plus souple.

À quatre bits par poids, le calcul idéalisé devient :

Les formats réels ajoutent des informations auxiliaires et peuvent conserver certains composants avec une précision supérieure. Mais la différence fondamentale reste considérable.

Le même ensemble de poids appris peut occuper beaucoup moins de VRAM.

Ces équations utilisent des gigaoctets décimaux, notés GB. Les logiciels peuvent afficher des GiB, une unité légèrement plus grande. Surtout, elles décrivent uniquement les données des poids, pas l’ensemble de la mémoire nécessaire au fonctionnement du modèle.

Quatre bits ne veut donc pas dire « nécessite une carte graphique de quatre gigaoctets ».

Le rapport utile est le suivant : pour un même modèle, moins de bits par poids laissent généralement plus de mémoire vidéo pour tout le reste.

Les huit milliards de paramètres sont toujours présents. Leur allocation logement a été révisée.

Ce que stockent réellement quatre bits

Revenons à notre poids imaginaire :

Comment un code de quatre bits peut-il représenter un nombre pareil ?

Un code de quatre bits peut désigner seize possibilités. Dans un exemple volontairement simple, ces codes pourraient représenter seize valeurs espacées de 0.1 :

Notre valeur originale n’est pas dans la liste. La valeur disponible la plus proche est 0.4.

Le système peut stocker le code compact 4, avec une information commune indiquant que chaque pas représente 0.1 :

La taille du pas s’appelle un facteur d’échelle.

La différence entre le poids original et son approximation est :

Cette différence est l’erreur de quantification.

C’est un exemple pédagogique, pas la recette exacte de Q4_K_M. Les vrais poids peuvent être négatifs, et les méthodes pratiques choisissent leurs représentations avec davantage de soin.

Beaucoup de méthodes divisent les poids en groupes, chacun utilisant une échelle adaptée ou d’autres informations d’interprétation. Un même code de quatre bits peut donc représenter différentes valeurs approchées selon le groupe. Le modèle entier n’est pas limité à une liste universelle de seize nombres. Le guide de quantification de Hugging Face explique ces correspondances.

Imaginez une règle dont on pourrait espacer les graduations en fonction des mesures à effectuer.

Un groupe de valeurs très proches profite de graduations fines. Des valeurs réparties sur une plage plus large demandent une autre disposition.

Le nombre de graduations reste limité. Vous pouvez les placer intelligemment, mais pas en créer de nouvelles par simple enthousiasme.

Les ordinateurs restent désespérément insensibles à l’enthousiasme.

Comment l’arrondi parvient jusqu’à la réponse

Notre poids original était 0.3726. Son approximation est 0.4.

Supposons que la valeur numérique entrante soit 2. Avec le poids original, on obtient :

Avec l’approximation :

L’opération est la même. Le résultat a changé.

Un modèle effectue d’immenses quantités de calculs faisant intervenir ses poids. Leurs résultats alimentent les calculs suivants à travers ses couches.

Quand vous posez une question sur Boston, votre texte est découpé en tokens — des mots ou des morceaux de mots — puis converti en représentations numériques. Celles-ci se transforment en traversant le modèle.

Ces valeurs numériques changeantes s’appellent les activations. Les poids appris contribuent à déterminer comment elles se transforment.

Une opération courante peut s’écrire simplement :

Ici, $X$ contient les informations numériques entrantes, $W$ les poids appris, et $Y$ le résultat transformé.

Derrière cette petite équation peut se cacher une quantité énorme de multiplications et d’additions. Alors que le modèle semble discuter paisiblement de l’architecture de Boston, le matériel fait de l’arithmétique avec une intensité qui inquiéterait un comptable humain.

Modifier les poids peut donc modifier les calculs, puis la réponse.

Mais il ne suffit pas d’additionner toutes les erreurs d’arrondi pour connaître l’effet final. Certaines différences se compensent. D’autres comptent peu en pratique. D’autres encore touchent des parties plus importantes du calcul.

Les bonnes méthodes de quantification cherchent à préserver un comportement utile malgré les approximations.

Les chercheurs examinent aussi l’utilisation réelle des poids. AWQ, ou Activation-aware Weight Quantization, utilise des informations sur les activations pour protéger des canaux importants par une mise à l’échelle. L’étude AWQ décrit cette approche.

La précision n’a pas partout la même importance.

Apparemment, même dans un réseau neuronal, certains nombres ont négocié de meilleurs contrats.

Boston survit. L’itinéraire demande davantage d’attention.

Supposons que vous interrogiez plusieurs versions du même modèle capable :

Boston se trouve-t-elle dans le Massachusetts ?

Elles peuvent toutes répondre correctement.

Boston survit à la quantification à quatre bits. Le Massachusetts reste où nous l’avons laissé. La rivière Charles n’a pas été déplacée dans l’Ohio.

Essayez maintenant une demande plus exigeante :

Je loge près de Back Bay. Organise une journée avec un musée, une librairie indépendante, un dîner de fruits de mer et deux heures libres l’après-midi. Je n’ai pas de voiture, je souhaite éviter les longues marches et je dois rejoindre South Station avant mon train du soir.

Le modèle doit coordonner plusieurs exigences. Il lui faut aussi des informations fiables sur les horaires et les transports.

Les faiblesses ont davantage d’occasions de se manifester.

Une bonne version à quatre bits peut très bien réussir. Une version plus précise peut mieux préserver la capacité du modèle original à coordonner ces exigences. Aucun de ces résultats ne découle automatiquement du nombre de bits.

La même difficulté peut apparaître lorsqu’on compare des propositions comportant des exclusions complexes, qu’on modifie du code sans perturber des fonctions liées ou qu’on résout un problème en plusieurs étapes dépendantes.

Ces tâches donnent des raisons de préserver le comportement acquis pendant l’entraînement.

Mais précision numérique et exactitude des faits sont deux choses distinctes.

Un modèle peut conserver ses poids très précisément et manquer pourtant des informations nécessaires pour répondre. Plus de bits ne fournissent pas un horaire actualisé qu’il n’a jamais reçu.

Seize bits ne convainquent pas un restaurant fermé de rouvrir.

Et une réponse plus détaillée n’est pas forcément plus juste. Un modèle peut se tromper brièvement ou fournir une explication admirablement structurée de son erreur.

L’assurance, malheureusement, occupe très peu de place.

Alors, pourquoi garder la version à seize bits ?

Si une version à quatre bits peut répondre correctement, pourquoi utiliser la plus grosse ?

Parce que « fonctionne aussi bien pour cette tâche » ne signifie pas « conserve tout le comportement du modèle original pour toutes les tâches ».

Un checkpoint à seize bits sert souvent de version de haute précision à partir de laquelle on crée des variantes plus compactes. Le conserver évite l’approximation supplémentaire introduite par la quantification à peu de bits.

C’est important lorsque préserver le comportement original compte davantage que réduire les besoins en mémoire.

Votre travail révèle peut-être une faiblesse de la version quantifiée. Vous évaluez peut-être le modèle sur un large éventail de tâches. Ou vous avez assez de VRAM pour les poids de haute précision, le contexte et l’espace de travail : peu de raisons, alors, d’accepter une perte numérique supplémentaire.

Une précision supérieure ne garantit pas une réponse correcte. Elle élimine une source supplémentaire de modifications.

La version originale est aussi un point de départ précieux : pour créer de nouvelles quantifications, comparer des méthodes ou préparer un entraînement supplémentaire.

Une fois les détails numériques abandonnés, reconvertir la petite représentation vers un format plus large ne les récupère pas.

Écrire 0.400000 au lieu de 0.4 ne fait pas réapparaître 0.3726. Cela offre simplement un costume plus long à l’approximation.

Il faut distinguer l’entraînement supplémentaire. Installer un modèle à seize bits ne le fait pas apprendre automatiquement pendant une conversation ordinaire. L’entraînement nécessite un processus qui met à jour des paramètres.

Les représentations plus précises sont utiles pour cela, mais des approches à peu de bits existent également. QLoRA, par exemple, garde un modèle de base à quatre bits figé tout en entraînant des composants supplémentaires appelés adaptateurs. L’article QLoRA explique cette méthode.

Les modèles à seize bits ont donc des usages pratiques. Ils préservent un point de départ plus fidèle et peuvent éviter des dégradations importantes pour un travail particulier.

Ils n’offrent pas, en revanche, une promotion automatique de « connaît Boston » à « a soutenu une thèse sur le Massachusetts ».

Et pourquoi seize bits ne vous sont peut-être pas nécessaires

La plupart des gens qui téléchargent un modèle local veulent accomplir quelque chose.

Ils veulent organiser des notes, comprendre un document, rédiger un courriel, comparer des produits, travailler sur du code ou explorer un sujet.

Ils ne cherchent généralement pas à conserver chaque détail numérique pour le plaisir.

Si une bonne version à quatre, cinq ou six bits accomplit bien leurs tâches, la mémoire supplémentaire d’une version plus précise peut apporter peu d’amélioration pratique pour cet usage précis.

C’est la distinction entre une différence mesurable et une différence qui change votre expérience.

Les deux comptent, mais répondent à des questions différentes.

Supposons que deux versions produisent des résumés aussi utiles des documents que vous lisez réellement. L’une occupe beaucoup plus de VRAM. L’autre laisse de la place pour des documents plus longs et davantage d’historique de conversation.

Choisir la représentation plus compacte peut être une décision technique judicieuse.

Vous n’êtes pas obligé de réserver une suite présidentielle à chaque décimale.

Il n’existe pas pour autant de règle universelle disant qu’une quantification à quatre bits ne perd que deux pour cent de qualité, ou conserve un pourcentage fixe d’intelligence.

Une différence publiée correspond à un modèle, une méthode de quantification, une évaluation et une configuration précis. Une autre tâche peut révéler un écart moindre, plus grand ou pratiquement sans importance.

Des recherches comme GPTQ ont démontré une quantification à trois et quatre bits avec de faibles pertes dans les évaluations rapportées, y compris sur de très grands modèles. Cela prouve que le compromis peut fonctionner remarquablement bien. Ce n’est pas une garantie pour chaque modèle et chaque tâche. L’article GPTQ décrit les résultats.

La bonne question est donc personnelle et vérifiable :

Cette version plus compacte fait-elle encore mon travail assez bien — et la VRAM économisée vaut-elle davantage pour moi que la différence restante ?

Pour de nombreuses tâches quotidiennes, la réponse peut être oui.

Pour certaines tâches exigeantes, une précision supérieure peut mériter sa place.

Aucun des deux choix ne nécessite de rejoindre un camp sur internet.

Quatre bits et un MacBook

L’idée de réduire la précision des réseaux neuronaux existait bien avant que les modèles de langage locaux deviennent populaires.

Ce qui a changé, c’est l’ampleur de la possibilité.

À mesure que les modèles atteignaient des milliards de paramètres, réduire les bits par poids pouvait transformer des besoins en mémoire irréalistes en quelque chose qu’un ordinateur personnel pouvait accueillir.

En mars 2023, cette possibilité est devenue particulièrement tangible avec llama.cpp, de Georgi Gerganov.

Le 11 mars, le développeur Simon Willison a relaté l’exécution du modèle LLaMA à sept milliards de paramètres sur son MacBook Pro M2. Son ordinateur disposait de 64 GB de mémoire ; le fichier du modèle faisait environ 4 GB après quantification à quatre bits. Son témoignage direct est toujours disponible.

Un modèle de langage entraîné répondait à des questions localement sur un portable.

Pour qui avait l’habitude d’entendre parler de centres de données et de budgets d’entraînement immenses, c’était un changement de perspective important. On pouvait expérimenter avec un modèle capable sur son ordinateur, sans acheter aussi un refroidissement industriel et recruter le responsable des services techniques.

La quantification n’a pas rendu l’entraînement initial gratuit. Elle a aidé à rendre son résultat pratique à utiliser.

Les modèles coûtaient cher à éduquer et se montraient étonnamment accommodants sur l’état de leurs notes de cours.

Et une fois l’utilité d’une très faible précision démontrée, les chercheurs ont continué à explorer jusqu’où aller.

Il arrive aux programmeurs d’atteindre la philosophie en soustrayant un, encore et encore.

Q4_K_M et autres formes de petites lignes

Vous revenez à la liste de téléchargement.

Vous comprenez désormais les quatre bits. Malheureusement, Q4_K_M semble contenir plusieurs avis supplémentaires.

L’étiquette désigne une recette particulière de quantification. Le quatre renvoie à une représentation des poids avec peu de bits, mais les formats pratiques ont besoin de davantage que les seuls codes compacts.

Ils peuvent aussi stocker des échelles, d’autres informations d’interprétation et certains composants avec une précision supérieure.

Un format « quatre bits » peut donc utiliser en moyenne plus de quatre bits effectifs par poids.

Deux fichiers portant cette étiquette peuvent différer en taille et en comportement. La recette compte, pas seulement le chiffre en gros caractères.

Un modèle à quatre bits ressemble à une installation logicielle « en cinq minutes » sur un seul point : le chiffre est utile, mais mieux vaut rester en bons termes avec les notes de bas de page.

Vous verrez peut-être aussi GGUF, le nom du format de fichier qui contient le modèle et ses métadonnées. C’est une autre catégorie d’étiquette que Q4_K_M, qui décrit une recette de quantification.

Et FP16 et BF16 sont tous deux des formats à virgule flottante sur seize bits, mais répartissent leurs bits différemment entre plage numérique et précision.

Vous pouvez comprendre le choix pratique sans mémoriser chaque organisation interne.

L’essentiel est que le nombre de bits ne définit pas entièrement le format, et que votre environnement d’exécution — le logiciel qui fait tourner le modèle — doit prendre en charge la version choisie.

Les abréviations peuvent rester de simples connaissances. Rien ne vous oblige à les adopter dans la famille.

Même les petits poids doivent circuler

Une question raisonnable se pose : si les poids sont stockés sous forme de codes compacts, l’ordinateur doit-il reconstituer une énorme copie de haute précision avant d’utiliser le modèle ?

Une implémentation adaptée n’a pas besoin de conserver en permanence une telle copie déployée.

Des routines optimisées peuvent lire des blocs compacts de poids et interpréter leurs valeurs approchées pendant le calcul. Certaines opérations peuvent toujours utiliser une précision supérieure.

Cela ne restaure pas les informations perdues lors de la quantification. Multiplier 0.4 très précisément ne révèle pas que le poids original était 0.3726.

Conserver des poids compacts réduit aussi le volume de données qui doit circuler dans le système mémoire.

Ce déplacement prend du temps. La bande passante mémoire décrit la vitesse de transfert des données. Lorsque leur déplacement constitue un goulot d’étranglement majeur, des représentations plus petites peuvent réduire l’attente du processeur.

Mais décoder des représentations compactes peut demander du travail supplémentaire. Les performances dépendent du matériel, de l’environnement d’exécution, du format et de la tâche.

Un format qui accélère la génération d’une réponse peut se comporter autrement lors du traitement d’une longue demande.

« Quatre bits, c’est toujours plus rapide » n’est donc pas une règle fiable. Pas plus que « le plus petit téléchargement donnera la réponse la plus rapide ».

À conditions égales, le petit fichier se téléchargera généralement plus vite. C’est réconfortant quand au moins une partie de la discussion se tient bien.

Pour connaître la vitesse réelle d’inférence, les mesures sur la configuration visée restent précieuses.

Les poids tiennent. Maintenant, le modèle voudrait travailler.

C’est ici que la VRAM économisée devient particulièrement utile.

Les poids ne sont qu’une partie des besoins en mémoire d’un modèle en fonctionnement. Il lui faut aussi de la place pour les calculs temporaires et les tampons de l’environnement d’exécution.

Beaucoup de modèles conservent un cache KV, qui stocke des informations intermédiaires liées aux tokens déjà traités. Les réutiliser évite de répéter une partie des mêmes calculs à la génération du token suivant. Hugging Face explique le fonctionnement de ce cache.

Vos instructions, les documents fournis, l’historique de conversation et la réponse en cours contribuent au contexte du modèle.

Un contexte plus long nécessite généralement plus de mémoire cache, même si la relation exacte dépend de l’architecture et de l’environnement d’exécution. Certaines conceptions limitent ou modifient cette croissance.

Les poids eux-mêmes ne grossissent pas parce que vous collez un chapitre supplémentaire. La demande additionnelle vient du traitement d’un contexte plus long.

Autre distinction facile à manquer : des poids à quatre bits ne signifient pas automatiquement un cache KV à quatre bits. La précision des poids et celle du cache se choisissent séparément.

Pour un plan simple de mémoire GPU, on peut raisonner ainsi :

La marge de travail couvre notamment les tampons de calcul et l’espace réservé à d’autres usages du GPU.

Donnons des nombres à cette idée.

La documentation de llama.cpp indique pour Llama 3.1 8B un fichier Q4_K_M d’environ 4.58 GiB et un fichier Q8_0 d’environ 7.95 GiB. Ces tailles publiées de fichiers de poids servent de point de départ à une estimation ; elles ne mesurent pas toute la VRAM consommée pendant l’exécution. Source : comparaison des quantifications de llama.cpp.

Supposons que notre exemple utilise ces chiffres pour les poids et réserve 1 GiB au cache de conversation, puis 1 GiB supplémentaire à l’espace de travail et aux autres usages.

Avec la petite représentation des poids :

Avec la plus grande :

Sur une carte graphique disposant d’un budget VRAM de 8 GiB, ce sont des situations très différentes.

Les marges d’un gigaoctet sont des hypothèses de cet exemple. Les besoins réels dépendent de l’environnement d’exécution et de la charge de travail.

Mais on voit maintenant pourquoi le calcul complet compte.

La grande représentation des poids tient presque à elle seule. Le travail prévu, non.

La représentation plus petite laisse de la place pour travailler.

Voilà pourquoi la représentation la plus fidèle n’est pas automatiquement la configuration la plus utile sur un ordinateur donné.

Un modèle qui consomme presque toute la VRAM ressemble à un somptueux canapé occupant presque tout le salon. Le canapé tient. Vous dînez désormais debout.

La quantification peut faire de la place pour le reste de la soirée.

La RAM du système peut-elle aider ?

Oui, lorsque l’environnement d’exécution et le modèle prennent en charge cette organisation.

Un modèle peut fonctionner sur le CPU avec la RAM du système. Il peut fonctionner sur un GPU avec de la VRAM. Ou le logiciel peut répartir le travail : une partie utilise la RAM, l’autre le GPU. Des projets comme llama.cpp permettent l’exécution sur CPU et le fonctionnement mixte CPU–GPU.

Dans les systèmes à mémoire unifiée, le processeur et le matériel graphique partagent un même ensemble de mémoire, ce qui change encore la répartition.

Ces approches permettent d’utiliser des modèles qui ne tiendraient pas entièrement dans la VRAM d’une carte dédiée. Les performances dépendent de l’organisation.

Cependant, 8 GB de VRAM dédiée et 32 GB de RAM système ne deviennent pas 40 GB de mémoire GPU uniformément rapide.

Le logiciel doit répartir correctement données et calculs. Les transferts et l’exécution d’une partie du travail sur le CPU peuvent affecter la vitesse.

Votre système d’exploitation et vos autres applications ont aussi besoin de RAM. Ils n’ont pas accepté de déménager simplement parce que vous vous intéressez à l’intelligence artificielle.

De même, toute la base de données d’un agent ne migre pas automatiquement vers la VRAM. Elle fonctionne dans son propre environnement ; les passages récupérés et envoyés au modèle rejoignent son contexte.

Les calculs GPU ci-dessus supposent que les poids se trouvent entièrement sur la carte graphique. Modifier cette répartition change le plan mémoire.

Retour au bouton de téléchargement

À présent, la liste des fichiers devrait moins ressembler à un examen d’entrée.

La version à seize bits conserve une représentation de haute précision des poids appris. La quantification à huit bits fait généralement une approximation moins poussée que les variantes à moins de bits. Les formats à cinq et six bits offrent des compromis intermédiaires. Ceux à quatre bits peuvent rendre un modèle capable utilisable avec beaucoup moins de VRAM.

Quel que soit le choix, la question reste la même : quelle fidélité numérique profite réellement à votre tâche ?

Pour de brèves tâches de classement, un contexte modeste et une bonne version à peu de bits peuvent suffire. Pour un assistant de programmation examinant plusieurs fichiers, ou un agent transportant instructions et historique de travail, la mémoire de travail peut peser lourd.

Certaines tâches révèlent un avantage utile de la haute précision. D’autres donnent des résultats aussi satisfaisants avec moins.

Un modèle qui tient avec une courte salutation peut encore peiner avec le document que vous vouliez lui faire lire. Un modèle très précis sans place pour ce document a magnifiquement conservé ses nombres, mais raté la mission.

C’est pourquoi les tests doivent ressembler à votre travail.

Pour comparer des commandes d’imprimerie, donnez-lui des commandes représentatives aux réponses connues. Pour le code, utilisez du code que vous pouvez évaluer. Pour un itinéraire à Boston, vérifiez les limites de marche et la fiabilité des sources des horaires.

Situer Boston dans le Massachusetts est un début prometteur. Cela ne qualifie pas le modèle pour organiser tout votre week-end.

Quand vous comparez des quantifications, gardez autant que possible le même modèle de départ et la même tâche. Vous jugerez plus facilement l’effet du changement de représentation.

C’est aussi le but de l’exploration des budgets mémoire dans Green Zone : voir comment les poids choisis, le contexte, la répartition de la mémoire et la capacité disponible pourraient fonctionner ensemble.

Une estimation aide à choisir une configuration plausible. L’essayer sur des tâches représentatives vous dira si elle vous est utile.

Vous découvrirez peut-être que quatre bits préservent suffisamment de capacités pour tous vos besoins. Vous préférerez peut-être cinq ou six. Ou votre travail bénéficiera d’une précision supérieure, avec assez de VRAM pour l’accueillir confortablement.

Il n’y a pas de récompense pour avoir consacré chaque octet disponible aux seuls poids.

Et aucune obligation d’abandonner de la précision lorsqu’elle apporte un bénéfice utile.

Le modèle a déjà appris. Vous décidez avec quelle fidélité préserver cet apprentissage tout en lui laissant assez de place pour travailler sur votre ordinateur.

Vous revenez à la page de téléchargement. Les étiquettes n’ont pas changé, mais vous savez maintenant les lire.

Vous choisissez une version adaptée à votre logiciel d’exécution, à votre mémoire de travail disponible et à la tâche que vous avez réellement en tête.

Boston est toujours dans le Massachusetts. Votre ordinateur a de la place pour travailler. Vous pouvez enfin fermer le fil de comparaison.

Quelqu’un vient de publier une argumentation détaillée sur la quantification à deux bits.

Vous n’êtes pas obligé de l’ouvrir.