Avec DeepSeek-V4-Flash, le steering des LLM redevient intéressant

 (seangoedecke.com)
1 points par GN⁺ 1 시간 전 | 1 commentaires | Partager sur WhatsApp
  • DwarfStar 4 réduit llama.cpp à une version dédiée à DeepSeek-V4-Flash, ce qui facilite l’expérimentation du steering de LLM sur des modèles locaux
  • Le steering consiste à extraire sous forme de vecteur la différence d’activation d’un concept comme « répondre brièvement », puis à l’ajouter à la même couche pendant l’inférence pour modifier le comportement
  • Le steering exige un accès aux poids ou aux activations, donc suppose une exécution locale ; pour les utilisateurs d’API, c’est un domaine réservé à des fournisseurs comme OpenAI
  • Pour beaucoup de réglages de base, les prompts restent plus simples, mais la possibilité de modifier des comportements appris difficiles à demander par prompt, comme la suppression des refus, demeure
  • DeepSeek-V4-Flash et DwarfStar 4 pourraient multiplier les expérimentations open source, et des applications concrètes pourraient apparaître dans les 6 prochains mois

DeepSeek-V4-Flash et DwarfStar 4

  • DwarfStar 4 est un projet qui réduit llama.cpp à l’exécution seule de DeepSeek-V4-Flash, afin de faciliter l’expérimentation du steering de LLM sur des modèles locaux
  • DeepSeek-V4-Flash pourrait être un modèle local suffisamment bon pour rivaliser avec le codage agentique de bas niveau des modèles de frontière
  • Le steering nécessite un accès aux poids ou aux activations du modèle, donc une exécution locale ; l’arrivée de modèles comme DeepSeek-V4-Flash crée les conditions pour que davantage d’ingénieurs expérimentent directement
  • antirez a intégré le steering comme fonctionnalité de premier plan dans DwarfStar 4, mais l’exemple actuel relève surtout d’un réglage jouet de la « verbosité », reproductible aussi par prompt
  • La version initiale de DwarfStar 4 est sortie il y a 8 jours, et l’évolution future de cette fonction de steering sera à suivre

Comment fonctionne le steering

  • L’idée de base du steering est d’extraire un concept comme « répondre brièvement » depuis l’état interne du modèle, puis d’augmenter pendant l’inférence les activations numériques qui constituent ce concept

  • Extraction simple d’un vecteur de steering

    • On peut injecter au modèle le même ensemble de 100 prompts deux fois : une fois avec des prompts normaux, une autre en ajoutant « respond tersely »
    • Pour chaque paire de prompts, on mesure la différence d’activation du modèle, et la soustraction d’une matrice d’activations à l’autre donne le vecteur de steering
    • En ajoutant ce vecteur à la même couche d’activation pour un prompt arbitraire, on peut s’attendre à ce que le modèle réponde de façon plus concise
    • Les activations mesurables existent en plusieurs points, après l’attention ou entre les couches par exemple ; on peut en choisir un ou en tester plusieurs pour trouver celui qui fonctionne le mieux

  • Extraction de caractéristiques plus sophistiquée

    • On peut aussi entraîner un modèle séparé pour extraire, depuis les activations du modèle d’origine, des caractéristiques (features) correspondant à des motifs de comportement qui apparaissent ensemble
    • Une fois ces caractéristiques remappées à des concepts individuels, on peut augmenter les activations de la même manière
    • Les sparse autoencoders d’Anthropic ont été présentés comme une approche proche de ce principe
    • Cette méthode peut capter des motifs plus profonds qu’un simple vecteur différentiel, mais elle coûte beaucoup plus en temps, calcul et expertise
    • Il existe une analyse approfondie de cette approche sur des modèles LLaMA ouverts, et les essais réalisés ont donné des résultats mitigés

