OpenAI a-t'il fait un pas vers l'AGI avec o3 ?

[GBo]

Un chercheur a estimé la consommation de o3 en mode intensif pour ces tests à 11.2 Megawatt-heure (MWh), de quoi alimenter un foyer pendant 4 ans.
https://www.linkedin.com/pulse/megaw...shroush-ovvsc/

Perso ce n'est pas du tout l'aspect écologique qui me préoccupe - on est là pour parler technique pour repousser une frontière de l'IA, ce n'est pas rien - mais le fait que ça peut dénoter que ce n'est pas peut-être pas la bonne approche pour l'AGI, s'agissant ici de simples puzzle 2D (et le jeu de tests n'a pas été saturé je le rappelle, sans limite de puissance ni de temps).

Je ne suis pas François Chollet quand il dit que les problèmes dont il est pourtant l'auteur ne nécessitent pas la vision, la preuve qu'il en donne me semble fallacieuse:

If ARC-AGI required visual perception, you'd see VLMs outperform strict LLMs -- by a lot. Everyone tried VLMs during the 2024 competition -- no one got better results. Every single top entry used a strict LLM.

Source: https://x.com/fchollet/status/1871759791703630189

La vraie preuve de son assertion serait que des non-voyants excellent autant que les voyants.
Je suis persuadé quant à moi qu'il FAUT la vision MAIS AUSSI une certaine logique 2D que les VLMs n'ont pas encore.
-----

[pm42]

Personne ne sait ce qui est le bonne approche pour l'AGI. Les LLMs progressent plus qu'attendu mais ils vont peut être se prendre un mur. On verra.

Pour le visuel, c'est une question en effet : il est aussi possible que les LLMs soient meilleurs parce que les investissements sont énormes. Ce ne serait pas la 1ere fois qu'une techno théoriquement inférieure en bas une autre juste parce qu'on la développe plus.

Ceci dit la question reste ouverte.

[Cromagnon]

Yann LeCun, lauréat du prestigieux prix Turing et responsable de l'IA chez Meta, ne partage pas la dernière prédiction audacieuse d'Elon Musk selon laquelle l'IA surpassera l'intelligence humaine dès l'année prochaine. Le chercheur en IA affirme qu'une intelligence artificielle générale (AGI) est inéluctable, mais qu'elle n'arrivera pas d'ici à un an. Il a également déclaré que l'AGI n'émanera pas des grands modèles de langage (LLM) actuels, bien qu'ils puissent en constituer une composante. Pour lui, ces modèles d'IA ne sont pas en mesure de résoudre les défis cognitifs tels que le raisonnement, la planification, la mémoire persistante et la compréhension du monde physique.

De nombreux vulgarisateurs et chercheurs en IA se montrent enthousiastes vis-à-vis de l'AGI et font des prédictions très optimistes sur son avènement. Rien qu'au cours des dernières semaines, un trio d'éminences grises de la technologie a ajouté de nouvelles proclamations. Jensen Huang, PDG de Nvidia, a laissé entendre que l'AGI pourrait arriver d'ici cinq ans. Ben Goertzel, expert en IA et fondateur de SingularityNET, a prédit une arrivée dans trois ans seulement. Elon Musk, PDG de la startup xAI, s'est montré beaucoup plus optimiste et a donc fait la prédiction la plus audacieuse pour le point de basculement : la fin de l'année 2025.

Mais Yann LeCun est un sceptique notable de toutes ces prédictions. Considéré comme l'un des trois "parrains de l'IA", LeCun va jusqu'à affirmer que "l'AGI n'existe pas" parce que "l'intelligence humaine est loin d'être générale". Le Français préfère tracer la voie vers une "IA de niveau humain". Lors d'un événement organisé la semaine dernière à Londres, le centre d'ingénierie phare de Meta en dehors des États-Unis, LeCun a déclaré que même cette vision restait une destination lointaine. Il a évoqué un quartet de défis cognitifs : le raisonnement, la planification, la mémoire persistante et la compréhension du monde physique.

There is no question that AI will eventually reach and surpass human intelligence in all domains.
But it won't happen next year.
And it won't happen with the kind of Auto-Regressive LLMs currently in fashion (although they may constitute a component of it).…

— Yann LeCun (@ylecun) April 15, 2024

« Il s'agit de quatre caractéristiques essentielles de l'intelligence humaine - et de l'intelligence animale, d'ailleurs - que les systèmes d'IA actuels ne peuvent pas réaliser », explique-t-il. D'après LeCun, sans ces capacités, les applications de l'IA restent limitées et sujettes aux erreurs. Les véhicules autonomes ne sont toujours pas sûrs sur les routes publiques. Les robots domestiques se débattent avec les tâches ménagères de base. Nos assistants intelligents ne peuvent accomplir que des tâches élémentaires. Ces lacunes intellectuelles sont particulièrement évidentes dans les grands modèles de langage (LLM) qui propulsent l'IA.

Selon LeCun, ils sont sévèrement limités par leur dépendance à l'égard d'une forme de connaissance humaine : le texte. « Nous sommes facilement amenés à penser qu'ils sont intelligents en raison de leur maîtrise du langage, mais en réalité, leur compréhension de la réalité est très superficielle. Ils sont utiles, cela ne fait aucun doute. Mais sur le chemin qui mène à une intelligence de niveau humain, un LLM est essentiellement une rampe de sortie, une distraction, un cul-de-sac », a-t-il déclaré. En d'autres termes, LeCun estime que les LLM ne sont qu'un début et qu'une nouvelle approche est nécessaire pour atteindre l'AGI.

