INTELLIGENCE ARTIFICIELLE INTELLIGENCE ARTIFICIELLE INTELLIGENCE ARTIFICIELLE ...

A I - I A

2- Suite - Elon Musk

lance Grok

pour défier ChatGPT 

Annonçant Grok

4 novembre 2023

Grok est une IA calquée sur le Guide de l’auto-stoppeur galactique, donc destinée à répondre à presque n’importe quoi et, beaucoup plus difficile, même à suggérer les questions à poser !

Grok est conçu pour répondre aux questions avec un peu d’esprit et a un côté rebelle, alors s’il vous plaît, ne l’utilisez pas si vous détestez l’humour !

Un avantage unique et fondamental de Grok est qu’il dispose d’une connaissance en temps réel du monde via la plate-forme X. Il répondra également à des questions piquantes qui sont rejetées par la plupart des autres systèmes d’IA.

Grok est encore un produit bêta très précoce – le mieux que nous puissions faire avec 2 mois d’entraînement – alors attendez-vous à ce qu’il s’améliore rapidement chaque semaine qui passe avec votre aide.

Merci
à l’équipe xAI

Pourquoi nous construisons Grok

Chez xAI, nous voulons créer des outils d’IA qui aident l’humanité dans sa quête de compréhension et de connaissance.

En créant et en améliorant Grok, nous visons à :

• Recueillez des commentaires et assurez-vous que nous construisons des outils d’IA qui profitent au maximum à l’ensemble de l’humanité. Nous pensons qu’il est important de concevoir des outils d’IA utiles aux personnes de tous horizons et de toutes opinions politiques. Nous voulons également donner à nos utilisateurs les moyens d’utiliser nos outils d’IA, sous réserve de la loi. Notre objectif avec Grok est d’explorer et de démontrer cette approche en public.
• Renforcer la recherche et l’innovation : nous voulons que Grok serve d’assistant de recherche puissant pour tout le monde, en l’aidant à accéder rapidement aux informations pertinentes, à traiter les données et à trouver de nouvelles idées.

Notre objectif ultime est que nos outils d’IA aident à la compréhension.

Le voyage vers Grok-1

Le moteur qui propulse Grok est le Grok-1, notre LLM de pointe, que nous avons développé au cours des quatre derniers mois. Grok-1 a connu de nombreuses itérations au cours de cette période.

Après l’annonce de xAI, nous avons entraîné un prototype de LLM (Grok-0) avec 33 milliards de paramètres. Ce modèle précoce se rapproche des capacités de LLaMA 2 (70B) sur des benchmarks LM standard, mais n’utilise que la moitié de ses ressources de formation. Au cours des deux derniers mois, nous avons apporté des améliorations significatives dans les capacités de raisonnement et de codage menant à Grok-1, un modèle de langage de pointe qui est nettement plus puissant, atteignant 63,2 % sur la tâche de codage HumanEval et 73 % sur MMLU.

Pour comprendre les améliorations de capacités que nous avons apportées avec Grok-1, nous avons mené une série d’évaluations à l’aide de quelques benchmarks d’apprentissage automatique standard conçus pour mesurer les capacités de mathématiques et de raisonnement.

GSM8k : Problèmes de mots mathématiques au collège (Cobbe et al. 2021), à l’aide de l’invite de chaîne de pensée.

MMLU : Les questions multidisciplinaires à choix multiples (Hendrycks et al. 2021) ont fourni des exemples contextuels à 5 coups.

HumanEval: Python code completion task, (Chen et al. 2021), zero-shot evaluated for pass@1.

MATH: Middle school and high school mathematics problems written in LaTeX, (Hendrycks et al. 2021), prompted with a fixed 4-shot prompt.

Benchmark	Grok-0 (33B)	LLaMa 2 70B	Inflection-1	GPT-3.5	Grok-1	Palm 2	Claude 2	GPT-4
GSM8k	56.8% 8-shot	56.8% 8-shot	62.9% 8-shot	57.1% 8-shot	62.9% 8-shot	80.7% 8-shot	88.0% 8-shot	92.0% 8-shot
MMLU	65.7% 5-shot	68.9% 5-shot	72.7% 5-shot	70.0% 5-shot	73.0% 5-shot	78.0% 5-shot	75.0% 5-shot + CoT	86.4% 5-shot
HumanEval	39.7% 0-shot	29.9% 0-shot	35.4% 0-shot	48.1% 0-shot	63.2% 0-shot	-	70% 0-shot	67% 0-shot
MATH	15.7% 4-shot	13.5% 4-shot	16.0% 4-shot	23.5% 4-shot	23.9% 4-shot	34.6% 4-shot	-	42.5% 4-shot