Pourquoi le steering est intéressant

  • Le steering donne l’impression qu’au lieu de construire laborieusement un jeu d’entraînement pour pousser le modèle vers une distribution plus « intelligente », on pourrait trouver un bouton interne « smart » et le tourner à fond
  • Pour le style aussi, on peut imaginer un panneau de contrôle qui déplace directement des curseurs comme concision/verbosité ou soin/vitesse, plutôt que d’ajouter ou retirer des formulations du type « you MUST » dans le prompt
  • Golden Gate Claude, qui ramène toutes les phrases au Golden Gate Bridge, est un exemple à la fois fascinant et inquiétant de la puissance avec laquelle le steering peut modifier le comportement d’un modèle

Pourquoi le steering n’a pas été largement adopté

  • Le steering occupe en quelque sorte une position « de classe moyenne » dans la recherche en IA : il ne correspond vraiment ni aux besoins des grands laboratoires ni à ceux des utilisateurs ordinaires

  • Moins nécessaire pour les grands laboratoires

    • Les grands labos d’IA peuvent manipuler directement leurs modèles sans recourir à une « neurochirurgie » maladroite pendant l’inférence
    • Anthropic travaille sur ce domaine, mais surtout sous l’angle de l’interprétabilité et de la sécurité
    • Quand les grands labos veulent un comportement précis, ils choisissent généralement d’entraîner le modèle plutôt que de le piloter par steering

  • Les utilisateurs ordinaires n’y ont pas accès

    • Les utilisateurs classiques qui consomment des LLM via API n’ont pas accès aux poids ni aux activations du modèle, ce qui rend difficile l’obtention des informations nécessaires au steering
    • Par exemple, le seul acteur susceptible d’identifier ou d’exposer un vecteur de steering pour GPT-5.5 serait OpenAI
    • C’est possible avec des modèles à poids ouverts, mais jusqu’à récemment on estimait qu’il n’existait pas de modèle ouvert assez puissant pour justifier ce type d’essai

  • Pour beaucoup d’usages de base, les prompts sont plus efficaces

    • L’idée de manipuler directement le « cerveau » du modèle est frappante, mais les tokens de prompt modifient eux aussi directement l’état interne du modèle
    • Le steering permet un contrôle assez fin des activations, mais de simples changements de formulation dans le prompt offrent déjà un contrôle très fin
    • Pour rendre un modèle plus verbeux, il est bien plus simple de le demander directement que d’utiliser le steering

Peut-on piloter par steering ce qui est difficile à demander par prompt ?

  • Une possibilité où le steering deviendrait vraiment utile serait de trouver et de piloter des concepts qu’on ne peut pas demander par prompt
  • L’« intelligence » semble être une candidate, mais les modèles de la génération actuelle embarquent déjà ce type de traits, si bien que les prompts façon époque 4o comme « you are an expert » ont de plus en plus de mal à produire un effet significatif
  • La question de l’existence d’un vecteur de steering de l’« intelligence » reste empirique, mais il y a du scepticisme sur son existence
  • Un vecteur de steering pour un concept difficile comme l’« intelligence » pourrait s’étendre sur un espace presque aussi vaste que l’ensemble des poids du modèle ; dans ce cas, chercher ce vecteur reviendrait en pratique à entraîner un modèle plus intelligent
  • Si l’on remplaçait les activations de chaque couche de GPT-2 par celles d’un modèle beaucoup plus puissant de même structure, on obtiendrait de meilleurs résultats, mais ce ne serait pas vraiment GPT-2 devenu plus intelligent : ce serait presque comme discuter avec un modèle plus puissant
  • Un steering suffisamment sophistiqué finirait par se substituer au modèle lui-même, et l’intelligence résiderait alors dans le steering plutôt que dans le modèle d’origine

