IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Mistral AI publie un nouvelle version de son modèle de langage open source. La startup française estime avoir le meilleur modèle
« en ce qui concerne les compromis coût / performance »

Le , par Stéphane le calme

5PARTAGES

13  0 
Mistral AI vient de publier une nouvelle version de son modèle de langage open source, baptisé Mixtral 8x7B, qui serait autant ou beaucoup plus performant que Llama 2 70B et GPT3.5 sur la plupart des benchmarks. Mixtral 8x7B a 46,7 milliards de paramètres au total mais n'utilise que 12,9 milliards de paramètres par jeton. Il traite donc les entrées et génère la sortie à la même vitesse et pour le même coût qu'un modèle 12,9 milliards de paramètres. Mistral AI se sert d'un procédé qui lui permet de rester efficace, mais avec un coût et une latence moindres.

Dans le paysage mondial de l’intelligence artificielle, dominé par des géants tels qu’OpenAI, Google et Meta, une nouvelle entreprise française fait parler d’elle : Mistral AI, fondée par cofondée par trois chercheurs français de l'IA passés par les GAFA américains. En effet, son PDG, Arthur Mensch, 30 ans, expert des modèles de langage, vient de passer près de trois ans au sein de DeepMind, le laboratoire d'IA de Google. Les deux autres cofondateurs viennent de Meta (Facebook) : Guillaume Lample est l'un des créateurs du modèle de langage LLaMA dévoilé par Meta en février et Timothée Lacroix était lui aussi chercheur chez Meta.

En septembre, la startup a publié un modèle d'IA open source de 7,3 milliards de paramètres appelé "Mistral 7B". Cette fois-ci, comme avec son premier modèle Mistral 7B, tout a commencé par un lien magnet permettant de télécharger un fichier torrent.

Mistral AI poursuit sa mission de fournir les meilleurs modèles ouverts à la communauté des développeurs. Pour progresser dans l’IA, il faut prendre de nouveaux tournants technologiques au-delà de la réutilisation d’architectures et de paradigmes de formation bien connus. Il s’agit surtout de faire bénéficier la communauté de modèles originaux pour favoriser de nouvelles inventions et usages.

Aujourd'hui, l'équipe est fière de lancer Mixtral 8x7B, un modèle de mélange d'experts (SMoE) de haute qualité avec des poids ouverts. Sous licence Apache 2.0. Mixtral surpasse Llama 2 70B sur la plupart des benchmarks avec une inférence 6 fois plus rapide. Il s’agit du modèle ouvert le plus puissant avec une licence permissive et du meilleur modèle global en termes de compromis coût/performance. En particulier, il correspond ou surpasse GPT3.5 sur la plupart des benchmarks standards.

Mixtral a les capacités suivantes.
  • Il gère gracieusement un contexte de 32 000 jetons.
  • Il gère l'anglais, le français, l'italien, l'allemand et l'espagnol.
  • Il montre de solides performances dans la génération de code.
  • Il peut être affiné dans un modèle de suivi d'instructions qui atteint un score de 8,3 sur MT-Bench.
Un modèle plus performant que la version GPT 3.5 de ChatGPT et Llama 2 de Facebook

La startup explique que Mixtral est un réseau clairsemé d’experts. Il s'agit d'un modèle de décodeur uniquement dans lequel le bloc de rétroaction sélectionne parmi un ensemble de 8 groupes distincts de paramètres. À chaque couche, pour chaque jeton, un réseau de routeurs choisit deux de ces groupes (les « experts ») pour traiter le jeton et combiner leurs sorties de manière additive.

Cette technique augmente le nombre de paramètres d'un modèle tout en contrôlant le coût et la latence, car le modèle n'utilise qu'une fraction de l'ensemble total de paramètres par jeton. Concrètement, Mixtral a 46,7 milliards de paramètres au total mais n'utilise que 12,9 milliards de paramètres par jeton. Il traite donc les entrées et génère la sortie à la même vitesse et pour le même coût qu'un modèle 12,9 milliards de paramètres.

Mistral AI explique que Mixtral 8x7B gère un contexte de 32 000 jetons. En clair, le modèle est censé traiter et comprendre un contexte de 32 000 tokens (comprendre des unités de texte, qui peuvent être des mots, des parties de mots, ou même des caractères, selon la manière dont le modèle a été entraîné).

