Modèles de langue de formation sur Google Colab

Modèles de grande langue (LLMS) à réglage fin comme Bert, Llama, Bart, et ceux de Mistral AI et d'autres peuvent être intensifs en calcul. Manquant d'un GPU local, Google Colab fournit une alternative gratuite, mais sa nature transitoire présente des défis dans la préservation de vos progrès. Ce guide montre comment tirer parti de Google Drive pour surmonter cette limitation, vous permettant d'économiser et de reprendre votre formation LLM sur plusieurs sessions Colab.

La solution consiste à utiliser Google Drive pour stocker les résultats intermédiaires et les points de contrôle du modèle. Cela garantit que votre travail persiste même après la réinitialisation de l'environnement Colab. Vous aurez besoin d'un compte Google avec un espace de conduite suffisant. Créez deux dossiers dans votre lecteur: "Données" (pour votre ensemble de données de formation) et "Points de contrôle" (pour stocker les points de contrôle du modèle).

Montage Google Drive dans Colab:

Commencez par monter votre Google Drive dans votre cahier Colab en utilisant cette commande:

<code class="language-python">from google.colab import drive
drive.mount('/content/drive')</code>

Vérifiez l'accès en répertoriant le contenu de vos répertoires de données et points de contrôle:

<code class="language-bash">!ls /content/drive/MyDrive/data
!ls /content/drive/MyDrive/checkpoints</code>

Si l'autorisation est requise, une fenêtre contextuelle apparaîtra. Assurez-vous d'accorder les autorisations d'accès nécessaires. Si les commandes échouent, réduisez la cellule de montage et vérifiez vos autorisations.

Enregistrer et charger des points de contrôle:

Le noyau de la solution réside dans la création de fonctions pour enregistrer et charger les points de contrôle du modèle. Ces fonctions sérialiseront l'état de votre modèle, l'optimiseur, le planificateur et d'autres informations pertinentes dans votre dossier "Points de contrôle".

Enregistrer la fonction de point de contrôle:

<code class="language-python">import torch
import os

def save_checkpoint(epoch, model, optimizer, scheduler, loss, model_name, overwrite=True):
    checkpoint = {
        'epoch': epoch,
        'model_state_dict': model.state_dict(),
        'optimizer_state_dict': optimizer.state_dict(),
        'scheduler_state_dict': scheduler.state_dict(),
        'loss': loss
    }
    direc = get_checkpoint_dir(model_name) #Assumed function to construct directory path
    if overwrite:
        file_path = os.path.join(direc, 'checkpoint.pth')
    else:
        file_path = os.path.join(direc, f'epoch_{epoch}_checkpoint.pth')
    os.makedirs(direc, exist_ok=True) # Create directory if it doesn't exist
    torch.save(checkpoint, file_path)
    print(f"Checkpoint saved at epoch {epoch}")

#Example get_checkpoint_dir function (adapt to your needs)
def get_checkpoint_dir(model_name):
    return os.path.join("/content/drive/MyDrive/checkpoints", model_name)
</code>

Fonction de point de contrôle de charge:

<code class="language-python">import torch
import os

def load_checkpoint(model_name, model, optimizer, scheduler):
    direc = get_checkpoint_dir(model_name)
    if os.path.exists(direc):
        #Find checkpoint with highest epoch (adapt to your naming convention)
        checkpoints = [f for f in os.listdir(direc) if f.endswith('.pth')]
        if checkpoints:
            latest_checkpoint = max(checkpoints, key=lambda x: int(x.split('_')[-2]) if '_' in x else 0)
            file_path = os.path.join(direc, latest_checkpoint)
            checkpoint = torch.load(file_path, map_location=torch.device('cpu'))
            model.load_state_dict(checkpoint['model_state_dict'])
            optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
            scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
            epoch = checkpoint['epoch']
            loss = checkpoint['loss']
            print(f"Checkpoint loaded from epoch {epoch}")
            return epoch, loss
        else:
            print("No checkpoints found in directory.")
            return 0, None
    else:
        print(f"No checkpoint directory found for {model_name}, starting from epoch 1.")
        return 0, None
</code>

intégrer dans votre boucle de formation:

Intégrez ces fonctions dans votre boucle de formation. La boucle doit vérifier les points de contrôle existants avant de commencer la formation. Si un point de contrôle est trouvé, il reprend la formation de l'époque enregistrée.

<code class="language-python">EPOCHS = 10
for exp in experiments: # Assuming 'experiments' is a list of your experiment configurations
    model, optimizer, scheduler = initialise_model_components(exp) # Your model initialization function
    train_loader, val_loader = generate_data_loaders(exp) # Your data loader function
    start_epoch, prev_loss = load_checkpoint(exp, model, optimizer, scheduler)
    for epoch in range(start_epoch, EPOCHS):
        print(f'Epoch {epoch + 1}/{EPOCHS}')
        # YOUR TRAINING CODE HERE... (training loop)
        save_checkpoint(epoch + 1, model, optimizer, scheduler, train_loss, exp) #Save after each epoch</code>

Cette structure permet une reprise transparente de la formation même si la session Colab se termine. N'oubliez pas d'adapter la fonction get_checkpoint_dir et les conventions de dénomination des fichiers de point de contrôle pour répondre à vos besoins spécifiques. Cet exemple amélioré gère les erreurs potentielles plus gracieusement et fournit une solution plus robuste. N'oubliez pas de remplacer les fonctions d'accueil (initialise_model_components, generate_data_loaders) par vos implémentations réelles.

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!