🤖 Qwen (Alibaba) – Le Guide Ultime

Qwen 1.5 (Fév 2024)

Une mise à jour "incrémentale" majeure (style "Llama 2.5").

• Modèles : 0.5B, 1.8B, 4B, 7B, 14B, 32B, 72B.
• Innovation (Plugin) : A adopté l'architecture de Llama 2 (GQA, RMSNorm) (voir 1.5).
• Tokenizer : Nouveau tokenizer de 150K+ (le "plugin" multilingue).
• Impact : Bat Llama 2 70B sur *tous* les benchmarks.

Qwen 2 (Juin 2024) - Le "SOTA"

La version SOTA (State-of-the-Art) actuelle, conçue pour battre Llama 3 et GPT-4.

• Modèles : 0.5B, 1.5B, 7B, 57B, 72B (le SOTA).
• Contexte : 128K tokens.
• Données : Entraîné sur 3 Trillions de tokens (multilingues).
• Impact : Le Qwen 2 72B *bat* Llama 3 70B sur MMLU, GPQA, MATH (voir 2.1).
• "Plugin" Géant : Inclus aussi Qwen 2 1.5T (1.5 Trillion de params), un "plugin" MoE (Mixture of Experts).

Clarification : "Qwen 3-235B"

Vous avez mentionné "Qwen 3-235B". Au moment de la rédaction (Fin 2024/Début 2025), cette terminologie est inexacte et semble être une confusion :

1. Qwen 3 : N'a pas encore été annoncé (Meta n'a pas non plus annoncé Llama 4).
2. 235B (235 Milliards) : Ce n'est pas une taille de paramètre standard pour Qwen (ou Llama).

Hypothèses :

• Vous pensez peut-être au Qwen 2 1.5T (1500 Milliards de params), qui est un MoE ?
• Ou au Llama 3 405B (405 Milliards) (le SOTA de Meta, non-public) ?

Ce guide se concentre sur le SOTA public et utilisable : la famille Qwen 2.

Innovations Clés (Les "Plugins" d'Archi)

• GQA (Grouped-Query Attention) :
  Problème : L'Attention (Self-Attention) est le "goulot" (coût en RAM/VRAM) des LLM.
  Solution (Plugin) : GQA "partage" les têtes (ex: 8 têtes de Query, mais seulement 2 têtes de Key/Value partagées).
  Résultat : Inférence *beaucoup* plus rapide (moins de VRAM nécessaire) pour (presque) la même précision.


• SwiGLU (FFN) :
  Utilise une "Feed-Forward Network" (FFN) basée sur SwiGLU (au lieu d'un simple ReLU/GeLU). C'est un "plugin" qui améliore l'efficacité des calculs dans le bloc Transformer.


• RMSNorm (Root Mean Square Normalization) :
  Un "plugin" de normalisation (comme LayerNorm) mais *plus simple* et *plus rapide*.
  Utilisé en pré-normalisation (avant l'attention), ce qui stabilise l'entraînement des très grands modèles.

QLoRA (Le "Plugin" Magique)

QLoRA (de 2023) est la technique "plugin" qui a *tout* changé. Elle permet de fine-tuner un 72B sur un GPU "gamer".

Elle combine 2 "plugins" :

1. Quantization (4-bit) : (via bitsandbytes). Le modèle 72B (FP16) est "compressé" en 4-bit (INT4) en mémoire. (Taille VRAM / 4).
2. LoRA (Adaptateurs) : On ajoute les "plugins" LoRA (petites matrices) qui, eux, sont entraînés en 16-bit.

C'est la méthode standard pour tout fine-tuning local.

Code (Hugging Face transformers + trl)

# (Nécessite: pip install transformers trl peft bitsandbytes)
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig
from trl import SFTTrainer

# 1. Modèle de base
model_id = "Qwen/Qwen2-7B-Instruct"

# 2. Config "Plugin" QLoRA (Quantization 4-bit)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

# 3. Config "Plugin" LoRA (Adaptateurs)
lora_config = LoraConfig(
    r=16, 
    lora_alpha=32, 
    lora_dropout=0.05, 
    task_type="CAUSAL_LM"
)

# 4. Charger le modèle (quantizé !)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_id)

# 5. Lancer l'entraînement (SFTTrainer = Supervised Fine-Tuning)
trainer = SFTTrainer(
    model=model,
    train_dataset=mon_dataset_jsonl,
    peft_config=lora_config,
    dataset_text_field="text",
    ...
)
trainer.train()

Exemple (Hugging Face transformers)

# 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. Transformer le "prompt" et les "tools" pour le chat_template
prompt = tokenizer.apply_chat_template(
    messages, 
    tools=tools, 
    tool_choice="auto", 
    add_generation_prompt=True,
    tokenize=False
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

# 4. Génération
outputs = model.generate(**inputs, max_new_tokens=128)

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

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