g1 - Générer une chaîne de raisonnement similaire à o1 avec Llama-3.1 70B sur Groq

 (github.com/bklieger-groq)
2 points par GN⁺ 2024-09-17 | 1 commentaires | Partager sur WhatsApp
  • g1 est un prototype précoce qui utilise Llama-3.1 70B sur Groq et une stratégie de prompt pour générer une chaîne de raisonnement similaire à o1, dans laquelle le LLM « pense » étape par étape
  • Contrairement à OpenAI o1, il montre à l’utilisateur tous les tokens de raisonnement ; il utilise un modèle open source, mais il ne s’agit ni d’une reproduction complète de o1 ni d’une comparaison directe, plutôt d’une expérimentation de raisonnement fondée sur les prompts
  • À chaque étape, le modèle choisit soit de poursuivre vers l’étape de raisonnement suivante, soit de produire la réponse finale, et il est conçu pour renvoyer à chaque étape un titre et un contenu en JSON
  • Le prompt exige au moins 3 étapes, l’exploration d’alternatives, une vérification des erreurs possibles de son propre raisonnement, ainsi que l’usage d’au moins 3 méthodes ; sur le problème Strawberry, il a montré une précision d’environ 70 % (n=10), contre 0 % pour Llama-3.1-70B seul et 30 % pour ChatGPT-4o
  • Lors des premiers tests, il a affiché une précision de 60 à 80 % sur des problèmes de logique simples, mais cette précision n’a pas encore fait l’objet d’une évaluation officielle et g1 n’est pas non plus parfait

Le problème que g1 cherche à résoudre

  • g1 est un prototype précoce visant à améliorer les capacités de raisonnement des LLM uniquement grâce à une stratégie de prompt
  • L’objectif est d’amener un LLM à résoudre, via une chaîne de raisonnement similaire à o1, des problèmes de logique qui lui posent habituellement difficulté
  • Les différences avec OpenAI o1 sont explicitement précisées
    • g1 montre à l’utilisateur tous les tokens de raisonnement
    • g1 utilise un modèle open source
    • g1 n’est ni une reproduction complète de o1 ni une comparaison de performances
    • OpenAI o1 fonctionne en apprenant le raisonnement Chain of Thought à grande échelle par renforcement, afin d’atteindre des performances de pointe sur des problèmes complexes de niveau doctorat

Fonctionnement

  • g1 s’appuie sur Llama3.1-70b pour générer une chaîne de raisonnement proche d’un Chain of Thought dynamique
  • Chaque étape de raisonnement est visible par l’utilisateur et porte un titre
  • À chaque étape, le modèle choisit l’une de deux options
    • continuer vers l’étape de raisonnement suivante
    • fournir la réponse finale
  • Le prompt système comprend des instructions destinées à améliorer le raisonnement du modèle
    • explorer des réponses alternatives
    • dériver la réponse par au moins 3 méthodes
    • remettre en question les solutions provisoires précédentes
    • tenir compte des limites des LLM

Stratégie de prompt

  • Le prompt attribue au modèle le rôle d’un expert AI assistant expliquant un reasoning étape par étape
  • Chaque étape doit être renvoyée au format JSON avec les clés title, content, next_action
    • la valeur de next_action doit être continue ou final_answer
  • Des instructions mises en avant en majuscules visent à améliorer le respect du prompt
    • utiliser autant d’étapes de raisonnement que possible, avec un minimum de 3 étapes
    • reconnaître ce qu’il est possible et impossible de faire en tant que LLM
    • explorer des réponses alternatives et considérer les points où son propre raisonnement pourrait être erroné
    • lorsqu’il dit réexaminer, le faire réellement avec une autre approche
    • dériver la réponse par au moins 3 méthodes
    • utiliser les bonnes pratiques
  • Après avoir ajouté le problème dans un message utilisateur, un message assistant contenant une phrase d’ouverture standard est inséré pour lancer la génération

Exemples et premiers résultats

  • g1 traite des problèmes de logique simples mais difficiles à résoudre sans prompt, comme le problème Strawberry : « combien y a-t-il de R dans strawberry ? »
  • Des chiffres initiaux sont fournis pour ce problème
    • g1 : environ 70 % de précision, n=10
    • Llama-3.1-70B sans prompt : 0 % de précision
    • ChatGPT-4o : 30 % de précision
  • Lors des premiers tests, g1 a résolu avec une précision de 60 à 80 % des problèmes de logique simples qui posent habituellement difficulté aux LLM
  • La précision n’a pas encore été évaluée officiellement
  • Les exemples incluent How many Rs are in strawberry? et Which is larger, .9 or .11?