Mixtral est pré-formé sur les données extraites du Web ouvert – la startup forme simultanément experts et routeurs, mais ne précise pas la nature des données de préformation.

Performance

Mistral AI a comparé Mixtral à la famille Llama 2 et au modèle de base GPT3.5. Mixtral correspond ou surpasse Llama 2 70B, ainsi que GPT3.5, sur la plupart des benchmarks.


Hallucinations et préjugés

Pour identifier d'éventuels défauts à corriger par un réglage fin/une modélisation des préférences, Mistral AI mesure les performances du modèle de base sur TruthfulQA/BBQ/BOLD.

Comparé à Llama 2, Mixtral est plus véridique (73,9 % contre 50,2 % sur le benchmark TruthfulQA) et présente moins de biais sur le benchmark BBQ. Dans l'ensemble, Mixtral s'en sort mieux que Llama 2 sur BOLD, avec des variances similaires au sein de chaque dimension.


Maîtrises des langues

Mistral 8x7B maîtrise le français, l'allemand, l'espagnol, l'italien et l'anglais.


Toutefois, il faut signaler que les points de comparaison semblent un peu dépassés, surtout pour ce qui concerne le modèle d'OpenAI. En effet, GPT-3.5 est un modèle sorti au mois de novembre 2022. Llama 2 est un peu plus récent, puisque ce modèle a fait ses débuts en juillet 2023. GPT-4 a été présenté en mars et a été rendu public en juillet 2023. GPT-4 Turbo quant à lui a été introduit le mois dernier.

À propos de GPT-4, OpenAI expliquait en mars : « GPT-4 est un grand modèle multimodal (acceptant en entrée des images et du texte, et produisant en sortie du texte) qui, bien qu'il soit moins performant que les humains dans de nombreux scénarios réels, présente des performances de niveau humain sur divers benchmarks professionnels et académiques. Par exemple, il réussit un examen du barreau simulé avec un score qui le positionne dans le top 10 % des candidats les mieux classés ; en contraste avec GPT-3.5 qui avait obtenu un score qui le plaçait au bas du classement dans le top 10 % des moins bien classés. Nous avons passé 6 mois à peaufiner de manière itérative GPT-4 en utilisant les enseignements de notre programme de tests ainsi que de ChatGPT, ce qui a donné nos meilleurs résultats à ce jour (bien qu'encore loin de la perfection) ».

Néanmoins, Mixtral 8x7B tend à s'imposer comme l'une des références open source en matière de modèle d'IA, du moins, pour l’instant.

La plateforme : les premiers points de terminaison d'IA de Mistral AI sont disponibles en accès anticipé

Mistral AI en a profité pour faire cette annonce :

Nous ouvrons aujourd’hui un accès bêta à nos premiers services de plateforme. Nous commençons simplement : la plateforme sert trois points de terminaison de chat pour générer du texte suivant des instructions textuelles et un point de terminaison d'intégration. Chaque point de terminaison a un compromis performance/prix différent.
Les deux premiers points de terminaison, mistral-tiny et mistral-small, utilisent actuellement les deux modèles ouverts publiés par Mistral AI ; le troisième, mistral-medium, utilise un modèle prototype « aux performances supérieures que nous testons en milieu déployé ».

La startup indique servir des versions préformées de ses modèles : « Nous avons travaillé à consolider les techniques d'alignement les plus efficaces (réglage fin efficace, optimisation directe des préférences) pour créer des modèles faciles à contrôler et agréables à utiliser. Nous pré-entraînons les modèles sur les données extraites du Web ouvert et effectuons un réglage fin des instructions à partir des annotations ».

Voici les différences entres les trois points de terminaison :
  • Mistral-tiny : Notre point de terminaison le plus rentable sert actuellement Mistral 7B Instruct v0.2, une nouvelle version mineure de Mistral 7B Instruct. Mistral-tiny ne fonctionne qu'en anglais. Il obtient 7,6 sur MT-Bench. Le modèle indiqué peut être téléchargé ici.
  • Mistral-small : Ce point de terminaison dessert actuellement notre nouveau modèle, Mixtral 8x7B, décrit plus en détail dans notre article de blog. Il maîtrise l'anglais/français/italien/allemand/espagnol et le code et obtient 8.3 sur MT-Bench.
  • Mistral-medium : Notre point de terminaison de la plus haute qualité sert actuellement un modèle prototype, qui figure actuellement parmi les modèles les mieux entretenus disponibles sur la base de références standard. Il maîtrise l'anglais/français/italien/allemand/espagnol et le code et obtient un score de 8,6 sur MT-Bench. Le tableau suivant compare les performances des modèles de base de Mistral-medium, Mistral-small et du point final d'un concurrent.