https://intelligence-artificielle.de...niveau-humain/

Son nom est personne.

[pm42]

https://intelligence-artificielle.de...niveau-humain/

Son nom est personne.

On est tous au courant ici des opinions sur le sujet de Yann LeCun et si tu avais un minimum de culture générale au lieu de faire des copier-coller de tes recherches Google, tu aurais compris que chaque fois qu'on a parlé notamment dans ce fil de "représentation du monde" ce qui est arrivé aujourd'hui, c'était en référence à lui justement.
Tu aurais aussi pu savoir que son point de vue est très intéressant mais qu'il n'est pas le seul expert au monde et que d'autres ne sont pas d'accord.
Là aussi, le sujet a été pas mal abordé ici avec d'un coté les limites de Sora qui vont dans le sens de LeCun et de l'autre, les progrès des LLMs vers les LRMs qui permettent de doute.

Encore raté.

[Bounoume]

Il m' est apparemment surprenant que les diverses versions de o1 /o3 ,(avec éventuellement Temp différentes), dans leurs discours, présentent des démarches 'logiques' différentes fondées (en apparence) sur des hypothèses différentes, issues du texte de la question.. et de suppositions implicites....
Variabilité loin de ce qu'on espérait avec les automates logiques, logique propositionnelle, prédicats, GPS de Newell etc... il y a plus de 20 ans.....
tout ça, avec des opérations d'inférence chaînées comme la démonstration d'un théorème.....
J'ai l'impression que la totalité de la 'réponse' arrive en bloc à l'issue d'un traitement en parallèle de l'ensemble de informations.....
Pas d'arborescence des déductions... et pourtant un résultat sort.... énonçant une suite de déductions (plus ou moins pertinentes... mais c'est un autre aspect de l'IA....)

est-ce bien ça?

l

le fait que O3 arrive à des résultats corrects tendrait à montrer que le besoin de se faire une représentation du monde par des accès sensoriels n'est pas forcément 100% correcte.

