Phi 4 Mini Instruct

🚀 Phi-4

Phi-4 is a powerful model with multiple variants, offering a range of capabilities for various applications. It supports multilingual use, making it suitable for a global audience. The model is designed to handle complex tasks, including reasoning, instruction following, and multimodal processing.

Model Variants

• [mini-reasoning | reasoning]
• [multimodal-instruct | onnx]
• [mini-instruct | onnx]

📚 Model Summary

Phi-4-mini-instruct is a lightweight open model built upon synthetic data and filtered publicly available websites, focusing on high-quality, reasoning-dense data. It belongs to the Phi-4 model family and supports a 128K token context length. The model has undergone enhancement, incorporating supervised fine-tuning and direct preference optimization to ensure precise instruction adherence and robust safety measures.

• 📰 Phi-4-mini Microsoft Blog
• 📖 Phi-4-mini Technical Report
• 👩‍🍳 Phi Cookbook
• 🏡 Phi Portal
• 🖥️ Try It Azure, Huggingface
• 🚀 Model paper

🎯 Intended Uses

Primary Use Cases

The model is intended for broad multilingual commercial and research use. It is suitable for general-purpose AI systems and applications that require:

1. Memory/compute constrained environments
2. Latency bound scenarios
3. Strong reasoning (especially math and logic)

The model is designed to accelerate research on language and multimodal models, serving as a building block for generative AI-powered features.

Use Case Considerations

The model is not specifically designed or evaluated for all downstream purposes. Developers should consider common limitations of language models, as well as performance differences across languages, when selecting use cases. They should evaluate and mitigate for accuracy, safety, and fairness before using the model in a specific downstream use case, particularly for high-risk scenarios.

Developers should be aware of and adhere to applicable laws or regulations (including but not limited to privacy, trade compliance laws, etc.) relevant to their use case.

⚠️ Important Note

Nothing contained in this Model Card should be interpreted as or deemed a restriction or modification to the license the model is released under.

📢 Release Notes

This release of Phi-4-mini-instruct is based on valuable user feedback from the Phi-3 series. The Phi-4-mini model employs a new architecture for efficiency, a larger vocabulary for multilingual support, and better post-training techniques for instruction following, function calling, and additional data, resulting in substantial gains in key capabilities.

It is anticipated that most use cases will benefit from this release, but users are encouraged to test the model in their particular AI applications. Feedback on Phi-4-mini-instruct is welcomed and crucial to the model's evolution and improvement.

Model Quality

To understand the capabilities of the 3.8B parameters Phi-4-mini-instruct model, it was compared with a set of models over a variety of benchmarks using an internal benchmark platform (See Appendix A for benchmark methodology). A high-level overview of the model quality is as follows:

Overall, the 3.8B-param model achieves a similar level of multilingual language understanding and reasoning ability as much larger models. However, it is still fundamentally limited by its size for certain tasks. The model may not have the capacity to store too much factual knowledge, and users may experience factual incorrectness. It may be possible to resolve this weakness by augmenting Phi-4 with a search engine, particularly when using the model under RAG settings.

💻 Usage

Tokenizer

Phi-4-mini-instruct supports a vocabulary size of up to 200064 tokens. The tokenizer files already provide placeholder tokens that can be used for downstream fine-tuning, but they can also be extended up to the model's vocabulary size.

Input Formats

Given the nature of the training data, the Phi-4-mini-instruct model is best suited for prompts using specific formats. Below are the two primary formats:

Chat format

This format is used for general conversation and instructions:

<|system|>Insert System Message<|end|><|user|>Insert User Message<|end|><|assistant|>

Tool-enabled function-calling format

This format is used when the user wants the model to provide function calls based on the given tools. The user should provide the available tools in the system prompt, wrapped by <|tool|> and <|/tool|> tokens. The tools should be specified in JSON format, using a JSON dump structure. Example:

<|system|>You are a helpful assistant with some tools.<|tool|>[{"name": "get_weather_updates", "description": "Fetches weather updates for a given city using the RapidAPI Weather API.", "parameters": {"city": {"description": "The name of the city for which to retrieve weather information.", "type": "str", "default": "London"}}}]<|/tool|><|end|><|user|>What is the weather like in Paris today?<|end|><|assistant|>

Inference with vLLM

Requirements

List of required packages:

flash_attn==2.7.4.post1
torch==2.5.1
vllm>=0.7.3

Example

To perform inference using vLLM, you can use the following code snippet:

from vllm import LLM, SamplingParams

llm = LLM(model="microsoft/Phi-4-mini-instruct", trust_remote_code=True)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "Can you provide ways to eat combinations of bananas and dragonfruits?"},
    {"role": "assistant", "content": "Sure! Here are some ways to eat bananas and dragonfruits together: 1. Banana and dragonfruit smoothie: Blend bananas and dragonfruits together with some milk and honey. 2. Banana and dragonfruit salad: Mix sliced bananas and dragonfruits together with some lemon juice and honey."},
    {"role": "user", "content": "What about solving an 2x + 3 = 7 equation?"},
]

sampling_params = SamplingParams(
  max_tokens=500,
  temperature=0.0,
)

output = llm.chat(messages=messages, sampling_params=sampling_params)
print(output[0].outputs[0].text)

