Outils open source pour affiner vos modèles LLM

Un modèle pré-entraîné est ensuite entraîné ou « réglé » sur un ensemble de données plus petit et spécifique adapté à une tâche particulière.

Supposons que vous développiez un modèle qui génère des manuels techniques pour l'électronique à l'aide de GPT-3 (un grand modèle de langage contenant 175 milliards de paramètres), mais que la sortie générique de GPT-3 ne répond pas à la précision technique et à la tonalité requises.

Dans ce cas, vous pouvez envisager de réentraîner le modèle pour votre cas d'utilisation spécifique, mais entraîner directement un modèle tel que GPT-3 à partir de zéro pour répondre à cette tâche de niche n'est pas pratique en raison des ressources de calcul requises et des données spécialisées.

C'est là que le réglage fin entre en jeu.

La mise au point, c'est comme enseigner une nouvelle astuce à GPT-3. Elle en sait déjà beaucoup sur les langues grâce à sa formation sur de nombreux textes, qu'il s'agisse de livres ou de sites Web. Votre travail consiste à le former davantage sur un ensemble de données ciblé, en l'occurrence un corpus de manuels techniques existants et de documentation spécifiques à l'électronique.

Quelques méthodes de base pour affiner les réglages :

1. Gel des couches : gèle de manière sélective les poids de certaines couches tout en permettant à d'autres de les mettre à jour pendant le processus de réglage.
2. Ajustement du taux d'apprentissage : ajustement de la vitesse d'apprentissage du modèle pendant le processus de réglage, généralement pour éviter de remplacer les précieuses connaissances pré-apprises.
3. Ajout de couches spécifiques à la tâche : cela implique d'étendre l'architecture du modèle avec de nouvelles couches directement entraînées pour la tâche.

Réglage fin efficace des paramètres

Le réglage fin efficace des paramètres (PEFT) est une technique visant à minimiser le nombre de paramètres supplémentaires requis lors du réglage fin de modèles de réseaux neuronaux pré-entraînés,

Cela permet de réduire les dépenses de calcul et l'utilisation de la mémoire tout en maintenant ou même en améliorant les performances. PEFT y parvient en ajoutant des intégrations rapides en tant que paramètres supplémentaires du modèle et en ne réglant qu'un petit nombre de paramètres supplémentaires.

Le PEFT nécessite également un ensemble de données beaucoup plus petit que le réglage fin traditionnel.

Étapes pour effectuer le PEFT

1. Chargement du modèle choisi

Chargez le modèle que vous avez choisi à l'aide d'un framework d'apprentissage automatique tel que TensorFlow, PyTorch ou la bibliothèque Transformers de Hugging Face. Ces frameworks fournissent des API permettant de télécharger et de charger facilement des modèles pré-entraînés.

Voici un exemple de code :

 
from transformers import GPT2Model, GPT2Tokenizer

model_name = 'gpt2-medium'  # Choose the model variant
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2Model.from_pretrained(model_name)

2. Ingénierie rapide

Avant de peaufiner, vous devez essayer différentes instructions pour orienter les réponses du modèle. Testez différentes instructions à l'aide du modèle pré-entraîné pour voir comment elles affectent le résultat et choisissez celle qui convient le mieux. Vous pouvez également modifier différents paramètres tels que max_length, temperature, etc.

C'est comme trouver la meilleure façon de poser votre question pour que le modèle comprenne ce que vous voulez.

from transformers import pipeline
generator = pipeline('text-generation', model='gpt2')
prompt = """"""
# Generate responses
responses = generator(prompt, max_length=200, num_return_sequences=3)
for i, response in enumerate(responses):
	print(f"Response {i+1}: {response['generated_text']}")

3. Ensemble de données

Dans un jeu de données destiné à être peaufiné, il comporte généralement deux parties : Prompt (entrée) et Réponse (sortie). L'invite est comme une question ou un point de départ, et la réponse correspond à ce que vous voulez que le modèle génère en réponse à cette question. Il peut prendre la forme de colonnes ou d'une séquence d'entrées de texte (plus courant).

La meilleure invite identifiée à la dernière étape sera utilisée ici et la réponse sera exactement ce que nous voulons que le modèle produise une fois cette invite donnée.

4. Ajustement du modèle

C'est ici que vous apprenez au modèle à mieux accomplir votre tâche. Vous utiliserez l'ensemble de données pour ajuster légèrement les « connaissances » du modèle.

Voici un aperçu simplifié de la configuration et de l'exécution du processus de réglage avec PyTorch :

Configuration pour la formation :

 
from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)  # lr is the learning rate

