242 lines
8.9 KiB
Markdown
242 lines
8.9 KiB
Markdown
---
|
|
base_model: google/functiongemma-270m-it
|
|
tags:
|
|
- function-calling
|
|
- mobile-actions
|
|
- gemma
|
|
library_name: transformers
|
|
datasets:
|
|
- google/mobile-actions
|
|
language:
|
|
- en
|
|
license: gemma
|
|
---
|
|
|
|
# FunctionGemma 270M for Mobile Actions
|
|
|
|
This model is a fine-tuned version of [google/functiongemma-270m-it](https://huggingface.co/google/functiongemma-270m-it) specialized for mobile assistant actions. It has been trained on the [google/mobile-actions](https://huggingface.co/datasets/google/mobile-actions) dataset to perform structured function calling for common mobile device tasks.
|
|
|
|
## Model Description
|
|
|
|
**Base Model**: `google/functiongemma-270m-it` - A 270M parameter instruction-tuned model from Google's FunctionGemma family, designed for function calling tasks.
|
|
|
|
**Specialization**: Mobile assistant actions including:
|
|
- Calendar event management
|
|
- Email composition and sending
|
|
- Contact creation
|
|
- Flashlight control
|
|
- Wi-Fi settings navigation
|
|
- Map location display
|
|
|
|
**Training Objective**: The model learns to emit structured function calls in the format `call:<function_name>{arg1:value1,arg2:value2,...}` instead of natural language responses.
|
|
|
|
## Supported Functions
|
|
|
|
The model is optimized to call these mobile action functions:
|
|
|
|
1. **`turn_on_flashlight()`** - Turns the device flashlight on
|
|
2. **`turn_off_flashlight()`** - Turns the device flashlight off
|
|
3. **`create_contact(first_name, last_name, phone_number?, email?)`** - Creates a new contact
|
|
4. **`send_email(to, subject, body?)`** - Sends an email to a recipient
|
|
5. **`show_map(query)`** - Displays a location on the map by name, business, or address
|
|
6. **`open_wifi_settings()`** - Opens the Wi-Fi settings screen
|
|
7. **`create_calendar_event(title, datetime)`** - Creates a calendar event (datetime in ISO format: `YYYY-MM-DDTHH:MM:SS`)
|
|
|
|
## Training Details
|
|
|
|
### Training Data
|
|
|
|
- **Dataset**: [google/mobile-actions](https://huggingface.co/datasets/google/mobile-actions)
|
|
- **Format**: JSONL with prompt-completion pairs
|
|
- **Splits**:
|
|
- Training set: examples with `"metadata": "train"`
|
|
- Evaluation set: examples with `"metadata": "eval"`
|
|
- **Preprocessing**: Converted to TRL prompt-completion format with `completion_only_loss=True`
|
|
|
|
### Training Procedure
|
|
|
|
Fine-tuned using Hugging Face [TRL (Transformer Reinforcement Learning)](https://huggingface.co/docs/trl) with the `SFTTrainer`.
|
|
|
|
**Training Configuration**:
|
|
- **Epochs**: 4
|
|
- **Batch size**: 8 per device
|
|
- **Gradient accumulation steps**: 4
|
|
- **Learning rate**: 5e-5
|
|
- **Scheduler**: Cosine
|
|
- **Max sequence length**: 997 tokens (based on longest example: 897 tokens)
|
|
- **Optimizer**: AdamW (fused)
|
|
- **Precision**: bfloat16
|
|
- **Gradient checkpointing**: Enabled
|
|
- **Completion only loss**: True (trains only on model outputs, not prompts)
|
|
|
|
**Training Infrastructure**:
|
|
- **Hardware**: Google Colab A100 GPU
|
|
- **Training time**: ~20 minutes for 2 epochs
|
|
- **Library versions**: transformers==4.57.1, trl==0.25.1, datasets==4.4.1
|
|
|
|
### Training Results
|
|
|
|
Final metrics after 2 epochs:
|
|
|
|
| Step | Training Loss | Validation Loss | Mean Token Accuracy |
|
|
|------|---------------|-----------------|---------------------|
|
|
| 500 | 0.008800 | 0.013452 | 0.996691 |
|
|
|
|
The model achieved 99.67% token-level accuracy on the validation set, showing significant improvement over the base model's mobile action capabilities.
|
|
|
|
## Intended Use
|
|
|
|
This model is designed for:
|
|
- **Mobile AI assistants** that need to execute device actions based on user requests
|
|
- **Voice-controlled mobile applications**
|
|
- **Conversational agents** that interact with mobile device features
|
|
- **On-device AI** applications (can be converted to `.litertlm` format for deployment)
|
|
|
|
## How to Use
|
|
|
|
### Basic Inference
|
|
|
|
```python
|
|
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
|
|
import json
|
|
|
|
# Load model and tokenizer
|
|
model_id = "jprtr/google_mobile_actions"
|
|
tokenizer = AutoTokenizer.from_pretrained(model_id)
|
|
model = AutoModelForCausalLM.from_pretrained(
|
|
model_id,
|
|
device_map="auto",
|
|
attn_implementation="eager",
|
|
torch_dtype="auto",
|
|
)
|
|
|
|
# Create pipeline
|
|
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
|
|
|
|
# Define the tools (function schemas)
|
|
tools = [
|
|
{
|
|
"function": {
|
|
"name": "create_calendar_event",
|
|
"description": "Creates a new calendar event.",
|
|
"parameters": {
|
|
"type": "OBJECT",
|
|
"properties": {
|
|
"title": {"type": "STRING", "description": "The title of the event."},
|
|
"datetime": {"type": "STRING", "description": "The date and time in YYYY-MM-DDTHH:MM:SS format."},
|
|
},
|
|
"required": ["title", "datetime"],
|
|
},
|
|
}
|
|
},
|
|
{
|
|
"function": {
|
|
"name": "send_email",
|
|
"description": "Sends an email.",
|
|
"parameters": {
|
|
"type": "OBJECT",
|
|
"properties": {
|
|
"to": {"type": "STRING", "description": "The recipient email address."},
|
|
"subject": {"type": "STRING", "description": "The email subject."},
|
|
"body": {"type": "STRING", "description": "The email body."},
|
|
},
|
|
"required": ["to", "subject"],
|
|
},
|
|
}
|
|
},
|
|
# ... add other function definitions
|
|
]
|
|
|
|
# Create messages
|
|
messages = [
|
|
{
|
|
"role": "developer",
|
|
"content": (
|
|
"Current date and time given in YYYY-MM-DDTHH:MM:SS format: 2025-07-10T19:06:29\n"
|
|
"Day of week is Thursday\n"
|
|
"You are a model that can do function calling with the following functions\n"
|
|
),
|
|
},
|
|
{
|
|
"role": "user",
|
|
"content": 'Schedule a "team meeting" tomorrow at 4pm.',
|
|
},
|
|
]
|
|
|
|
# Apply chat template
|
|
prompt = tokenizer.apply_chat_template(
|
|
messages,
|
|
tools=tools,
|
|
tokenize=False,
|
|
add_generation_prompt=True,
|
|
)
|
|
|
|
# Generate
|
|
output = pipe(prompt, max_new_tokens=200)[0]["generated_text"][len(prompt):].strip()
|
|
print("Model output:", output)
|
|
# Example output: call:create_calendar_event{datetime:2025-07-11T16:00:00,title:team meeting}
|
|
```
|
|
|
|
### Parsing Function Calls
|
|
|
|
The model outputs function calls in a simple format:
|
|
```
|
|
call:<function_name>{arg1:value1,arg2:value2,...}
|
|
```
|
|
|
|
For multiple function calls, they appear sequentially:
|
|
```
|
|
call:create_calendar_event{datetime:2025-07-15T10:30:00,title:Dental Checkup}
|
|
call:send_email{to:user@example.com,subject:Appointment,body:See you there!}
|
|
```
|
|
|
|
You can parse these by:
|
|
1. Splitting on `call:` to identify individual function calls
|
|
2. Extracting the function name (text before `{`)
|
|
3. Parsing the arguments block (content within `{}`)
|
|
|
|
## Evaluation
|
|
|
|
The model was evaluated on the held-out test set from the mobile-actions dataset. Evaluation metrics compare exact string matching of the model's function call outputs against ground truth labels.
|
|
|
|
**Key Observations**:
|
|
- The base FunctionGemma 270M model often fails to call appropriate functions for mobile actions
|
|
- After fine-tuning, the model reliably generates correct function calls with proper argument formatting
|
|
- Token-level accuracy on the validation set: **99.67%**
|
|
|
|
## Limitations
|
|
|
|
- The model is specialized for the 7 mobile action functions listed above and may not generalize well to other function calling tasks
|
|
- Date/time parsing relies on context provided in the developer message (current date/time must be specified)
|
|
- The model outputs may occasionally include variations in argument formatting that are semantically correct but don't exactly match the expected format
|
|
- This is a 270M parameter model, so while efficient for mobile deployment, it may have lower accuracy than larger models
|
|
|
|
## On-Device Deployment
|
|
|
|
The model can be converted to `.litertlm` format for on-device deployment using `ai-edge-torch`. See the [training notebook](https://colab.research.google.com/github/google-gemini/gemma-cookbook/blob/main/FunctionGemma/%5BFunctionGemma%5DFinetune_FunctionGemma_270M_for_Mobile_Actions_with_Hugging_Face.ipynb) for conversion instructions.
|
|
|
|
The converted model can be deployed on:
|
|
- Android devices via [Google AI Edge](https://ai.google.dev/edge)
|
|
- [AI Edge Gallery app](https://play.google.com/store/apps/details?id=com.google.ai.edge.gallery)
|
|
|
|
## Training Notebook
|
|
|
|
For full training details, hyperparameter tuning, and evaluation, see the original Colab notebook:
|
|
[Finetune FunctionGemma 270M for Mobile Actions](https://colab.research.google.com/github/google-gemini/gemma-cookbook/blob/main/FunctionGemma/%5BFunctionGemma%5DFinetune_FunctionGemma_270M_for_Mobile_Actions_with_Hugging_Face.ipynb)
|
|
|
|
## Citation
|
|
|
|
If you use this model, please cite the original FunctionGemma paper and the Google Mobile Actions dataset:
|
|
|
|
```bibtex
|
|
@misc{functiongemma2024,
|
|
title={FunctionGemma: Function Calling for Gemma Models},
|
|
author={Google},
|
|
year={2024},
|
|
url={https://huggingface.co/google/functiongemma-270m-it}
|
|
}
|
|
```
|
|
|
|
## License
|
|
|
|
This model is released under the Gemma license. See the [Gemma Terms of Use](https://ai.google.dev/gemma/terms) for details. |