L'open source, une opportunité pour faire des affaires en IA

Mensch et ses cofondateurs Timothée Lacroix et Guillaume Lample ont tous la trentaine et se connaissent depuis l’école, où ils étudiaient tous dans le domaine de l’intelligence artificielle. Mensch travaillait chez DeepMind à Paris, et Lacroix et Lample chez Meta ; et Mensch a déclaré que c’est l’année dernière qu’ils ont commencé à discuter de la direction qu’ils voyaient prendre le développement de l’IA.

« Nous avons vu la technologie vraiment commencer à s’accélérer l’année dernière », a-t-il déclaré dans une interview, probablement en référence aux progrès réalisés par OpenAI avec son modèle GPT, qui a été un coup de fouet pour beaucoup de gens dans le domaine de l’IA et du monde de la technologie en général. Mais les liens entre OpenAI et open source ne se limitent plus qu'à la mention “open” dans son nom. D'ailleurs, Elon Musk a tweeté en février « OpenAI a été créé comme open source (c'est pourquoi je l'ai nommée "Open" AI), une société à but non lucratif pour servir de contrepoids à Google, mais maintenant elle est devenue une société à source fermée et à profit maximum contrôlée de manière efficace par Microsoft ».

Mensch, Lacroix et Lample ont estimé qu’une approche propriétaire était en train de s’imposer comme la norme, et ils ont vu une opportunité de faire les choses différemment : « L’open source est une partie essentielle de notre ADN », a souligné Mensch. Il est trop tôt pour parler de ce que Mistral fait ou fera, mais d’après ce que Mensch a dit, le plan est de construire des modèles en utilisant uniquement des données publiques disponibles pour éviter les problèmes juridiques que certains ont rencontrés avec les données d’entraînement, a-t-il dit ; les utilisateurs pourront également contribuer avec leurs propres jeux de données.


Guillaume Lample, Arthur Mensch et Timothée Lacroix, les cofondateurs de Mistral AI

Une alternative à OpenAI

Mistral se positionne comme un concurrent direct d’OpenAI, qui a été fondé en 2015 par un groupe d’entrepreneurs et d’investisseurs du secteur technologique, dont Elon Musk et Peter Thiel. OpenAI s’est fait connaître pour ses recherches innovantes sur l’IA générative, notamment son modèle GPT-3 qui peut produire du texte cohérent à partir d’un simple mot-clé ou d’une phrase. OpenAI a également lancé une plateforme commerciale appelée OpenAI Codex, qui permet aux développeurs d’utiliser l’IA pour créer des applications, des sites web et des jeux.

Mistral veut offrir une alternative à OpenAI, en proposant des modèles d’IA générative plus accessibles, plus éthiques et plus personnalisables. Mensch a déclaré que Mistral vise à créer une « IA démocratique », qui ne soit pas contrôlée par quelques acteurs dominants, mais qui soit ouverte à la collaboration et à l’innovation de la communauté. Il a également souligné que Mistral s’engage à respecter les principes de l’IA responsable, en veillant à ce que ses modèles soient transparents, équitables et respectueux de la vie privée.

D'autres startups européennes à l'assaut de l'IA générative

Mistral n’est pas la seule start-up européenne à se lancer dans le domaine de l’IA générative. En avril, la société britannique Aleph Alpha a levé 27 millions d’euros pour développer son propre modèle de langage basé sur le GPT-3. En février, la société allemande Deepset a levé 5 millions d’euros pour créer une plateforme d’IA conversationnelle basée sur le modèle BERT de Google. Et en janvier, la société française ReciTAL a levé 3,5 millions d’euros pour proposer des solutions d’analyse et de génération de texte basées sur l’IA.

Mistral espère se démarquer par la qualité et la diversité de ses modèles, ainsi que par sa capacité à répondre aux besoins spécifiques de ses clients. Mensch a déclaré que Mistral vise à créer des modèles capables de gérer non seulement le texte, mais aussi les images, les sons et les vidéos. Il a également affirmé que Mistral sera en mesure de fournir des modèles adaptés à différents domaines, langues et cultures.

