funcgemma-event-parser-v2

FunctionGemma 270M — Sports Event Parser

A lightweight LoRA fine-tune of google/functiongemma-270m-it that converts natural language sports event requests into structured create_sports_event function calls with proper ISO 8601 timestamps and timezone handling.

"Soccer this Friday 4pm @ Central Park" → {"sport": "Soccer", "venue_name": "Central Park", "start_time": "2026-02-13T16:00:00-05:00", ...}

Model Details

Model Description

This adapter teaches a 270M-parameter Gemma model to act as a function-calling layer for sports event creation. Given a user's natural language request plus their timezone, the model outputs a JSON function call with the correct sport, venue, date (resolved from relative references like "tomorrow", "this Friday", "next Monday"), time in ISO 8601 with timezone offset, participant count, and event type.

• Developed by: sarvkk
• Model type: Causal Language Model (LoRA adapter)
• Language(s): English
• License: Apache 2.0
• Base model: google/functiongemma-270m-it (270M parameters)
• Adapter size: ~0.5% of base model parameters

Key Features

• Relative date resolution — understands "tomorrow", "this Friday", "next Monday", "Saturday", etc.
• Multi-timezone support — outputs correct UTC offsets for America/New_York, America/Los_Angeles, America/Chicago, Europe/London, Asia/Tokyo, Australia/Sydney, and more
• ISO 8601 timestamps — e.g. 2026-02-07T16:00:00-05:00
• Structured output — consistently produces valid JSON function calls

How to Get Started

Important: Must use bfloat16 — Gemma's RMSNorm produces NaN in fp16.

from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel
import torch
import json
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

BASE_MODEL = "google/functiongemma-270m-it"
ADAPTER_REPO = "sarvkk/funcgemma-event-parser-v2"

device = "cuda" if torch.cuda.is_available() else "cpu"

# Load base + LoRA adapter
base_model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    device_map={"": device},
    dtype=torch.bfloat16,
    attn_implementation="eager",
    low_cpu_mem_usage=True,
)
model = PeftModel.from_pretrained(base_model, ADAPTER_REPO, device_map={"": device})
tokenizer = AutoTokenizer.from_pretrained(ADAPTER_REPO)
model.eval()

# Function schema
FUNCTION_SCHEMA = {
    "name": "create_sports_event",
    "description": "Create a new sports event from natural language description",
    "parameters": {
        "type": "object",
        "properties": {
            "sport": {"type": "string", "description": "Type of sport"},
            "venue_name": {"type": "string", "description": "Name of the venue"},
            "start_time": {"type": "string", "description": "ISO 8601 with timezone"},
            "max_participants": {"type": "integer", "default": 2},
            "event_type": {
                "type": "string",
                "enum": ["Casual", "Light Training", "Looking to Improve", "Competitive Game"],
            },
        },
        "required": ["sport", "venue_name", "start_time"],
    },
}

# Build prompt with date context
now = datetime.now()
today_str = now.strftime("%Y-%m-%d")
today_day = now.strftime("%A")
current_time = now.strftime("%H:%M")
tomorrow_str = (now + timedelta(days=1)).strftime("%Y-%m-%d")
user_timezone = "America/New_York"
tz = ZoneInfo(user_timezone)
offset = now.replace(hour=12, tzinfo=tz).strftime("%z")
tz_offset = f"{offset[:3]}:{offset[3:]}"

user_query = "Soccer this Friday 4pm @ Central Park"

prompt = f"""<start_of_turn>user
Current date and time: {today_str} ({today_day}) at {current_time}
User timezone: {user_timezone} (UTC{tz_offset})

User request: {user_query}

Available functions:
{json.dumps([FUNCTION_SCHEMA], indent=2)}

Important:
- Calculate dates relative to {today_str}
- "tomorrow" = {tomorrow_str}
- "Friday" = the next upcoming Friday from {today_str}
- All times should be in ISO 8601 format with timezone offset
- Example: "{tomorrow_str}T16:00:00{tz_offset}"
<end_of_turn>
<start_of_turn>model
"""

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=300,
        do_sample=False,
        pad_token_id=tokenizer.eos_token_id,
    )

result = tokenizer.decode(outputs[0], skip_special_tokens=True)
start = result.find("<function_call>") + len("<function_call>")
end = result.find("</function_call>")
if end == -1:
    end = len(result)
parsed = json.loads(result[start:end].strip())
print(json.dumps(parsed, indent=2))

Example Output

{
  "name": "create_sports_event",
  "arguments": {
    "sport": "Soccer",
    "venue_name": "Central Park",
    "start_time": "2026-02-13T16:00:00-05:00",
    "max_participants": 22,
    "event_type": "Casual"
  }
}

Training Details

Training Data

Synthetically generated dataset of ~600 examples covering:

• 25 query templates per reference date — varied sports (Soccer, Basketball, Tennis, Volleyball, Running, Swimming, Cycling, Golf, Hockey, Badminton, Yoga), venues, times, and phrasing styles
• 6 reference dates across February 2026 (covering different days of the week)
• 4 user timezones: America/New_York, America/Los_Angeles, America/Chicago, Europe/London
• Additional timezone examples: Asia/Tokyo, Australia/Sydney embedded in the training set
• Event types: Casual, Light Training, Looking to Improve, Competitive Game

Each example includes the current date context in the prompt so the model learns to resolve relative dates ("tomorrow", "this Friday", "next Monday") dynamically.

Training Procedure

Fine-tuned using TRL's SFTTrainer with LoRA adapters via PEFT.

LoRA Configuration

Training Hyperparameters

Speeds, Sizes, Times

Evaluation

Testing Data

6 held-out queries with unseen venue names across 5 timezones, testing relative date resolution and diverse sports.

Metrics

• Parse success rate: Whether the model output is valid JSON with the correct function name
• Field accuracy: Correct sport, venue, date, time, and timezone offset

Results

6/6 queries parsed successfully (100% parse rate)

Benchmark vs Gemma-2 2B

Compared against a Gemma-2 2B LoRA adapter trained on the same task, on a Tesla T4 GPU:

The 270M model matches the 2B model on accuracy while being 1.3× faster at inference and 1.6× faster to load, with ~7× fewer parameters.

Technical Specifications

Model Architecture and Objective

• Architecture: Gemma 270M (decoder-only transformer) with LoRA adapters on attention projection layers
• Objective: Causal language modeling (next-token prediction) fine-tuned for structured function-call generation

Compute Infrastructure

Hardware

• GPU: NVIDIA Tesla T4 (15.8 GB VRAM)
• Platform: Lightning AI Studio

Software

• Transformers: latest
• PEFT: 0.18.1
• TRL: latest
• PyTorch: 2.x with CUDA
• Python: 3.12

Framework Versions

• PEFT 0.18.1