Points de contrôle pour la formation du modèle AI / ML | par Ayo Akinkugbe | Avril 2025

Comment préserver les progrès et l’efficacité des entraînements du modèle

Les modèles d’apprentissage automatique de formation, en particulier les modèles d’apprentissage en profondeur, peuvent être un processus long et gourmand en ressources. Il faut souvent des heures, des jours ou même des semaines pour atteindre un modèle satisfaisant. Sur un projet récent sur lequel j’ai commencé à travailler, mon temps de formation a été estimé à environ 527 heures (c’est 21 jours ou 3 semaines !!! 😭). Alors, que se passe-t-il si votre processus est interrompu pendant l’entraînement? Ou si vous souhaitez affiner un point antérieur sans recommencer?

C’est là que le point de contrôle entrera en jeu.

Le point de contrôle est la pratique de la sauvegarde périodique de l’état actuel d’un modèle (poids, de l’état d’optimiseur et parfois même de la configuration de la formation) pendant le processus de formation. Ces fichiers enregistrés, appelés points de contrôle, vous permettent de reprendre la formation exactement de l’endroit où vous vous êtes arrêté sans avoir à repartir de zéro. C’est comme frapper «sauvegarder» sur un long document que vous écrivez. Si votre ordinateur se bloque, vous pouvez récupérer la majeure partie de votre travail ou revenir à une version antérieure. Il ne peut pas être surestimé comment il s’agit d’une meilleure pratique dans la formation de l’IA ML, en particulier dans la recherche!

Le point de contrôle résout quelques problèmes de formation des modèles au-delà de la sauvegarde des États pendant la formation. Les offres de contrôle de contrôle de la proposition de valeur incluent

• Tolérance aux défauts: Le point de contrôle fournit le processus de formation avec une tolérance aux pannes. Si votre travail de formation s’écrase en raison de défaillances matérielles, de délais d’attente ou de pannes de courant, vous ne perdez pas toutes vos progrès. Tu n’as pas à recommencer
• Expérimentation: Vous pouvez enregistrer différentes versions de votre modèle et les comparer plus tard. Vous pouvez également tirer parti d’une version inachevée de votre modèle pour les tests précoces (J’ai récemment fait cela pour le modèle que je m’entraînais qui a pris des semaines. J’ai déployé un modèle inachevé lors de la formation pour tester l’intégration des applications et construire des pipelines.)
• Réglage fin: Vous pouvez charger un point de contrôle de modèle précédemment formé et les affiner sur de nouvelles données ou les ajuster pour une nouvelle tâche.
• Efficacité: Il permet d’économiser un temps de calcul et un coût important en évitant le recyclage redondant.

En règle générale, un point de contrôle comprend:

• Poids du modèle (paramètres appris pendant l’entraînement)
• Optimizer State (important pour reprendre une formation avec l’élan, les horaires des taux d’apprentissage, etc.)
• Époque actuelle ou étape de formation
• Parfois, les métadonnées comme les antécédents de perte ou les hyperparamètres

Différents cadres (Comme Tensorflow, Pytorch, étreignant les transformateurs de visage) Offrez leurs propres services publics de contrôle de contrôle.

• Économisez fréquemment: Surtout dans les longues séries d’entraînement, définissez des points de contrôle à des intervalles raisonnables (toutes les quelques époques ou un certain nombre d’étapes. J’utilise souvent toutes les 100 étapes lorsque je travaille dans Google Colab)
• Version Vos points de contrôle: Incluez des horodatages ou des numéros de pas dans les noms de fichiers pour suivre les progrès.
• Stocker à distance: Pour les grands travaux de formation, les points de contrôle de sauvegarde vers le stockage cloud ou les serveurs externes. N’oubliez pas que le stockage pour la plupart des cahiers cloud comme Google Colab n’est pas persistant
• Évaluer avant l’écrasement: Assurez-vous toujours que les nouveaux points de contrôle sont meilleurs ou stables avant de remplacer ceux précédents.
• Nettoyage: Gardez uniquement les meilleurs points de contrôle ou récents pour éviter de remplir l’espace de stockage. Cela peut également être automatisé à l’aide d’une fonction Python.

Le code ci-dessous est un modèle de jouet pour illustrer le fonctionnement du point de contrôle. La fonction de pointage de contrôle est incorporée dans la boucle de formation à l’aide de Torch.Save (). Vous trouverez également un exemple de chargement et de suppression de point de contrôle. Souvent, ceux-ci sont tous automatisés dans la boucle de formation du modèle. Vous pouvez trouver ou tester le code utilisé ici.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
# Setting random seed for reproducibility
torch.manual_seed(42)
# 1. Defining a simple dataset
X = torch.randn(100, 10)  # 100 samples, 10 features
y = torch.randint(0, 2, (100,))  # Binary classification
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)
# 2. Simple model
class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc = nn.Linear(10, 2)  # 10 input features, 2 output classes
def forward(self, x):
return self.fc(x)
model = SimpleNet()
# 3. Loss function and optimizer for model
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 4. Training loop with checkpointing
num_epochs = 5
for epoch in range(num_epochs):
model.train()
total_loss = 0.0
for inputs, targets in dataloader:
outputs = model(inputs)
loss = criterion(outputs, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
avg_loss = total_loss / len(dataloader)
# Save checkpoint after each epoch (Checkpoint can also be saved after a number of training step))
checkpoint_path = f'checkpoint_epoch{epoch}.pth'
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': avg_loss,
}, checkpoint_path)
print(f"(Epoch {epoch}) Avg Loss: {avg_loss:.4f} | Checkpoint saved to {checkpoint_path}")

Chargement d’un point de contrôle après enregistrer

#Loading a checkpoint
checkpoint = torch.load('checkpoint_epoch3.pth')
model.load_state_dict(checkpoint('model_state_dict'))
optimizer.load_state_dict(checkpoint('optimizer_state_dict'))
start_epoch = checkpoint('epoch') + 1
loss = checkpoint('loss')
print(f"Resumed from epoch {start_epoch}, previous loss: {loss}")

Suppression d’un point de contrôle après enregistrer

import os
# Delete checkpoint
if os.path.exists(checkpoint_path):
os.remove(checkpoint_path)
print(f"Checkpoint {checkpoint_path} deleted.")
else:
print("Checkpoint file not found.")

Le point de contrôle n’est pas seulement une commodité. Il est essentiel pour la robustesse, la reproductibilité et l’efficacité des ressources dans le travail intensif d’apprentissage automatique. Que vous formiez un petit modèle sur votre ordinateur portable ou un modèle de milliards de paramètres sur un supercalculateur, le point de contrôle intelligent peut vous faire gagner du temps, de l’énergie et même de votre santé mentale.

La prochaine fois que vous commencerez une course d’entraînement, n’oubliez pas de vérifier le point de contrôle. Économisez tôt et économisez souvent. Cela fera une différence dans votre processus d’IA / ML.

Pour en savoir plus sur les guides AI / ML 📝, consultez d’autres articles dans ce collection:

Guides AI / ML