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 mais puissant modèle de langage.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À 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@<proxy-address>

Qu'est-ce que Phi-4 ?

Phi-4 de Microsoft offre :

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

• Surpasse des modèles plus grands sur les benchmarks

• Raisonnement et mathématiques solides

• Inférence efficace

Variantes de modèle

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

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-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. Accédez à Mes commandes la page

2. Cliquez sur votre commande

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

Utilisez https://YOUR_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": "Expliquez la différence entre TCP et 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|>\nDécrivez ce diagramme en détail."}
]

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ésolvez étape par étape :
Un fermier a des poulets et des lapins.
Nombre total de têtes : 35
Nombre total de pattes : 94
Combien y a-t-il 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 infixe
Incluez 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="Vous êtes un assistant utile.", label="Système"),
        gr.Slider(0.1, 1.5, value=0.7, label="Température")
    ],
    title="Chat Phi-4"
)

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

Performances

Modèle	GPU	Jetons/s
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-bit)	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 égale ou dépasse des modèles bien plus grands

Dépannage

erreur "trust_remote_code"

• Ajoutez trust_remote_code=True à from_pretrained()

• C'est requis pour les modèles Phi

Sorties répétitives

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

• Ajoutez repetition_penalty=1.1

• Utilisez le bon modèle de chat

Problèmes de mémoire

• Phi-4 est efficace, mais nécessite tout de même environ 8 Go pour 14B

• Utilisez une quantification 4 bits si nécessaire

• Réduisez 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 version de base

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Cas d’usage

• Tutorat en mathématiques

• Assistance au code

• Analyse de documents (vision)

• Déploiement efficace en périphérie

• Inférence économique

Étapes suivantes

• Qwen2.5 - Modèle alternatif

• Gemma 2 - Modèle de Google

• Llama 3.2 - Modèle de Meta