Affineur profondément en profondeur R1 (modèle de raisonnement)

Les modèles de l'IA révolutionnaire de Deepseek défient la domination d'Openai. Ces modèles de raisonnement avancé sont disponibles gratuitement, démocratisant l'accès à une IA puissante. Apprenez à affiner Deepseek avec notre tutoriel vidéo:

Ce tutoriel affiche le modèle Deepseek-R1-Distill-Llama-8B utilisant l'ensemble de données médicales de la chaîne médicale de la pensée médicale. Ce modèle distillé, dérivé de LLAMA 3.1 8b, offre des capacités de raisonnement comparables à la profondeur d'origine de Deepseek-R1. Nouveau sur les LLM et les réglages fins? Considérez notre introduction aux LLMS dans Python Course.

Image par auteur

Présentation des modèles R1 Deepseek

Deepseek AI a des ouverts Deepseek-R1 et Deepseek-R1-Zero, rivalisant avec O1 d'Openai dans les tâches de raisonnement (mathématiques, codage, logique). Explorez notre guide complet de profondeur R1 pour plus de détails.

Deepseek-R1-Zero

Ce modèle pionnier utilise l'apprentissage par renforcement à grande échelle (RL), en contournant le réglage final (SFT) initial. Tout en permettant le raisonnement indépendant de la chaîne de pensées (COT), il présente des défis comme le raisonnement répétitif et les problèmes de lisibilité.

deepseek-r1

Adommageant les limites de Deepseek-R1-Zero, Deepseek-R1 intègre des données de démarrage à froid avant RL. Cette formation en plusieurs étapes atteint des performances de pointe, correspondant à OpenAI-O1 tout en améliorant la clarté de sortie.

Distillation profonde

Deepseek propose également des modèles distillés, équilibrant la puissance et l'efficacité. Ces modèles plus petits (paramètres de 1,5b à 70b) conservent un raisonnement solide, avec Deepseek-R1-Distill-QWEN-32B dépassant OpenAI-O1-MINI dans les références. Cela met en évidence l'efficacité du processus de distillation.

Source: Deepseek-ai / Deepseek-R1

En savoir plus sur les fonctionnalités de Deepseek-R1, le développement, les modèles distillés, l'accès, les prix et la comparaison Openai O1 dans notre article de blog: "Deepseek-R1: fonctionnalités, comparaison O1, modèles distillés et plus".

Fonction de profondeur R1: un guide pratique

Suivez ces étapes pour affiner votre modèle R1 Deepseek:

1. Configuration

Nous utilisons l'accès GPU gratuit de Kaggle. Créez un ordinateur portable Kaggle, en ajoutant vos tokens pour visage et poids et biais en tant que secrets. Installez le package unsloth Python pour un réglage fin plus rapide et plus économe en mémoire. Voir notre "Guide non inscrit: Optimiser et accélérer LLM Fine-tuning" pour plus de détails.

<code>%%capture
!pip install unsloth
!pip install --force-reinstall --no-cache-dir --no-deps git+https://github.com/unslothai/unsloth.git</code>

Authentifiez avec le visage étreint CLI et poids et biais (WANDB):

<code>from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(hf_token)

import wandb

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune-DeepSeek-R1-Distill-Llama-8B on Medical COT Dataset', 
    job_type="training", 
    anonymous="allow"
)</code>

2. Chargement du modèle et du tokenizer

Chargez la version non lot de Deepseek-R1-Distill-Llama-8b en utilisant la quantification 4 bits pour des performances optimisées:

<code>from unsloth import FastLanguageModel

max_seq_length = 2048 
dtype = None 
load_in_4bit = True


model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/DeepSeek-R1-Distill-Llama-8B",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
    token = hf_token, 
)</code>

3. Inférence de pré-fin

Définissez un style rapide avec les espaces réservés pour la question et la réponse. Cela guide le raisonnement étape par étape du modèle:

<code>prompt_style = """Below is an instruction that describes a task, paired with an input that provides further context. 
Write a response that appropriately completes the request. 
Before answering, think carefully about the question and create a step-by-step chain of thoughts to ensure a logical and accurate response.

### Instruction:
You are a medical expert with advanced knowledge in clinical reasoning, diagnostics, and treatment planning. 
Please answer the following medical question. 

### Question:
{}

### Response:
<think>{}"""</think></code>

Testez le modèle avec un exemple de question médicale:

