This model takes casual text like "I want to play soccer this week Friday 4 PM @ Central Park" and converts it into a properly formatted CreateEventRequest JSON object for backend API consumption.

Base Model: google/gemma-2-2b-it
Fine-tuning Method: LoRA (Low-Rank Adaptation)
Training Framework: Transformers + PEFT
Primary Use Case: Natural language to structured API requests for sports event creation

Usage

Installation

pip install transformers peft torch

Quick Start

python

from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel
import torch
import json

# Load base model
base_model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-2-2b-it",
    device_map="auto",
    dtype=torch.float16
)

# Load fine-tuned adapter
model = PeftModel.from_pretrained(base_model, "YOUR_USERNAME/gemma-event-parser")
tokenizer = AutoTokenizer.from_pretrained("YOUR_USERNAME/gemma-event-parser")

# Define 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": "Sport type (e.g., Soccer, Basketball, Tennis)"},
            "venue_name": {"type": "string", "description": "Venue name"},
            "start_time": {"type": "string", "description": "ISO 8601 format (e.g., 2026-02-07T16:00:00Z)"},
            "max_participants": {"type": "integer", "default": 2},
            "event_type": {
                "type": "string",
                "enum": ["Casual", "Light Training", "Looking to Improve", "Competitive Game"],
                "default": "Casual"
            }
        },
        "required": ["sport", "venue_name", "start_time"]
    }
}

# Parse natural language
def parse_event(user_query):
    prompt = f"""<start_of_turn>user
{user_query}

Available functions:
{json.dumps([function_schema], indent=2)}<end_of_turn>
<start_of_turn>model
"""
    
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,
        temperature=0.1,
        do_sample=True,
        top_p=0.95
    )
    
    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    # Extract JSON
    start = result.find("<function_call>") + len("<function_call>")
    end = result.find("</function_call>")
    function_call = json.loads(result[start:end].strip())
    
    return function_call["arguments"]

# Example
query = "I want to play soccer this week Friday 4 PM @ Central Park"
event_json = parse_event(query)
print(json.dumps(event_json, indent=2))

Output:

json

{
  "sport": "Soccer",
  "venue_name": "Central Park",
  "start_time": "2026-02-07T16:00:00Z",
  "max_participants": 22,
  "event_type": "Casual"
}

Examples

Input	Output
"Basketball game tomorrow 6pm at Riverside Courts, competitive"	`{"sport": "Basketball", "venue_name": "Riverside Courts", "start_time": "2026-02-07T18:00:00Z", "max_participants": 10, "event_type": "Competitive Game"}`
"Tennis match Wednesday 10 AM Ashburn Park, looking to improve"	`{"sport": "Tennis", "venue_name": "Ashburn Park", "start_time": "2026-02-12T10:00:00Z", "max_participants": 2, "event_type": "Looking to Improve"}`
"Casual volleyball Saturday 2pm Beach Courts"	`{"sport": "Volleyball", "venue_name": "Beach Courts", "start_time": "2026-02-08T14:00:00Z", "max_participants": 12, "event_type": "Casual"}`

Training Details

Training Data

Fine-tuned on synthetic examples covering:

Multiple sports (Soccer, Basketball, Tennis, Volleyball, Badminton, etc.)
Various time formats (relative dates, specific times)
All event types (Casual, Light Training, Looking to Improve, Competitive Game)
Different venue patterns

Training Size: ~10-20 high-quality examples (LoRA requires less data)

Training Hyperparameters

LoRA Rank (r): 16
LoRA Alpha: 32
Target Modules: q_proj, k_proj, v_proj, o_proj
Learning Rate: 2e-4
Epochs: 20
Batch Size: 2 (with gradient accumulation: 4)
Optimizer: AdamW
Scheduler: Cosine with warmup
Precision: FP16
Training Time: ~1-2 minutes on free Colab

Framework Versions

Transformers: 4.x
PEFT: 0.18.1
PyTorch: 2.x
Python: 3.10+

Limitations

Date Parsing: Currently handles relative dates ("Friday", "tomorrow") but assumes current week context
Time Zones: Defaults to UTC (Z suffix)
Sports Coverage: Best performance on common sports; may need examples for niche sports
Language: English only

Intended Use

✅ Good for:

Converting casual user input to structured API requests
Sports event management applications
Voice-to-API integrations
Chatbot backends for sports booking

❌ Not suitable for:

Mission-critical systems without validation
Non-English languages
Complex multi-event scheduling
Historical date parsing

License

This adapter follows the Gemma License. The base model is subject to Google's Gemma terms of use.

Citation

If you use this model, please cite:

bibtex

@misc{gemma-event-parser-2026,
  author = {YOUR_NAME},
  title = {Gemma 2B Event Parser - Sports Event Function Calling},
  year = {2026},
  publisher = {HuggingFace},
  url = {https://huggingface.co/YOUR_USERNAME/gemma-event-parser}
}

Acknowledgments

Base model: Google's Gemma 2B-IT
Fine-tuning framework: Hugging Face PEFT
Training compute: Google Colab

Questions? Open an issue or discussion on this model's page!

sarvkk/gemma-event-parser

Gemma 2B Event Parser - Sports Event Function Calling

Model Description