菜单
Enable non-English language models to reliably generate function calls and tool invocations through continued training on bilingual function-calling datasets. Achieves 28% improvement in parsing accuracy while preserving language understanding.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/ADu2021/skillXiv --skill tool-use-training-multilingual命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
| name | tool-use-training-multilingual |
| title | Teaching a Language Model to Speak the Language of Tools |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2506.23394 |
| keywords | ["Tool Use","Function Calling","Multilingual Models","Instruction Tuning","Language Model Adaptation"] |
| description | Enable non-English language models to reliably generate function calls and tool invocations through continued training on bilingual function-calling datasets. Achieves 28% improvement in parsing accuracy while preserving language understanding. |
Most language models with reliable tool-use capabilities are English-dominant, leaving multilingual and low-resource language models unable to make clean function calls. When you ask a Bulgarian or Japanese model to use a tool, it often responds with verbose natural language explanations instead of parsable structured output. This forces developers to use English models regardless of their language requirements, limiting tool-augmented AI to English-speaking users.
The core problem is that tool-use training is typically English-centric. Models learn to generate function calls by being fine-tuned on English function-calling examples, which creates a language-specific skill. Teaching a model to reliably generate tool calls in another language requires explicitly training it on function-calling examples in that language, paired with English to show the relationship between natural language requests and structured outputs.
Tool-use training works by treating function calls as a special output format that the model must learn to produce reliably. The key insight is:
The approach uses bilingual training data where the same functional intent appears in both English and the target language, showing the model that "call this function" should produce the same structured output regardless of input language.
Tool-use training leverages the model's existing architecture without modification. The training pipeline consists of:
Step 1: Create bilingual function-calling dataset
Build training data where the same function call appears in both English and the target language. Start with existing MCP (Model Context Protocol) specifications or tool definitions.
def create_bilingual_function_examples(tools_config, target_language='bg',
examples_per_tool=5):
"""
Generate bilingual function-calling examples from tool definitions.
Creates training pairs showing the same function call in multiple languages.
tools_config: dict with tool definitions (name, description, parameters)
"""
translator = load_translator('en', target_language)
examples = []
for tool in tools_config['tools']:
tool_name = tool['name']
tool_description = tool['description']
parameters = tool['function']['parameters']['properties']
# Generate natural language prompts in English
en_prompts = generate_prompts_for_tool(tool, num_prompts=examples_per_tool)
for en_prompt in en_prompts:
# Translate to target language
tgt_prompt = translator.translate(en_prompt)
# Generate the correct function call (deterministic from the prompt)
function_call = extract_function_call_from_prompt(en_prompt, tool)
# Add both language versions
examples.append({
'language': 'en',
'prompt': en_prompt,
'function_call': function_call,
'tool': tool_name
})
examples.append({
'language': target_language,
'prompt': tgt_prompt,
'function_call': function_call,
'tool': tool_name
})
return examples
def generate_prompts_for_tool(tool, num_prompts=5):
"""
Generate diverse natural language prompts for a tool.
Each prompt should elicit a function call when processed.
"""
prompts = []
tool_name = tool['name']
description = tool['description']
parameters = tool['function']['parameters']['properties']
param_names = list(parameters.keys())
# Template 1: Direct command
prompts.append(f"Use the {tool_name} function to {description}")
# Template 2: Question asking for action
prompts.append(f"Can you {description}?")
# Template 3: Task request
prompts.append(f"Please {description}")
# Template 4-5: Specific parameter requests (vary which parameters)
for i in range(2):
selected_params = param_names[:len(param_names)//2]
param_str = ', '.join(selected_params)
prompts.append(f"Use {tool_name} with {param_str} to {description}")
return prompts[:num_prompts]
Step 2: Format training examples with special tokens for tool calls
Structure the training data so the model learns to produce clean function call syntax in a consistent format.
def format_tool_training_example(prompt, function_call, tool_name):
"""
Format a training example with clear delimiters for function calls.
This teaches the model when to switch to structured output mode.
"""
# Standard format: prompt -> <TOOL_CALL>function_call</TOOL_CALL>
# Explicit markers help the model learn the boundary between natural language and structure
formatted = f"""User: {prompt}
Assistant: <TOOL_CALL>{function_call}</TOOL_CALL>"""
return formatted
Step 3: Train on mixed function-calling and instruction data
Combine function-calling examples with general instruction data to maintain general capabilities while improving tool use.
def train_tool_use_model(base_model, tool_examples, instruction_examples,
num_epochs=3, learning_rate=2e-5,
tool_example_ratio=0.3):
"""
Fine-tune a base model on mixed tool-use and instruction data.
Tool examples teach function calling; instruction examples maintain general abilities.
"""
optimizer = torch.optim.AdamW(base_model.parameters(), lr=learning_rate)
total_examples = tool_examples + instruction_examples
num_tool_batches = int(len(tool_examples) * tool_example_ratio)
num_instruction_batches = len(instruction_examples) - num_tool_batches
for epoch in range(num_epochs):
# Shuffle and interleave examples
random.shuffle(total_examples)
# Group by type for better batch composition
tool_batches = create_batches(tool_examples, batch_size=8)
instruction_batches = create_batches(instruction_examples, batch_size=8)
# Interleave: 30% tool examples, 70% instruction examples
interleaved = []
for i in range(max(len(tool_batches), len(instruction_batches))):
if i < len(tool_batches):
interleaved.append(('tool', tool_batches[i]))
if i < len(instruction_batches):
interleaved.append(('instruction', instruction_batches[i]))
for batch_type, batch in interleaved:
inputs = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['labels'].to(device)
# Forward pass
outputs = base_model(inputs, attention_mask=attention_mask, labels=labels)
loss = outputs.loss
# Backward pass
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(base_model.parameters(), 1.0)
optimizer.step()
if batch_type == 'tool':
print(f"Tool batch loss: {loss.item():.4f}")
else:
print(f"Instruction batch loss: {loss.item():.4f}")
return base_model
Step 4: Validate function-call parsing accuracy
Test whether the model generates valid, parsable function calls in both languages.
def evaluate_tool_use_accuracy(model, tokenizer, test_examples, language):
"""
Measure how often the model generates valid, parsable function calls.
Parsing accuracy is the key metric: the call must be valid JSON/structured format.
"""
valid_calls = 0
correct_calls = 0
for example in test_examples:
prompt = example['prompt']
expected_call = example['function_call']
# Generate output
input_ids = tokenizer.encode(prompt, return_tensors='pt').to(device)
output_ids = model.generate(input_ids, max_length=256, temperature=0.1)
generated_text = tokenizer.decode(output_ids[0])
# Extract function call from generated text
extracted_call = extract_function_call_text(generated_text)
# Validate parsing
is_valid = False
try:
parsed_call = json.loads(extracted_call)
is_valid = True
except json.JSONDecodeError:
is_valid = False
if is_valid:
valid_calls += 1
# Check if the call matches expected
if parsed_call == json.loads(expected_call):
correct_calls += 1
parsing_accuracy = valid_calls / len(test_examples)
correctness_accuracy = correct_calls / len(test_examples)
return {
'language': language,
'parsing_accuracy': parsing_accuracy,
'correctness_accuracy': correctness_accuracy,
'total_examples': len(test_examples)
}
| Hyperparameter | Recommended Value | Notes |
|---|---|---|
| Learning rate | 2e-5 to 5e-5 | Lower than general fine-tuning due to small dataset |
| Batch size | 8-16 | Small batches help with diverse tool examples |
| Function-calling data ratio | 20-40% | Balance against catastrophic forgetting |
| Number of examples per tool | 5-20 | 10-15 is usually sufficient for 95%+ accuracy |
| Training epochs | 2-4 | Often converges in 2-3 epochs |
| Temperature for inference | 0.1-0.3 | Low temperature ensures consistent function call format |
When to use tool-use training:
When NOT to use tool-use training:
Common pitfalls:
Teaching a Language Model to Speak the Language of Tools https://arxiv.org/abs/2506.23394
基于 SOC 职业分类