<code>question = "A 61-year-old woman with a long history of involuntary urine loss during activities like coughing or sneezing but no leakage at night undergoes a gynecological exam and Q-tip test. Based on these findings, what would cystometry most likely reveal about her residual volume and detrusor contractions?"


FastLanguageModel.for_inference(model) 
inputs = tokenizer([prompt_style.format(question, "")], return_tensors="pt").to("cuda")

outputs = model.generate(
    input_ids=inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_new_tokens=1200,
    use_cache=True,
)
response = tokenizer.batch_decode(outputs)
print(response[0].split("### Response:")[1])</code>

Observez le raisonnement pré-fin du modèle et identifiez les zones d'amélioration par le réglage fin.

4. Chargement et traitement de l'ensemble de données

Modifiez le style rapide pour inclure un espace réservé pour la chaîne de pensée complexe:

<code>train_prompt_style = """Below is an instruction that describes a task, paired with an input that provides further context. 
Write a response that appropriately completes the request. 
Before answering, think carefully about the question and create a step-by-step chain of thoughts to ensure a logical and accurate response.

### Instruction:
You are a medical expert with advanced knowledge in clinical reasoning, diagnostics, and treatment planning. 
Please answer the following medical question. 

### Question:
{}

### Response:
<think>
{}
</think>
{}"""</code>

Créez une fonction pour formater l'ensemble de données:

<code>EOS_TOKEN = tokenizer.eos_token  # Must add EOS_TOKEN


def formatting_prompts_func(examples):
    inputs = examples["Question"]
    cots = examples["Complex_CoT"]
    outputs = examples["Response"]
    texts = []
    for input, cot, output in zip(inputs, cots, outputs):
        text = train_prompt_style.format(input, cot, output) + EOS_TOKEN
        texts.append(text)
    return {
        "text": texts,
    }</code>

Chargez et traitez l'ensemble de données:

<code>from datasets import load_dataset
dataset = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT","en", split = "train[0:500]",trust_remote_code=True)
dataset = dataset.map(formatting_prompts_func, batched = True,)
dataset["text"][0]</code>

5. Configuration du modèle

Configurez le modèle à l'aide de Lora:

<code>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",  # True or "unsloth" for very long context
    random_state=3407,
    use_rslora=False,  
    loftq_config=None,
)</code>

Configurer l'entraîneur:

<code>from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    dataset_num_proc=2,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        # Use num_train_epochs = 1, warmup_ratio for full training runs!
        warmup_steps=5,
        max_steps=60,
        learning_rate=2e-4,
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=10,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_,
    ),
)</code>

6. Formation du modèle

former le modèle:

<code>trainer_stats = trainer.train()</code>

(Remarque: La réponse originale comprenait des images de progression de la formation; celles-ci sont omises ici car la reproduction d'image n'est pas possible.)

7. Inférence post-fin

Comparez les résultats en interrogeant le modèle affiné avec la même question qu'auparavant. Observer l'amélioration de la concision du raisonnement et de la réponse.

(Remarque: la réponse originale a inclus la sortie du modèle améliorée; ceci est omis ici pour brièveté.)

8. Économiser et pousser le modèle

Enregistrez le modèle localement et poussez-le vers le centre de visage étreint:

<code>new_model_local = "DeepSeek-R1-Medical-COT"
model.save_pretrained(new_model_local) 
tokenizer.save_pretrained(new_model_local)

model.save_pretrained_merged(new_model_local, tokenizer, save_method = "merged_16bit",)

new_model_online = "kingabzpro/DeepSeek-R1-Medical-COT"
model.push_to_hub(new_model_online)
tokenizer.push_to_hub(new_model_online)

model.push_to_hub_merged(new_model_online, tokenizer, save_method = "merged_16bit")</code>

(Remarque: La réponse originale comprenait des images montrant une épreuve et une poussées de modèle réussies; celles-ci sont omises ici.)

9. Déploiement et conclusion

Le tutoriel se termine en suggérant des options de déploiement en utilisant le format Bentoml ou local au format GGUF. Il met l'accent sur l'importance croissante des LLMS open-source et met en évidence les contre-mouvements d'Openai avec O3 et Operator AI. Les liens vers ces ressources sont conservés.

La réponse réécrite maintient les informations de base tout en simplifiant la structure et en supprimant les répétitions inutiles. Les blocs de code sont conservés pour l'exhaustivité. Les images sont référencées mais non reproduites.

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!