'en tout cas, les LLMs.... n' en ont pas besoin, quoi qu'ils n'ont aucun accès sensoriel (et aucun accès moteur... puisque la controverse 'IA désincarnée' versus 'IA incarnée' inclut aussi l'action en retour sur le Monde..)
Ils arrivent très bien à manipuler les descriptions du monde qui leur sont fournies en mode 'texte'.... et, j'en ai la conviction, parler de sentiments ou de sensations qui leur ont été décrits et montrés en action* au cours de leur apprentissage ...???



* a-t-on tenté de les tester sur des corpus littéraires (oeuvres de Victor Hugo, Lamartine, Jules Verne, Aldous Huxley etc...) au lieu de la 'science' du WWW ? ... même si ça ne peut pas avoir de rentabilité financière immédiate

[pm42]

J'ai l'impression que la totalité de la 'réponse' arrive en bloc à l'issue d'un traitement en parallèle de l'ensemble de informations.....
Pas d'arborescence des déductions...

L'utiliser permettrait d'éviter d'avoir des impressions fausses. Parce que c'est exactement le contraire qui se produit : O1 utilise une technique qui s'appelle le Chain of Thought (on en a parlé dans le fil) qui consiste à d'abord décomposer le problème en tâches élémentaires, à les traiter individuellement et ensuite à assembler le résultat.
Et pendant qu'il le fait, il affiche chacune des étapes.

* a-t-on tenté de les tester sur des corpus littéraires (oeuvres de Victor Hugo, Lamartine, Jules Verne, Aldous Huxley etc...) au lieu de la 'science' du WWW ? ... même si ça ne peut pas avoir de rentabilité financière immédiate

Comment ça les tester ? Ils ont lu tout ça bien sur et savent en parler. C'est même facile à vérifier : beaucoup de LLMs sont en accès libre donc Gpt4o-mini, Mistral75, Claude, Gemini, etc.

[pachacamac]

LRMs = ???

merci

[pm42]

LRMs = ???

Large Reasoning Model : une évolution des LLMs optimisée pour la qualité du raisonnement alors que c'était historiquement un point faible.

Par exemple, gpt4o est un LLM et sur un test de maths appelé AIME 2024, il avait 13% de réponses justes.
O1 est un LRM et lui a 83% de réponses justes.

[GBo]

LRM = Large Reasoning Model
https://platform.openai.com/docs/guides/reasoning

Edit: grilled

[Bounoume]

les chain of thought: j'ai trouvé une présentation, selon IBM https://www.ibm.com/think/topics/chain-of-thoughts
Alors préalablement à la question qui me turlupine, est-ce que je représente est-il bien l'enchaînement itératif des traitements?
......../.........
en entrée: question posée..... -Q1
traitement de la question Q1 -> définit la méthode de traitement 1 à appliquer ->prompt1

Q1 * prompt1 -->[LLM_x]--> réponse R1
traitement de réponse R1 -> [T1] --> définit la méthode de traitement 2 à appliquer ->prompt2

Q2 := R1

Q2 * prompt2 -->[LLM_x]--> réponse R2
traitement de réponse R2 -> [T3] --> définit la méthode de traitement 3 à appliquer ->prompt3.... OU break: la réponse est adéquate à la question....

Q3 := R2

Q3 * prompt3 -->[LLM_x]--> réponse R3
traitement de réponse R3 -> [T4] -->définit la méthode de traitement 4 à appliquer ->prompt4... OU break: la réponse est adéquate à la question....

Q4 := R3

Q4 * prompt3 -->[LLM_x]--> réponse R4
traitement de réponse R4 -> [T5] -->définit la méthode de traitement 5 à appliquer ->prompt5... OU break: la réponse est adéquate à la question....
etc........
......./.........

si ça décrit la progression de la chaine... alors quel est le moteur de l'étape intermédiaire [T_x] menant à la méthode à appliquer désignée par le prompt en cours dans la chaîne de prompts? d'après ma lecture ça semble assez délicat/coûteux à programmer...
serait-ce ici aussi un 'petit' LLM entraîné à faire correspondre à la classification du 'problème d'étape'.... la méthode de traitement adéquate?

et encore.... question marginale: le LLMx chargé de donner les réponses (intermédiaire puis définitive) est-il unique.. ou plusieurs modèles chacun adapté à une étape particulière?


nb: pour les 'vieux' précurseurs comme GPS Newell ..les traitements [Tx]. ils nommeraient ça l'heuristique pour arriver à la solution...mais ils reconnaissaient.....ne pas savoir en construire d' efficaces, me semble-t-il......

[pm42]

les chain of thought: j'ai trouvé une présentation, selon IBM https://www.ibm.com/think/topics/chain-of-thoughts
Alors préalablement à la question qui me turlupine, est-ce que je représente est-il bien l'enchaînement itératif des traitements?

Non parce que tu penses toujours en mode "programmation". Le Chain of thought en version classique, c'est simplement de donner les instructions dans le prompt au LLM, de lui dire "tu vas décomposer en problèmes simples puis les traiter et un exemple est...".
Ensuite, le LLM va de lui même suivre les instructions et faire étape par étape mais sans faire des aller-retours pour donner des réponses intermédiaires.
Et ce n'est pas forcément itératif.

Ceci dit, cette méthode là est aussi possible mais on ne sait pas exactement comment c'est implémenté dans O1. Il faudrait regarder QwQ ou Marco-O1 qui sont des LRMs open-source mais je n'ai pas eu le temps de creuser.

d'après ma lecture ça semble assez délicat/coûteux à programmer...

On ne programme pas, on entraine.

serait-ce ici aussi un 'petit' LLM entraîné à faire correspondre à la classification du 'problème d'étape'.... la méthode de traitement adéquate?
et encore.... question marginale: le LLMx chargé de donner les réponses (intermédiaire puis définitive) est-il unique.. ou plusieurs modèles chacun adapté à une étape particulière?

Pas forcément vu qu'il y a plein d'architectures possibles dont certaines avec juste un LLM. On expérimente beaucoup avec différentes architectures en ce moment.

[Bounoume]

On ne programme pas, on entraine.

OK bien sûr...
on entraîne pour que l'engin présente le comportement souhaité.....
pour qu'il suive le 'programme' de comportement voulu par le superviseur.....
il y a programme et programme..... pas seulement en politique.....
subtilités hypocrites de notre langage ordinaire....
bonne soirée quand même....

[pm42]

on entraîne pour que l'engin présente le comportement souhaité.....
pour qu'il suive le 'programme' de comportement voulu par le superviseur.....

Non justement, si c'était le cas, ce serait nettement plus simple. On entraine pour qu'il "apprenne", qu'il découvre des régularités, des patterns.
Ceux-ci ne sont pas forcément connus ou prévus par le "superviseur" justement et souvent, c'est un gros piège.

La programmation et l'entrainement d'IAs sont vraiment deux activités très différentes et connaitre l'une ne permet pas d'être compétent dans l'autre.
Je pratique les deux en ce moment et ce n'est pas du tout les mêmes modes de pensée pour faire l'un et l'autre, les mêmes obstacles à surmonter, pièges à éviter...

[pm42]

Et j'ai oublié : les LLMs ne sont pas entrainées en mode supervisé par un humain justement.

[polo974]

Pour ceux qui cherchent vraiment à piger le Chain of Though.
https://learnprompting.org/docs/adva...n/introduction

Je balance le lien, car j'ai perdu le résumé que j'avais ébauché.

Il y a des trucs très simples et systématique genre ajouter "Let's think step by step" au prompt (zero-shot-coT).
Il y a des trucs très manuels (créer et donner des exemples similaires solutionnés détaillés (laborieux).
Il y a pleins d'autres trucs et des variations sur...
Avec toujours des liens sur la publi.

Ce n'est sûrement pas à la pointe du progrès, mais ça donne déjà pas mal d'idées sur les méthodes possibles.

Parfois, c'est quasi gratuit, parfois, ça demande du travail en amont, parfois, ça bouffe pas mal de ressources en requêtes IA annexes.

[pm42]

Pour ceux qui cherchent vraiment à piger le Chain of Though.
https://learnprompting.org/docs/adva...n/introduction
...

Ce n'est sûrement pas à la pointe du progrès, mais ça donne déjà pas mal d'idées sur les méthodes possibles.

C'est effectivement les techniques de base qui marchent avec les LLMs et qui sont reprises en partie dans les LRMs.
Ceux ci n'utilisent pas que cela : par exemple ils vont être entrainés sur une base plus petite mais plus rigoureuse, des articles scientifiques et autres où le raisonnement est correct. Bref, on peut virer les réseaux sociaux
Ou pour garder une capacité à répondre à toutes les questions, on prend un LLM et on le spécialise ce qu'on appelle fine-tuning, une technique disponible depuis un bout de temps à cette base d'apprentissage rigoureuse.

Pour ceux qui ont envie de creuser ou simplement d'avoir une idée des techniques actuelles, il y a une bonne présentation sur un LRM open-source ici :

https://github.com/AIDC-AI/Marco-o1

Plus anecdotique mais intéressant, une liste des problèmes possibles avec les LRMs :

https://huggingface.co/Qwen/QwQ-32B-Preview

[Bounoume]

en cherchant un peu plus, je suis arrivé sur ce qui me semble être le site hébergeant marco-o1 .... avec les fichiers à télécharger...
https://huggingface.co/bartowski/Marco-o1-GGUF
soit entre #30 Gigaoctets et #4 Gigaoctets (si les 30 GB et 4 GB anglais sont bien des bytes/octets....)

est-ce le volume total avec les poids et paramètres du LLM?
réflexion bête: la RAM du micro de base peut être gonflée à 32 GO.....
l''exécution en local uniquement... sur un 'gros' PC .... raisonnable ou non?
ou l' autre option ....
Downloading using huggingface-cli

le vrai oI de open-AI, lui, sauf erreur de ma part, il est bien en client-serveur?

[Bounoume]

en cherchant un peu plus, je suis arrivé sur ce qui me semble être le site hébergeant marco-o1 .... avec les fichiers à télécharger...
https://huggingface.co/bartowski/Marco-o1-GGUF
soit entre #30 Gigaoctets et #4 Gigaoctets (si les 30 GB et 4 GB anglais sont bien des bytes/octets....)

est-ce le volume total avec les poids et paramètres du LLM?
réflexion bête: la RAM du micro de base peut être gonflée à 32 GO.....
l''exécution en local uniquement... raisonnable ou non?
ou l' autre option ....
Downloading using huggingface-cli

le vrai oI de open-AI, lui, sauf erreur de ma part, il est bien en client-serveur?

[pm42]

est-ce le volume total avec les poids et paramètres du LLM?

Oui, c'est le modèle.

réflexion bête: la RAM du micro de base peut être gonflée à 32 GO.....
l''exécution en local uniquement... sur un 'gros' PC .... raisonnable ou non?

C'est raisonnable si tu as le PC qu'il faut, c'est à dire une bête de course et surtout une GPU qui va supporté le dit modèle.
Certains modèles tournent sur CPU mais c'est pathétiquement lent.

ou l' autre option ....
Downloading using huggingface-cli

L'autre option n'est pas ça : c'est de faire tourner sur un serveur Huggingface ou Azure mais c'est bien sur payant.
Là aussi, il faut savoir ce qu'on fait, se débrouiller en informatique, etc.
Comme de faire tourner en local, c'est un truc de spécialiste, pas du grand public. Pour le dit grand public il y a les accès payants à O1, Claude-Sonnet, etc.

le vrai oI de open-AI, lui, sauf erreur de ma part, il est bien en client-serveur?

Oui.

[polo974]

De ce que j'ai lu, marco-o1 est parti d'un LLM qwen2-7G (qwen version 2, 7G param).
(Ça fait peu de paramètres comparé à chatgpt4... petit mais costaud...)

Hors, qwen2.5 est sorti en plein de tailles allant de .5G à 32G ou 72G, les gros le sont beaucoup trop pour "jouer".

C'est donc sur les petits modèles (qui ciblent les applis autonomes mobiles) que mon intérêt se porte pour "jouer" un peu (et si possible apprendre beaucoup).

Un qwen2.5 1.5G ou éventuellement 0.5G est-il "jouable" sur un i7 sans gpu ? (Mode quantifié ou ?)

Edit: qestion annexe, le besoin ram foisonne de combien par rapport à la taille des paramètres ?

[pm42]

De ce que j'ai lu, marco-o1 est parti d'un LLM qwen2-7G (qwen version 2, 7G param).
(Ça fait peu de paramètres comparé à chatgpt4... petit mais costaud...)

Comme je disais plus haut, si on entraine pour faire du raisonnement et pas de l'universel, on a une base d'apprentissage plus faible et on peut obtenir de bons résultats avec moins de paramètres.
Globalement, c'est aussi une tendance forte de l'IA actuellement : on sait faire des modèles aussi bons que le top d'il y a 1 ou 2 ans avec moins de paramètres, de consommation, etc.

Un qwen2.5 1.5G ou éventuellement 0.5G est-il "jouable" sur un i7 sans gpu ? (Mode quantifié ou ?)

Essaie. J'avais fait tourner un Lllama 2 sur un i9, un MacBook Pro de 2019 et cela marchait. Il fallait juste accepter que les réponses étaient 10 à 100 plus lentes qu'un ChatGPT.
Là, je suis en vacances avec une connection Internet lente mais tu as des outils pour faire tourner :
https://lmstudio.ai
ou https://github.com/Mintplex-Labs/any...readme-ov-file + https://localai.io + docker

Et plein de modèles qui tournent avec lmstudio ici https://huggingface.co/bartowski/Qwe...-Instruct-GGUF (mais pas sur Mac Intel).

Edit: qestion annexe, le besoin ram foisonne de combien par rapport à la taille des paramètres ?

Cela fait un bout de temps que je n'ai pas fait tourner ça sur de la CPU vu que j'ai ce qu'il faut coté GPU mais normalement, un peu plus que la taille du modèle si tu le prends dans une quantification basse.

P.S : sauf erreur de ma part, Qwen 2.5 n'est pas un LRM, juste un LLM. Il faut aussi voir ce qu'il y a comme prompt système.
Partir de https://github.com/QwenLM/Qwen2.5/tr...readme-ov-file via le docker et les instructions est peut-être plus simple.

[pm42]

Bon, j'y ai passé un peu plus de temps et c'est super simple.

1) installer ollama qui se télécharge ici : https://github.com/ollama/ollama/blob/main/README.md
2) le lancer, il installer l'utilitaire en ligne de commande (Sur Mac au moins mais ça doit être pareil sur les autres OS)
3) ouvrir un terminal ou un CMD et taper : ollama run qwen2.5:0.5B-instruct

