# Gemma 2

{% hint style="info" %}
**Nouvelle version disponible !** Google a publié [**Gemma 3**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/gemma3) en mars 2025 — le modèle 27B bat Llama 3.1 405B et ajoute la prise en charge multimodale native. Envisagez une mise à jour.
{% endhint %}

Exécutez les modèles Gemma 2 de Google pour une inférence efficace.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que Gemma 2 ?

Gemma 2 de Google offre :

* Modèles de 2B à 27B de paramètres
* Excellente performance par taille
* Bonne capacité à suivre les instructions
* Architecture efficace

## Variantes de modèle

| Modèle      | Paramètres | VRAM | Contexte |
| ----------- | ---------- | ---- | -------- |
| Gemma-2-2B  | 2B         | 3 Go | 8K       |
| Gemma-2-9B  | 9B         | 12Go | 8K       |
| Gemma-2-27B | 27B        | 32Go | 8K       |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Ports :**

```
22/tcp
8000/http
```

**Commande :**

```bash
pip install vllm && \
vllm serve google/gemma-2-9b-it --port 8000
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Utilisation d'Ollama

```bash

# Exécuter Gemma 2
ollama run gemma2

# Tailles spécifiques
ollama run gemma2:2b
ollama run gemma2:9b
ollama run gemma2:27b
```

## Installation

```bash
pip install transformers accelerate torch
```

## Utilisation de base

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "google/gemma-2-9b-it"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

messages = [
    {"role": "user", "content": "Expliquez comment les réseaux neuronaux apprennent."}
]

inputs = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt",
    add_generation_prompt=True
).to("cuda")

outputs = model.generate(
    inputs,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
print(response)
```

## Gemma 2 2B (Léger)

Pour le déploiement en périphérie/mobile :

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "google/gemma-2-2b-it"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Inférence rapide pour tâches simples
messages = [{"role": "user", "content": "Résumez en une phrase : L'IA transforme les industries."}]
```

## Gemma 2 27B (Meilleure qualité)

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_id = "google/gemma-2-27b-it"

# Utilisez du 4 bits pour tenir dans 24 Go de VRAM
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16
)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto"
)
```

## Serveur vLLM

```bash
vllm serve google/gemma-2-9b-it \
    --port 8000 \
    --dtype bfloat16 \
    --max-model-len 8192
```

### API compatible OpenAI

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

response = client.chat.completions.create(
    model="google/gemma-2-9b-it",
    messages=[
        {"role": "user", "content": "Écrivez un haïku sur la programmation"}
    ],
    temperature=0.8
)

print(response.choices[0].message.content)
```

## Streaming

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

stream = client.chat.completions.create(
    model="google/gemma-2-9b-it",
    messages=[{"role": "user", "content": "Raconte-moi une courte histoire"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

## Interface Gradio

```python
import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "google/gemma-2-9b-it"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto"
)

def chat(message, history, temperature):
    messages = []
    for h in history:
        messages.append({"role": "user", "content": h[0]})
        messages.append({"role": "assistant", "content": h[1]})
    messages.append({"role": "user", "content": message})

    inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True).to("cuda")
    outputs = model.generate(inputs, max_new_tokens=512, temperature=temperature, do_sample=True)

    return tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)

demo = gr.ChatInterface(
    fn=chat,
    additional_inputs=[gr.Slider(0.1, 1.5, value=0.7, label="Temperature")],
    title="Gemma 2 Chat"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Traitement par lots

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "google/gemma-2-9b-it"
tokenizer = AutoTokenizer.from_pretrained(model_id, padding_side="left")
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto"
)

prompts = [
    "Expliquez la gravité en une phrase.",
    "Qu'est-ce que la photosynthèse ?",
    "Définissez l'apprentissage automatique.",
    "Quelle est la vitesse de la lumière ?"
]

messages_batch = [[{"role": "user", "content": p}] for p in prompts]

inputs = tokenizer.apply_chat_template(
    messages_batch,
    return_tensors="pt",
    padding=True,
    add_generation_prompt=True
).to("cuda")

outputs = model.generate(inputs, max_new_tokens=128, pad_token_id=tokenizer.pad_token_id)

for i, output in enumerate(outputs):
    response = tokenizer.decode(output, skip_special_tokens=True)
    print(f"Q: {prompts[i]}")
    print(f"A: {response.split('<start_of_turn>model')[-1].strip()}\n")
```

## Performances

| Modèle               | GPU      | Tokens/sec |
| -------------------- | -------- | ---------- |
| Gemma-2-2B           | RTX 3060 | \~100      |
| Gemma-2-9B           | RTX 3090 | \~60       |
| Gemma-2-9B           | RTX 4090 | \~85       |
| Gemma-2-27B          | A100     | \~45       |
| Gemma-2-27B (4 bits) | RTX 4090 | \~30       |

## Comparaison

| Modèle       | MMLU  | Qualité   | Vitesse |
| ------------ | ----- | --------- | ------- |
| Gemma-2-9B   | 71.3% | Excellent | Rapide  |
| Llama-3.1-8B | 69.4% | Bon       | Rapide  |
| Mistral-7B   | 62.5% | Bon       | Rapide  |

## Dépannage

{% hint style="danger" %}
**CUDA out of memory**
{% endhint %}

pour 27B - Utilisez la quantification 4 bits avec BitsAndBytesConfig - Réduisez \`max\_new\_tokens\` - Videz le cache GPU : \`torch.cuda.empty\_cache()\`

### Génération lente

* Utilisez vLLM pour le déploiement en production
* Activez Flash Attention
* Essayez le modèle 9B pour une inférence plus rapide

### Problèmes de qualité de sortie

* Utilisez la version ajustée aux instructions (`-it` suffixe)
* Ajustez la température (0,7-0,9 recommandé)
* Ajoutez une invite système pour le contexte

### Avertissements du tokenizer

* Mettez à jour transformers vers la dernière version
* Utilisez `padding_side="left"` pour l'inférence par lot

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| RTX 3060  | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090  | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090  | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* Llama 3.2 - modèle de Meta
* Qwen2.5 - le modèle d'Alibaba
* vLLM Inference - Mise en production