from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "google/gemma-3-27b-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 quantum computing in simple terms"}
]

input_ids = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt",
    add_generation_prompt=True
).to(model.device)

outputs = model.generate(
    input_ids,
    max_new_tokens=512,
    temperature=0.7,
    top_p=0.9,
    do_sample=True
)

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

from transformers import AutoProcessor, Gemma3ForConditionalGeneration
from PIL import Image
import requests

model = Gemma3ForConditionalGeneration.from_pretrained(
    "google/gemma-3-27b-vision",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained("google/gemma-3-27b-vision")

# Load image
image_url = "https://example.com/chart.png"
image = Image.open(requests.get(image_url, stream=True).raw)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Analyze this chart and explain the trends"}
        ]
    }
]

inputs = processor.apply_chat_template(messages, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0], skip_special_tokens=True))

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import BitsAndBytesConfig, TrainingArguments
from trl import SFTTrainer

# Quantization config for memory efficiency
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-3-12b-it",
    quantization_config=bnb_config,
    device_map="auto"
)

model = prepare_model_for_kbit_training(model)

# LoRA configuration
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)

# Training
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=TrainingArguments(
        output_dir="./gemma3-finetuned",
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=10,
        save_strategy="epoch"
    ),
    tokenizer=tokenizer,
    max_seq_length=2048
)

trainer.train()

from datasets import Dataset

# Format for instruction tuning
data = [
    {
        "instruction": "Summarize this code",
        "input": "def fib(n): return n if n <= 1 else fib(n-1) + fib(n-2)",
        "output": "A recursive Fibonacci function that returns the nth Fibonacci number."
    },
    # ... more examples
]

def format_prompt(example):
    return f"""<start_of_turn>user
{example['instruction']}

{example['input']}<end_of_turn>
<start_of_turn>model
{example['output']}<end_of_turn>"""

dataset = Dataset.from_list(data)
dataset = dataset.map(lambda x: {"text": format_prompt(x)})

from vllm import LLM, SamplingParams

llm = LLM(
    model="google/gemma-3-27b-it",
    tensor_parallel_size=2,  # Multi-GPU
    dtype="bfloat16",
    max_model_len=32768
)

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=512
)

prompts = ["Question 1...", "Question 2...", "Question 3..."]
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(output.outputs[0].text)

system_prompt = """You are a helpful coding assistant. Follow these guidelines:
- Write clean, well-documented code
- Explain your reasoning step by step
- Consider edge cases and error handling
- Use type hints in Python code"""

def format_message(user_query: str) -> list:
    return [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_query}
    ]

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google/gemma-3-27b-it")

def truncate_context(messages: list, max_tokens: int = 120000) -> list:
    """Ensure context fits within model limits."""
    while True:
        text = tokenizer.apply_chat_template(messages, tokenize=False)
        tokens = len(tokenizer.encode(text))
        
        if tokens <= max_tokens:
            return messages
        
        # Remove oldest non-system message
        for i, msg in enumerate(messages):
            if msg["role"] != "system":
                messages.pop(i)
                break

import json
import re

def extract_json(response: str) -> dict:
    """Extract JSON from model response."""
    # Try to find JSON block
    json_match = re.search(r'```json\n(.*?)\n```', response, re.DOTALL)
    if json_match:
        return json.loads(json_match.group(1))
    
    # Try direct parse
    try:
        return json.loads(response)
    except json.JSONDecodeError:
        return {"raw": response}