On these benchmarks, Grok-1 displayed strong results, surpassing all other models in its compute class, including ChatGPT-3.5 and Inflection-1. It is only surpassed by models that were trained with a significantly larger amount of training data and compute resources like GPT-4. This showcases the rapid progress we are making at xAI in training LLMs with exceptional efficiency.

Since these benchmarks can be found on the web and we can’t rule out that our models were inadvertently trained on them, we hand-graded our model (and also Claude-2 and GPT-4) on the 2023 Hungarian national high school finals in mathematics, which was published at the end of May, after we collected our dataset. Grok passed the exam with a C (59%), while Claude-2 achieved the same grade (55%), and GPT-4 got a B with 68%. All models were evaluated at temperature 0.1 and the same prompt. It must be noted that we made no effort to tune for this evaluation. This experiment served as a “real-life” test on a dataset our model was never explicitly tuned for.

Human-graded evaluation	Grok-0	GPT-3.5	Claude 2	Grok-1	GPT-4
Hungarian National High School Math Exam (May 2023)	37% 1-shot	41% 1-shot	55% 1-shot	59% 1-shot	68% 1-shot

We provide a summary of the important technical details of Grok-1 in the model card.

Engineering at xAI

At the frontier of deep learning research, reliable infrastructure must be built with the same care as datasets and learning algorithms. To create Grok, we built a custom training and inference stack based on Kubernetes, Rust, and JAX.

LLM training runs like a freight train thundering ahead; if one car derails, the entire train is dragged off the tracks, making it difficult to set upright again. There are a myriad of ways GPUs fail: manufacturing defects, loose connections, incorrect configuration, degraded memory chips, the occasional random bit flip, and more. When training, we synchronize computations across tens of thousands of GPUs for months on end, and all these failure modes become frequent due to scale. To overcome these challenges, we employ a set of custom distributed systems that ensure that every type of failure is immediately identified and automatically handled. At xAI, we have made maximizing useful compute per watt the key focus of our efforts. Over the past few months, our infrastructure has enabled us to minimize downtime and maintain a high Model Flop Utilization (MFU) even in the presence of unreliable hardware.

Rust has proven to be an ideal choice for building scalable, reliable, and maintainable infrastructure. It offers high performance, a rich ecosystem, and prevents the majority of bugs one would typically find in a distributed system. Given our small team size, infrastructure reliability is crucial, otherwise, maintenance starves innovation. Rust provides us with confidence that any code modification or refactor is likely to produce working programs that will run for months with minimal supervision.

We are now preparing for our next jump in model capabilities, which will require reliably coordinating training runs on tens of thousands of accelerators, running internet-scale data pipelines, and building new kinds of capabilities and tools into Grok. If that sounds exciting to you, apply to join the team here.

Research at xAI

We give Grok access to search tools and real-time information, but as with all the LLMs trained on next-token prediction, our model can still generate false or contradictory information. We believe that achieving reliable reasoning is the most important research direction to address the limitations of current systems. Here, we would like to highlight a few promising research directions we are most excited about at xAI:

• Scalable oversight with tool assistance. Human feedback is essential. However, providing consistent and accurate feedback can be challenging, especially when dealing with lengthy code or complex reasoning steps. AI can assist with scalable oversight by looking up references from different sources, verifying intermediate steps with external tools, and seeking human feedback when necessary. We aim to make the most effective use of our AI tutors' time with the help of our models.
• Integrating with formal verification for safety, reliability, and grounding. To create AI systems that can reason deeply about the real world, we plan to develop reasoning skills in less ambiguous and more verifiable situations. This allows us to evaluate our systems without human feedback or interaction with the real world. One major immediate goal of this approach is to give formal guarantees for code correctness, especially regarding formally verifiable aspects of AI safety.
• Long-context understanding and retrieval. Training models for efficiently discovering useful knowledge in a particular context are at the heart of producing truly intelligent systems. We are working on methods that can discover and retrieve information whenever it is needed.
• Adversarial robustness. Adversarial examples demonstrate that optimizers can easily exploit vulnerabilities in AI systems, both during training and serving time, causing them to make egregious mistakes. These vulnerabilities are long-standing weaknesses of deep learning models. We are particularly interested in improving the robustness of LLMs, reward models, and monitoring systems.
• Multimodal capabilities. Currently, Grok doesn’t have other senses, such as vision and audio. To better assist users, we will equip Grok with these different senses that can enable broader applications, including real-time interactions and assistance.

We believe that AI holds immense potential for contributing significant scientific and economic value to society, so we will work towards developing reliable safeguards against catastrophic forms of malicious use. We believe in doing our utmost to ensure that AI remains a force for good.

