Gemma 2

Ejecuta los modelos Gemma 2 de Google de forma eficiente en GPUs de Clore.ai

¡Nueva versión disponible! Google lanzó Gemma 3 en marzo de 2025: el modelo de 27B supera a Llama 3.1 405B y agrega soporte multimodal nativo. Considere actualizar.

Ejecute los modelos Gemma 2 de Google para una inferencia eficiente.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

Visita CLORE.AI Marketplace
Filtrar por tipo de GPU, VRAM y precio
Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)
Configura tu pedido:
- Selecciona imagen Docker
- Establece puertos (TCP para SSH, HTTP para interfaces web)
- Agrega variables de entorno si es necesario
- Introduce el comando de inicio
Selecciona pago: CLORE, BTC, o USDT/USDC
Crea el pedido y espera el despliegue

Accede a tu servidor

Encuentra los detalles de conexión en Mis Pedidos
Interfaces web: Usa la URL del puerto HTTP
SSH: ssh -p <port> root@<proxy-address>

¿Qué es Gemma 2?

Gemma 2 de Google ofrece:

Modelos de 2B a 27B de parámetros
Excelente rendimiento por tamaño
Fuerte seguimiento de instrucciones
Arquitectura eficiente

Variantes de modelo

Modelo

Parámetros

VRAM

Contexto

Gemma-2-2B

3GB

Gemma-2-9B

12GB

Gemma-2-27B

27B

32GB

Despliegue rápido

Imagen Docker:

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

Puertos:

22/tcp
8000/http

Comando:

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

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

Ir a Mis Pedidos página
Haz clic en tu pedido
Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Usando Ollama


# Ejecutar Gemma 2
ollama run gemma2

# Tamaños específicos
ollama run gemma2:2b
ollama run gemma2:9b
ollama run gemma2:27b

Instalación

pip install transformers accelerate torch

Uso básico

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": "Explain how neural networks learn."}
]

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 (Ligero)

Para despliegue en borde/móvil:

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

# Inferencia rápida para tareas simples
messages = [{"role": "user", "content": "Summarize in one sentence: AI is transforming industries."}]

Gemma 2 27B (Mejor calidad)

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

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

# Use 4-bit para caber en 24GB 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"
)

Servidor vLLM

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

API compatible con 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": "Write a haiku about programming"}
    ],
    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": "Tell me a short story"}],
    stream=True
)

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

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

Procesamiento por lotes

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 = [
    "Explain gravity in one sentence.",
    "What is photosynthesis?",
    "Define machine learning.",
    "What is the speed of light?"
]

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

Rendimiento

Modelo

GPU

Tokens/seg

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

Comparación

Modelo

MMLU

Calidad

Velocidad

Gemma-2-9B

71.3%

Genial

Rápido

Llama-3.1-8B

69.4%

Bueno

Rápido

Mistral-7B

62.5%

Bueno

Rápido

Solución de problemas

CUDA fuera de memoria

para 27B - Use cuantización a 4 bits con BitsAndBytesConfig - Reduzca `max_new_tokens` - Limpie la caché de GPU: `torch.cuda.empty_cache()`

Generación lenta

Use vLLM para despliegue en producción
Habilitar Flash Attention
Pruebe el modelo de 9B para una inferencia más rápida

Problemas de calidad de salida

Use la versión afinada con instrucciones (-it sufijo)
Ajuste la temperatura (recomendado 0.7-0.9)
Agregue un prompt de sistema para contexto

Advertencias del tokenizador

Actualice transformers a la versión más reciente
Usa padding_side="left" para inferencia por lotes

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU

Tarifa por hora

Tarifa diaria

Sesión de 4 horas

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

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)
Paga con CLORE tokens
Compara precios entre diferentes proveedores

Próximos pasos

Llama 3.2 - El modelo de Meta
Qwen2.5 - el modelo de Alibaba
Inferencia vLLM - Servicio en producción

AnteriorCodeLlama SiguientePhi-4

Última actualización hace 1 día

¿Te fue útil?

hashtagAlquilar en CLORE.AI

hashtagAccede a tu servidor

hashtag¿Qué es Gemma 2?

hashtagVariantes de modelo

hashtagDespliegue rápido

hashtagAccediendo a tu servicio

hashtagUsando Ollama

hashtagInstalación

hashtagUso básico

hashtagGemma 2 2B (Ligero)

hashtagGemma 2 27B (Mejor calidad)

hashtagServidor vLLM

hashtagAPI compatible con OpenAI

hashtagStreaming

hashtagInterfaz Gradio

hashtagProcesamiento por lotes

hashtagRendimiento

hashtagComparación

hashtagSolución de problemas

hashtagGeneración lenta

hashtagProblemas de calidad de salida

hashtagAdvertencias del tokenizador

hashtagEstimación de costos

hashtagPróximos pasos

Alquilar en CLORE.AI

Accede a tu servidor

¿Qué es Gemma 2?

Variantes de modelo

Despliegue rápido

Accediendo a tu servicio

Usando Ollama

Instalación

Uso básico

Gemma 2 2B (Ligero)

Gemma 2 27B (Mejor calidad)

Servidor vLLM

API compatible con OpenAI

Streaming

Interfaz Gradio

Procesamiento por lotes

Rendimiento

Comparación

Solución de problemas

Generación lenta

Problemas de calidad de salida

Advertencias del tokenizador

Estimación de costos

Próximos pasos