Phi-4

Exécutez le petit modèle de langage Phi-4 de Microsoft sur les GPU Clore.ai

Exécutez Phi-4 de Microsoft - un petit modèle de langage mais puissant.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces Web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<adresse-proxy>

Qu'est-ce que Phi-4 ?

Phi-4 de Microsoft offre :

• 14 milliards de paramètres avec d'excellentes performances

• Batte des modèles plus grands aux benchmarks

• Fort en raisonnement et en mathématiques

• Inférence efficace

Variantes de modèle

Modèle	Paramètres	VRAM	Spécialité
Phi-4	14B	16Go	Général
Phi-3.5-mini	3,8 milliards	4 Go	Léger
Phi-3.5-MoE	42 milliards (6,6 milliards actifs)	16Go	Mélange d'experts
Phi-3.5-vision	4,2 milliards	6 Go	Vision

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

Ports :

22/tcp
8000/http

Commande :

pip install transformers accelerate torch && \
python phi4_server.py

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à la Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Utilisation d'Ollama

# Exécuter Phi-4
ollama run phi4

# Phi-3.5 mini (plus rapide)
ollama run phi3.5

# Phi-3.5 vision
ollama run phi3.5-vision

Installation

pip install transformers accelerate torch

Utilisation de base

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "microsoft/Phi-4"

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

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."}
]

inputs = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt",
    add_generation_prompt=True
).to("cuda")

outputs = model.generate(
    inputs,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
print(response)

Phi-3.5-Vision

Pour la compréhension d'images :

from transformers import AutoModelForCausalLM, AutoProcessor
from PIL import Image
import torch

model_id = "microsoft/Phi-3.5-vision-instruct"

processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

image = Image.open("diagram.png")

messages = [
    {"role": "user", "content": "<|image_1|>\nDescribe this diagram in detail."}
]

prompt = processor.tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)

inputs = processor(prompt, [image], return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    temperature=0.7
)

response = processor.decode(outputs[0], skip_special_tokens=True)
print(response)

Mathématiques et raisonnement

messages = [
    {"role": "user", "content": """
Résoudre étape par étape :
Un fermier a des poules et des lapins.
Nombre total de têtes : 35
Nombre total de pattes : 94
Combien de chaque animal ?
"""}
]

# Phi-4 excelle dans le raisonnement étape par étape

Génération de code

messages = [
    {"role": "user", "content": """
Écrivez une implémentation Python d'un arbre binaire de recherche avec :
- Insertion
- Recherche
- Suppression
- Parcours en ordre
Inclure des annotations de type et des docstrings.
"""}
]

Inférence quantifiée

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-4",
    quantization_config=quantization_config,
    device_map="auto",
    trust_remote_code=True
)

Interface Gradio

import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "microsoft/Phi-4"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True
)

def chat(message, history, system_prompt, temperature):
    messages = [{"role": "system", "content": system_prompt}]
    for h in history:
        messages.append({"role": "user", "content": h[0]})
        messages.append({"role": "assistant", "content": h[1]})
    messages.append({"role": "user", "content": message})

    inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
    outputs = model.generate(inputs, max_new_tokens=512, temperature=temperature, do_sample=True)

    return tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)

demo = gr.ChatInterface(
    fn=chat,
    additional_inputs=[
        gr.Textbox(value="You are a helpful assistant.", label="System"),
        gr.Slider(0.1, 1.5, value=0.7, label="Temperature")
    ],
    title="Phi-4 Chat"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Performances

Modèle	GPU	Tokens/sec
Phi-3.5-mini	RTX 3060	~100
Phi-3.5-mini	RTX 4090	~150
Phi-4	RTX 4090	~60
Phi-4	A100	~90
Phi-4 (4 bits)	RTX 3090	~40

Benchmarks

Modèle	MMLU	HumanEval	GSM8K
Phi-4	84.8%	82.6%	94.6%
GPT-4-Turbo	86.4%	85.4%	94.2%
Llama-3.1-70B	83.6%	80.5%	92.1%

Phi-4 égalise ou bat des modèles beaucoup plus grands

Dépannage

"trust_remote_code" erreur

• Ajoutez trust_remote_code=True à from_pretrained()

• Ceci est requis pour les modèles Phi

Sorties répétitives

• Température plus basse (0,3-0,6)

• Ajouter repetition_penalty=1.1

• Utiliser un modèle de chat approprié

Problèmes de mémoire

• Phi-4 est efficace mais nécessite encore ~8 Go pour 14B

• Utiliser la quantification 4 bits si nécessaire

• Réduire la longueur du contexte

Format de sortie incorrect

• Utilisez apply_chat_template() pour un formatage correct

• Vérifiez que vous utilisez la version instruct, pas la base

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)

• Payer avec CLORE jetons

• Comparer les prix entre différents fournisseurs

Cas d'utilisation

• Tutorat en mathématiques

• Assistance au code

• Analyse de documents (vision)

• Déploiement efficace en périphérie

• Inférence rentable

Prochaines étapes

• Qwen2.5 - Modèle alternatif

• Gemma 2 - modèle de Google

• Llama 3.2 - modèle de Meta