If you share our optimism and want to contribute to our mission, apply to join the team here.

Early Access to Grok

We are offering a limited number of users in the United States to try out our Grok prototype and provide valuable feedback that will help us improve its capabilities before a wider release. You can join the Grok waitlist here. This release just represents the first step for xAI. Looking ahead, we have an exciting roadmap and will be rolling out new capabilities and features in the coming months.

xAI PromptIDE 

Environnement de développement intégré pour une recherche rapide sur l’ingénierie et l’interprétabilité

6 novembre 2023

xAI PromptIDE est un environnement de développement intégré pour l’ingénierie rapide et la recherche d’interprétabilité. Il accélère l’ingénierie des invites grâce à un SDK qui permet de mettre en œuvre des techniques d’incitation complexes et des analyses riches qui visualisent les sorties du réseau. Nous l’utilisons beaucoup dans notre développement continu de Grok.

Nous avons développé le PromptIDE pour donner un accès transparent à Grok-1, le modèle qui alimente Grok, aux ingénieurs et aux chercheurs de la communauté. L’IDE est conçu pour responsabiliser les utilisateurs et les aider à explorer les capacités de nos grands modèles de langage (LLM) à un rythme soutenu. Au cœur de l’IDE se trouve un éditeur de code Python qui, combiné à un nouveau SDK, permet d’implémenter des techniques d’incitation complexes. Lors de l’exécution d’invites dans l’IDE, les utilisateurs voient des analyses utiles telles que la tokenisation précise, les probabilités d’échantillonnage, les jetons alternatifs et les masques d’attention agrégés.

L’IDE offre également des fonctionnalités de qualité de vie. Il enregistre automatiquement toutes les invites et dispose d’un contrôle de version intégré. Les analyses générées par l’exécution d’une invite peuvent être stockées de manière permanente, ce qui permet aux utilisateurs de comparer les résultats de différentes techniques d’invite. Enfin, les utilisateurs peuvent télécharger de petits fichiers tels que des fichiers CSV et les lire à l’aide d’une seule fonction Python à partir du SDK. Lorsqu’il est combiné avec les fonctionnalités de concurrence du SDK, même les fichiers les plus volumineux peuvent être traités rapidement.

Nous espérons également construire une communauté autour de PromptIDE. N’importe quelle invite peut être partagée publiquement en cliquant sur un bouton. Les utilisateurs peuvent décider s’ils souhaitent partager une seule version de l’invite ou l’arborescence entière. Il est également possible d’inclure des analyses stockées lors du partage d’une invite.

Le PromptIDE est disponible pour les membres de notre programme d’accès anticipé. Vous trouverez ci-dessous une présentation des principales fonctionnalités de l’IDE.

Merci
à l’équipe xAI

Éditeur de code et SDK

Au cœur de PromptIDE se trouve un éditeur de code et un SDK Python. Le SDK fournit un nouveau paradigme de programmation qui permet de mettre en œuvre des techniques d’incitation complexes avec élégance. Toutes les fonctions Python sont exécutées dans un contexte implicite, qui est une séquence de jetons. Vous pouvez ajouter manuellement des jetons au contexte à l’aide de la fonction ou vous pouvez utiliser nos modèles pour générer des jetons en fonction du contexte à l’aide de la fonction. Lors de l’échantillonnage à partir du modèle, vous disposez de diverses options de configuration qui sont passées en tant qu’argument à la fonction :prompt()sample()

