En este tutorial, creamos y ejecutamos un flujo de trabajo de Colab para Gemma 3 1B Instruct utilizando Hugging Face Transformers y HF Token, de una manera práctica, reproducible y fácil de seguir paso a paso. Comenzamos instalando las bibliotecas necesarias, autenticándonos de forma segura con nuestro token Hugging Face y cargando el tokenizador y el modelo en el dispositivo disponible con la configuración de precisión correcta. A partir de ahí, creamos utilidades de generación reutilizables, formateamos mensajes en una estructura estilo chat y probamos el modelo en múltiples tareas realistas, como generación básica, respuestas estructuradas de estilo JSON, encadenamiento de mensajes, evaluación comparativa y resumen determinista, de modo que no solo cargamos Gemma sino que realmente trabajamos con él de manera significativa.
Configuramos el entorno necesario para ejecutar el tutorial sin problemas en Google Colab. Instalamos las bibliotecas necesarias, importamos todas las dependencias principales y nos autenticamos de forma segura con Hugging Face utilizando nuestro token. Al final de esta parte, prepararemos el cuaderno para acceder al modelo Gemma y continuar el flujo de trabajo sin problemas de configuración manual.
Configuramos el tiempo de ejecución detectando si estamos usando una GPU o una CPU y seleccionando la precisión adecuada para cargar el modelo de manera eficiente. Luego definimos la ruta del modelo Gemma 3 1 B Instruct y cargamos tanto el tokenizador como el modelo desde Hugging Face. En esta etapa, completamos la inicialización del modelo central, preparando el cuaderno para generar texto.
{“role”: “user”, “content”: user_prompt}
]
intente: texto = tokenizer.apply_chat_template( mensajes, tokenize=False, add_generación_prompt=True ) excepto Excepción: texto = f”user\n{user_prompt}\nmodel\n” texto de retorno def generate_text(prompt, max_new_tokens=256, temperatura=0.7, do_sample=True): chat_text = build_chat_prompt(prompt) entradas = tokenizer(chat_text, return_tensors=”pt”).to(model.device) con torch.no_grad(): salidas = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=do_sample, temperatura=temperatura si do_sample else Ninguno, top_p=0.95 si do_sample else Ninguno, eos_token_id=tokenizer.eos_token_id, pad_token_id=tokenizer.eos_token_id, ) generado = salidas[0][inputs[“input_ids”].forma[-1]:]return tokenizer.decode(generated, skip_special_tokens=True).strip() print(“=” * 100) print(“PASO 4 — Generación básica”) print(“=” * 100) Prompt1 = “””Explique Gemma 3 en inglés sencillo. Luego proporcione: 1. un caso de uso práctico 2. una limitación 3. un consejo de Colab Sea conciso.””” resp1 = generate_text(prompt1, max_new_tokens=220, temperatura=0.7, do_sample=True) print(resp1)
Construimos las funciones reutilizables que dan formato a las indicaciones en la estructura de chat esperada y manejamos la generación de texto a partir del modelo. Hacemos que el canal de inferencia sea modular para que podamos reutilizar la misma función en diferentes tareas en el cuaderno. Después de eso, ejecutamos un ejemplo práctico de primera generación para confirmar que el modelo funciona correctamente y produce resultados significativos.
}, “api”: { “ventajas”: [“”, “”, “”]”contras”: [“”, “”, “”]
}, “best_for”: { “local”: “”, “api”: “” } } Solo genera JSON. “”” resp2 = generate_text(prompt2, max_new_tokens=300, Temperature=0.2, do_sample=True) print(resp2) print(“=” * 100) print(“PASO 6 — Encadenamiento de mensajes”) print(“=” * 100) task = “Redactar una lista de verificación de 5 pasos para evaluar si Gemma se ajusta a un prototipo empresarial interno.” resp3 = generate_text(task, max_new_tokens=250, temperatura=0.6, do_sample=True) print(resp3) followup = f””” Aquí hay una lista de verificación inicial: {resp3} Ahora reescríbala para una audiencia de gerente de producto. “”” resp4 = generar_texto(seguimiento, max_new_tokens=250, temperatura=0.6, do_sample=True) print(resp4)
Llevamos el modelo más allá de las simples indicaciones probando la generación de resultados estructurados y el encadenamiento de indicaciones. Le pedimos a Gemma que devuelva una respuesta en un formato similar a JSON definido y luego use una instrucción de seguimiento para transformar una respuesta anterior para una audiencia diferente. Esto nos ayuda a ver cómo el modelo maneja las restricciones de formato y el refinamiento de varios pasos en un flujo de trabajo realista.
“Explain tokenization in two lines.”,
“Give three use cases for local LLMs.”,
“What is one downside of small local models?”,
“Explain instruction tuning in one paragraph.”
]
filas = []
para p en indicaciones: t0 = time.time() out = generate_text(p, max_new_tokens=140, temperatura=0.3, do_sample=True) dt = time.time() – t0 rows.append({ “prompt”: p, “latency_sec”: round(dt, 2), “chars”: len(out), “preview”: out[:160].replace(“\n”, ” “) }) df = pd.DataFrame(rows) print(df) print(“=” * 100) print(“PASO 8: resumen determinista”) print(“=” * 100) long_text = “”” En el uso práctico, los equipos a menudo evalúan las compensaciones entre el costo de implementación local, la latencia, la privacidad, la controlabilidad y la capacidad bruta. Los modelos más pequeños pueden ser más fáciles de implementar, pero puede tener más dificultades con razonamientos complejos o tareas específicas de un dominio “”” resumen_prompt = f””” Resuma lo siguiente exactamente en 4 viñetas: {long_text} “”” resumen = generate_text(summary_prompt, max_new_tokens=180, do_sample=False) print(summary) print(“=” * 100) print(“PASO 9 – Guardar resultados”) print(“=” * 100) report = { “model_id”: model_id, “device”: str(model.device), “basic_generación”: resp1, “structured_output”: resp2, “chain_step_1”: resp3, “chain_step_2”: resp4, “summary”: resumen, “benchmark”: filas, } con open(“gemma3_1b_text_tutorial_report.json”, “w”, codificación=”utf-8″) as f: json.dump(report, f, indent=2, sure_ascii=False) print(“Guardado gemma3_1b_text_tutorial_report.json”) print(“Tutorial completo.”)
Evaluamos el modelo a través de un pequeño punto de referencia de indicaciones para observar el comportamiento de la respuesta, la latencia y la duración de la salida en un experimento compacto. Luego realizamos una tarea de resumen determinista para ver cómo se comporta el modelo cuando se reduce la aleatoriedad. Finalmente, guardamos todos los resultados principales en un archivo de informe, convirtiendo el cuaderno en una configuración experimental reutilizable en lugar de solo una demostración temporal.
En conclusión, tenemos un proceso completo de generación de texto que muestra cómo se puede usar Gemma 3 1B en Colab para experimentación práctica y creación de prototipos livianos. Generamos respuestas directas, comparamos resultados entre diferentes estilos de mensajes, medimos el comportamiento de latencia simple y guardamos los resultados en un archivo de informe para su posterior inspección. Al hacerlo, convertimos el portátil en más que una demostración única: lo convertimos en una base reutilizable para probar indicaciones, evaluar resultados e integrar Gemma en flujos de trabajo más grandes con confianza.
Consulte el cuaderno de codificación completo aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 120.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.