Gemma 2

Exécutez efficacement les modèles Gemma 2 de Google sur les GPU Clore.ai

Nouvelle version disponible ! Google a publié Gemma 3 en mars 2025 — le modèle 27B bat Llama 3.1 405B et ajoute la prise en charge multimodale native. Envisagez une mise à jour.

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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

3 Go

Gemma-2-9B

12Go

Gemma-2-27B

27B

32Go

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
8000/http

Commande :

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:

Aller à la Mes commandes page
Cliquez sur votre commande
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


# Exécuter Gemma 2
ollama run gemma2

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

Installation

pip install transformers accelerate torch

Utilisation de base

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 :

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é)

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

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

API compatible OpenAI

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

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

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

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

CUDA out of memory

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 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

PrécédentCodeLlama SuivantPhi-4

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce que Gemma 2 ?

hashtagVariantes de modèle

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagUtilisation d'Ollama

hashtagInstallation

hashtagUtilisation de base

hashtagGemma 2 2B (Léger)

hashtagGemma 2 27B (Meilleure qualité)

hashtagServeur vLLM

hashtagAPI compatible OpenAI

hashtagStreaming

hashtagInterface Gradio

hashtagTraitement par lots

hashtagPerformances

hashtagComparaison

hashtagDépannage

hashtagGénération lente

hashtagProblèmes de qualité de sortie

hashtagAvertissements du tokenizer

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce que Gemma 2 ?

Variantes de modèle

Déploiement rapide

Accéder à votre service

Utilisation d'Ollama

Installation

Utilisation de base

Gemma 2 2B (Léger)

Gemma 2 27B (Meilleure qualité)

Serveur vLLM

API compatible OpenAI

Streaming

Interface Gradio

Traitement par lots

Performances

Comparaison

Dépannage

Génération lente

Problèmes de qualité de sortie

Avertissements du tokenizer

Estimation des coûts

Prochaines étapes