async def sample(
self,
max_len: int = 256,
temperature: float = 1.0,
nucleus_p: float = 0.7,
stop_tokens: Optional[list[str]] = None,
stop_strings: Optional[list[str]] = None,
rng_seed: Optional[int] = None,
add_to_context: bool = True,
return_attention: bool = False,
allowed_tokens: Optional[Sequence[Union[int, str]]] = None,
disallowed_tokens: Optional[Sequence[Union[int, str]]] = None,
augment_tokens: bool = True,
) -> SampleResult:
"""Generates a model response based on the current prompt.
The current prompt consists of all text that has been added to the prompt either since the
beginning of the program or since the last call to `clear_prompt`.
Args:
max_len: Maximum number of tokens to generate.
temperature: Temperature of the final softmax operation. The lower the temperature, the
lower the variance of the token distribution. In the limit, the distribution collapses
onto the single token with the highest probability.
nucleus_p: Threshold of the Top-P sampling technique: We rank all tokens by their
probability and then only actually sample from the set of tokens that ranks in the
Top-P percentile of the distribution.
stop_tokens: A list of strings, each of which will be mapped independently to a single
token. If a string does not map cleanly to one token, it will be silently ignored.
If the network samples one of these tokens, sampling is stopped and the stop token
*is not* included in the response.
stop_strings: A list of strings. If any of these strings occurs in the network output,
sampling is stopped but the string that triggered the stop *will be* included in the
response. Note that the response may be longer than the stop string. For example, if
the stop string is "Hel" and the network predicts the single-token response "Hello",
sampling will be stopped but the response will still read "Hello".
rng_seed: See of the random number generator used to sample from the model outputs.
add_to_context: If true, the generated tokens will be added to the context.
return_attention: If true, returns the attention mask. Note that this can significantly
increase the response size for long sequences.
allowed_tokens: If set, only these tokens can be sampled. Invalid input tokens are
ignored. Only one of `allowed_tokens` and `disallowed_tokens` must be set.
disallowed_tokens: If set, these tokens cannot be sampled. Invalid input tokens are
ignored. Only one of `allowed_tokens` and `disallowed_tokens` must be set.
augment_tokens: If true, strings passed to `stop_tokens`, `allowed_tokens` and
`disallowed_tokens` will be augmented to include both the passed token and the
version with leading whitespace. This is useful because most words have two
corresponding vocabulary entries: one with leading whitespace and one without.
Returns:
The generated text.
"""

Le code est exécuté localement à l’aide d’un interpréteur Python intégré au navigateur qui s’exécute dans un Web Worker distinct. Plusieurs Web Workers peuvent s’exécuter en même temps, ce qui signifie que vous pouvez exécuter de nombreuses invites en parallèle.

Des techniques d’incitation complexes peuvent être mises en œuvre à l’aide de plusieurs contextes au sein d’un même programme. Si une fonction est annotée avec le décorateur, elle est exécutée dans son propre contexte. La fonction peut effectuer certaines opérations indépendamment de son contexte parent et renvoyer les résultats à l’appelant à l’aide de l’instruction. Ce paradigme de programmation permet des invites récursives et itératives avec des sous-contextes imbriqués arbitrairement.@prompt_fnreturn

Concurrence

Le Kit de développement logiciel (SDK) utilise des coroutines Python qui permettent de traiter simultanément plusieurs fonctions Python annotées. Cela peut accélérer considérablement le temps d’achèvement, en particulier lorsque vous travaillez avec des fichiers CSV.@prompt_fn

Entrées de l’utilisateur

Les invites peuvent être rendues interactives via la fonction, qui bloque l’exécution jusqu’à ce que l’utilisateur ait entré une chaîne dans une zone de texte de l’interface utilisateur. La fonction renvoie la chaîne saisie par l’utilisateur, qui peut ensuite, par exemple, être ajoutée au contexte via la fonction. À l’aide de ces API, un chatbot peut être implémenté en seulement quatre lignes de code :user_input()user_input()prompt()

await prompt(PREAMBLE)
while text := await user_input("Write a message"):
await prompt(f"<|separator|>\n\nHuman: {text}<|separator|>\n\nAssistant:")
await sample(max_len=1024, stop_tokens=["<|separator|>"], return_attention=True)

Fichiers

Les développeurs peuvent télécharger de petits fichiers sur le PromptIDE (jusqu’à 5 Mio par fichier. Au maximum 50 Mio au total) et utilisent leurs fichiers téléchargés dans l’invite. La fonction renvoie n’importe quel fichier téléchargé sous la forme d’un tableau d’octets. Lorsqu’elle est combinée avec la fonctionnalité de concurrence mentionnée ci-dessus, elle peut être utilisée pour implémenter des invites de traitement par lots afin d’évaluer une technique d’incitation sur une variété de problèmes. La capture d’écran ci-dessous montre une invite qui calcule le score d’évaluation MMLU.read_file()

Analytics

Lors de l’exécution d’une invite, les utilisateurs voient des analyses détaillées par jeton pour les aider à mieux comprendre la sortie du modèle. La fenêtre d’achèvement affiche la tokenisation précise du contexte ainsi que les identifiants numériques de chaque jeton. Lorsqu’ils cliquent sur un jeton, les utilisateurs voient également les jetons top-K après l’application du seuillage top-P et le masque d’attention agrégé au niveau du jeton.

Lors de l’utilisation de la fonction, une zone de texte s’affiche dans la fenêtre pendant l’exécution de l’invite dans laquelle les utilisateurs peuvent entrer leur réponse. La capture d’écran ci-dessous montre le résultat de l’exécution de l’extrait de code du chatbot répertorié ci-dessus.user_input()

Enfin, le contexte peut également être rendu en Markdown pour améliorer la lisibilité lorsque les fonctionnalités de visualisation des jetons ne sont pas requises.