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 11 décembre 2023 à 19:37, par Stéphane le calme

21PARTAGES

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.

[TWITTER]<blockquote class="twitter-tweet"><p lang="en" dir="ltr">magnet

xt=urn:btih:5546272da9065eddeb6fcd7ffddeef5b75be79a7&dn=mixtral-8x7b-32kseqlen&tr=udp%3A%2F%<a href="https://t.co/uV4WVdtpwZ">https://t.co/uV4WVdtpwZ</a>%3A6969%2Fannounce&tr=http%3A%2F%<a href="https://t.co/g0m9cEUz0T">https://t.co/g0m9cEUz0T</a>%3A80%2Fannounce<br><br>RELEASE a6bbd9affe0c2725c1b7410d66833e24</p>— Mistral AI (@MistralAI) <a href="https://twitter.com/MistralAI/status/1733150512395038967?ref_src=twsrc%5Etfw">December 8, 2023</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script> [/TWITTER]

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 !

Votre nom : Votre e-mail :

Décrivez l'erreur que vous souhaitez porter à notre connaissance :

>>> 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 
...                 } 
...         } 
... }

Identifiez-vous

Créer un compte

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 »

Identifiant
Mot de passe

Mot de passe oublié ?

Identifiez-vous

Créer un compte

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 »

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 »