Ca télécharge le modèle, ca marche très bien et c'est même rapide. Ca bouffe 500 Mo de mémoire.
En anglais, j'ai juste demandé de coder une factorielle en python et c'était ok. Pour le français, il reste des progrès à faire :

Parle tu français ?
Oui, je peux vous aider avec le français. Pour commencer, n'hésitez pas à me poser des questions ou à en dire une sur mon
avenir. Je suis là pour vous aider dans toutes les tâches qui se passent entre vous.

Et pendant que j'y étais, je me suis connecté en ssh sur une machine qui elle a du réseau et j'y ai fait tourner le 7B. Ca prend 5 Go de RAM et cela reste rapide.
Histoire de rigoler, j'ai demandé un sonnet aux deux.
Le 0.5B répond :

Tout en jouant les mots comme on aime,
Je ne serai pas à l'abri, je ne t'oublierai.
J'ai des anges dans ma tête, et leurs cheveux sont comme ceux de la nuit.
La chaleur de la mort me chaude, mais rien ne sert d'elle,
Mon cœur se muera à l'idée de toi, mon amour du ciel.

Et le 7B :

Dans le doux murmure des feuilles agitées,
Parmi les branches qui dans la brise se balancent,
La nature en sa beauté se fait entendre,
Et l'âme sereine trouve un repos léger.