Boucle d'entraînement :

 
for epoch in range(total_epochs):
    for batch in data_loader:
        inputs, labels = batch
        outputs = model(**inputs)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()  

Outils pour peaufiner

Lorsque vous explorez des outils permettant une ingénierie rapide, il est utile de les classer en deux domaines principaux : les plateformes de code et les plates-formes sans code. Cette distinction simplifie le processus de sélection
Les plates-formes de code font référence à des plates-formes qui fournissent des machines virtuelles qui peuvent être utilisées pour exécuter votre script Python personnalisé à des fins de réglage, comme celui mentionné précédemment. Par ailleurs, les plateformes No-Code font référence à des outils qui nécessitent un script Python simple ou aucun script Python pour s'exécuter. Il possède une interface utilisateur dédiée où vous pouvez commencer à vous entraîner en quelques clics.

Plateformes de code :

Les plateformes de code sont conçues pour les utilisateurs ayant une solide expérience en programmation. Ces plateformes fournissent des machines virtuelles qui permettent d'exécuter des scripts Python personnalisés pour des tâches telles que la mise au point. Ces plateformes sont parfaites pour les projets qui exigent une personnalisation élevée et un contrôle complexe des phases de formation et de déploiement.

1. Amazon Sagemaker :

Amazon SageMaker est un service entièrement géré qui permet aux développeurs et aux data scientists de créer, de former et de déployer rapidement des modèles d'apprentissage automatique.

Amazon SageMaker ne dispose pas d'une fonction de « réglage fin » intégrée dédiée, spécifiquement étiquetée comme telle pour les modèles linguistiques de grande taille. Il fournit plutôt une plate-forme puissante et flexible qui vous permet d'exécuter des scripts Python personnalisés pour effectuer des tâches de réglage.

Voici un exemple simple de la façon dont vous pourriez commencer à peaufiner un modèle linguistique avec Hugging Face sur SageMaker. Cela suppose que vous avez déjà créé un compte AWS et configuré l'AWS CLI. (vous pouvez utiliser TensorFlow ou PyTorch directement sur Amazon SageMaker pour affiner les tâches)

1. Configuration et initialisation de la session SageMaker :

 
import sagemaker
from sagemaker.huggingface import HuggingFace

# Initialize a sagemaker session
sagemaker_session = sagemaker.Session()

# Set up the role for SageMaker
role = sagemaker.get_execution_role()

2. Préparez le script de réglage fin :

Vous écrivez généralement un script de réglage fin (train.py) que vous transmettez à l'estimateur. Ce script doit inclure la logique de chargement, de réglage et de sauvegarde de votre modèle.

 
# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters)

3. Créez un estimateur Hugging Face :

 
# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters
)

4. Commencez le job de formation :

 
	# Assuming you have your training data in an S3 bucket
data = {'train': 's3://your-bucket/train-dataset/', 'test': 's3://your-bucket/test-dataset/'}

# Fit the model
huggingface_estimator.fit(data)

Caractéristiques principales :

1. Algorithmes prédéfinis et prise en charge des frameworks les plus courants : SageMaker prend en charge TensorFlow, PyTorch, Hugging Face, entre autres, ce qui facilite le réglage précis des LLM sur des ensembles de données personnalisés.
2. Formation ponctuelle gérée : elle réduit le coût des modèles de formation en utilisant les instances Spot Amazon EC2.
3. Formation distribuée : SageMaker permet de former des modèles plus rapidement et de manière plus rentable en répartissant la tâche de formation sur plusieurs GPU ou instances.

2. Collaboration avec Google :

Google Colab est un service de bloc-notes Jupyter populaire basé sur le cloud qui offre un accès gratuit aux ressources informatiques, y compris les GPU et les TPU, ce qui en fait une excellente plateforme pour affiner les grands modèles de langage (LLM)

Il est particulièrement adapté aux débutants. Les blocs-notes Colab fonctionnent dans le cloud, directement depuis votre navigateur, sans nécessiter de configuration locale.

Voici un extrait de code simple pour affiner un modèle de transformateur avec Hugging Face Transformers et PyTorch dans Google Colab

1. Configuration de l'environnement :

 
!pip install torch torchvision transformers

2. Chargement d'un modèle pré-entraîné et d'un tokenizer :

 
from transformers import BertTokenizer, BertForSequenceClassification
from transformers import AdamW

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

# Prepare the model for training
model.train()

3. Ajustement du modèle : (en supposant que vous ayez un ensemble de données chargé dans les variables input_ids, attention_masks et labels)

