Affiner la technique LoRA avec le LLM Granite

Low-Rank Adaptation (LoRA) est une méthode efficace d’affinage qui réduit le nombre de paramètres pouvant être entraînés, ce qui augmente la vitesse et l’utilisation des ressources d’entraînement tout en conservant la même qualité de production. Au lieu de mettre à jour tous les paramètres d’un réseau de neurones pendant l’affinage, la LoRA gèle les poids préentraînés initiaux et ajoute de petites matrices de faible rang pouvant être entraînées qui représentent une approximation des modifications nécessaires pour la nouvelle tâche. Cette approche repose sur l’hypothèse que les mises à jour de pondération pendant l’adaptation ont un « rang intrinsèque » faible.

Un avantage supplémentaire de la LoRA est que, étant donné que les poids préentraînés sont conservés figés, l’adaptateur généré est léger, portable et facilement stockable.

Dans ce tutoriel, vous utiliserez LLaMA-Factory. LLaMA-Factory est un grand modèle de langage (LLM) d’entraînement et d’optimisation de la plateforme low code et no-code qui permet aux utilisateurs de régler les LLM sur des jeux de données personnalisés, d’évaluer la performance et de fournir des modèles. Il possède à la fois une interface utilisateur Web et une interface de ligne de commande faciles à utiliser et prend en charge plus de 100 LLM. La plateforme prend en charge les jeux de données aux formats Alpaca et ShareGPT. LLaMA-Factory n’est pas le seul moyen d’affiner les LLM : la bibliothèque PEFT pour l’optimisation des paramètres permet également de mettre à jour des grands modèles. Le PEFT permet de réaliser une LoRA quantifiée (QLoRA) pour compacter davantage le modèle finement réglé. Dans ce tutoriel, vous utiliserez une version non quantifiée de Granite 3.3.

Bien que LLaMA-Factory puisse fonctionner sans utiliser de nombreuses ressources de calcul, il nécessite un GPU et des ressources de mémoire importantes. Dans ce tutoriel, vous utiliserez LLaMA-Factory sur watsonx pour fournir des ressources GPU et du stockage pour les adaptateurs générés.

e. Sélectionnez « Cloud Object Storage »

f. Dans la boîte de dialogue suivante, sélectionnez l’instance que vous avez créée aux étapes a–d par nom.

g. Sélectionnez « Créer ».

Créer un Jupyter Notebook

Créez un Jupyter Notebook.

a. Sélectionnez l’onglet Actifs dans votre environnement de projet.

b. Cliquez sur Nouvel actif.

c. Sélectionnez l’option Fonctionne avec les modèles dans le panneau de gauche.

d. Cliquez sur Fonctionne avec les données et les modèles à l’aide de blocs-notes Python et R.

e. Saisissez un nom pour votre notebook dans le champ Nom. Choisissez l’option Exécution 23.1 sur Python (4 vCPU 16 Go de RAM) pour définir la configuration.

f. Sélectionnez Créer.

Ensuite, vous allez installer des dépendances sur le moteur d'exécution. D’abord, llama-factory pour générer les adaptateurs de bas rang, puis Pandas pour formater le jeu de données au format Alpaga.

!pip install -q llamafactory 2>/dev/null
# pandas needed to format the dataset
!pip install -q --upgrade pandas 2>/dev/null

Vérifiez l’environnement du GPU

Ensuite, vous vous assurerez que votre environnement Watsonx a fourni un GPU compatible Torch qui sera nécessaire pour utiliser LLaMa-Factory.

import torch

try:
  assert torch.cuda.is_available() is True
except AssertionError:
  print("No GPU found, please set up a GPU before using LLaMA Factory.")

Si le code précédent n’affiche pas « Aucun GPU trouvé », alors vous êtes prêt.

Ensuite, vous allez importer des bibliothèques pour manipuler les données et créer le fichier de configuration LLama Factory utilisé pour la formation.