« Nous voulons créer une IA qui soit utile pour tous les cas d’usage, pas seulement pour quelques-uns », a-t-il dit. « Nous voulons créer une IA qui soit capable de comprendre le monde et de le rendre meilleur ».

Source : Mistal AI (1, 2), Hugging Face (compte Mistral AI)

Et vous ?

Quels sont les avantages et les inconvénients des modèles d’IA génératifs comme Mixtral 8x7B par rapport aux solutions propriétaires plus importantes ?
Comment Mistral AI pourrait-elle influencer l’écosystème de la French Tech et renforcer la position de la France dans le domaine de l’intelligence artificielle ?
Quelles pourraient être les implications de l’accès au modèle Mixtral 8x7B pour les développeurs ?
En quoi l’approche de Mistral AI en matière d’entraînement plus économique pourrait-elle changer la donne pour les startups d’IA ?
Quel rôle les investisseurs et le gouvernement français devraient-ils jouer pour soutenir des initiatives comme Mistral AI ?

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de Diablo150
Membre régulier https://www.developpez.com
Le 13/12/2023 à 11:39
Tu devrais essayer leur modèle Mistral-7B, il est devenu la référence parmi les modèles libres.
Depuis le mois de Septembre, il a presque éclipsé Llama de Meta sur HugginfFace et des modèles dérivés comme OpenChat 3.5 sont presque au même niveau que ChatGPT pour une fraction de la taille (et donc en ressources nécessaires).

Donc oui, Mistral AI est bien une des entreprises les plus en vues depuis ces derniers mois.

Range donc tes sarcasmes au tiroir, va militer à la LFI et laisse les gens qui bossent tranquilles.
8  2 
Avatar de OrthodoxWindows
Membre émérite https://www.developpez.com
Le 13/12/2023 à 12:22
Une chose est sûr, sur le plan de la qualité de ses modèles, MistralAI ne démérite pour l'instant absolument pas.

C'est marrant, j'ai comme l'impression que si ça avait été le cas, il y aurais de nombreux commentaires moqueurs...
7  1 
Avatar de blackcellar
Futur Membre du Club https://www.developpez.com
Le 12/01/2024 à 13:38
Citation Envoyé par Anselme45 Voir le message
Perso, je me pose une question que jamais aucun média ne pose quand ils nous parlent de startup...

Les médias commencent toujours leur article par un "startup ... évaluée à xxx millions de dollars" quand ce n'est pas "évaluée à x milliard", histoire de donner à la startup en question une importance (que souvent elle n'a pas!). A remarquer qu'il ne viendrait jamais à l'idée d'un média d'écrire un "Total, multinationale active dans l'énergie, évaluée à xxx milliards"

Nous avons donc ici un "Mistral : la startup française d'IA évaluée à 260 millions de dollars"

Ok! Alors je pose ma question:

Qui a évalué cette startup à 260 millions? Ses fondateurs? Les financiers qui y ont mis du pognon et espèrent un retour rapide sur investissement?
En fait une startup n'est ni plus ni moins qu'une société en devenir qui a un status particulier. Une évaluation de startups est le prix que les investisseurs imposent à l'entreprise à ses débuts, lorsqu'elle est encore privée. L'évaluation est basée sur un certain nombre de facteurs, notamment le modèle économique de la startup, la taille de son marché, son paysage concurrentiel et son équipe de direction.
La méthode la plus courante pour évaluer une Start-up est la méthode des flux de trésorerie actualisés (DCF). Cette approche actualise les flux de trésorerie futurs attendus de l'entreprise à leur valeur actuelle, en utilisant un taux d'actualisation qui reflète le risque des flux de trésorerie des startups.
Une autre méthode courante d'évaluation des startups est l'analyse des sociétés comparables (CCA). Cette approche examine les sociétés cotées en bourse qui sont similaires à la Start-up en termes de modèle commercial, de taille et de potentiel de croissance, et utilise les valorisations de ces sociétés comme référence.
La dernière méthode bien discutée est la méthode du capital-risque (VC). Cette approche valorise une start-up en fonction du montant d'argent que les sociétés de capital-risque sont prêtes à investir dans l'entreprise. Cette méthode est généralement utilisée pour les startups à un stade ultérieur qui ont déjà levé un capital-risque important. C'est comme ça qu'on procède on choisit la méthode de calcul qui correspond le mieux à la startup qui doit être évaluée.
4  0 
Avatar de Anselme45
Membre extrêmement actif https://www.developpez.com
Le 07/02/2024 à 10:13
Qui veut parier que l'on va avoir droit prochainement à une news "IA Open rachète Mistral"?