from torch.utils.data import DataLoader, RandomSampler, TensorDataset

# Create a data loader
dataset = TensorDataset(input_ids, attention_masks, labels)
dataloader = DataLoader(dataset, sampler=RandomSampler(dataset), batch_size=32)

optimizer = AdamW(model.parameters(), lr=2e-5)

# Example training loop
for epoch in range(4):  # loop over the dataset multiple times
    for step, batch in enumerate(dataloader):
        batch = [r.to('cuda') for r in batch]  # Move batch to GPU
        b_input_ids, b_input_mask, b_labels = batch

        # Forward + backward + optimize
        outputs = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)
        loss = outputs[0]
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

4. Sauvegarde du modèle :

model.save_pretrained("/content/drive/My Drive/Colab Models/my_finetuned_model")

Caractéristiques principales :

1. Accès gratuit aux GPU/TPU : Colab fournit un accès gratuit aux GPU NVIDIA et aux TPU Google, ce qui peut accélérer considérablement la formation et la mise au point des modèles d'apprentissage automatique.
2. Intégration à Google Drive : stockez et accédez facilement à vos ensembles de données et à vos modèles directement depuis Google Drive, ce qui facilite la gestion des données et la sauvegarde des modèles.
3. Bibliothèques préinstallées : Colab est livré avec la plupart des bibliothèques de science des données et d'apprentissage automatique préinstallées, notamment TensorFlow, PyTorch, Hugging Face Transformers et bien d'autres, ce qui permet de commencer facilement à peaufiner les modèles immédiatement.
4. Environnement interactif : l'interface du bloc-notes permet un développement et une documentation interactifs, combinant du code en direct, des visualisations et des annotations de texte.

3. Paperspace Gradient

Paperspace Gradient est une suite d'outils conçue pour simplifier le processus de développement, de formation et de déploiement de modèles d'apprentissage automatique dans le cloud.

Gradient est particulièrement efficace pour des tâches telles que la mise au point de grands modèles de langage (LLM) en raison de son infrastructure évolutive et de sa prise en charge des conteneurs, ce qui en fait un choix idéal pour les data scientists et les praticiens du ML.

Voici un exemple de réglage précis d'un modèle de transformateur avec PyTorch sur Paperspace Gradient.

1. Chargement d'un modèle pré-entraîné et d'un tokenizer :

 
from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

2. Préparation de l'ensemble de données :

from transformers import TextDatasetForNextSentencePrediction

dataset = TextDatasetForNextSentencePrediction(
    tokenizer=tokenizer,
    file_path="./my_dataset.txt",
    block_size=128
)

3. Ajustement du modèle :

from torch.utils.data import DataLoader
from transformers import AdamW

dataloader = DataLoader(dataset, shuffle=True, batch_size=8)
optimizer = AdamW(model.parameters(), lr=1e-5)