# Import libraries
import pandas as pd
import json
import yaml

Téléchargez et traitez le jeu de données MedReason

Dans ce tutoriel, vous utiliserez une partie du MedReason jeu de données. MedReason est un jeu de données de raisonnement médical à grande échelle et de haute qualité, conçu pour permettre la résolution de problèmes médicaux explicables dans les LLM. Alors que MedReason se concentre sur le raisonnement d'un modèle et la validation des chaînes de pensée qu'un modèle utilise, dans ce cas, il est également utile de fournir un jeu de données qui est trop récent pour être inclus dans les données d'entraînement pour IBM® Granite® 3.3.

Granite 3.3 a été conçu pour apprendre en peaufinant. Les deux seront exécutés avec LLama Factory. Les modèles Granite peuvent être efficacement affinés même avec des ressources informatiques limitées.

Vous allez charger une sélection du jeu de données MedReason depuis GitHub :

from datasets import load_dataset

training = pd.read_json("https://raw.githubusercontent.com/UCSC-VLAA/MedReason/refs/heads/main/eval_data/medbullets_op4.jsonl", lines=True)

LLama Factory exige que le jeu de données soit préformaté aux formats Alpaca ou ShareGPT. Ainsi, nous reformatons les champs de questions et réponses du jeu de données juridique original pour contenir les champs d’instruction, d’entrée et de sortie selon le format Alpaga.

Alpaga est un format JSON pour représenter une instruction, une entrée utilisateur et une sortie système comme ceci :

{
    "instruction": "user instruction (required)",
    "input": "user input (optional)",
    "output": "model response (required)",
    "system": "system prompt (optional)",
}

Comme MedReason n’est pas formaté en Alpaga, vous créerez un jeu de données Alpaga dans la cellule suivante :

!mkdir -p data

# Format Med Dataset to Alpaca Format
formatted_data = [
    {
        "instruction": row["question"] + str(row["options"]),
        "input": "",
        "output": row["answer"]
    }
    for _, row in training.iterrows()
]

# output formatted MedReason dataset
with open("data/med.json", "w", encoding="utf-8") as f:
  json.dump(formatted_data, f, indent=2, ensure_ascii=False)

Llama Factory utilise un fichier spécifique pour comprendre comment charger des jeux de données pour la formation. Ce fichier doit exister dans le chemin « data/dataset_info.json ». Nous devons donc créer un fichier dataset_info.json. fichier qui inclut le chemin d'accès au nouveau jeu de données médicales formatées que nous avons créé pour la CLI de Llama afin d'accéder au jeu de données. Pour plus de détails sur le fichier dataset_info.json afficher la documentation. Le dépôt Llama Factory contient des jeux de données disponibles. Cependant, comme nous utilisons notre propre jeu de données personnalisé, nous devons l'ajouter au fichier JSON.

# "med" will be the identifier for the dataset 
# which points to the local file that contains the dataset
dataset_info = {
  "med": {
    "file_name": "med.json",
  }
}

# Create dataset_info.json with legal dataset so can reference with llama factory
with open("data/dataset_info.json", "w", encoding="utf-8") as f:
  json.dump(dataset_info, f, indent=2, ensure_ascii=False)

Une fois l'objet JSON au format Alpaca enregistré dans l'environnement, vous pouvez commencer l'entraînement.

L’étape suivante consiste à définir les configurations d’entraînement, puis à les écrire dans un fichier YAML que LLaMA-Factory utilise pour exécuter l’entraînement.

Vous allez maintenant procéder au réglage fin supervisé (SFT) sur le sous-ensemble du jeu de données MedReason. LLaMA-Factory prend en charge différents types d’entraînement. Parmi les plus couramment utilisés, on trouve :

• Préentraînement : un modèle subit un entraînement initial en utilisant un vaste jeu de données pour générer des réponses au langage et aux idées fondamentaux.