Certains ont depuis longtemps oublié l'objectif premier de toute start-up, faire parler d'elle et se vendre au plus offrant le plus rapidement possible pour que ses fondateurs deviennent riches le plus rapidement possible.

Avec les start-up, on est loin de la philosophie de la PME familiale!!!
4  0 
Avatar de Mingolito
Membre extrêmement actif https://www.developpez.com
Le 13/12/2023 à 14:53
Il y a des startups bidons qui lèvent des centaines de millions d'euros pour monter des escroqueries à l'IA et au lieu d'IA les services "IA" sont en fait des employés offshore payés une misère, on a vu ça par exemple sur les IA de services aux entreprises, de fastfood et même de robot taxi, mais Mistral c'est du sérieux, ce qu'ils proposent c'est vraiment de l'IA et c'est largement valable.
3  0 
Avatar de RenarddeFeu
Membre régulier https://www.developpez.com
Le 21/02/2024 à 14:24
J'ai testé mistral-next, et je trouve que mistral-medium produit de meilleurs résultats. Sans compter que des verrous qui n'existent pas dans medium ont été ajoutés dans next, par exemple : next refusera de générer les paroles à la façon d'un artiste connu en invoquant les droits d'auteur, là où medium le fait sans problème.

C'est d'autant plus surprenant qu'OpenAI fait l'exact inverse : GPT-4 a beaucoup moins de restrictions que GPT-3.5. C'est d'ailleurs la principale raison de son Elo score plus élevé selon moi.
3  0 
Avatar de Diablo150
Membre régulier https://www.developpez.com
Le 13/12/2023 à 15:29
1.
"Idiotie" écris-tu? Avant d'insulter l'avis des autres, commence par nous fournir la preuve de ce que tu avances! Qui a dit que ton modèle machin est "devenu la référence"?????????????????????????????

Perso, tous ce que je vois... C'est 3 gravures du mode qui posent sur une photo et qui font plus penser au prochain "boys-band" à la mode qu'à des entrepreneurs qui pèsent 2 milliards! Mais peut-être es-tu l'un d'eux?

2.
Seul le temps dit si une entreprise est sérieuse et si elle a du succès ou non! Tout ce que je sais, c'est qu'il n'y a pas une seule entreprise française qui a émergé dans le monde du numérique... Ayons une pensée émue pour Qwant qui était LA startup à succès qui allait détrôner les américains... On a vu ce qu'il est advenu...

3. En l'état, tout ce que je constate est que TA référence fait plus parler d'elle pour obtenir du financement que pour étaler ses succès technologiques.

Alors n'hésite pas, si tu es si convaincu, je t'invite à participer au financement de cette merveilleuse startup à succès et évite d'insulter les autres...Merci!
"Idiotie": Tu peux le voir comme une insulte, mais c'est en miroir de ton message pédant sans argument autre que "vous vous prenez pour qui les français à essayer de rivaliser avec les ricains".

Je dis que le modèle est devenu la référence car en dehors des grands médias qui ne regardent qu'OpenAI et les millliards de Microsoft, il y a beaucoup d'effervescence autour de Mistral IA.

Code : Sélectionner tout
En l'état, tout ce que je constate est que TA référence fait plus parler d'elle pour obtenir du financement que pour étaler ses succès technologiques.
Là oui, on peut vraiment parler d'idiotie.
Alpaca eval:
https://tatsu-lab.github.io/alpaca_eval/

C'est un comparatif où on a tout un tas de problèmes posés au llm qui sont ensuite évaluées par GPT-4.
GPT-4-Turbo est là 97.7 % de réussite, Zephyr-7B est à 90.60%, ChatGPT à 81.71%
Pour info Zephyr-7B est basé sur Mistral et a été développé par les équipes de HuggingFace (cette dernière entreprise étant également créée par des Français, on le rappelle)