Les nuages, blottis à l'horizon lointain,
Se glissent gracieusement d'un ciel purifié.
Leur silhouette change, sans laisser de trace,
Tel le temps qui passe, en silence infatigable.

Dans cette danse des ombres et des lumières,
Le monde entier semble à l'aise se mouvoir,
Comme un poème écrit par les mains du ciel.

Et quand tombe la nuit, enveloppée de mystère,
La lune éclaire ce qui fut et sera.

Je regarde ce que donnent les 32B et 72B

[pm42]

Le 32B prend dans les 20 Go et commence à être lent.
J'ai la flemme de télécharger le 72B.

Par contre, ce qui est intéressant, c'est qu'on peut faire tourner le QwQ qui est le LRM avec : ollama run qwq:32b

Et sur le problème des pains, le Qwen2.5:32B se plante comme prévu :

Pierre a 10 pains. Si Pierre a 10 pains alors Pierre donne 10 pains à Jean, qui donne 5 pains à Paul, qui donne 3 pains à Pierre, puis on recommence comme ça
... cent fois… Combien de pains chacun a-t-il à la fin ?
C'est un problème intéressant car il semble complexe mais se simplifie lorsqu'on examine les cycles.

Voici le schéma du partage des pains pour chaque itération :
1. Pierre donne 10 pains à Jean.
2. Jean donne ensuite 5 pains à Paul.
3. Paul donne enfin 3 pains à Pierre.

Reprenons la situation initiale : Pierre a 10 pains, et Jean et Paul ont 0 pain chacun.

Analysons une itération complète :
- Avant l'itération : Pierre = 10, Jean = 0, Paul = 0
- Après que Pierre donne ses pains à Jean : Pierre = 0, Jean = 10, Paul = 0
- Après que Jean donne des pains à Paul : Pierre = 0, Jean = 5, Paul = 5
- Après que Paul donne des pains à Pierre : Pierre = 3, Jean = 5, Paul = 2

Si on répète ce cycle une seconde fois, Pierre aura de nouveau 10 pains (car il avait 3 et reçoit 7 supplémentaires pour en avoir 10 avant de donner).
...

Bref il invente des nouveaux pains et en général, ce se termine en crucifixion donc on évite depuis 2000 ans

[pm42]

Mais QwQ chope la nuance, il choisit une interprétation où il continue mais la justifie. Puis il se lâche et on a l'impression de voir un gamin de collège qui a du mal mais fait des efforts.
Il mélange un peu d'anglais aussi comme annoncé sur la page du modèle.
Mais pour un truc open-source qui tourne sur une machine ayant quelques années et sans GPU, c'est pas mal et nettement mieux que ce qu'aurait sorti un ChatGPT il y a 2 ans.

