Training distribué

Exécuter des training jobs sur plusieurs workers avec le federated learning. Fonctionnement des rounds, de l'agrégation des poids et de la coordination multi-GPU.

Vue d'ensemble

Parsyn prend en charge le training distribué via le federated learning. Chaque worker s'entraîne sur un sous-ensemble des données, et la plateforme agrège périodiquement les résultats en un modèle global. Cette approche fonctionne entre des machines situées sur des réseaux différents, sans nécessiter d'interconnexions à haut débit.

Vous pouvez combiner différents types de workers : utilisez vos propres GPU pour une partie du calcul et des Parsyn Workers pour le reste. La plateforme se charge de la distribution des données, de la coordination des rounds et de l'agrégation des poids.

Fonctionnement

Training par rounds

Le federated training s'exécute en rounds :

Distribution : La plateforme envoie les poids du modèle global actuel à tous les workers participants.
Training local : Chaque worker s'entraîne sur sa partition des données pendant un nombre configuré de steps.
Upload : Chaque worker uploade ses poids mis à jour sur S3.
Agrégation : La plateforme agrège les poids par federated averaging (FedAvg), pondéré par le nombre d'exemples de chaque worker.
Round suivant : Les poids agrégés deviennent le nouveau modèle global. On recommence.

Round 1:
  Platform ──[global weights]──> Worker A (votre GPU)
  Platform ──[global weights]──> Worker B (Parsyn A100)
  Platform ──[global weights]──> Worker C (votre GPU)

  Les workers s'entraînent localement, uploadent les poids

  La plateforme agrège ──> nouveaux poids globaux

Round 2:
  Platform ──[new weights]──> Worker A, B, C
  ...

Configuration

Activez le training distribué lors de la création d'un job. Dans le formulaire de training job du dashboard, dépliez la section avancée pour accéder aux paramètres distribués. Vous pouvez aussi le configurer via l'API :

POST /api/v1/training-jobs
{
  "name": "distributed-llama-finetune",
  "dataset_id": 42,
  "model_id": 7,
  "config": {
    "epochs": 3,
    "batch_size": 4,
    "learning_rate": 2e-4,
    "mixed_precision": "bf16",
    "use_peft": true,
    "lora_r": 16,
    "lora_alpha": 32
  },
  "distributed": {
    "enabled": true,
    "strategy": "federated_averaging",
    "num_rounds": 10,
    "steps_per_round": 500,
    "min_workers": 2,
    "max_workers": 5,
    "aggregation_timeout": 600,
    "fault_tolerance": 1
  },
  "worker_selection": {
    "mode": "mixed",
    "worker_ids": [1, 3],
    "parsyn_worker_ids": [5]
  }
}

Paramètres distribués

Paramètre	Défaut	Description
`strategy`	`federated_averaging`	Stratégie d'agrégation. FedAvg est actuellement la seule méthode supportée.
`num_rounds`	10	Nombre total de rounds d'agrégation.
`steps_per_round`	500	Nombre de steps d'entraînement que chaque worker effectue par round.
`min_workers`	2	Nombre minimum de workers requis pour démarrer un round.
`max_workers`	5	Nombre maximum de workers à inclure.
`aggregation_timeout`	600	Délai en secondes avant d'agréger avec les résultats disponibles, sans attendre tous les workers.
`fault_tolerance`	1	Nombre de rounds échoués consécutifs avant d'abandonner le job.

Distribution des données

La plateforme répartit le dataset entre les workers participants. La répartition est à peu près égale et aléatoire (avec une graine pour la reproductibilité). Chaque worker ne télécharge que sa partition.

Le jeu de validation n'est pas découpé. Chaque worker reçoit l'intégralité du jeu de validation pour que les métriques d'évaluation soient comparables entre les workers.

Suivi de la progression

Ouvrez le training job depuis la page Training pour voir le statut du training distribué dans la vue détaillée :

Round en cours et nombre total de rounds
Progression par worker dans le round actuel
Quels workers ont rapporté leurs résultats et lesquels sont encore en cours d'entraînement
Courbes de loss par worker
Loss agrégée après chaque round
Utilisation GPU et débit de chaque worker

Gestion des pannes

Déconnexion d'un worker en cours de round

La plateforme attend les workers restants. Tant que min_workers terminent le round, l'agrégation se poursuit. Le worker déconnecté peut rejoindre un round ultérieur avec les derniers poids globaux.

Pas assez de workers

Si moins de min_workers terminent un round dans le délai aggregation_timeout, le round échoue. Après fault_tolerance échecs consécutifs, le job entier est marqué comme échoué.

Reconnexion d'un worker

Quand un worker se reconnecte, la plateforme lui envoie les derniers poids agrégés. Il reprend au round en cours, pas là où il s'était arrêté.

Quand utiliser le training distribué

Cas adaptés

Plusieurs machines GPU situées dans des emplacements ou comptes cloud différents.
Dataset volumineux qui prendrait trop de temps sur un seul GPU.
Contraintes de localisation des données (les workers gardent les données sur site, seuls les poids du modèle sont partagés).
Redondance : si une machine tombe, les autres continuent.

Cas moins adaptés

Petits datasets (<1000 exemples). Un seul GPU terminera plus vite que le surcoût de coordination.
Une seule machine avec plusieurs GPU. Utilisez plutôt des instances de worker séparées par GPU au lieu du federated learning.
La qualité d'entraînement maximale est indispensable. FedAvg introduit un léger écart de convergence par rapport au training centralisé.

Conseils pratiques

Utilisez LoRA pour le training distribué. Les poids d'adaptateur sont légers (quelques dizaines de Mo), ce qui rend l'agrégation rapide. L'agrégation de poids complets déplace des gigaoctets à chaque round.
Plus de rounds avec moins de steps par round donne une meilleure convergence, mais augmente le surcoût de communication. Commencez avec 10 rounds / 500 steps et ajustez.
Surveillez la validation loss à chaque round. Si elle stagne après 5-6 rounds, vous pouvez arrêter plus tôt.
Équilibrez les données. Si un worker possède 90% des données, la moyenne pondérée sera dominée par ce worker.