Et on rappelle également que ce comparatif n'est pas à jour, qu'OpenChat 3.5 fait mieux et que ces modèles sont minuscules en temps de calcul comparé à GPT4 ou même ChatGPT.

Autre comparatifs:
https://huggingface.co/spaces/Huggin...lm_leaderboard

Si tu regarde bien, il y a tout un tas de modèles basés sur Mistral-7B en haut du tableau et qu'ils sont souvent (suivant la qualité de l'apprentissage) d'un niveau proche de Llama 2 et ses 70 milliards de paramètres.
Il y a également un modèle Chinois récent baptisé Yi qui est également très performant.

Et oui, si tu suivais ce qu'ils se passe en dehors de ce que tu peux trouver sur les médias grand publique, ils ont su créer un réél engouement derrière leurs modèle.
Tu noteras que leur modèle Mistral-7B a été téléchargé plus de 500 000 fois sur huggingface:
https://huggingface.co/mistralai

(Plus de 502K pour le modèle de base, 428K pour le modèle Instruct).

Sans parler des centaines de modèles dérivés:
https://huggingface.co/models?other=...sort=downloads

Et t'imagines bien que ceux qui téléchargent ces modèles sont généralement pas des utilisateurs lambda, nombre de ces téléchargement alimentent des clouds qui génèrent du texte, du code et tout un tas de choses que tu ne vois pas si tu ne regarde que la partie émergée de l'Iceberg
Si c'est pas un succès je sais pas ce que c'est !

Essai de voir ce qu'il se passe en ce moment depuis la sortie de leur denier modèle, c'est le feu, tout un tas de projets comme vLLM ou Llama.cpp sont en plein bouillonement pour le faire tourner.

Concernant le *succès*, tu ne semble regarder que l'aspect financier, mais on en sais rien si OpenAI fait du bénéfice, la seule certitude est qu'ils ont Microsoft derrière eux qui est en mesure de leur fournir des sommes astronomiques et que pour l'instant ils peuvent s'en servir pour essayer d'écraser la concurrence en vendant leurs tokens à perte.

Autrement dit l'avantage d'OpenAI semble plus être financier (et celui de la notoriété du fait d'avoir été les pionniers dans leur branche) que strictement technique.

Tu peux considérer que je t'insulte si tu veux, mais je t'invite vraiment à essayer leur modèle, tu verras, tu découvriras tout un monde :p
Petit indice:
https://github.com/ggerganov/llama.cpp

Et essai ce modèle, tu m'en diras des nouvelles:
https://huggingface.co/TheBloke/Neur...istral-7B-GGUF
2  0 
Avatar de unanonyme
Membre éclairé https://www.developpez.com
Le 13/12/2023 à 15:36
Code : Sélectionner tout
1
2
3
curl https://ollama.ai/install.sh | sh
ollama run mistral
2  0 
Avatar de Diablo150
Membre régulier https://www.developpez.com
Le 21/02/2024 à 0:57
Mensch a déclaré que Mistral vise à créer des modèles capables de gérer non seulement le texte, mais aussi les images, les sons et les vidéos. Il a également affirmé que Mistral sera en mesure de fournir des modèles adaptés à différents domaines, langues et cultures.
A mon avis la vrai info intéressante est là.

Sinon j'ai essayé le modèle et il semble assez facile de le faire halluciner, bien qu'en dehors de ça il semble être souvent pertinent.
Je sais pas si c'est un truc dérivé de Miqu qui ne dit pas non nom (donc en fait c'est du Llama 70b retravaillé par Mistral AI), ou si c'est vraiment un nouveau modèle. On verra bien, mais pour l'instant ça me parait pas tout à fait au niveau, il y a probablement quelques ajustements d’alignement à faire.

Edit: Au fait Aleph Alpha est une société Allemande et non Anglaise.
2  0 
Avatar de unanonyme
Membre éclairé https://www.developpez.com
Le 13/12/2023 à 16:29
C'est le délire quand même, tu lui files un bout de code dégueulasse sans commentaires,
avec la moitié des fonctions non définies, et ça te sort une explication raisonnable....

