YAML

YAML (YAML Ain't Markup Language) est une norme de sérialisation de données lisible par l'homme qui est largement utilisée dans l'industrie du logiciel pour écrire des fichiers de configuration. Contrairement aux langages de balisage plus complexes, YAML privilégie un formatage clair et la lisibilité, ce qui en fait un excellent choix pour les développeurs et les scientifiques de données qui ont besoin d'inspecter ou de modifier rapidement des paramètres . Sa structure simple repose sur l'indentation plutôt que sur des crochets ou des balises, ce qui permet aux utilisateurs de définir des structures de données hiérarchiques telles que des listes et des dictionnaires avec un encombrement visuel minimal. Dans le contexte de l'intelligence artificielle et de l'apprentissage automatique, YAML sert de pont essentiel entre l'intention humaine et l'exécution machine, stockant tout, des chemins d'accès aux ensembles de données aux paramètres de réglage des hyperparamètres, dans un format facile à contrôler et à partager.

Pertinence dans l'apprentissage automatique

Dans les opérations modernes d'apprentissage automatique (MLOps), il est essentiel de maintenir des expériences reproductibles et organisées. Les fichiers YAML servent de plans pour ces expériences, encapsulant tous les détails de configuration nécessaires dans un seul document. Des cadres tels que les modèles Ultralytics s'appuient fortement sur ces fichiers de configuration pour définir les architectures des modèles et les protocoles d'entraînement.

Lorsque vous entraînez un modèle de vision par ordinateur, vous devez souvent spécifier l'emplacement de vos données d'entraînement, le nombre de classes que vous détectez et les noms de ces classes. Au lieu de coder en dur ces valeurs dans Python , ce qui peut entraîner des bases de code désordonnées, vous séparez ces données dans un fichier YAML. Cette séparation des préoccupations permet aux chercheurs d'échanger des ensembles de données ou d'ajuster les taux d'apprentissage sans toucher à la base de code principale, ce qui facilite un meilleur suivi des expériences et la collaboration.

YAML vs JSON vs XML

Bien que le YAML soit souvent comparé au JSON (JavaScript Object Notation) et au XML (eXtensible Markup Language), ces formats ont des objectifs légèrement différents dans l'écosystème de l'IA.

• YAML : Idéal pour les fichiers de configuration écrits et lus par des humains. Il prend en charge les commentaires, qui sont essentiels pour documenter les raisons pour lesquelles des poids ou des paramètres de modèle spécifiques ont été choisis.
• JSON : idéal pour la communication entre machines, comme les API Web ou l'enregistrement des résultats d'inférence. Il est plus strict et plus difficile à modifier manuellement pour les humains en raison des guillemets et des accolades nécessaires, et il ne prend pas en charge les commentaires.
• XML : un format plus détaillé souvent utilisé dans les systèmes hérités ou le stockage de documents complexes (comme VOC Pascal VOC ). Il est généralement considéré comme trop lourd pour les tâches de configuration simples dans les workflows modernes d'apprentissage profond.

Applications de l'IA dans le monde réel

YAML trouve sa place dans plusieurs étapes critiques du cycle de vie du développement de l'IA :

• Configuration de l'ensemble de données : Lorsque vous travaillez avec détection d'objets ensembles de données tels que COCO données personnalisées sur le Plate-forme Ultralytics, un fichier YAML (data.yaml) définit généralement les chemins d'accès aux répertoires pour les ensembles d'entraînement, de validation et de test. Il associe également les indices de classe (0, 1, 2) aux noms de classe (personne, vélo, voiture), garantissant ainsi que le modèle comprend la structure des données.
• Pipelines CI/CD : dans les workflows d'intégration continue, des outils tels que GitHub Actions utilisent YAML pour définir les étapes d'automatisation. Cela peut inclure l'exécution de tests unitaires sur une nouvelle architecture de réseau neuronal ou le déploiement d'un modèle dans un conteneur Docker chaque fois que du code est poussé vers un référentiel.

Exemple : configuration d'une exécution YOLO

L'exemple suivant montre comment un fichier YAML type sert d'interface de jeu de données pour l'entraînement d'un modèle YOLO26. Python ci-dessous montre comment la Ultralytics utilise ce fichier pour lancer le processus d'entraînement.

1. Le coco8.yaml fichier (Concept) :Ce fichier contiendrait les chemins d'accès aux images et une liste de noms de classes.

path: ../datasets/coco8  # dataset root dir
train: images/train  # train images (relative to 'path')
val: images/val  # val images (relative to 'path')

# Classes
names:
  0: person
  1: bicycle
  2: car
  ...

2. Python :le code lit la configuration et lance l'entraînement à l'aide des paramètres spécifiés. paramètres.

from ultralytics import YOLO

# Load the YOLO26 model (recommended for new projects)
model = YOLO("yolo26n.pt")

# Train the model using the dataset configuration defined in the YAML file
# The 'data' argument points directly to the YAML file
results = model.train(data="coco8.yaml", epochs=5, imgsz=640)

Concepts clés de syntaxe

Comprendre quelques règles syntaxiques clés permet d'éviter les erreurs courantes, telles que ScannerError ou ParserError, qui surviennent souvent en raison d'une indentation incorrecte.

• Indentation : YAML utilise des espaces (et non des tabulations) pour indiquer la structure. Les éléments imbriqués doivent être encore plus indentés que leurs éléments parents.
• Paires clé-valeur : Les données sont stockées sous forme de key: value. Par exemple, epochs: 100 définit le nombre de cycles d'entraînement.
• Listes : les séquences sont indiquées par un trait d'union -. Ceci est utile pour définir des listes de augmentation des données étapes ou plusieurs sources d'entrée .
• Commentaires : Lignes commençant par # sont ignorées par l'analyseur, ce qui vous permet de laisser des notes sur des éléments spécifiques. hyperparamètres directement dans le fichier.

En maîtrisant YAML, les praticiens peuvent rationaliser leurs workflows de formation de modèles, réduire les erreurs de configuration et garantir que leurs projets d'IA restent évolutifs et faciles à maintenir.