Comment affiner PHI-4 localement?

Ce guide montre un réglage fin du modèle de grande langue (LLM) Microsoft PHI-4 pour les tâches spécialisées en utilisant des adaptateurs d'adaptation de faible rang (LORA) et un visage étreint. En vous concentrant sur des domaines spécifiques, vous pouvez optimiser les performances de PHI-4 pour des applications telles que le support client ou les conseils médicaux. L'efficacité de Lora rend ce processus plus rapide et moins à forte intensité de ressources.

Résultats d'apprentissage clés:

• Finez-le Microsoft PHI-4 en utilisant les adaptateurs LORA pour les applications ciblées.
• Configurer et charger PHI-4 efficacement avec la quantification 4 bits.
• Préparer et transformer des ensembles de données pour le réglage fin avec le visage étreint et la bibliothèque unsloth.
• Optimiser les performances du modèle à l'aide de Hugging Face's SFTTrainer.
• Surveiller l'utilisation du GPU et enregistrer / télécharger des modèles affinés sur le visage étreint pour le déploiement.

Prérequis:

Avant de commencer, assurez-vous que vous avez:

• python 3.8
• pytorch (avec support CUDA pour l'accélération du GPU)
• unsloth bibliothèque
• étreindre le visage transformers et datasets bibliothèques

Installez les bibliothèques nécessaires en utilisant:

pip install unsloth
pip install --force-reinstall --no-cache-dir --no-deps git+https://github.com/unslothai/unsloth.git

Fonction de PHI-4: une approche étape par étape

Cette section détaille le processus de réglage fin, de la configuration au déploiement sur la face étreinte.

Étape 1: Configuration du modèle

Cela consiste à charger le modèle et à importer des bibliothèques essentielles:

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
load_in_4bit = True

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Phi-4",
    max_seq_length=max_seq_length,
    load_in_4bit=load_in_4bit,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

Étape 2: Préparation de l'ensemble de données

Nous utiliserons l'ensemble de données Finetome-100K au format ShareGPT. unsloth aide à convertir cela au format de Face étreint:

from datasets import load_dataset
from unsloth.chat_templates import standardize_sharegpt, get_chat_template

dataset = load_dataset("mlabonne/FineTome-100k", split="train")
dataset = standardize_sharegpt(dataset)
tokenizer = get_chat_template(tokenizer, chat_template="phi-4")

def formatting_prompts_func(examples):
    texts = [
        tokenizer.apply_chat_template(convo, tokenize=False, add_generation_prompt=False)
        for convo in examples["conversations"]
    ]
    return {"text": texts}

dataset = dataset.map(formatting_prompts_func, batched=True)

Étape 3: Modèle de réglage fin

affiner en utilisant les câlins de la face SFTTrainer:

from trl import SFTTrainer
from transformers import TrainingArguments, DataCollatorForSeq2Seq
from unsloth import is_bfloat16_supported
from unsloth.chat_templates import train_on_responses_only

trainer = SFTTrainer(
    # ... (Trainer configuration as in the original response) ...
)

trainer = train_on_responses_only(
    trainer,
    instruction_part="user",
    response_part="assistant",
)

Étape 4: surveillance de l'utilisation du GPU

Surveiller l'utilisation de la mémoire GPU:

import torch
# ... (GPU monitoring code as in the original response) ...

Étape 5: Inférence

générer des réponses:

pip install unsloth
pip install --force-reinstall --no-cache-dir --no-deps git+https://github.com/unslothai/unsloth.git

Étape 6: Enregistrement et téléchargement

Enregistrez localement ou poussez le visage étreint:

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
load_in_4bit = True

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Phi-4",
    max_seq_length=max_seq_length,
    load_in_4bit=load_in_4bit,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

N'oubliez pas de remplacer <your_hf_token></your_hf_token> par votre jeton de visage étreint.

Conclusion:

Ce guide rationalisé autorise les développeurs à affiner efficacement PHI-4 pour des besoins spécifiques, en tirant parti de la puissance de LORA et en étreignant la face pour des performances optimisées et un déploiement facile. N'oubliez pas de consulter la réponse originale pour les extraits de code complets et les explications détaillées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!