• Réglage fin supervisé (SFT) : un modèle reçoit un entraînement supplémentaire avec des données annotées pour améliorer la précision d’une fonction ou d’un sujet donnés.

• Modélisation de la récompense : lorsque le modèle acquiert des connaissances sur la manière d’obtenir une incitation ou une récompense spécifique qui informera l’optimisation stratégique probable (PPO) de sa sortie.

• Entraînement : une technique d’apprentissage par renforcement (RL) où le modèle est affiné grâce à des techniques de gradient de politique pour renforcer son efficacité dans un contexte spécifique.

De nombreux paramètres sont utilisés dans la configuration LoRA, mais voici quelques-uns des plus importants et des plus couramment utilisés :

• Taux d’apprentissage (LR) : Le taux d’apprentissage détermine le niveau de mise à jour de chaque paramètre du modèle au cours de chaque itération d’entraînement. Un LR plus élevé peut accélérer la convergence en permettant des mises à jour plus volumineuses, avec le risque de dépasser la solution optimale ou de fluctuer autour d’elle. Un LR inférieur conduit à une convergence plus lente mais plus stable, réduisant ainsi le risque d’instabilité au niveau de la solution optimale.

• loraplus_lr_ratio : cette étape définit le ratio des taux d’apprentissage. En général, il devrait être > 1, mais le choix optimal de loraplus_lr_ratio dépend du modèle et de la tâche. En règle générale, le loraplus_lr_ratio doit être plus grand lorsque la tâche est plus difficile et que le modèle doit mettre à jour ses fonctionnalités pour bien apprendre. Dans ce cas, il permet de réduire légèrement le taux d’apprentissage (par exemple, d’un facteur 2) par rapport aux taux d’apprentissage LoRA classiques.

• Taille de lot effective : configurer correctement la taille de votre lot est indispensable pour équilibrer la stabilité de l’entraînement avec les limites VRAM du GPU que vous utilisez. La taille effective du lot est définie par le produit per_device_train_batch_size * gradient_accumulation_steps. Une taille de lot effective plus importante conduit généralement à un entraînement plus fluide et plus stable, mais peut également nécessiter plus de VRAM que contient votre GPU. Une taille de lot effective plus petite peut introduire plus de variance.

Voici le code configurant la formation :

# setup training configurations
args = dict(
  stage="sft",  # do supervised fine-tuning
  do_train=True,  # we're actually training
  model_name_or_path="ibm-granite/granite-3.3-2b-instruct",  # use IBM Granite 3.3 2b instruct model
  dataset="med",  # use medical datasets we created
  template="granite3",   # use granite3 prompt template
  finetuning_type="lora", # use LoRA adapters to save memory
  lora_target="all",  # attach LoRA adapters to all linear layers
  loraplus_lr_ratio=16.0,  # use LoRA+ algorithm with lambda=16.0
  output_dir="granite3_lora",  # the path to save LoRA adapters
  per_device_train_batch_size=4,  # the batch size
  gradient_accumulation_steps=2,  # the gradient accumulation steps
  learning_rate=1e-4,  # the learning rate
  num_train_epochs=3.0, # the epochs of training
  max_samples=500,  # use 500 examples in each dataset
  fp16=True,  # use float16 mixed precision training
  report_to="none", # disable wandb logging
)

# create training config file to run with llama factory
with open("train_granite3_lora_med.yaml", "w", encoding="utf-8") as file:
  yaml.dump(args, file, indent=2)

La cellule suivante entraînera le modèle et son exécution peut prendre jusqu'à 10 minutes :

!llamafactory-cli train train_granite3_lora_med.yaml;

Ensuite, vous allez créer deux méthodes pour charger et télécharger des données depuis IBM Cloud Object Storage :

from ibm_botocore.client import Config
import ibm_boto3

