Trainingssprachmodelle auf Google Colab

Feinabstimmungsmodelle (LLMs) wie Bert, Lama, Bart und solche von Mistral AI und anderen können rechenintensiv sein. Google Colab fehlt eine lokale GPU und bietet eine kostenlose Alternative, aber ihre vorübergehende Natur stellt Herausforderungen bei der Erhaltung Ihrer Fortschritte dar. Dieser Leitfaden zeigt, wie Google Drive diese Einschränkung überwinden kann, sodass Sie Ihr LLM -Training in mehreren Colab -Sitzungen speichern und fortsetzen können.

Die Lösung umfasst die Verwendung von Google Drive, um Zwischenergebnisse und Modellkontrollpunkte zu speichern. Dies stellt sicher, dass Ihre Arbeit auch nach dem Zurücksetzen der Colab -Umgebung bestehen bleibt. Sie benötigen ein Google -Konto mit ausreichend Antriebsspeicher. Erstellen Sie zwei Ordner in Ihrem Laufwerk: "Daten" (für Ihren Trainingsdatensatz) und "Checkpoints" (zum Speichern von Modell -Checkpoints).

Google Drive in Colab:

Montage

Beginnen Sie mit diesem Befehl mit Ihrem Google -Laufwerk in Ihrem Colab -Notebook:

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

Zugriff überprüfen, indem Sie den Inhalt Ihrer Daten- und Checkpoints -Verzeichnisse auflisten:

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

Wenn die Autorisierung erforderlich ist, wird ein Popup-Fenster angezeigt. Stellen Sie sicher, dass Sie die erforderlichen Zugangsberechtigungen gewähren. Wenn die Befehle fehlschlagen, führen Sie die Befestigungszelle erneut aus und überprüfen Sie Ihre Berechtigungen.

Speichern und Laden von Kontrollpunkten:

Der Kern der Lösung liegt beim Erstellen von Funktionen zum Speichern und Laden von Modellkontrollpunkten. Diese Funktionen werden den Status, den Optimierer, den Scheduler und die anderen relevanten Informationen Ihres Modells in Ihrem "Checkpoints" -Fordner serialisieren.

Checkpoint -Funktion speichern:

<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>

Funktionsweise der Checkpoint -Funktion:

<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>

Integrieren in Ihre Trainingsschleife:

Integrieren Sie diese Funktionen in Ihre Trainingsschleife. Die Schleife sollte vor dem Training nach vorhandenen Kontrollpunkten überprüfen. Wenn ein Kontrollpunkt gefunden wird, wird das Training aus der gespeicherten Epoche fortgesetzt.

<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>

Diese Struktur ermöglicht eine nahtlose Wiederaufnahme des Trainings auch dann, wenn die Colab -Sitzung endet. Denken Sie daran, die Funktions- und Checkpoint -Datei -Benennungskonventionen an Ihre spezifischen Anforderungen anzupassen. Dieses verbesserte Beispiel behandelt potenzielle Fehler anmutiger und bietet eine robustere Lösung. Denken Sie daran, Platzhalterfunktionen (get_checkpoint_dir, initialise_model_components) durch Ihre tatsächlichen Implementierungen zu ersetzen. generate_data_loaders

Das obige ist der detaillierte Inhalt vonTrainingssprachmodelle auf Google Colab. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!