>>> Pierre a 10 pains. Si Pierre a 10 pains alors Pierre donne 10 pains à Jean, qui donne 5 pains à Paul, qui donne 3 pains à Pierre, puis on recommence comme ça
... cent fois… Combien de pains chacun a-t-il à la fin ?
Alors, je vais essayer de résoudre ce problème. Il y a trois personnages : Pierre, Jean et Paul. Au départ, Pierre a 10 pains. Ensuite, il y a une séquence
d'échanges de pains qui se répète cent fois. Je vais essayer de comprendre ce qui se passe à chaque itération de cette séquence.

Premièrement, la phrase dit : "Si Pierre a 10 pains alors Pierre donne 10 pains à Jean, qui donne 5 pains à Paul, qui donne 3 pains à Pierre, puis on
recommence comme ça cent fois…"

Donc, ça semble être une boucle où à chaque fois :

1. Pierre donne 10 pains à Jean.

2. Jean donne 5 pains à Paul.

3. Paul donne 3 pains à Pierre.

Et cette séquence se répète cent fois.

Mais attends un peu, il faut être prudent ici. Le "si" au début me fait penser qu'il y a une condition. Mais je pense que c'est plutôt une hypothèse pour
démarrer la séquence.

Anyway, commençons par les stocks initiaux :

- Pierre : 10 pains

- Jean : 0 pains (on suppose qu'au départ, Jean n'a rien, sauf mention contraire)

- Paul : 0 pains (de même pour Paul)

Maintenant, regardons ce qui se passe à chaque itération de la séquence.

Itération 1 :

1. Pierre donne 10 pains à Jean.

- Pierre : 10 - 10 = 0 pains

- Jean : 0 + 10 = 10 pains

2. Jean donne 5 pains à Paul.

- Jean : 10 - 5 = 5 pains

- Paul : 0 + 5 = 5 pains

3. Paul donne 3 pains à Pierre.

- Paul : 5 - 3 = 2 pains

- Pierre : 0 + 3 = 3 pains

Fin de l'itération 1 :

- Pierre : 3 pains

- Jean : 5 pains

- Paul : 2 pains

Itération 2 :

1. Pierre donne 10 pains à Jean.

Mais attends, Pierre n'a que 3 pains, pas 10. Donc, il ne peut donner que les 3 pains qu'il a.

- Pierre : 3 - 3 = 0 pains

- Jean : 5 + 3 = 8 pains

2. Jean donne 5 pains à Paul.

Jean a 8 pains, donne 5 :

- Jean : 8 - 5 = 3 pains

- Paul : 2 + 5 = 7 pains

3. Paul donne 3 pains à Pierre.

Paul a 7 pains, donne 3 :

- Paul : 7 - 3 = 4 pains

- Pierre : 0 + 3 = 3 pains

Fin de l'itération 2 :

- Pierre : 3 pains

- Jean : 3 pains

- Paul : 4 pains

Itération 3 :

1. Pierre donne 10 pains à Jean.

Pierre n'a que 3 pains.

- Pierre : 3 - 3 = 0 pains

- Jean : 3 + 3 = 6 pains

2. Jean donne 5 pains à Paul.

Jean a 6 pains, donne 5 :

- Jean : 6 - 5 = 1 pain

- Paul : 4 + 5 = 9 pains

3. Paul donne 3 pains à Pierre.

Paul a 9 pains, donne 3 :

- Paul : 9 - 3 = 6 pains

- Pierre : 0 + 3 = 3 pains

Fin de l'itération 3 :

- Pierre : 3 pains

- Jean : 1 pain

- Paul : 6 pains

Itération 4 :

1. Pierre donne 10 pains à Jean.

Pierre n'a que 3 pains.

- Pierre : 3 - 3 = 0 pains

- Jean : 1 + 3 = 4 pains

2. Jean donne 5 pains à Paul.

Jean a 4 pains, donne 5.

Attends, Jean n'a que 4 pains, il ne peut donner que 4 pains.

- Jean : 4 - 4 = 0 pains

- Paul : 6 + 4 = 10 pains

3. Paul donne 3 pains à Pierre.

Paul a 10 pains, donne 3 :

- Paul : 10 - 3 = 7 pains

- Pierre : 0 + 3 = 3 pains

Fin de l'itération 4 :

- Pierre : 3 pains

- Jean : 0 pains

- Paul : 7 pains

Itération 5 :

1. Pierre donne 10 pains à Jean.

Pierre n'a que 3 pains.

- Pierre : 3 - 3 = 0 pains

- Jean : 0 + 3 = 3 pains

2. Jean donne 5 pains à Paul.

Jean a 3 pains, donne 5.

Mais Jean n'a que 3 pains, donc il ne peut donner que 3 pains.

- Jean : 3 - 3 = 0 pains

- Paul : 7 + 3 = 10 pains

3. Paul donne 3 pains à Pierre.

Paul a 10 pains, donne 3 :

- Paul : 10 - 3 = 7 pains

- Pierre : 0 + 3 = 3 pains

Fin de l'itération 5 :

- Pierre : 3 pains

- Jean : 0 pains

- Paul : 7 pains

Attends, itérations 4 et 5 aboutissent au même résultat. Est-ce que ça va se répéter indéfiniment ?