model.train()
for epoch in range(3):  # Loop over the dataset multiple times
    for batch in dataloader:
        optimizer.zero_grad()
        inputs, labels = batch['input_ids'], batch['labels']
        outputs = model(inputs, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

4. Sauvegarde du modèle :

model.save_pretrained("./my_finetuned_model")

Caractéristiques principales :

1. Environnements préconfigurés : Gradient propose des environnements préconfigurés pour TensorFlow, PyTorch, Hugging Face et d'autres frameworks d'apprentissage automatique, permettant une configuration rapide pour affiner les tâches.
2. GPU puissants : l'accès à un large éventail d'options de GPU vous permet d'adapter votre puissance de calcul aux besoins de votre projet, qu'il s'agisse d'options plus rentables pour les premières expériences ou de GPU haut de gamme pour des sessions de formation intensives.
3. Gradient Notebooks : environnement de codage interactif similaire à Jupyter Notebooks, mais avec l'avantage supplémentaire de fonctionner sur l'infrastructure cloud de Paperspace. C'est la solution idéale pour développer, peaufiner et expérimenter directement dans le cloud.
4. Tâches et flux de travail : automatisez vos processus d'apprentissage automatique en exécutant des tâches en séquence ou en parallèle, ce qui permet une formation et un déploiement efficaces des modèles.

4. Run.ai

Run.AI est une plate-forme conçue pour optimiser les ressources GPU pour les charges de travail d'apprentissage automatique, permettant ainsi aux data scientists et aux chercheurs en IA d'exécuter et de gérer plus facilement des modèles d'IA complexes, notamment en peaufinant les grands modèles de langage (LLM).

Il est basé sur Kubernetes, un outil qui organise efficacement les ressources informatiques. Ainsi, il facilite la gestion de projets d'IA complexes et permet aux équipes de développer leurs projets en douceur.

Vous pouvez consulter la documentation Run.AI pour obtenir des informations détaillées. Voici un exemple simplifié basé sur le flux de travail général pour affiner un modèle tel que LLama-2 sur la plate-forme Run.AI.

1. Préparer votre environnement

2. Configuration de votre projet et des requêtes GPU

runai submit my-fine-tuning-job -p my-project --gpu 2 --image my-llama2-fine-tuning-image train.py

3. Rédaction du script de réglage

Votre script train.py doit inclure la logique de chargement de LLama-2 (ou le modèle que vous avez choisi), de votre ensemble de données et d'exécution du processus de réglage. Cela peut impliquer l'utilisation de bibliothèques telles que Hugging Face Transformers pour le chargement du modèle et TensorFlow ou PyTorch pour la boucle d'entraînement.

from transformers import LlamaForConditionalGeneration, LlamaTokenizer

# Load model and tokenizer
model = LlamaForConditionalGeneration.from_pretrained('Llama-2-model-name')
tokenizer = LlamaTokenizer.from_pretrained('Llama-2-tokenizer-name')

# Load your dataset, prepare data loaders, define your training loop here #
model.train()


for epoch in range(num_epochs):
    for batch in dataloader:
        # Training loop logic
        pass

# Save your fine-tuned model
model.save_pretrained('./fine-tuned-model')

4. Suivi et gestion du poste de formation

Run.AI fournit des outils permettant de surveiller l'utilisation du GPU et la progression de vos tâches de formation, et de gérer efficacement les ressources informatiques. Utilisez le tableau de bord ou l'interface de ligne de commande Run.AI pour suivre l'état et les performances de votre tâche.

offres d'emploi de Runai List

Cette commande répertorie toutes les tâches en cours, ce qui vous permet de suivre la progression et l'utilisation des ressources de votre tâche de réglage.

Caractéristiques principales :

1. Optimisation du GPU et allocation élastique du GPU : optimise automatiquement l'utilisation du GPU, améliore l'efficacité et alloue dynamiquement les ressources GPU en fonction des demandes de charge de travail, réduisant ainsi considérablement les coûts.
2. Gestion simplifiée des ressources : offre un tableau de bord intuitif et une interface de ligne de commande pour gérer les charges de travail de l'IA, ce qui facilite le suivi et l'ajustement de l'utilisation des ressources en temps réel.
3. Intégration avec les frameworks populaires : prend en charge les frameworks d'apprentissage automatique populaires tels que TensorFlow, PyTorch et Hugging Face Transformers, facilitant ainsi une intégration fluide dans les flux de travail existants.

Plateformes sans code :

Les plateformes sans code, quant à elles, sont conçues pour des raisons de simplicité et de facilité d'utilisation. Ils éliminent le besoin d'écrire des scripts Python, offrant une interface utilisateur intuitive où la formation peut être initiée en quelques clics. Ce domaine convient aux utilisateurs sans connaissances en programmation ou à ceux qui préfèrent une approche simple pour une ingénierie rapide.

1. API Open AI

L'API OpenAI donne accès à des modèles avancés d'intelligence artificielle développés par OpenAI, notamment aux dernières versions de GPT (Generative Pre-trained Transformer). L'une des caractéristiques les plus remarquables de l'API OpenAI est sa capacité à affiner les modèles sur des ensembles de données personnalisés.

Vous pouvez ainsi adapter le comportement de modèles tels que GPT-3 ou des versions plus récentes à des applications spécifiques ou pour respecter des styles de contenu et des préférences particuliers.

Puisque je fais référence à l'API, elle n'est pas exactement « No-Code », mais on peut facilement la configurer pour la formation par rapport aux autres outils de la section précédente.

Exemple de code pour affiner les réglages :

1. Préparation de votre ensemble de données

Pour affiner un modèle, vous devez d'abord préparer votre jeu de données dans un format compréhensible par l'API OpenAI. En général, vous devez créer un fichier JSON qui ressemble à ceci :

{"prompt": "The capital of France is", "completion": " Paris"}
{"prompt": "The largest planet in the solar system is", "completion": " Jupiter"}

2. Téléchargement de votre ensemble de données sur OpenAI

Vous pouvez facilement télécharger le jeu de données à l'aide de l'Open AI CLI (interface de ligne de commande).

openai tools fine_tunes.prepare_data -f your_dataset.jsonl

3. Ajustement du modèle

Une fois que votre jeu de données est préparé et téléchargé, vous pouvez lancer un processus de réglage. Voici un exemple utilisant la bibliothèque Python d'OpenAI :

import openai

openai.api_key = "your-api-key"

response = openai.FineTune.create(
  training_file="file-YourFileIDHere",
  model="gpt-3.5-turbo",
  n_epochs=4,
  learning_rate_multiplier=0.1,
  batch_size=4
)

4. Utilisation de votre modèle affiné

Une fois le processus de réglage terminé, vous pouvez utiliser votre modèle affiné pour générer du texte ou d'autres tâches en spécifiant l'ID du modèle affiné :

response = openai.Completion.create(
  model="YOUR_FINE_TUNED_MODEL_ID",
  prompt="The capital of Italy is",
  max_tokens=50
)
print(response.choices[0].text.strip())

Vous pouvez également déployer votre modèle affiné.

Caractéristiques principales :

• Facilité d'utilisation : l'API simplifie les interactions avec de puissants modèles d'IA, éliminant ainsi les complexités liées à la gestion directe ou à l'entraînement de grands réseaux de neurones.
• Évolutivité : OpenAI gère l'infrastructure et la mise à l'échelle, fournissant des performances constantes quelle que soit la charge de travail.
• Mises à jour continues : OpenAI met fréquemment à jour son API et ses modèles, ce qui permet aux utilisateurs d'accéder aux dernières avancées en matière de recherche sur l'IA.

2. Microsoft Azure

Microsoft Azure est une plateforme de cloud computing proposant une large gamme de services, notamment informatiques, de stockage, d'analyse, etc. Il fournit aux utilisateurs les outils nécessaires pour créer, déployer et gérer efficacement des applications.

L'une des caractéristiques remarquables est son interface intuitive, qui permet aux débutants de naviguer facilement sans connaissances approfondies en matière de codage. Grâce à de simples clics plutôt qu'à un codage complexe, les utilisateurs peuvent affiner leurs applications, faisant d'Azure un outil accessible pour un développement sans stress.

Voici une procédure pas à pas simple expliquant comment configurer une « tâche » de réglage dans Azure :

1. Préparation de vos données :

Il s'agit évidemment de l'exigence de base pour tous les outils. Les données d'entraînement peuvent être au format JSON Lines (JSONL), CSV ou TSV. Les exigences relatives à vos données varient en fonction de la tâche spécifique pour laquelle vous souhaitez affiner votre modèle.

Pour la classification du texte :
Deux colonnes : Phrase (chaîne) et Libellé (entier/chaîne)

2. Choisissez un modèle de fondation

3. Configurez une tâche de réglage :

Une fois que vous avez soumis la tâche de réglage, une tâche de pipeline sera créée pour entraîner votre modèle. Vous pouvez passer en revue toutes les entrées et collecter le modèle à partir des résultats des tâches.

4. Évaluez votre modèle affiné

Pour déterminer si votre modèle affiné fonctionne comme prévu, vous pouvez consulter les mesures d'entraînement et d'évaluation.

Caractéristiques principales :

• Interface conviviale : l'interface facile à utiliser d'Azure simplifie la navigation pour les débutants.
• Options sans code : le réglage précis ne nécessite pas de codage approfondi ; les utilisateurs peuvent effectuer des tâches en quelques clics.
• Évolutivité : les applications peuvent être facilement étendues ou réduites pour répondre à l'évolution des demandes.
• Services complets : Azure propose une gamme d'outils d'optimisation, notamment des fonctionnalités d'analyse et de surveillance.
• Intégration : s'intègre parfaitement à Microsoft et à des outils tiers pour une flexibilité des flux de travail.

3. Répliquer

Replicate est un outil polyvalent conçu pour affiner divers aspects des applications logicielles. Les applications de Replicate en tant qu'outil de réglage fin incluent l'optimisation des performances, l'ajustement des configurations et l'amélioration des fonctionnalités avec un minimum d'effort. Il simplifie le processus en gérant la configuration du GPU. Semblable à l'API Open AI, il n'est pas exactement « No-Code » comme les autres outils de la liste, mais on peut facilement le configurer pour la formation par rapport aux autres outils de la section précédente.

Étapes pour affiner le réglage de llama-2b :

1. Préparez vos données d'entraînement

Vos données d'entraînement doivent être au format JSONL. Vous trouverez ci-dessous un exemple de la manière dont vous pourriez structurer ce fichier :

{"prompt": "What's the weather like?", "completion": "The weather is sunny."}
{"prompt": "Tell me a joke.", "completion": "Why don't scientists trust atoms? Because they make up everything!"}

2. Authentifiez-vous avec Replicate

Vous devez définir votre jeton d'API Replicate en tant que variable d'environnement dans votre terminal :

export REPLICATE_API_TOKEN=

3. Téléchargez vos données d'entraînement

Vous pouvez télécharger vos données dans un compartiment S3 ou directement sur Replicate à l'aide des commandes curl :

RESPONSE=$(curl -s -X POST -H "Authorization: Bearer $REPLICATE_API_TOKEN" https://dreambooth-api-experimental.replicate.com/v1/upload/data.jsonl)

curl -X PUT -H "Content-Type: application/jsonl" --upload-file data.jsonl "$(jq -r ".upload_url" <<< "$RESPONSE")"

SERVING_URL=$(jq -r ".serving_url" <<< $RESPONSE)
echo $SERVING_URL

4. Création d'un modèle sur Replicate

Vous devez créer un modèle vide sur Replicate pour votre modèle entraîné. Une fois votre entraînement terminé, il sera intégré en tant que nouvelle version à ce modèle.

5. Créer un poste de formation

Vous devez créer un job de formation sur votre IDE, comme indiqué ci-dessous :

import replicate

training = replicate.trainings.create(
  version="meta/llama-2-7b:version-id", # Replace "version-id" with the actual version ID of the model you chose
  input={
    "train_data": "https://yourdata.com/data.jsonl", # Use your actual data URL here
    "num_train_epochs": 3
  },
  destination="your-username/your-model-name" # Use your actual username and model name here
)

print(training)

6. Surveiller les progrès de la formation

Pour suivre la progression par programmation, vous pouvez utiliser :

training.reload()
print(training.status)

7. Exécutez votre modèle affiné

Une fois la formation terminée, vous pouvez exécuter votre modèle avec l'API :

output = replicate.predictions.create(
  version=training.output["version"], # Use the version output from your training
  input={"prompt": "Your prompt here"}
)
print(output)

Caractéristiques principales :

• Facilité d'utilisation : simplifie le processus de réglage grâce à une interface conviviale et à une API simple, le rendant accessible aux débutants comme aux praticiens expérimentés.
• Formation basée sur le cloud : Supprime le besoin de ressources GPU locales en proposant une formation basée sur le cloud, permettant aux utilisateurs d'entraîner des modèles quel que soit leur matériel.
• Saisie de données flexible : prend en charge le format JSONL pour les données d'entraînement, ce qui permet une saisie flexible et structurée pour une variété de tâches.
• Hébergement de modèles : héberge automatiquement des modèles affinés, ce qui facilite l'intégration et le déploiement de modèles d'IA dans les applications.
• Contrôle des versions : permet de suivre les différentes versions d'entraînement, ce qui facilite la gestion, la comparaison et le retour aux versions précédentes d'un modèle.

4. Google Gen AI Studio

Chez Gen AI Studio, vous avez les deux options pour configurer des tâches de réglage, via l'API ou le site Web. Ici, je ne parlerai que de la méthode API. Il possède le processus le plus rationalisé par rapport aux outils décrits ci-dessus.

Voici un guide étape par étape :

1. Préparez votre ensemble de données

Votre ensemble de données doit être au format JSONL, chaque ligne étant un objet JSON avec les clés « input_text » et « output_text ». Il peut commencer la formation avec seulement 10 exemples, mais au moins 100 exemples sont recommandés.

2. Téléchargez votre ensemble de données

Vous devez télécharger votre ensemble de données dans le bucket Google Cloud Storage (GCS). Si vous n'en avez pas, vous pouvez en créer un dans Google Drive.

3. Authentification et initialisation

Vous devez maintenant fournir vos informations d'identification pour établir la connexion :

from google.auth import default
from google.cloud import aiplatform
from vertexai import init

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
project_id = "your-project-id"
location = "your-project-location" # e.g., "us-central1"
init(project=project_id, location=location, credentials=credentials)

4. Préparer la fonction de réglage

Vous devez définir une fonction de réglage avec les paramètres nécessaires.

from vertexai.language_models import TextGenerationModel
from vertexai.preview.language_models import TuningEvaluationSpec

def tuning(project_id, location, model_display_name, training_data, train_steps=10, evaluation_dataset=None, tensorboard_instance_name=None):
    eval_spec = TuningEvaluationSpec(evaluation_data=evaluation_dataset)
    if tensorboard_instance_name:
        eval_spec.tensorboard = aiplatform.Tensorboard(tensorboard_name=tensorboard_instance_name)
    model = TextGenerationModel.from_pretrained("text-bison@002")

    model.tune_model(
        training_data=training_data,
        model_display_name=model_display_name,
        train_steps=train_steps,
        tuning_job_location="europe-west4",
        tuned_model_location=location,
        tuning_evaluation_spec=eval_spec,
    )
    print(model._job.status)
    return model

5. Exécuter le réglage du modèle

Appelez la fonction de réglage spécifiée précédemment, avec vos paramètres spécifiques. Le paramètre training_data peut être un URI GCS ou un Pandas DataFrame.

model_display_name = "your-model-name"
training_data = "gs://your-bucket/your-dataset.jsonl" # or your DataFrame
train_steps = 300 # Number of training steps

# Call the tuning function
tuned_model = tuning(project_id, location, model_display_name, training_data, train_steps)

Caractéristiques principales :

1. Fourniture à la fois d'un accès à l'API et d'une interface utilisateur : pour ceux qui préfèrent une approche graphique, Gen AI Studio propose une interface utilisateur intuitive.
2. Infrastructure évolutive : tirez parti de l'infrastructure évolutive de Google Cloud pour gérer efficacement de grands ensembles de données et des tâches de réglage gourmandes en calcul.
3. Intégration avec Google Cloud Services : intégration fluide avec d'autres services Google Cloud, tels que Cloud Storage pour la gestion des ensembles de données et Vertex AI pour le déploiement de modèles.
4. Large gamme de modèles pré-entraînés : accédez à une variété de modèles pré-entraînés adaptés à différentes tâches et à différentes langues, offrant un point de départ solide pour les affiner.
5. Collaboration et contrôle de version : fonctionnalités permettant de collaborer avec les membres de l'équipe, de partager des projets de mise au point et de maintenir le contrôle des versions sur des modèles affinés.

5. Prédibase

Predibase est une plateforme spécialisée conçue pour faciliter l'ajustement de grands modèles de langage (LLM), tels que GPT-4, pour des tâches ou des applications spécifiques. Il donne accès aux fonctionnalités avancées des LLM en fournissant un environnement simplifié et convivial permettant de personnaliser ces modèles en fonction des besoins individuels.

Predibase vous offre la possibilité d'utiliser à la fois le SDK Python et l'interface utilisateur pour effectuer des tâches de réglage.

Voici un guide étape par étape pour affiner mistral-7b-instruct :

1. Configuration de base

Tout d'abord, créez un compte sur Predibase et effectuez un dépôt pour ajouter des crédits. Générez ensuite votre clé API.

2. Création d'un référentiel de modèles

Accédez à Modèles, puis cliquez sur « Nouveau référentiel de modèles » comme indiqué ci-dessous :

Maintenant, nommez votre dépôt et ajoutez une description.

3. Démarrez le réglage fin :

Remplissez les zones surlignées, puis appuyez sur Train. Cela mettra votre demande en file d'attente jusqu'à ce qu'un calcul soit disponible.

6. True Foundry

TrueFoundry est un outil qui aide les équipes de machine learning à mettre en place et à faire fonctionner leurs modèles sans problème. Il est basé sur Kubernetes, ce qui signifie qu'il peut fonctionner sur différents clouds ou même sur vos propres serveurs. C'est important pour les entreprises soucieuses de protéger leurs données et de contrôler les coûts.

Pour le réglage fin, c'est l'un des meilleurs outils du marché, destiné à la fois aux débutants et aux experts. Deux options s'offrent à vous : déployer un bloc-notes de mise au point à des fins d'expérimentation ou lancer une tâche de réglage dédiée.

1. Carnets : terrain de jeu d'expérimentation

Les ordinateurs portables offrent une configuration idéale pour les réglages exploratifs et itératifs. Vous pouvez expérimenter sur un petit sous-ensemble de données, en essayant différents hyperparamètres afin de déterminer la configuration idéale pour les meilleures performances.

2. Emplois : fiables et évolutifs

Une fois que vous avez identifié les hyperparamètres et la configuration optimaux grâce à des expériences, le passage à une tâche de déploiement vous permet d'affiner l'ensemble de données et facilite une formation rapide et fiable.

Par conséquent, les ordinateurs portables sont vivement recommandés pour les premières étapes de l'exploration et les tâches de réglage et de déploiement des hyperparamètres constituent le choix préféré pour le réglage fin du LLM à grande échelle, en particulier lorsque la configuration optimale a été établie à la suite d'expériences préalables.

Voici un guide étape par étape pour affiner les réglages en utilisant à la fois Notebook et Jobs :

1. Configuration des données d'entraînement

Truefoundry prend en charge deux formats de données différents :

1. Chat : les données doivent être au format JSONL, chaque ligne contenant une conversation complète au format OpenAI Chat

Chaque ligne contient une clé appelée messages. Chaque clé de message contient une liste de messages, chaque message étant un dictionnaire avec des clés de rôle et de contenu. La clé de rôle peut être utilisateur, assistant ou système et la clé de contenu contient le contenu du message.

2. Complétion : les données doivent être au format JSONL et chaque ligne doit contenir une chaîne codée JSON contenant deux touches d'invite et de complétion.

{"prompt": "What is 2 + 2?", "completion": "The answer to 2 + 2 is 4"}
{"prompt": "Flip a coin", "completion": "I flipped a coin and the result is heads!"}
{"prompt": "", "completion": ""}

2. Réglage fin

Vous pouvez commencer à peaufiner le réglage en trois clics seulement :

1. Sélectionnez l'espace de travail dans lequel vous souhaitez travailler
2. Choisissez le modèle :

Vous pouvez choisir le modèle dans la liste complète présente ou simplement coller l'URL huggingface pour commencer à peaufiner.

3. Cliquez sur Suivant

Maintenant, après avoir sélectionné le GPU souhaité, vous avez deux options : Exécuter en tant que bloc-notes ou Job.

3. Réglage précis à l'aide d'un ordinateur portable

Après avoir choisi « Lancer en tant que bloc-notes » et sélectionné les valeurs par défaut pour les hyperparamètres, vous pouvez voir votre bloc-notes :

4. Le peaufinage en tant que tâche :

Avant de commencer, vous devez d'abord créer un référentiel ML (il sera utilisé pour stocker vos indicateurs et artefacts d'entraînement, tels que vos points de contrôle et vos modèles) et donner à votre espace de travail l'accès au référentiel ML. Vous pouvez en savoir plus sur ML Repo dans la documentation de Truefoundry.

Vous devez maintenant choisir « Lancer en tant que tâche » et sélectionner les valeurs par défaut des hyperparamètres pour lancer le réglage fin.

Dans les déploiements, vous pouvez voir la liste des tâches et cliquer sur Exécuter la tâche.

Caractéristiques principales :

• Prise en charge des LLM populaires : permet d'affiner les LLM open source largement utilisés tels que Llama 2, Mistral, Zephyr et Mixtral.
• Flexibilité dans l'approche de réglage : offre la possibilité d'affiner les LLM à l'aide de Jobs pour l'évolutivité et la fiabilité ou de Notebooks pour l'expérimentation et le réglage itératif.
• Technique QLoRa : utilise la technique de réglage fin QLoRa, qui équilibre efficacité et performances, permettant d'affiner le matériel moins puissant sans compromettre la qualité.
• Prise en charge du format de données : prend en charge les données au format jsonl, prenant en charge à la fois les ensembles de données de type chat et complétion, facilitant ainsi une gamme d'applications LLM.
• Intégration facile des données : offre des options pour télécharger les données de formation sous forme d'artefact TrueFoundry, vers des services de stockage cloud ou localement, offrant ainsi une flexibilité dans la gestion des données.
• Assistance au déploiement : après la mise au point, des guides sur le déploiement du modèle affiné pour une application pratique sont disponibles, améliorant ainsi l'utilité du modèle.
• Intégration du référentiel ML : permet de suivre les progrès d'ajustement et de gérer les métriques/artefacts de formation via les référentiels ML, garantissant ainsi un développement de modèles organisé et accessible.

Choisir l'outil qui vous convient :

Facilité d'utilisation : Choisissez des outils simples, surtout si vous n'êtes pas passionné par le codage. Certains outils ne nécessitent même pas que vous écriviez du code !

Évolutivité : Assurez-vous que l'outil peut évoluer avec votre projet, en gérant de manière fluide des ensembles de données plus volumineux et des modèles plus complexes.

Support des modèles et des ensembles de données : Choisissez des outils qui fonctionnent bien avec les types spécifiques de données et de modèles que vous utilisez.

Ressources informatiques : Recherchez l'accès à des GPU ou à des TPU si votre projet nécessite une puissance de calcul importante.

Coût : Réfléchissez au montant que vous êtes prêt à dépenser. Certains outils sont gratuits ; d'autres sont payants en fonction des ressources que vous utilisez.

Personnalisation et contrôle : Si vous connaissez le code, vous préférerez peut-être des outils qui vous permettent de tout modifier.

Intégration : C'est plus facile si l'outil s'intègre parfaitement à votre flux de travail et à vos outils existants.

Communauté et soutien : Une communauté solidaire et une bonne documentation peuvent vous éviter bien des maux de tête.