How to Build a Production-Ready Gemma 3 1B Instruct Generation AI Pipeline with Hugging Face Transformers, Chat Templates, and Colab Inference

import os
import sys
import time
import json
import getpass
import subprocess
import warnings
warnings.filterwarnings("ignore")


def pip_install(*pkgs):
   subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", *pkgs])


pip_install(
   "transformers>=4.51.0",
   "speed up",
   "sentencepiece",
   "safetensors",
   "pandas",
)


import torch
import pandas as pd
from huggingface_hub import login
from transformers import AutoTokenizer, AutoModelForCausalLM


print("=" * 100)
print("STEP 1 — Hugging Face authentication")
print("=" * 100)


hf_token = None
attempt:
   from google.colab import userdata
   attempt:
       hf_token = userdata.get("HF_TOKEN")
   besides Exception:
       hf_token = None
besides Exception:
   cross


if not hf_token:
   hf_token = getpass.getpass("Enter your Hugging Face token: ").strip()


login(token=hf_token)
os.environ["HF_TOKEN"] = hf_token
print("HF login profitable.")

print("=" * 100)
print("STEP 2 — Device setup")
print("=" * 100)


system = "cuda" if torch.cuda.is_available() else "cpu"
dtype = torch.bfloat16 if torch.cuda.is_available() else torch.float32
print("system:", system)
print("dtype:", dtype)


model_id = "google/gemma-3-1b-it"
print("model_id:", model_id)


print("=" * 100)
print("STEP 3 — Load tokenizer and mannequin")
print("=" * 100)


tokenizer = AutoTokenizer.from_pretrained(
   model_id,
   token=hf_token,
)


mannequin = AutoModelForCausalLM.from_pretrained(
   model_id,
   token=hf_token,
   torch_dtype=dtype,
   device_map="auto",
)


mannequin.eval()
print("Tokenizer and mannequin loaded efficiently.")

def build_chat_prompt(user_prompt: str):
   messages = [
       {"role": "user", "content": user_prompt}
   ]
   attempt:
       textual content = tokenizer.apply_chat_template(
           messages,
           tokenize=False,
           add_generation_prompt=True
       )
   besides Exception:
       textual content = f"<start_of_turn>usern{user_prompt}<end_of_turn>n<start_of_turn>modeln"
   return textual content


def generate_text(immediate, max_new_tokens=256, temperature=0.7, do_sample=True):
   chat_text = build_chat_prompt(immediate)
   inputs = tokenizer(chat_text, return_tensors="pt").to(mannequin.system)


   with torch.no_grad():
       outputs = mannequin.generate(
           **inputs,
           max_new_tokens=max_new_tokens,
           do_sample=do_sample,
           temperature=temperature if do_sample else None,
           top_p=0.95 if do_sample else None,
           eos_token_id=tokenizer.eos_token_id,
           pad_token_id=tokenizer.eos_token_id,
       )


   generated = outputs[0][inputs["input_ids"].form[-1]:]
   return tokenizer.decode(generated, skip_special_tokens=True).strip()


print("=" * 100)
print("STEP 4 — Basic era")
print("=" * 100)


prompt1 = """Explain Gemma 3 in plain English.
Then give:
1. one sensible use case
2. one limitation
3. one Colab tip
Keep it concise."""
resp1 = generate_text(prompt1, max_new_tokens=220, temperature=0.7, do_sample=True)
print(resp1)

print("=" * 100)
print("STEP 5 — Structured output")
print("=" * 100)


prompt2 = """
Compare native open-weight mannequin utilization vs API-hosted mannequin utilization.


Return JSON with this schema:
{
 "native": {
   "execs": ["", "", ""],
   "cons": ["", "", ""]
 },
 "api": {
   "execs": ["", "", ""],
   "cons": ["", "", ""]
 },
 "best_for": {
   "native": "",
   "api": ""
 }
}
Only output JSON.
"""
resp2 = generate_text(prompt2, max_new_tokens=300, temperature=0.2, do_sample=True)
print(resp2)


print("=" * 100)
print("STEP 6 — Prompt chaining")
print("=" * 100)


activity = "Draft a 5-step guidelines for evaluating whether or not Gemma suits an inner enterprise prototype."
resp3 = generate_text(activity, max_new_tokens=250, temperature=0.6, do_sample=True)
print(resp3)


followup = f"""
Here is an preliminary guidelines:


{resp3}


Now rewrite it for a product supervisor viewers.
"""
resp4 = generate_text(followup, max_new_tokens=250, temperature=0.6, do_sample=True)
print(resp4)

print("=" * 100)
print("STEP 7 — Mini benchmark")
print("=" * 100)


prompts = [
   "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."
]


rows = []
for p in prompts:
   t0 = time.time()
   out = generate_text(p, max_new_tokens=140, temperature=0.3, do_sample=True)
   dt = time.time() - t0
   rows.append({
       "immediate": p,
       "latency_sec": spherical(dt, 2),
       "chars": len(out),
       "preview": out[:160].substitute("n", " ")
   })


df = pd.DataFrame(rows)
print(df)


print("=" * 100)
print("STEP 8 — Deterministic summarization")
print("=" * 100)


long_text = """
In sensible utilization, groups typically consider
trade-offs amongst native deployment price, latency, privateness, controllability, and uncooked functionality.
Smaller fashions will be simpler to deploy, however they could battle extra on advanced reasoning or domain-specific duties.
"""


summary_prompt = f"""
Summarize the next in precisely 4 bullet factors:


{long_text}
"""
abstract = generate_text(summary_prompt, max_new_tokens=180, do_sample=False)
print(abstract)


print("=" * 100)
print("STEP 9 — Save outputs")
print("=" * 100)


report = {
   "model_id": model_id,
   "system": str(mannequin.system),
   "basic_generation": resp1,
   "structured_output": resp2,
   "chain_step_1": resp3,
   "chain_step_2": resp4,
   "abstract": abstract,
   "benchmark": rows,
}


with open("gemma3_1b_text_tutorial_report.json", "w", encoding="utf-8") as f:
   json.dump(report, f, indent=2, ensure_ascii=False)


print("Saved gemma3_1b_text_tutorial_report.json")
print("Tutorial full.")