def upload_file_cos(credentials, local_file_name, key):  
    cos = ibm_boto3.client(service_name='s3',
    ibm_api_key_id=credentials['IBM_API_KEY_ID'],
    ibm_service_instance_id=credentials['IAM_SERVICE_ID'],
    ibm_auth_endpoint=credentials['IBM_AUTH_ENDPOINT'],
    config=Config(signature_version='oauth'),
    endpoint_url=credentials['ENDPOINT'])
    try:
        res=cos.upload_file(Filename=local_file_name, Bucket=credentials['BUCKET'],Key=key)
    except Exception as e:
        print(Exception, e)
    else:
        print(' File Uploaded')


def download_file_cos(credentials,local_file_name,key):  
    cos = ibm_boto3.client(service_name='s3',
    ibm_api_key_id=credentials['IBM_API_KEY_ID'],
    ibm_service_instance_id=credentials['IAM_SERVICE_ID'],
    ibm_auth_endpoint=credentials['IBM_AUTH_ENDPOINT'],
    config=Config(signature_version='oauth'),
    endpoint_url=credentials['ENDPOINT'])
    try:
        res=cos.download_file(Bucket=credentials['BUCKET'],Key=key,Filename=local_file_name)
    except Exception as e:
        print(Exception, e)
    else:
        print('File Downloaded')

La cellule suivante contient les identifiants de Cloud Object Storage.

Dans votre carnet de notes, cliquez sur l'onglet Extraits de code dans le coin droit. Cette étape ouvre un menu avec plusieurs options pour les extraits de code générés. Sélectionnez « Lire les données » :

Cette étape ouvre un menu permettant de sélectionner un fichier de données. Si vous n’avez rien importé sur votre instance Cloud Object Storage, vous devrez en importer un pour générer des identifiants. Il peut s’agir d’un jeu de données classique comme wine.csv.

Après avoir cliqué sur « Sélectionner », vous pouvez désormais générer l’extrait d’identifiants sous l’option « Charger sous ». Choisissez « Insérer le code dans la cellule » :

Cette étape génère une cellule comme la suivante avec des identifiants contenant les bons ID et les points de terminaison générés :

# @hidden_cell
# The following code contains metadata for a file in your project storage.
# You might want to remove secret properties before you share your notebook.

storage_metadata = {
    'IAM_SERVICE_ID': '',
    'IBM_API_KEY_ID': '',
    'ENDPOINT': '',
    'IBM_AUTH_ENDPOINT': '',
    'BUCKET': '',
    'FILE': ''
}

Maintenant, le dossier zip contenant l'adaptateur et les informations sur l'adaptateur lui-même :

!zip -r "granite3_lora.zip" "granite3_lora"

Vérifiez que vous avez créé le dossier zip correctement :

!ls

Il est maintenant temps de faire des inférences. L'inférence sera étayée par la génération HuggingFace, qui fournit un model.generate () pour générer des textes en utilisant PyTorch.

Ce tutoriel montre comment poser au modèle de base une question médicale extraite du jeu de données MedReason. Il est raisonnable que le modèle de base ne soit pas en mesure de répondre à cette question, car il s'agit d'un modèle à usage général formé sur de grands jeux de données diversifiés.

D’abord, configurez les configurations d’inférence :

# setup inference configurations
args = dict(
  model_name_or_path="ibm-granite/granite-3.3-2b-instruct",  # use IBM Granite 3.3 2b instruct model
  template="granite3",  # set to the same one used in training, template for constructing prompts
  infer_backend="huggingface"  # choices： [huggingface, vllm]
)

# create inference config file to run with llama factory
with open("inference_config.yaml", "w", encoding="utf-8") as file:
  yaml.dump(args, file, indent=2)

Vous allez maintenant poser au chatbot l’une des questions du jeu de données MedReason :

from llamafactory.chat import ChatModel
chat_model = ChatModel(args)
messages = []

