Dans mon parcours en deep learning, j'ai régulièrement rencontré des défis liés aux ressources matérielles. Bien que mon ordinateur personnel suffise pour les petits projets, j'ai constaté que les modèles plus exigeants ralentissaient considérablement mon workflow de développement. Comme beaucoup de praticiens, j'ai utilisé Google Colab qui offre une solution pratique avec ses ressources GPU gratuites. Cependant, je me suis rendu compte que je préférais travailler dans mon environnement de développement local avec PyCharm, où j'ai configuré mes outils, extensions et raccourcis clavier pour optimiser ma productivité.
Cette préférence pour mon environnement local ne remet pas en cause l'utilité de Colab - qui reste une excellente solution pour de nombreuses situations - mais reflète simplement mon besoin de cohérence dans mon processus de travail. J'apprécie particulièrement la possibilité de déboguer en temps réel, d'utiliser mes outils de profiling habituels, et de bénéficier d'une configuration stable sans risque de déconnexion. Lorsque Hugging Face a annoncé trackio, une alternative intégrée à leur écosystème pour le suivi d'expériences, j'ai vu une opportunité d'explorer une solution intermédiaire : utiliser des ressources cloud tout en conservant mon workflow de développement habituel.
C'est alors que j'ai découvert les GPU Droplets de DigitalOcean. Avec un coût d'environ $1.99/GPU/hr et 100$ de crédit gratuit à l'inscription, l'idée m'a séduit immédiatement. Contrairement aux GPU NVIDIA qui nécessitent CUDA, ces machines équipées de cartes AMD fonctionnaient avec TinyGrad, un framework léger que j'utilisais déjà localement. Cette compatibilité était cruciale pour moi, car elle éliminait la complexité des drivers propriétaires. Pas de dépendances lourdes, pas de drivers à installer — juste du code pur qui fonctionne.
Pour pouvoir accéder au Droplet, il fallait d'abord sécuriser l'accès. J'ai ouvert mon terminal et lancé ssh-keygen -t ed25519, appuyant trois fois sur Entrée pour valider les paramètres par défaut. J'ai copié le contenu de ~/.ssh/id_ed25519.pub et l'ai collé dans l'interface DigitalOcean sous « Networking → Add SSH Key ». Cette configuration permet d'établir une connexion sécurisée entre mon terminal et le serveur sans avoir à utiliser de mot de passe à chaque connexion.
Après avoir configuré la clé SSH, j'ai pu créer mon GPU Droplet. Une fois la création terminée, j'ai récupéré l'IP publique du serveur dans la section Networking de l'interface DigitalOcean. Pour me connecter, j'ai simplement utilisé la commande ssh root@MON_IP dans mon terminal, suivi d'un yes pour confirmer la première connexion. Cette étape simple mais essentielle m'a donné accès à un environnement propre et dédié pour mes entraînements.
Avant de lancer l'entraînement, une étape cruciale consiste à configurer les tokens d'authentification de manière sécurisée. Pour l'upload automatique des modèles sur Hugging Face, j'ai utilisé mon token personnel (HF_TOKEN), mais je n'ai jamais intégré ce token directement dans mon code.
La bonne pratique que j'ai adoptée est d'utiliser des variables d'environnement. Avant de lancer l'entraînement, j'exporte mon token dans le terminal :
export HF_TOKEN="votre_token_ici"Cette commande définit la variable d'environnement pour la session en cours. Mon script Python récupère ensuite cette valeur via os.getenv("HF_TOKEN"), comme dans ce fragment de code :
from huggingface_hub import HfApi
api = HfApi(token=os.getenv("HF_TOKEN"))
api.upload_file(
path_or_fileobj="best_model.safetensors",
path_in_repo="best_model.safetensors",
repo_id="jonathansuru/cnn",
repo_type="model",
)Cette approche présente plusieurs avantages :
Pour éviter de devoir retaper cette commande à chaque nouvelle session SSH, j'ai également créé un petit script setup_env.sh (que je n'ajoute pas au dépôt Git) contenant l'export du token. Avant chaque entraînement, j'exécute simplement source setup_env.sh.
Pour transférer mes fichiers locaux vers le serveur cloud, j'ai choisi FileZilla plutôt que de lutter avec scp. J'ai eu du mal à maîtriser scp dans un premier temps, mais je compte m'y consacrer prochainement pour améliorer mon workflow. J'ai commencé par installer FileZilla selon la documentation DigitalOcean : sur mon Mac, j'ai téléchargé la version officielle, tandis que sur Ubuntu, j'aurais pu utiliser sudo apt-get update && sudo apt-get install filezilla.
Après avoir ouvert FileZilla, je suis allé dans Éditer → Paramètres, puis dans la section Connexion → SFTP. J'ai cliqué sur Ajouter un fichier de clé... et sélectionné ma clé privée id_ed25519. FileZilla a demandé à convertir le fichier dans un format pris en charge — j'ai accepté avec un « Oui » prudent. Ensuite, j'ai ouvert le Gestionnaire de sites via le menu Fichier, créé un Nouveau site, et rempli les champs :
Cette configuration simple mais efficace m'a permis de glisser-déposer mes fichiers entre mon ordinateur local et le Droplet sans effort. Pour une documentation plus détaillée sur l'utilisation de FileZilla, DigitalOcean propose un excellent guide complet disponible ici : How to Transfer Files to Droplets With FileZilla.
Sur le Droplet, j'ai installé Python 3.12 via apt install python3.12-venv, créé un environnement virtuel avec python3 -m venv venv, et activé les dépendances listées dans requirements.txt : tinygrad, trackio, huggingface_hub, et safetensors. Ce choix de framework léger a été déterminant : TinyGrad fonctionne nativement avec les GPU AMD via OpenCL, éliminant toute friction liée aux drivers propriétaires.
Une des fonctionnalités les plus appréciables est que l'intégration de trackio avec Hugging Face crée automatiquement un Space dédié qui affiche un dashboard interactif des différentes métriques de l'entraînement, permettant de visualiser en temps réel la perte, la précision et l'utilisation des ressources GPU sans configuration supplémentaire.
L'intégration de trackio a transformé mon workflow. En remplaçant simplement import wandb par import trackio as wandb dans mon script, j'ai pu envoyer directement mes métriques vers Hugging Face Spaces sans configurer de token supplémentaire. Chaque appel à wandb.log() se synchronisait automatiquement avec mon espace personnel, affichant en temps réel perte, précision, et utilisation GPU. Ce détail a éliminé l'anxiété de perdre des heures de calcul : même si le script plantait, les logs restaient accessibles.
Il est important de noter qu'il faut faire un choix sur la fréquence de wandb.log() pour ne pas ralentir l'entraînement. Trouver le bon équilibre entre rapidité d'entraînement et précision du suivi est essentiel pour optimiser les performances.
Lors du premier lancement de python cnn.py, j'ai observé les métriques défiler : « step 0, loss 2.3102, acc 10.53% ». En 8 minutes, le modèle atteignait 98,7 % de précision sur MNIST — contre 30 minutes sur mon ordinateur personnel. Cette accélération, bien que modeste pour ce modèle simple de test, démontre déjà l'avantage du GPU pour le deep learning. Avec des architectures plus complexes, la différence de temps deviendrait encore plus significative.
À la fin de l'entraînement, le script a sauvegardé best_model.safetensors et uploadé automatiquement le fichier sur Hugging Face via l'API. Une vérification rapide sur huggingface.co/jonathansuru/cnn confirmait sa présence. Ce processus automatisé, couplé au tracking en temps réel, a rendu l'expérience fluide et reproductible.
Cette intégration transparente avec Hugging Face est particulièrement appréciée, car elle permet de centraliser tous les éléments du workflow de deep learning : du développement au déploiement, en passant par le suivi des expériences.
Aujourd'hui, mon workflow est structuré mais léger. Je code localement dans PyCharm, transfère les fichiers via FileZilla, et lance l'entraînement via SSH. Les métriques sont suivies en temps réel via trackio, et les modèles sont archivés sur Hugging Face. Mon ordinateur portable, libéré de la charge GPU, reste silencieux et frais, réservé à ce qu'il fait de mieux : coder.
Cette configuration me permet de bénéficier du meilleur des deux mondes : la puissance de calcul du cloud pour les entraînements intensifs, et la familiarité de mon environnement de développement local pour l'écriture et le débogage du code.
Cette expérience m'a appris que le cloud n'est pas réservé aux experts. Avec les bons outils — un framework léger comme TinyGrad, un service cloud simplifié comme DigitalOcean, et un écosystème intégré comme Hugging Face — il est possible de dépasser les limites matérielles sans se noyer dans la complexité. Et si FileZilla n'est pas la méthode la plus élégante pour transférer des fichiers, elle a rempli sa mission : me permettre de me concentrer sur ce qui compte vraiment, le code.
Maintenant, je vais continuer à apprendre et mieux intégrer ces outils dans mon workflow quotidien. Mon prochain objectif est de maîtriser scp pour les transferts de fichiers plus avancés, et d'adapter davantage mon code pour optimiser son fonctionnement dans un environnement cloud. L'objectif final est de créer un pipeline d'entraînement entièrement automatisé, où je pourrais simplement envoyer mon code et recevoir les résultats sans intervention manuelle.
Ma recommandation musicale du jour : à écouter sans modération !
Écouter sur YouTube