On trouvera des dizaines de reproche à faire, mais moi ça me fait déjà froid dans le dos...

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
>>> package main
... 
... import (
...         "bufio"
...         "bytes"
...         "encoding/binary"
...         "flag"
...         "fmt"
...         "io"
...         "math"
...         "os"
...         "sort"
...         "strconv"
...         "strings"
...         "sync"
...         "time"
... 
...         "github.com/fxtlabs/primes"
...         "github.com/pkg/profile"
...         "golang.org/x/text/language"
...         "golang.org/x/text/message"
... )
... 
... func main() {
... 
...         n := flag.Int("n", 100_000, "n")
...         k := flag.Int("k", 5, "k")
...         path := flag.String("path", "-", "path")
...         prof := flag.Bool("prof", true, "profile")
...         dbg := flag.Bool("debug", false, "debug")
...         vrb := flag.Bool("verbose", true, "verbose")
...         mt := flag.Bool("mt", false, "parallel")
...         cache := flag.Int("cache", -1, "cache")
... 
...         flag.Parse()
... 
...         debug = *dbg
...         verbose = *vrb
... 
...         st := time.Now()
...         defer func() {
...                 fmt.Fprintln(os.Stderr, time.Since(st))
...         }()
... 
...         if *prof {
...                 defer profile.Start(profile.CPUProfile, profile.ProfilePath(".")).Stop()
...         }
... 
...         var dst io.Writer = os.Stdout
...         if p := strings.TrimSpace(*path); p != "-" && p != "" {
...                 f, err := os.Create(p)
...                 if err != nil {
...                         panic(err)
...                 }
...                 dst = f
...                 defer f.Close()
...         }
... 
...         load_primes := load_primes_bin
... 
...         if *cache > -1 {
...                 primes_cache = load_primes(*cache)
...         } else {
...                 k := 1
...                 if *n%10 == 0 {
...                         for i := len(strconv.Itoa(*n/10)) * 2; i > 0; i-- {
...                                 k *= 10
...                         }
...                 } else {
...                         for i := len(strconv.Itoa(*n)) * 2; i > 0; i-- {
...                                 k *= 10
...                         }
...                 }
...                 primes_cache = load_primes(k)
...         }
... 
...         out := dst
...         fn := combin_primes
...         if *mt {
...                 fn = combin_primes_mt
...         }
...         print_res := func(res []int) {
...                 fmt.Fprint(out, "  => ")
...                 s := 0
...                 for _, r := range res[:len(res)-1] {
...                         fmt.Fprintf(out, "%v,", r)
...                         s += r
...                 }
...                 fmt.Fprintf(out, "%v", res[len(res)-1])
...                 s += res[len(res)-1]
...                 fmt.Fprintf(out, "  => %v %v\n", check_primes(res), s)
...         }
...         allres := [][]int{}
...         fn(*n, *k, func(res []int) {
...                 print_res(res)
...                 t := make([]int, len(res))
...                 copy(t, res)
...                 allres = append(allres, t)
...         })
... 
...         if p := strings.TrimSpace(*path); p == "-" || p == "" {
...                 fmt.Println()
...                 fmt.Println()
...         }
...         for _, res := range allres {
...                 print_res(res)
...         }
... }
... 
... var verbose = !true
... var debug = !true
... 
... func combin_primes(n, k int, cb func([]int)) {
... 
...         ps := load_primes(n)
...         u := len(ps)
...         if debug {
...                 fmt.Fprintln(os.Stderr, "n", n)
...                 fmt.Fprintln(os.Stderr, "k", k)
...                 fmt.Fprintln(os.Stderr, "u", u)
...         }
...         res := make([]int, k)
...         idx := make([]int, k)
...         for i := range idx {
...                 idx[i] = i + 1
...         }
...         l := k - 1
...         c := 1
...         var best_sum int
...         var best_sumk1 int
...         for idx[0] <= u-k && (best_sumk1 < 1 || ps[idx[0]] <= best_sumk1) {
...                 if idx[0] == 2 {
...                         idx[0]++
...                         idx[1] = idx[0] + 1
...                 }
...                 ok := valid_primes_pairs(ps, idx[:c], idx[c])
...                 if debug {
...                         fmt.Fprintf(os.Stderr, "c=%v ", c)
...                         fmt.Fprintf(os.Stderr, "idx=%-20v ", fmt.Sprint(idx[:c+1]))
...                         fmt.Fprintf(os.Stderr, "primes=%v ", print_primes(ps, idx[:c+1]))
...                         fmt.Fprintln(os.Stderr)
...                         <-time.After(time.Second / (2 * 5))
...                 }
... 
...                 if c == l-1 {
...                         if ok {
...                                 s := sum_primes(ps, idx[:c+1])
...                                 r := (n - s) / (k - (c + 1))
...                                 n := sort.SearchInts(ps, r)
...                                 if n < idx[c] {
...                                         n = idx[c] + 1
...                                 }
...                                 c++
...                                 idx[c] = n
...                         } else {
...                                 if idx[c] >= u-(k-c) {
...                                         c--
...                                 } else if best_sum > 0 {
...                                         s := sum_primes(ps, idx[:c+1])
...                                         if s > best_sum || s+(ps[idx[c]]*(k-c+1)) > best_sum {
...                                                 c--
...                                         }
...                                 }
...                                 idx[c]++
...                         }
...                 } else if c == l {
...                         if ok {
...                                 s := sum_primes(ps, idx)
...                                 if s >= n && (best_sum < 1 || best_sum >= s) {
...                                         for i, v := range idx {
...                                                 res[i] = ps[v]
...                                         }
...                                         best_sum = s
...                                         best_sumk1 = s / k
...                                         cb(res)
...                                         c--
...                                 }
...                                 if idx[c] >= u-(k-c) {
...                                         c--
...                                 } else if best_sumk1 > 0 && ps[idx[c]] > best_sumk1 {
...                                         c--
...                                 }
...                                 idx[c]++
... 
...                         } else {
...                                 if idx[c] >= u-(k-c) {
...                                         c--
...                                 } else if best_sum > 0 {
...                                         s := sum_primes(ps, idx[:c+1])
...                                         if s > best_sum {
...                                                 c--
...                                         }
...                                 }
...                                 idx[c]++
...                         }
...                 } else {
...                         if ok {
...                                 c++
...                                 idx[c] = idx[c-1] + 1
...                         } else {
...                                 if idx[c] >= u-(k-c) {
...                                         c--
...                                 } else if best_sum > 0 {
...                                         s := sum_primes(ps, idx[:c+1])
...                                         if s > best_sum || s+(ps[idx[c]]*(k-c+1)) > best_sum {
...                                                 c--
...                                         }
...                                 }
...                                 idx[c]++
...                         }
...                 }
... 
...                 if c == 0 {
...                         if verbose {
...                                 fmt.Fprintln(os.Stderr, "....", ps[idx[0]])
...                         }
...                         c = 1
...                         idx[c] = idx[c-1] + 1
...                 }
...         }
... }
This Go program is designed to find combinations of prime numbers that sum up to a given number `n`, with exactly `k` numbers in the combination. The
program supports various command-line flags for controlling its behavior, such as specifying the input values for `n` and `k`, setting a debug mode,
enabling verbose output, using parallel processing, and loading primes from a cache file instead of computing them on the fly.

