# Phi-4

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://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 :**

```bash
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

```bash

# 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

```bash
pip install transformers accelerate torch
```

## Utilisation de base

```python
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 :

```python
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

```python
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

```python
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

```python
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

```python
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*](https://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