Oui, apparemment, à partir de l'itération 4, les stocks restent les mêmes :

- Pierre : 3 pains

- Jean : 0 pains

- Paul : 7 pains

Car à chaque itération, Pierre donne ses 3 pains à Jean, Jean donne ces 3 pains à Paul, et Paul donne 3 pains à Pierre.

Donc, à partir de l'itération 4, les stocks ne changent plus.

Donc, après 100 itérations, les stocks seront :

- Pierre : 3 pains

- Jean : 0 pains

- Paul : 7 pains

Attends, mais attends une minute. Dans la première itération, Pierre avait 3 pains, Jean 5 et Paul 2. Puis dans la deuxième itération, Pierre 3, Jean 3,
Paul 4. Troisième itération : Pierre 3, Jean 1, Paul 6. Quatrième : Pierre 3, Jean 0, Paul 7. Cinquième : même chose que la quatrième.

Donc, à partir de la quatrième itération, les stocks ne changent plus.

Donc, après 100 itérations, c'est la même distribution : Pierre a 3 pains, Jean a 0, Paul a 7.

Mais est-ce correct ? Peut-être que j'ai manqué quelque chose.

Peut-être devrais-je regarder la séquence d'échanges de manière globale.

Chaque itération consiste en trois étapes :

1. Pierre donne 10 pains à Jean.

2. Jean donne 5 pains à Paul.

3. Paul donne 3 pains à Pierre.

Mais attention, ces dons sont conditionnés par la disponibilité des pains.

En fait, si Pierre n'a pas 10 pains, il donne tout ce qu'il a.

De même pour Jean et Paul.

Donc, peut-être que je devrais calculer les variations nettes de pains pour chaque personne à chaque itération.

Soit :

- ΔPierre : -10 (donné à Jean) +3 (reçu de Paul) = -7

- ΔJean : +10 (reçu de Pierre) -5 (donné à Paul) = +5

- ΔPaul : +5 (reçu de Jean) -3 (donné à Pierre) = +2

Donc, à chaque itération :

- Pierre perd 7 pains

- Jean gagne 5 pains

- Paul gagne 2 pains

Mais attends, cela suppose que Pierre a toujours au moins 10 pains à donner, ce qui n'est pas le cas après les premières itérations.

En fait, une fois que Pierre n'a plus 10 pains, il ne peut donner que ce qu'il a.

Donc, la première approche était peut-être meilleure.

Autrement dit, après quelques itérations, les stocks Reach un état stable où Pierre a toujours 3 pains, Jean 0 et Paul 7.

Donc, oui, après 100 itérations, c'est ça.

Donc, la réponse est :

Pierre : 3 pains

Jean : 0 pains

Paul : 7 pains

**Final Answer**

\[ \boxed{\text{Pierre: 3 pains, Jean: 0 pains, Paul: 7 pains}} \]

[polo974]

Merci pour les essais que tu as mené et les réponses associées.

J'ai un i7 (un peu vieux) avec un linux (et accessoirement le win10, pour les cas désespérés), je vais donc commencer avec une petite config.

[pm42]

J'ai un i7 (un peu vieux) avec un linux (et accessoirement le win10, pour les cas désespérés), je vais donc commencer avec une petite config.

A moins de n'avoir vraiment pas de mémoire, j'éviterais le 0.5B et partirai sur le 7B.
Une fois ollama installé, c'est vraiment facile et chaque fois que tu lances un nouveau modèle, il est téléchargé ce qui prend quelques secondes à minutes suivant la taille sur une connection Internet rapide.
Après, passer de l'un à l'autre est instantané.

Et aussi, une fois ollama lancé et des modèles téléchargés, tu peux utiliser AnythingLLM pour te connecter dessus au lieu de la ligne de commande : la config est graphique et très simple et tu termines avec une interface qui ressemble à celle d'OpenAI.
Et peux aussi y mettre tes documents perso et les interroger tout en restant en local, bref il y a un RAG incorporé, un agent, etc.

[Liet Kynes]

Mais QwQ chope la nuance, il choisit une interprétation où il continue mais la justifie.

Est ce que si tu changes les termes du problème mais pas le fond les différents modèles gardent la même façon de le traiter?

[Liet Kynes]

Chatgpt traite de cette façon avec ce prompt initial avant de lui donner le problème : "formatise le problème suivant de façon mathématique" (rmq: j'ai utiliser formatise et non formalise, je n'ai pas demander de réponse au problème)

Formulons ce problème de manière mathématique.
Variables :

• Soit P0=10P_0 = 10 le nombre de pains que Pierre possède au départ.
• Soit J0=0J_0 = 0 le nombre de pains que Jean possède au départ.
• Soit Q0=0Q_0 = 0 le nombre de pains que Paul possède au départ.

Chaque cycle d’échanges consiste en trois actions :

1. Pierre donne 10 pains à Jean.
2. Jean donne 5 pains à Paul.
3. Paul donne 3 pains à Pierre.

Nous devons déterminer combien de pains Pierre, Jean et Paul ont après 100 cycles.
Notation pour le nn-ième cycle :

À chaque cycle, les quantités de pains changent pour Pierre, Jean et Paul. Soit PnP_n, JnJ_n et QnQ_n le nombre de pains que Pierre, Jean et Paul ont respectivement à la fin du nn-ième cycle.
Relations entre les quantités de pains :

