> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/mlops-et-deploiement/clearml.md). # ClearML {% hint style="info" %} **ClearML** (anciennement Trains) est une plateforme MLOps open source pour le suivi d'expériences, la gestion des versions de données, la gestion des modèles, l'orchestration de pipelines et la gestion des ressources de calcul — le tout dans une suite unifiée. {% endhint %} ## Aperçu ClearML est une plateforme complète de gestion du cycle de vie ML développée par Allegro AI. Elle capture automatiquement les paramètres d'expérience, les métriques, les artefacts et le code avec des modifications de code minimales. ClearML prend en charge l'ensemble du flux de travail ML : de la gestion des données et du suivi des expériences au registre de modèles, aux pipelines automatisés et à l'exécution distribuée des tâches sur des clusters GPU. | Propriété | Valeur | | --------------- | --------------------------------------------------------- | | **Catégorie** | MLOps / Suivi d'expériences | | **Développeur** | Allegro AI | | **Licence** | Apache 2.0 | | **GitHub** | [allegroai/clearml](https://github.com/allegroai/clearml) | | **Étoiles** | 5,5K+ | | **Docker Hub** | `allegroai/clearml` | | **Ports** | 22 (SSH), 8008 (API Server), 8081 (Web UI) | *** ## Architecture ClearML se compose de quatre composants principaux : | Composant | Port | Description | | ------------------ | ---- | -------------------------------------- | | **ClearML Server** | — | Coordinateur backend | | **Web UI** | 8081 | Tableau de bord basé sur le navigateur | | **API Server** | 8008 | API REST pour le SDK et les agents | | **File Server** | 8081 | Stockage des artefacts et des modèles | | **ClearML Agent** | — | Worker qui exécute les tâches ML | *** ## Fonctionnalités clés * **Suivi d'expériences sans code** — ajoutez 2 lignes de code pour tout capturer automatiquement * **Journalisation automatique** — métriques, paramètres, modèles, sortie console, graphiques, images * **Intégration Git** — capture automatique du commit git, du diff et des modifications non committées * **Gestion des données** — jeux de données versionnés avec suivi de lignage * **Registre de modèles** — stocker, versionner et servir des modèles ML * **Orchestration de pipelines** — construire et exécuter des pipelines ML multi-étapes * **Exécution distante** — mettre les expériences en file d'attente et les exécuter sur des workers GPU distants (ClearML Agent) * **Optimisation d'hyperparamètres** — HPO automatisée avec entraînement basé sur la population * **Surveillance des ressources** — surveillance GPU/CPU/RAM par expérience * **Auto-hébergé ou cloud** — exécutez votre propre serveur ou utilisez la plateforme hébergée de ClearML *** ## Configuration Clore.ai ### Option 1 — Serveur auto-hébergé complet Exécutez le serveur ClearML sur Clore.ai pour un contrôle total. ### Étape 1 — Choisir un serveur | Cas d'utilisation | Recommandé | VRAM | RAM | | -------------------------------------- | ------------- | ----- | ------ | | Serveur uniquement (sans entraînement) | Instance CPU | — | 8 Go+ | | Serveur + entraînement | RTX 3080 | 10 Go | 16 Go | | Cluster MLOps complet | Plusieurs GPU | — | 32 Go+ | ### Étape 2 — Louer un serveur sur Clore.ai 1. Aller sur [clore.ai](https://clore.ai) → **Marketplace** 2. Pour le **composant : les instances CPU conviennent** Pour 3. les workers d'entraînement **: instances GPU (RTX 3090, 4090, A100)**Ouvrir les ports : 4. Assurez-vous **22**, **8008**, **8081** 5. ≥ 50 Go de disque **pour les artefacts d'expérience** Étape 3 — Déployer avec Docker Compose ### Créer docker-compose.yml `version : "3.6"`: ```yaml services : apiserver : image : allegroai/clearml:latest restart : unless-stopped volumes : - /opt/clearml/logs:/var/log/clearml - /opt/clearml/config:/opt/clearml/config - /opt/clearml/data/fileserver:/mnt/fileserver environnement : CLEARML_MONGODB_SERVICE_HOST: mongo CLEARML_MONGODB_SERVICE_PORT: 27017 CLEARML_ELASTICSEARCH_SERVICE_HOST: elasticsearch CLEARML_ELASTICSEARCH_SERVICE_PORT: 9200 CLEARML_REDIS_SERVICE_HOST: redis CLEARML_REDIS_SERVICE_PORT: 6379 ports : depends_on : - "8008:8008" - mongo - elasticsearch - redis webserver : image : allegroai/clearml-webserver:latest CLEARML_API_HOST: http://localhost:8008 volumes : depends_on : - "8081:80" CLEARML_MONGODB_SERVICE_HOST: mongo fileserver : image : allegroai/clearml-fileserver:latest mongo : volumes : - /opt/clearml/logs:/var/log/clearml environnement : depends_on : - "8081:8081" image : mongo:4.4 - /opt/clearml/data/mongo:/data/db volumes : - /opt/clearml/logs:/var/log/clearml command : --setParameter internalQueryMaxBlockingSortMemoryUsageBytes=196100200 elasticsearch : image : docker.elastic.co/elasticsearch/elasticsearch:7.17.6 ES_JAVA_OPTS : "-Xms512m -Xmx2048m" volumes : CLEARML_MONGODB_SERVICE_HOST: mongo bootstrap.memory_lock : "true" cluster.name : "clearml" discovery.type : "single-node" http.publish_host : "$CLEARML_HOST_IP" ulimits : memlock : soft : -1 hard : -1 - /opt/clearml/data/elastic:/usr/share/elasticsearch/data - /opt/clearml/logs:/var/log/clearml redis : image : redis:6 - /opt/clearml/data/redis:/data volumes : - /opt/clearml/logs:/var/log/clearml networks : default : name : clearml_network Démarrer la stack : ``` mkdir -p /opt/clearml/{logs,config,data/{fileserver,mongo,elastic,redis}} ```bash # Définissez l'IP publique de votre serveur export CLEARML_HOST_IP= docker-compose up -d Le serveur ClearML nécessite ~4 Go de RAM pour la stack complète (MongoDB + Elasticsearch + Redis + API server + WebUI). Assurez-vous que votre instance Clore.ai dispose de suffisamment de RAM. ``` {% hint style="warning" %} Option 2 — Utiliser ClearML hébergé (gratuit) {% endhint %} ### Pour le suivi d'expériences sans exécuter de serveur, utilisez le plan hébergé gratuit : \# Installer le SDK ```bash pip install clearml # Configurer avec le serveur hébergé clearml-init # Saisir : https://api.clear.ml lorsqu'on demande l'hôte API # Obtenez les identifiants depuis : https://app.clear.ml/settings/workspace-configuration Accéder à l'interface ``` *** ## Tableau de bord Web ### http\://\:8081 ``` Identifiants par défaut : créez votre compte lors de la première connexion. ``` http\://\:8008 ### API Server ``` Via SSH ``` ### ssh root@\ -p 22 ```bash Intégration SDK ``` *** ## Installation ### Configuration initiale ```bash # Configurer avec le serveur hébergé ``` ### Saisissez l'URL de votre serveur ( ```bash # Saisir : https://api.clear.ml lorsqu'on demande l'hôte API ``` ) et les identifiants API depuis le tableau de bord.`Via SSH`Ou configurez programmatiquement : from clearml import Task ```python Task.set_credentials( api_host="http://:8008", web_host="http://:8081", files_host="http://:8081", key="VOTRE_CLE_D_ACCES", secret="VOTRE_CLE_SECRETE" Suivi des expériences ) ``` *** ## Intégration minimale (2 lignes) ### # Initialiser la tâche — cela capture TOUT automatiquement ```python Task.set_credentials( task = Task.init(project_name="MyProject", task_name="experiment-001") # Votre code d'entraînement existant — aucune modification nécessaire import torch import torch.nn as nn model = nn.Linear(10, 1) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) for epoch in range(10): loss = torch.tensor(1.0 / (epoch + 1)) # ClearML détecte et journalise automatiquement la loss si vous utilisez des frameworks standard print(f"Epoch {epoch}, Loss: {loss.item():.4f}") task.close() Journalisation manuelle des métriques ``` ### from clearml import Task, Logger ```python task = Task.init(project_name="MyProject", task_name="manual-logging-demo") logger = task.get_logger() for epoch in range(50): train_loss = 1.0 / (epoch + 1) val_accuracy = 0.95 - 0.5 / (epoch + 1) # Journaliser des scalaires logger.report_scalar("Loss", "train", value=train_loss, iteration=epoch) logger.report_scalar("Accuracy", "validation", value=val_accuracy, iteration=epoch) # Journaliser le taux d'apprentissage logger.report_scalar("Learning Rate", "lr", value=0.001 * 0.9**epoch, iteration=epoch) print("Entraînement terminé !") Suivi des hyperparamètres Journalisation manuelle des métriques ``` ### task = Task.init(project\_name="HPO-Demo", task\_name="run-001") ```python Task.set_credentials( # Connecter les hyperparamètres — journalisés automatiquement et surclassables à distance params = { "learning_rate": 0.001, "batch_size": 32, "num_layers": 4, "dropout": 0.3, "optimizer": "adam", "epochs": 100, params = task.connect(params) # Maintenant modifiables par le HPO de ClearML } print(f"Entraînement avec lr={params['learning_rate']}, batch={params['batch_size']}") Gestion des données ``` *** ## from clearml import Dataset ```python # Créer un jeu de données versionné dataset = Dataset.create( dataset_name="my-training-data", dataset_project="MyProject", dataset_version="1.0", # Ajouter des fichiers ) dataset.add_files(path="/data/images/", recursive=True) dataset.add_files(path="/data/labels.csv") # Téléverser vers le serveur ClearML dataset.upload() dataset.finalize() print(f"ID du dataset : {dataset.id}") # Plus tard : utiliser le dataset dans les expériences dataset = Dataset.get(dataset_name="my-training-data", dataset_version="1.0") local_path = dataset.get_local_copy() print(f"Dataset à : {local_path}") Registre de modèles ``` *** ## from clearml import Task, OutputModel, InputModel ```python task = Task.init(project_name="ModelRegistry", task_name="training-run") import torch.nn as nn # Après l'entraînement, enregistrer le modèle model = torch.nn.Linear(100, 10) torch.save(model.state_dict(), "my_model.pt") # Enregistrer le modèle de sortie output_model = OutputModel(task=task, name="MyModel-v1") output_model.update_weights("my_model.pt") output_model.publish() # Marquer comme prêt à l'emploi print(f"Modèle enregistré : {output_model.id}") # En production : charger le modèle par nom input_model = InputModel(model_id="") local_model_path = input_model.get_local_copy() state_dict = torch.load(local_model_path) Orchestration de pipelines ``` *** ## from clearml.automation import PipelineController ```python def step_preprocess(dataset_id: str) -> str: """Étape de prétraitement des données.""" from clearml import Task, Dataset task = Task.init(task_name="step-preprocess") # ... logique de prétraitement return "processed_data_id" def step_train(data_id: str, lr: float = 0.001) -> str: """Étape d'entraînement du modèle.""" task = Task.init(task_name="step-train") Task.set_credentials( # ... logique d'entraînement return "model_id" def step_evaluate(model_id: str) -> float: """Étape d'évaluation du modèle.""" task = Task.init(task_name="step-evaluate") Task.set_credentials( # ... logique d'évaluation return 0.95 # Construire le pipeline pipe = PipelineController( name="ML-Training-Pipeline", project="MyPipelines", version="1.0" pipe.add_function_step( ) name="preprocess", function=step_preprocess, function_kwargs={"dataset_id": "raw-data-id"}, function_return=["processed_id"], name="train", ) name="preprocess", parents=["preprocess"], function=step_train, function_kwargs={"data_id": "${preprocess.processed_id}"}, function_return=["model_id"], execution_queue="gpu-queue", # Exécuter sur un worker GPU name="evaluate", ) name="preprocess", parents=["train"], function=step_evaluate, function_kwargs={"model_id": "${train.model_id}"}, function_return=["accuracy"], pipe.start() ) pipe.wait() print("Pipeline terminée !") ClearML Agent (Worker) ``` *** ## Exécutez un ClearML Agent sur un serveur GPU pour exécuter les expériences en file d'attente : \# Installer l'agent ```bash pip install clearml-agent # Configurer (utilise les mêmes identifiants que le SDK) clearml-agent init # Démarrer le worker sur GPU clearml-agent daemon --queue "gpu-queue" --gpus 0,1 # Démarrer le worker avec isolation Docker (recommandé) clearml-agent daemon \ --queue "gpu-queue" \ --docker pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime \ --gpus all Sur Clore.ai, lancez plusieurs nœuds GPU en tant qu'agents ClearML pour créer un cluster de calcul distribué. ``` Optimisation d'hyperparamètres *** ## from clearml.automation import ( ```python HyperParameterOptimizer, UniformParameterRange, DiscreteParameterValues, GridSearch, optimizer = HyperParameterOptimizer( ) base_task_id="", hyper_parameters=[ UniformParameterRange("General/learning_rate", min_value=1e-5, max_value=1e-2, step_size=1e-5), DiscreteParameterValues("General/batch_size", values=[16, 32, 64, 128]), DiscreteParameterValues("General/optimizer", values=["adam", "sgd", "adamw"]), objective_metric_title="Accuracy", ], objective_metric_series="validation", objective_metric_sign="max", # Maximiser la précision de validation max_number_of_concurrent_tasks=4, optimizer_class=GridSearch, execution_queue="gpu-queue", total_max_jobs=50, optimizer.start() ) top_exps = optimizer.get_top_experiments(top_k=3) print("Meilleures expériences :", top_exps) Surveillance & Alertes ``` *** ## task = Task.init(project\_name="Production", task\_name="monitoring") ```python Task.set_credentials( # Définir des tags de tâche pour un filtrage facile task.add_tags(["production", "v2.1", "gpu"]) # Journaliser automatiquement les métriques système — il suffit d'initialiser la tâche # ClearML capture : utilisation CPU, RAM, GPU, VRAM GPU automatiquement # Ajouter une surveillance scalaire personnalisée import time for epoch in range(50): for i in range(100): gpu_util = 85 + (i % 10) logger.report_scalar("GPU", "utilization_%", value=gpu_util, iteration=i) time.sleep(1) Dépannage ``` *** ## Elasticsearch ne démarre pas {% hint style="warning" %} **— Définir** vm.max\_map\_count=262144 `sur l'hôte :` sysctl -w vm.max\_map\_count=262144 `. Ajouter à`/etc/sysctl.conf `pour la persistance.` Impossible de se connecter au serveur {% endhint %} {% hint style="warning" %} **— Vérifiez que les ports 8008 et 8081 sont ouverts dans les paramètres de ports Clore.ai. Vérifiez** docker ps `pour vous assurer que tous les conteneurs sont en cours d'exécution.` Les expériences n'apparaissent pas dans l'UI {% endhint %} {% hint style="info" %} **— Vérifiez que** CLEARML\_API\_HOST `dans votre configuration SDK pointe vers` , pas vers localhost. `Via SSH`Espace disque insuffisant {% endhint %} {% hint style="info" %} **— ClearML stocke tous les artefacts localement. Configurez le stockage S3/GCS ou augmentez l'allocation de disque dans Clore.ai.** Problème {% endhint %} | Correction | Connexion MongoDB refusée | | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------- | | Vérifier le conteneur mongo : | docker logs clearml\_mongo\_1 `Tâche bloquée dans la file d'attente` | | Assurez-vous que ClearML Agent fonctionne et est connecté à la file d'attente | UI lente | | Elasticsearch a besoin de temps pour indexer — attendre 2–3 min après le démarrage | API 401 Non autorisé | | Régénérez les identifiants API dans le tableau de bord web ClearML | Cas d'utilisation pour les chercheurs GPU | *** ## Suivre les runs d'entraînement * **— ne perdez plus jamais les hyperparamètres ou les résultats** Comparer les expériences * **— comparaison côte à côte des métriques dans l'UI** Reproduire les résultats * **— ClearML capture automatiquement le commit git et le diff de code** Partager les résultats * **— les collaborateurs voient toutes les expériences dans le tableau de bord partagé** Jobs GPU distants * **— mettre les jobs d'entraînement en file depuis le portable, exécuter sur les nœuds GPU Clore.ai** HPO automatisé * **— exécuter la recherche d'hyperparamètres sur plusieurs nœuds GPU en parallèle** Outils connexes *** ## MLflow * [— alternative pour le suivi d'expériences](/guides/guides_v2-fr/mlops-et-deploiement/mlflow.md) Weights & Biases * [— suivi d'expériences ML hébergé](https://wandb.ai/) Ray * [— entraînement ML distribué et HPO](https://www.ray.io/) ClearML sur Clore.ai combine le suivi d'expériences avec la gestion du calcul GPU — offrant à votre équipe ML des capacités MLOps complètes sans verrouillage fournisseur cloud. *** *Recommandations GPU Clore.ai* *** ## GPU recommandé | Cas d'utilisation | Coût estimé sur Clore.ai | Développement/Test | | ----------------- | ------------------------ | ---------------------------- | | RTX 3090 (24 Go) | \~0,12 $/GPU/heure | Entraînement en production | | RTX 4090 (24 Go) | \~0,70 $/GPU/heure | Expériences à grande échelle | | A100 80 Go | \~1,20 $/GPU/heure | \~1,20 $/GPU/heure | > 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/mlops-et-deploiement/clearml.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.