Model Bahasa Latihan di Google Colab

Model Bahasa Besar Fine-Tuning (LLMS) seperti Bert, Llama, BART, dan mereka dari Mistral AI dan lain-lain boleh dikira secara intensif. Kurangnya GPU tempatan, Google Colab menyediakan alternatif percuma, tetapi sifat sementaranya memberikan cabaran dalam memelihara kemajuan anda. Panduan ini menunjukkan cara memanfaatkan Google Drive untuk mengatasi batasan ini, membolehkan anda menyimpan dan menyambung semula latihan LLM anda di beberapa sesi Colab.

Penyelesaian ini melibatkan menggunakan Google Drive untuk menyimpan hasil pertengahan dan pemeriksaan model. Ini memastikan kerja anda berterusan walaupun selepas persekitaran Colab diset semula. Anda memerlukan akaun Google dengan ruang pemacu yang mencukupi. Buat dua folder dalam pemacu anda: "Data" (untuk dataset latihan anda) dan "pemeriksaan" (untuk menyimpan titik pemeriksaan model).

Pemasangan Google Drive di Colab:

Mulailah dengan memasang pemacu google anda dalam buku nota colab anda menggunakan arahan ini:

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

Sahkan akses dengan menyenaraikan kandungan direktori data dan pemeriksaan anda:

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

Jika kebenaran diperlukan, tetingkap pop timbul akan muncul. Pastikan anda memberikan kebenaran akses yang diperlukan. Sekiranya arahan gagal, lari semula sel pemasangan dan periksa keizinan anda.

menjimatkan dan memuatkan titik pemeriksaan:

teras penyelesaiannya terletak pada mewujudkan fungsi untuk menyimpan dan memuatkan titik pemeriksaan model. Fungsi -fungsi ini akan menyatukan keadaan model, pengoptimal, penjadual, dan maklumat lain yang berkaitan dengan folder "pemeriksaan" anda.

Simpan fungsi pemeriksaan:

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

Fungsi Pemeriksaan Beban:

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

Mengintegrasikan ke dalam gelung latihan anda:

Mengintegrasikan fungsi -fungsi ini ke dalam gelung latihan anda. Gelung harus memeriksa pusat pemeriksaan yang ada sebelum memulakan latihan. Sekiranya pusat pemeriksaan dijumpai, ia menyambung semula latihan dari zaman yang disimpan.

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

Struktur ini membolehkan latihan semula latihan yang lancar walaupun sesi COLAB berakhir. Ingatlah untuk menyesuaikan konvensyen penamaan fail

dan pemeriksaan fail untuk memenuhi keperluan khusus anda. Contoh yang lebih baik ini mengendalikan kesilapan yang berpotensi dengan lebih anggun dan menyediakan penyelesaian yang lebih mantap. Ingatlah untuk menggantikan fungsi pemegang letak (get_checkpoint_dir, initialise_model_components) dengan pelaksanaan sebenar anda. generate_data_loaders

Atas ialah kandungan terperinci Model Bahasa Latihan di Google Colab. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!