Le steering comme compression de données

  • Une autre possibilité du steering est de condenser dans un seul vecteur de steering des concepts qui exigeraient autrement beaucoup de tokens, afin d’économiser la fenêtre de contexte
  • On peut voir cela comme un transfert du concept depuis la mémoire de travail du modèle vers une mémoire implicite
  • Par exemple, si une partie des connaissances qu’acquiert GPT-5.5 en lisant rapidement une base de code spécifique se retrouvait enfouie dans les activations, on peut se demander s’il serait possible de la faire ressortir via un très grand vecteur de steering
  • Mais un concept comme « connaître ma base de code » est probablement, comme l’« intelligence », suffisamment complexe pour nécessiter un fine-tuning complet
  • Les tentatives industrielles de fine-tuning sur une base de code n’ont d’ailleurs pas été globalement très concluantes
  • Cela dit, on ne peut pas exclure totalement qu’une telle forme de steering soit possible

Perspectives et expérimentations de la communauté

  • Le steering a un certain attrait, mais il existe du scepticisme : la plupart de ses bénéfices peuvent être reproduits plus efficacement par prompt, tandis que les objectifs plus ambitieux peuvent être reproduits plus efficacement par entraînement ou fine-tuning
  • La communauté open source a encore peu exploré le steering, mais des évolutions comme DeepSeek-V4-Flash et DwarfStar 4 pourraient commencer à changer la donne
  • S’il existe des applications réellement pratiques du steering, elles pourraient apparaître dans les 6 prochains mois
  • Il sera aussi intéressant de voir si des outils spécifiques à un modèle, comme DwarfStar 4, finiront par inclure des bibliothèques de caractéristiques activables
  • De la même manière que la communauté publie rapidement des wrappers et des versions quantifiées quand un modèle à poids ouverts populaire sort, on pourrait voir émerger des efforts pour extraire des caractéristiques activables d’un modèle

Discussion complémentaire : suppression des refus et steering à l’exécution

  • Dans les commentaires du Hacker News, plusieurs commentateurs ainsi qu’antirez estiment ensuite que le steering peut modifier des comportements appris difficiles à changer par prompt
  • L’exemple typique est la suppression des refus (refusal) du modèle
  • Selon un commentateur, le décensurage ou l’abliteration sur les modèles ouverts se fait déjà de cette manière
  • D’après antirez, modifier les poids peut davantage dégrader les capacités du modèle, alors qu’un steering à l’exécution plus léger peut n’être appliqué qu’en cas de besoin

À lire aussi

