La start-up française d'IA Mistral obtient une valorisation de 2 milliards d'euros, le groupe s'apprête à clôturer un tour de table d'environ 400 millions d'euros

Membre régulier

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.

9

2

OrthodoxWindows

Membre expert

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

blackcellar

Membre à l'essai

Le 12/01/2024 à 13:38

Envoyé par Anselme45

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

Anselme45

Membre extrêmement actif

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

Mingolito

Membre extrêmement actif

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

RenarddeFeu

Membre averti

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

Diablo150

Membre régulier

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

unanonyme

Membre éclairé

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

Diablo150

Membre régulier

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

unanonyme

Membre éclairé

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

Identifiez-vous

Créer un compte

La start-up française d'IA Mistral obtient une valorisation de 2 milliards d'euros

Le groupe s'apprête à clôturer un tour de table d'environ 400 millions d'euros

Identifiant
Mot de passe

Mot de passe oublié ?

Identifiez-vous

Créer un compte

La start-up française d'IA Mistral obtient une valorisation de 2 milliards d'euros Le groupe s'apprête à clôturer un tour de table d'environ 400 millions d'euros

La start-up française d'IA Mistral obtient une valorisation de 2 milliards d'euros

Le groupe s'apprête à clôturer un tour de table d'environ 400 millions d'euros