Here's a brief overview of the code:

- The program begins by defining flags for various command-line arguments, such as `n`, `k`, `path`, `prof`, `debug`, `verbose`, and `mt`. The
`flag.Parse()` function is then called to parse the command-line arguments and set the corresponding flags based on their values.

- The program sets some global variables, such as `debug` and `verbose`, based on the command-line flags. It also defines some helper functions, such as
`load_primes_bin` for loading primes from a binary file, `valid_primes_pairs` for checking if a pair of prime indices represents valid prime numbers, and
`sum_primes` for computing the sum of the first `n` prime numbers.

- The main function is defined, which sets up the input flags, loads the primes based on the cache flag, defines some helper functions, and then calls the
`combin_primes` function to find the combinations of prime numbers that sum up to `n` with exactly `k` numbers in each combination.

- The `combin_primes` function is defined, which takes as input the value of `n`, the number of desired combinations, and a callback function `cb` that
will be called with each combination that is found. The function initializes some variables and then enters a loop to find all valid combinations. Within
the loop, it checks if the current combination is valid based on whether its sum is equal to `n` and whether the prime numbers in the combination are
valid. If a valid combination is found, it sums up the prime numbers in the combination and checks if it's greater than or equal to `n`. If so, it calls
the callback function with the combination as an argument and then backtracks to find other combinations.

- The program outputs the results to the standard output stream by default, but can also write them to a file if the `path` flag is set to a valid file
path. It also profiles the CPU usage if the `prof` flag is set to true.
brrr
1  0