🦙 Llama (Meta AI) – Le Guide Ultime

Llama (Large Language Model Meta AI) est une famille de "Large Language Models" (LLM) créée par Meta AI (le laboratoire de recherche de Facebook/Meta).

Contrairement à GPT-4 (OpenAI) ou Claude (Anthropic), qui sont des modèles "fermés" (accessibles uniquement via une API payante), Llama est un "open-weight" (ou "gated open source") : Meta *publie les poids* (le "cerveau" entraîné du modèle), permettant aux développeurs de le télécharger et de le faire tourner sur leurs propres serveurs (ou même localement).

Llama est le catalyseur qui a *démocratisé* la recherche et le développement des LLM SOTA (State-of-the-Art) en dehors des "Big 3".

La stratégie de Meta avec Llama est "Open", mais ce n'est pas de l'open-source "classique" (comme Linux ou Python).

L'Impact du "Plugin" Open-Weight

• Démocratisation : A permis aux startups, chercheurs et amateurs de *posséder* un LLM SOTA.
• Fine-Tuning : A lancé l'explosion du "fine-tuning" (adapter Llama à des tâches spécifiques, ex: "Llama-Médical", "Llama-Code").
• Local : A permis l'émergence d'outils (plugins) comme Ollama (voir 2.3) pour faire tourner des LLM sur un simple MacBook.
• Concurrence : Force OpenAI et Google à baisser leurs prix d'API.

Llama 3 (Avril 2024) a été lancé avec 2 modèles (et un 3ème en cours d'entraînement).

Llama 3 (Avril 2024) a (temporairement) pris la couronne SOTA, en battant les modèles fermés (GPT-4, Claude 3 Opus) pour la première fois.

Note : Ces chiffres sont *déjà* obsolètes. Claude 3.5 Sonnet (Juin 2024) et GPT-4o (Mai 2024) ont (légèrement) dépassé Llama 3 70B.

L'essentiel : Llama 3 est *compétitif* avec les meilleurs modèles *payants*, tout en étant *open-weight*.

Il y a deux façons principales d'utiliser Llama :

Hugging Face (HF) est la plateforme (le "GitHub") de l'IA. transformers est leur "plugin" (librairie) Python pour charger et utiliser *tous* les LLM (Llama, GPT-2, Mistral...).

Inférence (Python transformers)

# (Nécessite: pip install transformers torch accelerate)
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# 1. Définir le modèle (depuis le Hub HF)
model_id = "meta-llama/Llama-3-8B-Instruct"

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16, # (Précision (FP16/BF16))
    device_map="auto" # (Met le modèle sur le GPU si dispo)
)

# 3. Format de Chat (Llama 3 Instruct)
#    (Chaque modèle a un "chat template" spécifique)
messages = [
    {"role": "system", "content": "Tu es un assistant Python."},
    {"role": "user", "content": "C'est quoi GQA ?"},
]

# 4. Appliquer le template (transforme en string/IDs)
input_ids = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to(model.device)

# 5. Génération
outputs = model.generate(
    input_ids,
    max_new_tokens=256,
    do_sample=True,
    temperature=0.7,
)

# 6. Décodage
response = tokenizer.decode(outputs[0][input_ids.shape[-1]:], skip_special_tokens=True)
print(response)

Ollama est le "Docker" des LLM. C'est le "plugin" (l'outil) le plus *simple* pour télécharger et exécuter des modèles (comme Llama 3) localement (macOS, Windows, Linux).

Il gère les poids, la quantification (GGUF), et expose une API REST locale (http://localhost:11434).

1. Utilisation (CLI)

# 1. Télécharger et exécuter Llama 3 8B
$ ollama run llama3

# 2. (La première fois, il télécharge ~4.7GB)
pulling manifest ...
pulling 8B-file.gguf ... 100%

# 3. Chatter !
>>> Pourquoi le ciel est bleu ?
La diffusion de Rayleigh...

2. Le Modelfile (Le "Plugin" de Customisation)

C'est le "Dockerfile" d'Ollama. Il permet de créer un *nouveau* modèle (custom) à partir d'un modèle de base (Llama 3).

Modelfile (Exemple)

# 1. Modèle de base
FROM llama3

# 2. Changer le "Prompt Système" (le "plugin" de personnalité)
SYSTEM """
Tu es un assistant expert en Python.
Tu es concis et ne donnes que du code.
Tu refuses de parler d'autre chose.
"""

# 3. Changer les paramètres (le "plugin" de créativité)
PARAMETER temperature 0.3
PARAMETER top_k 20

Ollama (CLI)

# 1. Créer le modèle custom
$ ollama create mon-python-bot -f ./Modelfile

# 2. L'utiliser
$ ollama run mon-python-bot "C'est quoi VGG ?"
# (Il va répondre sur Python, ou refuser)

Llama 3 (Instruct) a été entraîné pour le "Tool Use" (Appel de Fonctions), un "plugin" essentiel (similaire à Claude 2.1 et GPT). Il permet au LLM de *demander* à utiliser des outils (plugins) externes.

L'implémentation est gérée par le framework (ex: Ollama, LangChain, transformers).

Exemple (Hugging Face transformers)

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "meta-llama/Llama-3-70B-Instruct"
# ... (charger model & tokenizer) ...

# 1. Définir le "plugin" (l'outil) au format OpenAI
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "La ville"},
                },
                "required": ["location"],
            },
        },
    }
]

# 2. Le "Prompt"
messages = [{"role": "user", "content": "Quelle est la météo à Paris ?"}]

# 3. Génération (en forçant un 'tool_choice')
tool_call_response = model.generate(
    ...,
    tools=tools,
    tool_choice="auto" 
)

# 4. 'tool_call_response' (la réponse de Llama)
# (Le modèle s'arrête et demande d'appeler l'outil)
# -> "J'appelle: get_current_weather(location='Paris')"

# 5. (Votre code exécute la vraie fonction 'get_current_weather'...)
# 6. (Vous re-appelez le modèle avec le résultat...)

Spéculations sur Llama 4

L'industrie s'attend à ce que Llama 4 (ou le "vrai" Llama 3 405B+) sorte fin 2024 / début 2025 pour concurrencer GPT-4o et Claude 3.5.

Les "plugins" (innovations) attendus sont :

• Multimodalité NATIVE : Gérer (en entrée *et* sortie) Texte, Image, Audio (comme GPT-4o).
• MoE (Mixture of Experts) : (Comme Mixtral/GPT-4). Au lieu d'un "gros" 405B, ce sera (peut-être) 8x "experts" de 100B, pour une inférence plus rapide.
• Contexte 1M+ : Une fenêtre de contexte de 1M+ tokens (natif).