# Llama3

```python
import torch

import transformers

model_id = "meta-llama/Meta-Llama-3-8B"

pipeline = transformers.pipeline("text-generation", model=model_id, model_kwargs={"dtype": torch.bfloat16}, device_map="auto")
pipeline("Hey how are you doing today?")
```

## Aperçu

Le modèle [Llama3](https://huggingface.co/papers/2407.21783) a été proposé dans [Introducing Meta Llama 3: The most capable openly available LLM to date](https://ai.meta.com/blog/meta-llama-3/) par l'équipe Meta AI.

L’abstract du billet de blog est le suivant :

*Aujourd’hui, nous avons le plaisir de partager les deux premiers modèles de la prochaine génération de Llama, Meta Llama 3, disponibles pour un usage large. Cette version propose des modèles de langage pré-entraînés et affinés par instruction, dotés de 8B et 70B paramètres, capables de soutenir une large gamme de cas d’usage. Cette nouvelle génération de Llama démontre des performances de pointe sur un large éventail de benchmarks sectoriels et offre de nouvelles capacités, notamment un raisonnement amélioré. Nous considérons qu’il s’agit des meilleurs modèles open source de leur catégorie, point final. Dans le cadre de notre approche ouverte de longue date, nous remettons Llama 3 entre les mains de la communauté. Nous souhaitons lancer la prochaine vague d’innovation en IA à travers toute la pile — des applications aux outils de développement, en passant par les évaluations et les optimisations d’inférence, et bien plus encore. Nous attendons avec impatience de voir ce que vous allez créer et nous réjouissons de recevoir vos retours.*

Retrouvez tous les points de contrôle des modèles Llama3 [ici](https://huggingface.co/models?search=llama3). Le code original des auteurs est disponible [ici](https://github.com/meta-llama/llama3).

## Conseils d'utilisation

Les modèles `Llama3` ont été entraînés en utilisant `bfloat16`, mais l'inférence d'origine utilise `float16`. Les points de contrôle téléversés sur le Hub utilisent `dtype = 'float16'`, ce qui sera utilisé par l'API `AutoModel` pour convertir les points de contrôle de `torch.float32` en `torch.float16`.

Le `dtype` des poids en ligne est généralement sans importance, sauf si vous utilisez `dtype="auto"` lors de l’initialisation d’un modèle via `model = AutoModelForCausalLM.from_pretrained("path", dtype = "auto")`. En effet, le modèle est d’abord téléchargé (en utilisant le `dtype` des points de contrôle en ligne), puis il est converti au `dtype` par défaut de `torch` (ce qui donne `torch.float32`, device_map="auto"), et enfin, si un `dtype` ou un `torch_dtype` est fourni dans la configuration, c’est celui-ci qui sera utilisé.

L’entraînement du modèle en `float16` n’est pas recommandé et est connu pour produire des `nan` ; le modèle doit donc être entraîné en `bfloat16`.

Astuces :

- Les poids des modèles Llama3 peuvent être obtenus en remplissant [ce formulaire](https://ai.meta.com/resources/models-and-libraries/llama-downloads/)
- L'architecture est exactement la même que celle de Llama2.
- Le tokenizer est un modèle BPE basé sur [tiktoken](https://github.com/openai/tiktoken) (par opposition à celui basé sur l'implémentation sentencepiece pour Llama2). La principale différence est qu'il ignore les règles de fusion BPE lorsqu'un jeton d'entrée fait partie du vocabulaire. Cela signifie que si aucune fusion n'existe pour produire `"hugging"`, au lieu d'obtenir les plus petites unités, comme `["hug","ging"]` formant 2 jetons, si `"hugging"` fait partie du vocabulaire, il sera automatiquement renvoyé en tant que jeton.
- Le modèle d'origine utilise `pad_id = -1`, ce qui signifie qu'il n'y a pas de jeton de bourrage. Nous ne pouvons pas adopter la même logique : veillez à ajouter un jeton de bourrage à l'aide de `tokenizer.add_special_tokens({"pad_token":"<pad>"})` et à redimensionner l'incorporation des jetons en conséquence. Vous devez également définir `model.config.pad_token_id`. La couche `embed_tokens` du modèle est initialisée avec `self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.config.padding_idx)`, ce qui garantit que l'encodage du jeton de bourrage produit des zéros ; il est donc recommandé de le passer lors de l'initialisation.
- Le point de contrôle d'origine peut être converti à l'aide du [script de conversion](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/convert_llama_weights_to_hf.py). Le script peut être appelé avec la commande (exemple) suivante :

    ```bash
    python src/transformers/models/llama/convert_llama_weights_to_hf.py \
        --input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path --llama_version 3
    ```

- Après conversion, le modèle et le tokeniseur peuvent être chargés via :

    ```python
    from transformers import AutoModelForCausalLM, AutoTokenizer

    tokenizer = AutoTokenizer.from_pretrained("/output/path")
    model = AutoModelForCausalLM.from_pretrained("/output/path", device_map="auto")
    ```

    Notez que l’exécution du script nécessite suffisamment de RAM CPU pour héberger l’intégralité du modèle en précision float16 (même si les plus grandes versions sont fournies sous forme de plusieurs points de contrôle, chacun contient une partie de chaque poids du modèle, il faut donc tous les charger en RAM). Pour le modèle 75B, il faut ainsi 145 Go de RAM.

- Lors de l’utilisation de Flash Attention 2 via `attn_implementation="flash_attention_2"`, ne passez pas `dtype` à la méthode de classe `from_pretrained` et utilisez l’entraînement en précision mixte automatique. Avec `Trainer`, il suffit de définir `fp16` ou `bf16` sur `True`. Sinon, assurez-vous d’utiliser `torch.autocast`. Cela est nécessaire car Flash Attention ne prend en charge que les types de données `fp16` et `bf16`.

## Ressources

De nombreuses ressources intéressantes sont déjà disponibles sur la page de documentation de [Llama2](./llama2), invitant les contributeurs à ajouter ici de nouvelles ressources sélectionnées pour Llama3 ! 🤗