Inference with Transformers

Requirements

The Phi-4 family has been integrated into the 4.49.0 version of transformers. The current transformers version can be verified with: pip list | grep transformers. Python 3.8 and 3.10 will work best.

List of required packages:

flash_attn==2.7.4.post1
torch==2.5.1
transformers==4.49.0
accelerate==1.3.0

Phi-4-mini-instruct is also available in Azure AI Studio

Example

After obtaining the Phi-4-mini-instruct model checkpoints, users can use this sample code for inference.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

torch.random.manual_seed(0)

model_path = "microsoft/Phi-4-mini-instruct"

model = AutoModelForCausalLM.from_pretrained(
    model_path,
    device_map="auto",
    torch_dtype="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(model_path)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "Can you provide ways to eat combinations of bananas and dragonfruits?"},
    {"role": "assistant", "content": "Sure! Here are some ways to eat bananas and dragonfruits together: 1. Banana and dragonfruit smoothie: Blend bananas and dragonfruits together with some milk and honey. 2. Banana and dragonfruit salad: Mix sliced bananas and dragonfruits together with some lemon juice and honey."},
    {"role": "user", "content": "What about solving an 2x + 3 = 7 equation?"},
]

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
)

generation_args = {
    "max_new_tokens": 500,
    "return_full_text": False,
    "temperature": 0.0,
    "do_sample": False,
}

output = pipe(messages, **generation_args)
print(output[0]['generated_text'])

⚠️ Responsible AI Considerations

Like other language models, the Phi family of models can potentially behave in ways that are unfair, unreliable, or offensive. Some of the limiting behaviors to be aware of include:

• Quality of Service: The Phi models are trained primarily on English text and some additional multilingual text. Languages other than English will experience worse performance, as well as performance disparities across non-English languages. English language varieties with less representation in the training data might experience worse performance than standard American English.
• Multilingual performance and safety gaps: While it is important to make language models more widely available across different languages, the Phi 4 models still exhibit challenges common across multilingual releases. Developers should test for performance or safety gaps in their linguistic and cultural context and customize the model with additional fine-tuning and appropriate safeguards.
• Representation of Harms & Perpetuation of Stereotypes: These models can over- or under-represent groups of people, erase representation of some groups, or reinforce demeaning or negative stereotypes. Despite safety post-training, these limitations may still be present due to differing levels of representation of different groups, cultural contexts, or prevalence of examples of negative stereotypes in training data that reflect real-world patterns and societal biases.
• Inappropriate or Offensive Content: These models may produce other types of inappropriate or offensive content, which may make it inappropriate to deploy for sensitive contexts without additional mitigations specific to the case.
• Information Reliability: Language models can generate nonsensical content or fabricate content that might sound reasonable but is inaccurate or outdated.
• Limited Scope for Code: The majority of Phi 4 training data is based in Python and uses common packages such as "typing, math, random, collections, datetime, itertools". If the model generates Python scripts that utilize other packages or scripts in other languages, it is strongly recommended that users manually verify all API uses.
• Long Conversation: Phi 4 models, like other models, can in some cases generate responses that are repetitive, unhelpful, or inconsistent in very long chat sessions in both English and non-English languages. Developers are encouraged to place appropriate mitigations, like limiting conversation turns to account for the possible conversational drift.

Developers should apply responsible AI best practices, including mapping, measuring, and mitigating risks associated with their specific use case and cultural, linguistic context. The Phi 4 family of models are general-purpose models. As developers plan to deploy these models for specific use cases, they are encouraged to fine-tune the models for their use case and leverage the models as part of broader AI systems with language-specific safeguards in place. Important areas for consideration include:

• Allocation: Models may not be suitable for scenarios that could have consequential impact on legal status or the allocation of resources or life opportunities (e.g., housing, employment, credit, etc.) without further assessments and additional debiasing techniques.
• High-Risk Scenarios: Developers should assess the suitability of using models in high-risk scenarios where unfair, unreliable, or offensive outputs might be extremely costly or lead to harm. This includes providing advice in sensitive or expert domains where accuracy and reliability are critical (e.g., legal or health advice). Additional safeguards should be implemented at the application level according to the deployment context.
• Misinformation: Models may produce inaccurate information. Developers should follow transparency best practices and inform end-users they are interacting with an AI system. At the application level, developers can build feedback mechanisms and pipelines to ground responses in use-case specific, contextual information, a technique known as Retrieval Augmented Generation (RAG).
• Generation of Harmful Content: Developers should assess outputs for their context and use available safety classifiers or custom solutions appropriate for their use case.
• Misuse: Other forms of misuse such as fraud, spam, or malware production may be possible, and developers should ensure that their applications do not violate applicable laws and regulations.

🔧 Training

Model

• Architecture: Phi-4-mini-instruct has 3.8B parameters and is a dense decoder-only Transformer model. Compared with Phi-3.5-mini, the major changes in Phi-4-mini-instruct are a 200K vocabulary, grouped-query attention, and shared input and output embedding.
• Inputs: Text. It is best suited for prompts using the chat format.
• Context length: 128K tokens
• GPUs: 512 A100-80G
• Training time: 21 days
• Training data: 5T tokens
• Outputs: Generated text

📄 License

This model is released under the MIT License.