# run inference chatbot
question = '''
A 1-year-old girl is brought to a neurologist due to increasing seizure frequency over the past 2 months. 
She recently underwent a neurology evaluation which revealed hypsarrhythmia on electroencephalography (EEG) with a mix of slow waves, multifocal spikes, and asynchrony. 
Her parents have noticed the patient occasionally stiffens and spreads her arms at home. She was born at 38-weeks gestational age without complications. 
She has no other medical problems. Her medications consist of lamotrigine and valproic acid. Her temperature is 98.3\u00b0F (36.8\u00b0C), blood pressure is 90/75 mmHg, pulse is 94/min, and respirations are 22/min. 
Physical exam reveals innumerable hypopigmented macules on the skin and an irregularly shaped, thickened, and elevated plaque on the lower back. 
Which of the following is most strongly associated with this patient's condition?"
"A": "Cardiac rhabdomyoma", "B": "Glaucoma", "C": "Optic glioma", "D": "Polyostotic fibrous dysplasia"
'''

Créez un nouveau message à partir de la question et passez-le au modèle de base :

messages.append({"role": "user", "content": question})

response = ""
for new_text in chat_model.stream_chat(messages):
    response += new_text

print(response)
messages.append({"role": "assistant", "content": response})

Voici la sortie d’exemple du modèle de base Granite 3.3 :

Utilisateur :

A 1-year-old girl is brought to a neurologist due to increasing seizure frequency over the past 2 months. 
She recently underwent a neurology evaluation which revealed hypsarrhythmia on electroencephalography (EEG) with a mix of slow waves, multifocal spikes, and asynchrony. 
Her parents have noticed the patient occasionally stiffens and spreads her arms at home. She was born at 38-weeks gestational age without complications. 
She has no other medical problems. Her medications consist of lamotrigine and valproic acid. Her temperature is 98.3\F (36.8\C), blood pressure is 90/75 mmHg, pulse is 94/min, and respirations are 22/min. 
Physical exam reveals innumerable hypopigmented macules on the skin and an irregularly shaped, thickened, and elevated plaque on the lower back. 
Which of the following is most strongly associated with this patient's condition?"
"A": "Cardiac rhabdomyoma", "B": "Glaucoma", "C": "Optic glioma", "D": "Polyostotic fibrous dysplasia"

Réponse :

The most strongly associated condition with this patient's condition is "C": "Optic glioma".

The patient's symptoms of hypsarrhythmia on EEG, seizure frequency increase, and the presence of hypopigmented macules and a thickened plaque on the lower back are indicative of a neurological disorder. Optic glioma is a type of brain tumor that can present with these symptoms, including seizures and visual disturbances.

Option A, "Cardiac rhabdomyoma", typically presents with cardiac involvement and is not associated with the described EEG findings or skin manifestations.

Option B, "Glaucoma", is an eye disease that can lead to vision loss but is not associated with the EEG findings or skin lesions described.

Option D, "Polyostotic fibrous dysplasia", is a bone disorder characterized by multiple bone lesions and is not associated with the neurological symptoms and EEG findings presented.

Therefore, based on the clinical presentation, the most likely diagnosis is an optic glioma.

La réponse correcte du jeu de données est :

answer: Cardiac rhabdomyoma

Donc le modèle de base ne génère pas la bonne réponse.

Inférer avec l’adaptateur LoRA finement réglé Nous comparons les résultats en les comparant au modèle de base et à l’adaptateur LoRA réglé. Nous posons ensuite la même question pour voir comment l'adaptation au jeu de données a permis au modèle de mieux comprendre les questions médicales et d'y répondre.

La cellule suivante ne sera pas nécessaire si vous avez effectué LoRA lors de la même séance. Toutefois, si vous revenez à Jupyter Notebook et que vous ne souhaitez pas effectuer une nouvelle formation, vous pouvez télécharger les adaptateurs optimisés depuis votre instance COS.

download_file_cos(credentials, "granite3_lora.zip", "granite3_lora.zip")
!unzip granite3_lora.zip

Maintenant vous configurerez les options pour le ChatModel afin qu’il intègre les adaptateurs.