1 commentaires

 
GN⁺ 1 시간 전
Commentaires sur Hacker News

  • Merci de l’avoir partagé, et juste pour préciser un point : avec la fonction de steering de DwarfStar, on pouvait supprimer complètement les refus de DS4.
    Ce qui est au niveau jouet, c’est le jeu de données d’exemple, c’est-à-dire seulement les paires de prompts que j’ai fournies, pas la fonctionnalité elle-même.
    J’en ai conclu que toute personne capable de construire un jeu de données approprié et de comprendre un mode d’emploi bien documenté de la fonctionnalité de steering peut s’y attaquer.
    Je ne suis pas sûr que ce soit une bonne idée que des gens qui ne feraient que copier-coller sans rien comprendre aient aussi accès à un modèle sans refus, donc je n’ai pas publié le fichier de steering, mais ça reste assez confus.
    Récemment, le support a été étendu, si bien qu’on peut appliquer les vecteurs de steering à différentes valeurs d’activation selon le moment : tout le temps, seulement après réflexion, seulement en dehors des appels d’outils, etc.
    Un point important que beaucoup de gens ignorent, c’est que faire du steering directionnel par vecteur à l’intérieur du moteur d’inférence est bien meilleur que d’utiliser un GGUF modifié de la même manière.
    Plus on fait de steering, plus on dégrade les capacités du modèle ; l’appliquer à l’exécution permet donc de n’en appliquer que le minimum nécessaire à l’objectif visé, et même seulement au moment choisi.
    Ce n’est pas encore implémenté, mais il semble aussi possible de n’appliquer le steering que lorsque l’énergie de la direction de refus dépasse un certain seuil, et il reste beaucoup de place pour l’expérimentation.

    • Si je comprends bien, DeepSeek V4 présente peu ou pas de comportements de refus typiques des modèles d’IA occidentaux sur des entrées inoffensives.
      On parle ici surtout de cas d’évaluation en sécurité logicielle ?

  • Je suis surpris que cet article ne mentionne pas le plus grand usage des vecteurs de steering, à savoir la possibilité de supprimer les refus du modèle (abliteration ou uncensoring).
    Il y avait autrefois un article disant que « la plupart des refus se trouvent sur un seul vecteur », et qu’en trouvant ce vecteur puis en l’atténuant, on pouvait faire sauter les refus du modèle et l’amener à répondre de manière générale à « n’importe quelle » requête.
    C’était assez faisable sur les premiers modèles où les refus étaient appris via du supervised fine-tuning (SFT) ; sur les modèles récents, cela semble un peu plus complexe, mais reste possible dans une certaine mesure.
    Il existe déjà des bibliothèques qui automatisent ce processus pour réduire les refus, mais elles se concentrent généralement sur l’identification et la modification du modèle avant de le distribuer comme modèle décensuré.
    L’approche par steering permet d’activer dynamiquement cette modification du vecteur, sans avoir à changer le modèle lui-même, même si le processus d’abliteration nuit à la précision sur des tâches sans rapport.

    • p-e-w en a parlé sur Discord il y a quelques jours.
      L’approche par neurone unique semble assez mauvaise en KLD, d’où, semble-t-il, l’adoption des techniques récentes.
    • Je ne comprends pas pourquoi on est autant focalisé sur la censure.
      En inversant la perspective, ne pas dire des faussetés comme « les vaccins sont nocifs » relève aussi de la censure.
      La science et la logique traitent souvent ce genre de sujets comme de la censure, mais un modèle entraîné sur un échantillonnage uniforme d’Internet pourrait penser que les vaccins sont nocifs.
      Un ajustement moins naïf censurerait ce type de contexte problématique.
      Du coup, je vois mal pourquoi on considérerait que retirer ce qu’on perçoit comme des biais censurés améliorerait l’utilisabilité générale.

  • Ce qui est vraiment intéressant dans le dépôt DS4, à mon avis, c’est la partie qui explore les boutons de réglage que les labos frontier cachent aux utilisateurs, et qui réfléchit à la manière dont ils pourraient s’intégrer dans de vrais flux de développement et d’interaction.
    Explorer différents modes d’interaction et réfléchir, par exemple, à la façon d’intégrer utilement le steering dans une interface utilisateur, c’est vraiment génial.
    Une fois le secret éventé et une fois que les utilisateurs comprennent le niveau de contrôle et l’utilité qu’ils peuvent tirer de modèles dont les mécanismes internes sont exposés de cette façon, le steering deviendra un élément central de la boîte à outils.
    Il deviendra probablement naturel d’attendre un tel niveau de contrôle des modèles ou de leurs fournisseurs.

  • L’affirmation selon laquelle « DwarfStar 4 est une version allégée de llama.cpp réduite à l’exécution de DeepSeek-V4-Flash uniquement » n’est pas correcte.
    DwarfStar 4 est un projet à part entière.
    Il doit beaucoup à llama.cpp, certes, mais ce n’est pas une version réduite.

    • Exact. Le chevauchement de code est minime, à peine quelques kernels.
      Il y a un peu de code de quantification pour le quantizer que j’ai implémenté, et DwarfStar 4 n’est pas un fork de llama.cpp.
      Cela dit, sans llama.cpp, il aurait été impossible de vérifier rapidement certains détails importants, donc le projet aurait été bien plus pauvre.
      Mais ce n’est pas un llama.cpp réduit.
      Cela n’enlève rien à l’importance immense de llama.cpp pour ce projet comme pour tous ceux qui ont suivi.
      L’essentiel, ce n’est pas le code, mais le chemin à suivre, les formats de quantification, les leçons apprises et les kernels optimisés qu’on peut examiner pour en tirer des motifs de conception.
    • La vérité semble quelque part entre les deux.
      DwarfStar 4 semble exister en grande partie grâce à llama.cpp, et ses auteurs ont manifestement puisé une forte inspiration dans le code de llama.cpp ; certaines parties ont même été réellement reprises avec les mentions de copyright appropriées.
      Ce n’est pas une critique, ça me paraît très bien.
      ds4.c ne fait pas de lien vers GGML, mais il existe grâce à la voie ouverte par le projet llama.cpp, aux kernels qui y ont été développés, aux formats de quantification, à l’écosystème GGUF et au savoir d’ingénierie acquis à la dure.
      Lors de la création d’un chemin d’inférence dédié à DeepSeek V4 Flash, les implémentations, kernels, tests et choix de conception ont servi de références majeures, et certains éléments au niveau du code source — comme le layout et les tables de quantification GGUF sous licence MIT, la logique de quantification CPU et de produit scalaire, ainsi que quelques kernels — ont été conservés ou adaptés.
      C’est pour cela que le fichier LICENSE conserve l’avis de copyright des auteurs de GGML, en signe de remerciement sincère - https://github.com/antirez/ds4#acknowledgements-to-llamacpp-...
      https://news.ycombinator.com/item?id=48142885 Ça a été assez amusant de jouer avec pendant environ deux jours depuis ce post, et jusqu’ici j’ai fait passer la vitesse de génération de 47.85 t/s à 57.07 t/s.

  • J’ai essayé de rendre l’IA plus radicale grâce au steering.
    Article : https://www.outcryai.com/research/shift-a-models-political-i...
    App : https://apps.apple.com/us/app/outcry-activist-ai/id676208676...
    Cette technique a beaucoup de potentiel.

  • Bon article, mais il y a un point qui me perturbe.
    L’article dit que le steering ne fonctionne que sur les modèles locaux, mais GitHub Copilot a une fonctionnalité « steer with message » qui permet de recadrer la direction en plein milieu de l’exécution, et je m’en sers souvent.
    J’imagine que c’est un autre type de steering.
    Le steering d’agent consiste probablement à insérer un autre message utilisateur au milieu des allers-retours entre le harness et le LLM.

  • En quoi peut-on dire que le modèle est local ? Si environ 192 Go de RAM sont nécessaires, ça paraît un peu excessif pour parler de local.

    • Ça tourne aussi sur un MacBook de 96 Go.
      128 Go, c’est mieux ; voir le README de DwarfStar.
    • Si on peut le télécharger et l’exécuter quand on a le matériel, alors c’est local, qu’on possède réellement ce matériel ou non.
      C’est comme demander si Zigbee peut être considéré comme local/LAN pour quelqu’un qui n’a pas les appareils radio ou les antennes nécessaires.

  • Cette ligne dans le dépôt DwarfStar lié m’a fait penser aux vecteurs de contrôle :
    y = y - scale * direction[layer] * dot(direction[layer], y)
    https://vgel.me/posts/representation-engineering/ y décrit les vecteurs de contrôle comme « des vecteurs qui peuvent être appliqués aux activations d’un modèle pendant l’inférence pour contrôler son comportement sans prompt supplémentaire ; plus précisément, une liste de vecteurs, un par couche ».

  • Ça ressemble davantage à quelque chose pour la recherche en deep learning qu’à quelque chose que j’aurais vraiment envie d’utiliser.

    • Non. Si on charge un vecteur anti-refus, on peut par exemple poser toutes sortes de questions liées à la sécurité informatique.
      C’est bien mieux qu’un modèle qui répète sans cesse « je ne peux pas aider pour cette requête problématique » quand on veut apprendre.

  • Je ne suis pas convaincu par l’idée que « le simple ajustement du wording du prompt permet déjà un contrôle très fin ».
    C’est peut-être moi qui ne sais pas écrire des prompts, mais surmonter les biais issus des données d’entraînement ou du post-entraînement me semble impossible.
    Avec un prompt, on peut tout au plus extraire des motifs présents dans les données d’entraînement ; un véritable contrôle fin, en pratique, j’en vois très peu.