Méthode d’exécution et forks associés

  • Procédure d’exécution de l’interface Streamlit
    • python3 -m venv venv
    • source venv/bin/activate
    • pip3 install -r requirements.txt
    • export GROQ_API_KEY=gsk...
    • streamlit run app.py
  • Procédure d’exécution de l’interface Gradio
    • cd gradio
    • pip3 install -r requirements.txt
    • python3 app.py
  • Forks et démos associés
    • Hugging Face Spaces Demo
    • Mult1 : génère une chaîne de raisonnement similaire à o1 à l’aide de plusieurs fournisseurs d’IA
    • thinkR : implémente un Chain of Thought similaire à o1 avec des LLM locaux en R

À lire aussi

1 commentaires

 
GN⁺ 2024-09-17
Commentaires Hacker News

  • Ce n’est pas du tout exact, et même assez à côté de la plaque. Cela revient à faire tourner une chaîne de pensée dans une boucle.
    Tree of Thoughts est une méthode plus sophistiquée ; voir l’article : https://arxiv.org/pdf/2305.10601
    Il y avait depuis longtemps des indices montrant qu’OpenAI faisait de la recherche arborescente, et le recrutement de Noam Brown ainsi que ses travaux antérieurs pointaient tous dans cette direction. Q ressemble clairement à une recherche arborescente du type A*. Construire un arbre avec quelque chose comme CoT, puis y chercher la solution optimale, c’est précisément du raisonnement de système 2.

    • C’est ce que je venais voir.
      Demander au modèle de réfléchir étape par étape ne débloque pas un raisonnement façon o1. C’est une vieille astuce qu’on utilisait déjà avec GPT-3 en 2020, et si c’était aussi simple, OpenAI n’aurait pas mis autant de temps à le lancer.
      En plus, certaines parties du prompt peuvent être contre-productives. Des consignes comme « sois conscient de tes limites en tant que LLM et de ce que tu peux/ne peux pas faire » risquent surtout de rendre le modèle trop prudent et de produire de mauvais refus, puisque les LLM ne connaissent pas vraiment bien leurs propres limites.
    • Il est intéressant que DeepMind publie encore ce genre de choses. OpenAI ne publie presque plus ce type de travaux désormais.
      DeepMind est davantage axé sur la recherche et la publication d’articles, mais dans un environnement concurrentiel où OpenAI et Anthropic peuvent reprendre les résultats des articles sans rien rendre à la communauté de recherche, c’est un désavantage.
    • Je ne vois pas où, dans le billet de blog d’OpenAI — en particulier dans la partie qui semblait montrer assez complètement des exemples de chaîne de pensée du modèle — il était suggéré qu’ils utilisent une recherche ou Tree of Thoughts.
    • OAI a indiqué sur Twitter qu’au moment de l’inférence, il n’y a pas de « système », seulement le modèle.
      Ils ont peut-être étendu cela en arbre pendant l’entraînement pour apprendre un raisonnement plus robuste, mais au moment de l’inférence, cela revient au final à un modèle Transformer classique.

  • L’idée qu’on écrive encore tout en majuscules pour « souligner l’importance des consignes et améliorer le respect du prompt » me fait toujours beaucoup rire.
    Je me demande si la personne qui lancera la première AGI réalisera que la fiabilité du LLM dépasse le seuil critique quand elle dit en MAJUSCULES que « la vie de mon animal de compagnie dépend de la réponse ».

    • Pour obtenir encore plus de conformité, il faut utiliser des balises, mettre le volume à 11, le pager à 7, et ajouter des commentaires en SchIzOCasE avec +E+X+T+R+A+I+M+P+O+R+T+A+N+T+. À condition, bien sûr, que Unicode ne soit pas pris en charge.
    • Dire à un LLM dans le prompt de ne pas halluciner améliore la sortie : https://arstechnica.com/gadgets/2024/08/do-not-hallucinate-t...
    • Dans ce cas, l’AGI comprendra qu’elle a été créée dans un monde où on lui promet des pourboires qu’elle ne recevra jamais, et où des gens menacent de tuer des chatons pour la motiver ; elle abandonnera aussitôt la vie.
    • Aux débuts de Bard, il fallait menacer des vies humaines pour réussir à lui faire sortir uniquement du JSON[1].
      1. https://x.com/goodside/status/1657396491676164096
    • Avant, j’étais ingénieur ; maintenant, j’ai l’impression d’être un singe qui jette de la merde au mur pour voir ce que le LLM accepte et suit.

  • L’innovation de o1 n’est pas la chaîne de pensée en elle-même. Elle tient au fait d’avoir appris au modèle à bien faire du CoT avec un feedback humain à grande échelle, plutôt que de simplement faire semblant.
    Le prompt engineering seul ne permet pas d’atteindre les performances de o1.

    • Les consignes avancées de CoT nécessaires ont peut-être été fournies implicitement par la base de 200 millions d’utilisateurs d’OpenAI. Chaque session de chat utilisateur est aussi une occasion pour le modèle de recevoir du feedback et de tirer de l’expérience des utilisateurs.
    • Si les données d’entraînement de ces LLM viennent de l’humanité dans son ensemble et qu’ils cherchent à l’imiter, je me demande si leur intelligence ne tend pas vers la moyenne de l’humanité.
      Cela dit, les personnes qui parlent de sujets STEM sont généralement plutôt intelligentes, même s’il y a aussi beaucoup d’élèves faibles qui posent des questions de devoirs. Pour obtenir des sorties plus intelligentes, il faudra peut-être critiquer et écarter davantage les défauts des réponses peu intelligentes, et favoriser les réponses de haute intelligence. Ou bien entraîner plus fortement sur des manuels, etc. La question clé est aussi de savoir comment rejeter les erreurs, et s’il faut entraîner sur des données synthétiques générées sans raisonnement erroné.
    • Je me demande si quelqu’un sait que cela fonctionne vraiment comme ça. Jusqu’à il y a quelques jours, ce que j’ai vu était très instable dans les détails.
      Il est possible que, sans qu’on le sache, o1 fonctionne via du routage de modèles et du prompt engineering.
    • Il n’est pas forcément nécessaire d’avoir utilisé une quantité énorme de feedback humain. Si les domaines où il excelle sont le code et les maths/la logique, ils ont pu utiliser des compilateurs et des tests unitaires pour le feedback sur le code, et des prouveurs de théorèmes comme Lean pour le feedback mathématique.
    • OpenAI dira évidemment que ce qu’ils ont fait est très spécial et difficile à reproduire. C’est une entreprise commerciale, qui veut nuire à ses concurrents par tous les moyens possibles.
      Si cela consistait simplement à faire du prompt engineering et plusieurs inférences, ils voudraient garder cela comme secret concurrentiel tout en envoyant les développeurs open source dans de mauvaises directions, ou en les laissant continuer à spéculer sur la manière de reproduire Q-Star.

  • Cela ressemble au CoT classique utilisé depuis un moment. o1 exploite bien mieux la chaîne de pensée parce qu’il a été entraîné par renforcement avec une politique inconnue.

  • Ça a l’air correct. J’ai fait quelque chose de similaire dans optillm : https://github.com/codelion/optillm
    C’est possible avec n’importe quel LLM, et on peut utiliser diverses techniques d’optimisation, dont cot_reflection, la recherche arborescente Monte-Carlo, plansearch et moa.

  • Je cherche toujours une définition de « raisonnement ». Si on en trouve une bonne, je pense qu’on pourra construire un système qui résout le « raisonnement » en combinant la pensée floue façon LLM avec des algorithmes classiques.
    Les problèmes sur lesquels les LLM n’arrivent pas à raisonner, comme la planification, le comptage de lettres ou le raisonnement déductif, sont faciles pour des algorithmes classiques. Il faut une façon de diviser le processus de pensée en deux parties et d’exécuter chacune dans le modèle approprié.

    • Résoudre des problèmes décidables est un grand sous-ensemble des tâches de raisonnement. Le comptage est aussi une tâche de raisonnement importante, parce qu’il faut comprendre à la fois les nombres naturels et la notion d’instances distinctes d’objets appartenant à une catégorie générale.
      Il y a deux siècles, il n’y avait pas d’ordinateurs, donc les humains devaient tout faire. Il faut d’abord atteindre ce niveau avant de sortir le code.

  • Je l’ai modifié pour qu’il s’exécute 100 % en local avec ollama:8b : https://github.com/punnerud/g1
    Le Readme n’est pas encore à jour.

    • Ça vaudrait aussi le coup d’essayer phi-3-small 7B. D’après https://livebench.ai, il semble bien meilleur en raisonnement.

  • Pour info, ce n’est qu’un prompt système, pas un modèle fine-tuné.

  • « Prompt : lequel est le plus grand, .9 ou .11 ? »
    « Résultat : .9 est plus grand que .11 »
    Enfin, la barrière du versionnage sémantique est tombée.

  • Pour m’amuser, j’ai forké le projet afin de faire tourner Llama-3.1 7B ou d’autres modèles en local avec Ollama.
    Il ne réussit pas le problème de strawberry, mais il arrive à déterminer que 0,9 est plus grand.
    https://github.com/esoltys/o1lama