# setup inference configurations
args = dict(
  model_name_or_path="ibm-granite/granite-3.3-2b-instruct",  # use IBM Granite 3.3 2b instruct model
  adapter_name_or_path="granite3_lora", # load the saved LoRA adapters
  template="granite3", # set to the same one used in training, template for constructing prompts
  finetuning_type="lora", # which fine-tuning technique used in training
  infer_backend="huggingface" # choices： [huggingface, vllm]
)

# create inference config file to run with llama factory
with open("inference_config.yaml", "w", encoding="utf-8") as file:
  yaml.dump(args, file, indent=2)


from llamafactory.chat import ChatModel
chat_model = ChatModel(args)

Maintenant nous pouvons tester le même défi de raisonnement pour le modèle affiné :

messages = []

# run inference chatbot
question = '''
A 1-year-old girl is brought to a neurologist due to increasing seizure frequency over the past 2 months. 
She recently underwent a neurology evaluation which revealed hypsarrhythmia on electroencephalography (EEG) with a mix of slow waves, multifocal spikes, and asynchrony. 
Her parents have noticed the patient occasionally stiffens and spreads her arms at home. She was born at 38-weeks gestational age without complications. 
She has no other medical problems. Her medications consist of lamotrigine and valproic acid. Her temperature is 98.3\u00b0F (36.8\u00b0C), blood pressure is 90/75 mmHg, pulse is 94/min, and respirations are 22/min. 
Physical exam reveals innumerable hypopigmented macules on the skin and an irregularly shaped, thickened, and elevated plaque on the lower back. 
Which of the following is most strongly associated with this patient's condition?"
"A": "Cardiac rhabdomyoma", "B": "Glaucoma", "C": "Optic glioma", "D": "Polyostotic fibrous dysplasia"
'''

Créez un nouveau message en utilisant la question et transmettez-le au modèle affiné :

messages.append({"role": "user", "content": question})

response = ""
for new_text in chat_model.stream_chat(messages):
    response += new_text

print(response)
messages.append({"role": "assistant", "content": response})
Cardiac rhabdomyoma

Exemple de sortie d'un modèle affiné :

Utilisateur :

A 1-year-old girl is brought to a neurologist due to increasing seizure frequency over the past 2 months. 
She recently underwent a neurology evaluation which revealed hypsarrhythmia on electroencephalography (EEG) with a mix of slow waves, multifocal spikes, and asynchrony. 
Her parents have noticed the patient occasionally stiffens and spreads her arms at home. She was born at 38-weeks gestational age without complications. 
She has no other medical problems. Her medications consist of lamotrigine and valproic acid. Her temperature is 98.3\u00b0F (36.8\u00b0C), blood pressure is 90/75 mmHg, pulse is 94/min, and respirations are 22/min. 
Physical exam reveals innumerable hypopigmented macules on the skin and an irregularly shaped, thickened, and elevated plaque on the lower back. 
Which of the following is most strongly associated with this patient's condition?"
"A": "Cardiac rhabdomyoma", "B": "Glaucoma", "C": "Optic glioma", "D": "Polyostotic fibrous dysplasia"

Réponse :

Cardiac rhabdomyoma

Cette fois, le modèle a généré la bonne réponse, grâce à l'adaptateur entraîné.

Un aspect à noter, le modèle ne répond plus avec son raisonnement. Ce résultat est dû au fait que le jeu de données utilisé pour LoRa ne contient que la bonne réponse en tant que production attendue du modèle. Le réglage fin de la LoRA peut être utilisé à la fois pour fournir de nouvelles informations et pour indiquer au modèle comment réagir.

Dans ce tutoriel, vous avez affiné le modèle IBM Granite-3.3-2b-Instruct suivant la méthode LoRA, lui ajoutant de nouvelles connaissances médicales et un modèle détaillé sur la façon de répondre. Vous avez constaté la capacité de Granite 3.3 à apprendre même avec un petit modèle et des échantillons limités du jeu de données.