ClearML

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.

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
É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 → 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":

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

# Définissez l'IP publique de votre serveur

export CLEARML_HOST_IP=<votre-ip-serveur>
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.

Option 2 — Utiliser ClearML hébergé (gratuit)

Pour le suivi d'expériences sans exécuter de serveur, utilisez le plan hébergé gratuit :

# Installer le SDK

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://<server-ip>:8081

Identifiants par défaut : créez votre compte lors de la première connexion.

http://<server-ip>:8008

API Server

Via SSH

ssh root@<server-ip> -p 22

Intégration SDK

---

Installation

Configuration initiale

# Configurer avec le serveur hébergé

Saisissez l'URL de votre serveur (

# Saisir : https://api.clear.ml lorsqu'on demande l'hôte API

) et les identifiants API depuis le tableau de bord.Via SSHOu configurez programmatiquement :

from clearml import Task

Task.set_credentials(

api_host="http://<server-ip>:8008",
    web_host="http://<server-ip>:8081",
    files_host="http://<server-ip>: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

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

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

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

# 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

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="<model-id-from-dashboard>")
local_model_path = input_model.get_local_copy()
state_dict = torch.load(local_model_path)
Orchestration de pipelines

---

from clearml.automation import PipelineController

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

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 (

HyperParameterOptimizer,
    UniformParameterRange,
    DiscreteParameterValues,
    GridSearch,
    optimizer = HyperParameterOptimizer(
)

base_task_id="<task-id-to-optimize>",
    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")

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

— 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

— 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

— Vérifiez que CLEARML_API_HOST dans votre configuration SDK pointe vers , pas vers localhost. Via SSHEspace disque insuffisant

— ClearML stocke tous les artefacts localement. Configurez le stockage S3/GCS ou augmentez l'allocation de disque dans Clore.ai. Problème

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 Weights & Biases

• — suivi d'expériences ML hébergé Ray

• — entraînement ML distribué et HPO 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 serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.