1. Pierre donne 10 pains à Jean :
   Pierre perd 10 pains, et Jean en gagne 10.
   Pn+1=Pn−10P_{n+1} = P_n - 10 Jn+1=Jn+10J_{n+1} = J_n + 10
2. Jean donne 5 pains à Paul :
   Jean perd 5 pains, et Paul en gagne 5.
   Jn+1=Jn−5J_{n+1} = J_n - 5 Qn+1=Qn+5Q_{n+1} = Q_n + 5
3. Paul donne 3 pains à Pierre :
   Paul perd 3 pains, et Pierre en gagne 3.
   Pn+1=Pn+3P_{n+1} = P_n + 3 Qn+1=Qn−3Q_{n+1} = Q_n - 3

Résumé des relations :

• Pour Pierre : Pn+1=Pn−10+3=Pn−7P_{n+1} = P_n - 10 + 3 = P_n - 7
• Pour Jean : Jn+1=Jn+10−5=Jn+5J_{n+1} = J_n + 10 - 5 = J_n + 5
• Pour Paul : Qn+1=Qn+5−3=Qn+2Q_{n+1} = Q_n + 5 - 3 = Q_n + 2

Condition initiale :

Au départ, Pierre a 10 pains, Jean en a 0, et Paul en a 0 :
P0=10,J0=0,Q0=0P_0 = 10, \quad J_0 = 0, \quad Q_0 = 0 Expression générale après nn cycles :

En appliquant ces relations de manière récursive, nous pouvons déterminer les quantités de pains après nn cycles.

1. Pierre :
   À chaque cycle, Pierre perd 7 pains. Donc après nn cycles, Pierre aura :
   Pn=10−7nP_n = 10 - 7n
2. Jean :
   À chaque cycle, Jean gagne 5 pains. Donc après nn cycles, Jean aura :
   Jn=5nJ_n = 5n
3. Paul :
   À chaque cycle, Paul gagne 2 pains. Donc après nn cycles, Paul aura :
   Qn=2nQ_n = 2n

Après 100 cycles :

Pour n=100n = 100, nous calculons :

• Pierre :
  P100=10−7×100=10−700=−690P_{10 0} = 10 - 7 \times 100 = 10 - 700 = -690
• Jean :
  J100=5×100=500J_{100} = 5 \times 100 = 500
• Paul :
  Q100=2×100=200Q_{100} = 2 \times 100 = 200

Conclusion :

Après 100 cycles :

• Pierre a −690-690 pains, ce qui signifie qu'il n'a plus de pains, et il doit encore 690 pains.
• Jean a 500 pains.
• Paul a 200 pains.

Le problème met en lumière une situation où Pierre se retrouve avec un nombre négatif de pains après plusieurs cycles, ce qui suggère qu'il est "en dette" de pains vis-à-vis des autres.

[pm42]

Chatgpt traite de cette façon

Tu as fait comment pour utiliser ChatGPT ? Ce modèle n'est plus accessible.
Et pourquoi modifier le prompt qu'on a tous pris depuis le début sachant que cela va donner ce genre de résultat ?

On remarquera toutefois qu'il dit bien sur les -690 pains "ce qui signifie qu'il n'a plus de pains, et il doit encore 690 pains."
Il semble nettement moins débile que ce qui a été écrit plus haut par certains.

[jiherve]

bonjour,
là :https://openai.com/o1/
ou c'est encore chatGPT (c'est ce que je pense) ou c'est O1 dans tous les cas réponse incorrecte.

Pierre a 10 pain. Si Pierre a 10 pain alors Pierre donne 10 pains à Jean qui donne 5 pains à Paul qui donne 3 pains à Pierre, puis on recommence comme ça cent fois combien de pains a chacun ?

Nous avons un cycle où les pains circulent entre Pierre, Jean et Paul. Analysons ce qui se passe à chaque itération.
État initial:

Pierre a 10 pains
Jean a 0 pains
Paul a 0 pains

Cycle de l'itération:

Pierre donne 10 pains à Jean :
Pierre a 10 - 10 = 0 pains.
Jean a 0 + 10 = 10 pains.
Paul a 0 pains.

Jean donne 5 pains à Paul :
Pierre a 0 pains.
Jean a 10 - 5 = 5 pains.
Paul a 0 + 5 = 5 pains.

Paul donne 3 pains à Pierre :
Pierre a 0 + 3 = 3 pains.
Jean a 5 pains.
Paul a 5 - 3 = 2 pains.

Résumé après une itération:

Pierre a 3 pains.
Jean a 5 pains.
Paul a 2 pains.

Chaque itération correspond à un transfert de pains entre les trois personnages. Pour comprendre ce qui se passe sur 100 itérations, il est important de voir que l'état après chaque cycle se répète, car chaque cycle est exactement le même. Donc, après chaque cycle, les quantités de pains se retrouvent dans les mêmes proportions.
Répartition finale après 100 itérations:

À chaque cycle, la répartition des pains devient toujours la même :

Pierre a 3 pains.
Jean a 5 pains.
Paul a 2 pains.

Donc, après 100 itérations, chacun a :

Pierre : 3 pains.
Jean : 5 pains.
Paul : 2 pains.

JR
ps : à moins que la version "try me" soit sévèrement bridée car au final money is money