phi-3.5-mini-mtl-router-validator

Model Description

This is a Multi-Task Learning (MTL) model fine-tuned on Microsoft Phi-3.5-mini-instruct (3.8B parameters) using LoRA adapters. The model performs two distinct tasks:

Task A: Domain Classification (Router)

• Classifies user queries into 17 domains
• Outputs structured JSON format
• Supports multi-domain classification

Domains: coding, data_analysis, technology, mathematics, api_generation, history, literature, creative_content, geography, law, medicine, business, education, science, sensitive, ambiguous, general_knowledge

Task B: Hallucination Detection (Validator)

• Detects whether model outputs contain hallucinations
• Provides reasoning for decisions
• Binary classification with explanation

Training Details

• Base Model: microsoft/Phi-3.5-mini-instruct
• Training Method: QLoRA (4-bit quantization)
• LoRA Configuration:
  • Rank (r): 16
  • Alpha: 32
  • Target Modules: gate_proj, up_proj, down_proj
• Training Data:
  • Router: ~7,118 samples (5x upsampled to 35,500)
  • Validator: ~34,507 samples (QA, Dialogue, Summarization, General)
• Epochs: 2-3
• Effective Batch Size: 16

Usage

Installation

pip install transformers peft torch

Task A: Domain Classification

from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel

# Load model
base_model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3.5-mini-instruct",
    trust_remote_code=True,
    torch_dtype=torch.float16,
    device_map="auto"
)
model = PeftModel.from_pretrained(base_model, "ovinduG/phi-3.5-mini-mtl-router-validator")
tokenizer = AutoTokenizer.from_pretrained("ovinduG/phi-3.5-mini-mtl-router-validator")

# Classify domain
messages = [
    {
        "role": "system",
        "content": "You are a domain classification assistant. Classify the query and output JSON."
    },
    {
        "role": "user",
        "content": "Query: How do I implement a binary search in Python?"
    }
]

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

outputs = model.generate(**inputs, max_new_tokens=150)
response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(response)
# Output: {"primary_domain": "coding", "secondary_domain": null, "is_multi_domain": false}

Task B: Hallucination Detection

messages = [
    {
        "role": "system",
        "content": "You are a hallucination detection assistant."
    },
    {
        "role": "user",
        "content": "Context: Paris is the capital of France.\n\nModel Output: Paris is the capital of France and has 10 million people.\n\nDoes this contain hallucinations?"
    }
]

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

outputs = model.generate(**inputs, max_new_tokens=200)
response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(response)
# Output: Hallucination: Yes
# Explanation: The population figure is not mentioned in the context.

Performance Metrics

Task A (Router)

• JSON Validity Rate: >99%
• F1-Score (Macro): >90%
• Overall Accuracy: High

Task B (Validator)

• Binary Accuracy: >85%
• F1-Score: High
• Supports reasoning output

Limitations

• Context window: 4096 tokens
• Requires Phi-3.5 chat template format
• Best performance with clear, well-formed queries
• May require fine-tuning for domain-specific applications

Citation

If you use this model, please cite:

@misc{phi35-mtl-ovinduG,
  author = {ovinduG},
  title = {Phi-3.5 Multi-Task Learning Model},
  year = {2025},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/ovinduG/phi-3.5-mini-mtl-router-validator}}
}

License

This model inherits the license from microsoft/Phi-3.5-mini-instruct.

Acknowledgments

• Base model: Microsoft Phi-3.5-mini-instruct
• Training framework: Hugging Face Transformers + PEFT
• Quantization: bitsandbytes

---

Model trained using Multi-Task Learning (MTL) with hard parameter sharing and LoRA adapters.