Point de vue de l'IA et du ML: fiabilité

Last reviewed 2025-08-07 UTC

Ce document du Google Cloud Framework Well-Architected : perspective de l'IA et du ML fournit une présentation des principes et des recommandations pour concevoir et exploiter des systèmes d'IA et de ML fiables sur Google Cloud. Il explique comment intégrer des pratiques de fiabilité et d'observabilité avancées dans vos plans architecturaux. Les recommandations de ce document sont conformes au pilier de fiabilité du framework Google Cloud Well-Architected.

Dans le paysage de l'IA et du ML, qui évolue rapidement, des systèmes fiables sont essentiels pour assurer la satisfaction des clients et atteindre les objectifs commerciaux. Pour répondre aux exigences uniques du ML prédictif et de l'IA générative, vous avez besoin de systèmes d'IA et de ML robustes, fiables et adaptables. Pour gérer la complexité des MLOps (du développement au déploiement, en passant par l'amélioration continue), vous devez adopter une approche axée sur la fiabilité. Google Cloud offre une infrastructure d'IA spécialement conçue, alignée sur les principes de l'ingénierie de la fiabilité des sites (SRE), qui fournit une base solide pour des systèmes d'IA et de ML fiables.

Les recommandations de ce document sont associées aux principes fondamentaux suivants :

S'assurer que l'infrastructure de ML est évolutive et à disponibilité élevée

Les systèmes d'IA et de ML fiables dans le cloud nécessitent une infrastructure évolutive et à disponibilité élevée. Ces systèmes ont des exigences dynamiques, des besoins variés en ressources et des dépendances critiques vis-à-vis de la disponibilité des modèles. Les architectures évolutives s'adaptent aux fluctuations de charge et aux variations du volume de données ou des demandes d'inférence. La haute disponibilité permet d'assurer la résilience en cas de défaillance au niveau des composants, des zones ou des régions.

Pour créer une infrastructure de ML évolutive et à disponibilité élevée, tenez compte des recommandations suivantes.

Implémenter des capacités de scaling automatique et dynamique

Les charges de travail d'IA et de ML sont dynamiques, avec une demande qui fluctue en fonction des taux d'arrivée des données, de la fréquence d'entraînement et du volume de trafic d'inférence. La mise à l'échelle automatique et dynamique adapte de manière fluide les ressources d'infrastructure aux fluctuations de la demande. La mise à l'échelle efficace de vos charges de travail permet d'éviter les temps d'arrêt, de maintenir les performances et d'optimiser les coûts.

Pour autoscaler vos charges de travail d'IA et de ML, utilisez les produits et fonctionnalités suivants dans Google Cloud :

  • Pipelines de traitement des données : créez des pipelines de données dans Dataflow. Configurez les pipelines pour qu'ils utilisent la fonctionnalité d'autoscaling horizontal de Dataflow, qui ajuste de manière dynamique le nombre d'instances de nœuds de calcul en fonction de l'utilisation du processeur, du parallélisme du pipeline et des données en attente. Vous pouvez configurer les paramètres d'autoscaling à l'aide des options de pipeline lorsque vous lancez des jobs.
  • Jobs d'entraînement : automatisez la mise à l'échelle des jobs d'entraînement à l'aide de l'entraînement personnalisé Vertex AI. Vous pouvez définir les spécifications du pool de nœuds de calcul, telles que le type de machine, le type et le nombre d'accélérateurs, et le nombre de pools de nœuds de calcul. Pour les jobs qui peuvent tolérer les interruptions et pour ceux dont le code d'entraînement implémente la création de points de contrôle, vous pouvez réduire les coûts en utilisant des VM Spot.
  • Inférence en ligne : pour l'inférence en ligne, utilisez les points de terminaison Vertex AI. Pour activer l'autoscaling, configurez le nombre minimal et maximal de réplicas. Spécifiez au moins deux répliques pour la haute disponibilité. Vertex AI ajuste automatiquement le nombre d'instances répliquées en fonction du trafic et des métriques d'autoscaling configurées, telles que l'utilisation du processeur et l'utilisation des instances répliquées.
  • Charges de travail conteneurisées dans Google Kubernetes Engine : configurez l'autoscaling au niveau des nœuds et des pods. Configurez l'autoscaler de cluster et le provisionnement automatique des nœuds pour ajuster le nombre de nœuds en fonction des demandes de ressources de pods en attente, comme le processeur, la mémoire, le GPU et le TPU. Utilisez l'autoscaler horizontal de pods (AHP) pour les déploiements afin de définir des règles de scaling basées sur des métriques telles que l'utilisation du processeur et de la mémoire. Vous pouvez également effectuer un scaling en fonction de métriques d'IA et de ML personnalisées, telles que l'utilisation du GPU ou du TPU, et les requêtes de prédiction par seconde.
  • Services conteneurisés sans serveur : déployez les services dans Cloud Run et configurez l'autoscaling en spécifiant le nombre minimal et maximal d'instances de conteneur. Suivez les bonnes pratiques pour autoscaler les instances compatibles avec les GPU en spécifiant le type d'accélérateur. Cloud Run adapte automatiquement les instances entre les limites minimales et maximales configurées en fonction des requêtes entrantes. En l'absence de requêtes, il s'adapte efficacement à zéro instance. Vous pouvez tirer parti du scaling automatique à la demande de Cloud Run pour déployer des agents Vertex AI et des charges de travail tierces, comme des modèles quantifiés à l'aide d'Ollama, l'inférence de modèles LLM à l'aide de vLLM et l'inférence de génération de texte (TGI) Hugging Face.

Concevoir des solutions à haute disponibilité et tolérantes aux pannes

Pour les charges de travail d'IA et de ML de niveau production, il est essentiel de garantir un fonctionnement continu et une résilience face aux défaillances. Pour implémenter la haute disponibilité et la tolérance aux pannes, vous devez intégrer la redondance et la réplication à votre architecture sur Google Cloud. Cette approche permet de s'assurer qu'une défaillance d'un composant individuel n'entraîne pas celle de l'ensemble du système.

Implémentez la redondance pour les composants critiques d'IA et de ML dans Google Cloud. Voici quelques exemples de produits et de fonctionnalités qui vous permettent d'implémenter la redondance des ressources :

  • Déployez des clusters régionaux GKE sur plusieurs zones.
  • Assurez la redondance des données pour les ensembles de données et les points de contrôle en utilisant des buckets Cloud Storage multirégionaux ou birégionaux.
  • Utilisez Spanner pour un stockage de métadonnées cohérent à l'échelle mondiale et disponibilité élevée.
  • Configurez des instances répliquées Cloud SQL avec accès en lecture pour les bases de données opérationnelles.
  • Assurez-vous que les bases de données vectorielles pour la génération augmentée de récupération (RAG) sont disponibilité élevée et multizones ou multirégionales.

Gérer les ressources de manière proactive et anticiper les besoins

Une gestion efficace des ressources est importante pour vous aider à optimiser les coûts, les performances et la fiabilité. Les charges de travail d'IA et de ML sont dynamiques et la demande en matériel spécialisé comme les GPU et les TPU est élevée. Il est donc essentiel d'appliquer une gestion proactive des ressources et de veiller à leur disponibilité.

Planifiez la capacité en fonction des données de surveillance historiques, telles que l'utilisation des GPU ou des TPU et les débits, à partir de Cloud Monitoring et des journaux dans Cloud Logging. Analysez ces données de télémétrie à l'aide de BigQuery ou de Looker Studio, et prévoyez la demande future de GPU en fonction de la croissance ou des nouveaux modèles. L'analyse des tendances et des schémas d'utilisation des ressources vous aide à prédire quand et où vous aurez besoin d'accélérateurs spécialisés critiques.

  • Validez les estimations de capacité grâce à des tests de charge rigoureux. Simulez le trafic sur les services d'IA et de ML tels que le serving et les pipelines à l'aide d'outils comme Apache JMeter ou LoadView.
  • Analysez le comportement du système sous contrainte.
    • Pour anticiper et répondre à l'augmentation des besoins en charge de travail en production, identifiez de manière proactive les besoins en ressources. Surveillez la latence, le débit, les erreurs et l'utilisation des ressources, en particulier l'utilisation des GPU et des TPU. Augmentez les quotas de ressources si nécessaire.
    • Pour le serving d'IA générative, effectuez des tests sous des charges simultanées élevées et identifiez le niveau auquel la disponibilité des accélérateurs limite les performances.
  • Effectuez une surveillance continue des requêtes de modèle et configurez des alertes proactives pour les agents.
    • Utilisez le tableau de bord d'observabilité des modèles pour afficher les métriques collectées par Cloud Monitoring, telles que les requêtes par seconde (RPS) du modèle, le débit de jetons et les latences du premier jeton.

Optimiser la disponibilité et l'accessibilité des ressources

Optimisez les coûts et assurez-vous de la disponibilité des ressources en sélectionnant stratégiquement les ressources de calcul appropriées en fonction des exigences de la charge de travail.

  • Pour les charges de travail d'inférence stables 24h/24 et 7j/7 ou d'entraînement avec des besoins en capacité fixes ou prévisibles, utilisez les remises sur engagement d'utilisation pour les VM et les accélérateurs.

  • Pour les nœuds GKE et les VM Compute Engine, utilisez les VM Spot et les fonctionnalités du planificateur de charges de travail dynamique (DWS) :

    • Pour les tâches tolérantes aux pannes, telles que les charges de travail d'évaluation et d'expérimentation, utilisez des VM spot. Les VM Spot peuvent être préemptées, mais elles peuvent vous aider à réduire vos coûts globaux.
    • Pour gérer le risque de préemption pour les accélérateurs à forte demande, vous pouvez assurer une meilleure disponibilité en utilisant DWS.
      • Pour l'entraînement par lot complexe qui nécessite des GPU haut de gamme pour s'exécuter jusqu'à sept jours, utilisez le mode DWS Flex-Start.
      • Pour les charges de travail de longue durée (jusqu'à trois mois), utilisez le mode "Calendrier" pour réserver des GPU (H100 et H200) et des TPU (Trillium) spécifiques.

  • Pour optimiser l'inférence d'IA sur GKE, vous pouvez exécuter un moteur vLLM qui utilise dynamiquement des TPU et des GPU pour répondre aux besoins fluctuants en termes de capacité et de performances. Pour en savoir plus, consultez Fongibilité des GPU/TPU vLLM.

  • Pour les scénarios avancés avec des besoins complexes en ressources et en topologie impliquant des accélérateurs, utilisez des outils pour abstraire la gestion des ressources.

    • Cluster Director vous permet de déployer et de gérer des groupes d'accélérateurs avec colocation et planification pour l'entraînement multi-GPU (A3 Ultra H200 et A4 B200). Cluster Director est compatible avec les clusters GKE et Slurm.
    • Ray sur Vertex AI abstrait l'infrastructure de calcul distribué. Il permet aux applications de demander des ressources pour l'entraînement et le service sans avoir à gérer directement les VM et les conteneurs.

Répartir le trafic entrant sur plusieurs instances

Un équilibrage de charge efficace est essentiel pour les applications d'IA dont la demande fluctue. L'équilibrage de charge répartit le trafic, optimise l'utilisation des ressources, offre une haute disponibilité et une faible latence, et contribue à garantir une expérience utilisateur fluide.

  • Inférence avec des besoins en ressources variables : implémentez l'équilibrage de charge en fonction des métriques du modèle. La passerelle d'inférence GKE vous permet de déployer des modèles derrière un équilibreur de charge avec un routage adapté aux modèles. La passerelle donne la priorité aux instances avec des accélérateurs GPU et TPU pour les tâches gourmandes en ressources de calcul, comme l'IA générative et l'inférence LLM. Configurez des vérifications d'état détaillées pour évaluer l'état du modèle. Utilisez des frameworks de diffusion tels que vLLM ou Triton pour les métriques LLM, et intégrez les métriques dans Cloud Monitoring à l'aide de Google Cloud Managed Service pour Prometheus.
  • Charges de travail d'inférence nécessitant des GPU ou des TPU : pour vous assurer que les charges de travail d'inférence critiques d'IA et de ML s'exécutent de manière cohérente sur des machines adaptées à leurs exigences, en particulier lorsque la disponibilité des GPU et des TPU est limitée, utilisez les classes de calcul personnalisées GKE. Vous pouvez définir des profils de calcul spécifiques avec des règles de remplacement pour l'autoscaling. Par exemple, vous pouvez définir un profil qui spécifie une priorité plus élevée pour les instances GPU ou TPU réservées. Le profil peut inclure un recours à des VM Spot économiques si les ressources réservées sont temporairement indisponibles.
  • IA générative sur diverses plates-formes d'orchestration : utilisez un équilibreur de charge centralisé. Par exemple, pour optimiser les coûts et la gestion, vous pouvez acheminer les requêtes qui nécessitent peu de GPU vers Cloud Run et les tâches plus complexes et gourmandes en GPU vers GKE. Pour la communication entre les services et la gestion des règles, implémentez un maillage de services à l'aide de Cloud Service Mesh. Assurez-vous d'avoir une journalisation et une surveillance cohérentes en utilisant Cloud Logging et Cloud Monitoring.
  • Distribution de charge mondiale : pour équilibrer la charge du trafic des utilisateurs du monde entier qui ont besoin d'une faible latence, utilisez un équilibreur de charge d'application externe global. Configurez le routage par géolocalisation vers la région la plus proche et implémentez le basculement. Établissez la réplication des points de terminaison régionaux dans Vertex AI ou GKE. Configurez Cloud CDN pour les éléments statiques. Surveillez le trafic et la latence mondiaux à l'aide de Cloud Monitoring.
  • Gestion précise du trafic : pour les requêtes qui comportent différents types de données ou qui sont complexes et de longue durée, implémentez une gestion précise du trafic.
    • Configurez le routage basé sur le contenu pour diriger les requêtes vers des backends spécialisés en fonction d'attributs tels que les chemins d'URL et les en-têtes. Par exemple, dirigez les requêtes vers des backends compatibles avec les GPU pour les modèles d'images ou de vidéos, et vers des backends optimisés pour les CPU pour les modèles basés sur du texte.
    • Pour les requêtes d'IA générative de longue durée ou les charges de travail par lot, utilisez WebSockets ou gRPC. Implémentez la gestion du trafic pour gérer les délais d'attente et la mise en mémoire tampon. Configurez les délais d'expiration et les nouvelles tentatives de requête, et implémentez la limitation du débit et les quotas à l'aide d'API Gateway ou d'Apigee.

Utiliser une architecture modulaire et faiblement couplée

Dans une architecture d'IA et de ML modulaire et faiblement couplée, les systèmes complexes sont divisés en composants plus petits et autonomes qui interagissent via des interfaces bien définies. Cette architecture minimise les dépendances des modules, simplifie le développement et les tests, améliore la reproductibilité et renforce la tolérance aux pannes en limitant les échecs. L'approche modulaire est essentielle pour gérer la complexité, accélérer l'innovation et assurer la maintenabilité à long terme.

Pour concevoir une architecture modulaire et faiblement couplée pour les charges de travail d'IA et de ML, tenez compte des recommandations suivantes.

Implémenter de petits modules ou composants autonomes

Séparez votre système d'IA et de ML de bout en bout en petits modules ou composants autonomes. Chaque module ou composant est responsable d'une fonction spécifique, telle que l'ingestion de données, la transformation de caractéristiques, l'entraînement de modèles, la diffusion d'inférences ou l'évaluation. Une conception modulaire offre plusieurs avantages clés pour les systèmes d'IA et de ML : une meilleure facilité de maintenance, une évolutivité accrue, une réutilisabilité, ainsi qu'une flexibilité et une agilité accrues.

Les sections suivantes décrivent les produits, fonctionnalités et outils Google Cloud que vous pouvez utiliser pour concevoir une architecture modulaire pour vos systèmes d'IA et de ML.

Microservices conteneurisés sur GKE

Pour les systèmes d'IA et de ML complexes ou les pipelines d'IA générative complexes qui nécessitent une orchestration précise, implémentez les modules en tant que microservices orchestrés à l'aide de GKE. Empaquetez chaque étape distincte sous la forme d'un microservice individuel dans des conteneurs Docker. Ces étapes distinctes incluent l'ingestion de données adaptée à différents formats, le prétraitement spécialisé des données ou l'extraction de caractéristiques, l'entraînement distribué des modèles ou l'ajustement précis des grands modèles de base, l'évaluation ou la diffusion.

Déployez les microservices conteneurisés sur GKE et profitez du scaling automatisé en fonction de l'utilisation du processeur et de la mémoire, ou de métriques personnalisées telles que l'utilisation du GPU, les mises à jour progressives et les configurations reproductibles dans les fichiers manifestes YAML. Assurez une communication efficace entre les microservices à l'aide de la détection de services GKE. Pour les modèles asynchrones, utilisez des files d'attente de messages comme Pub/Sub.

L'approche des microservices sur GKE vous aide à créer des plates-formes évolutives et résilientes pour des tâches telles que les applications RAG complexes, où les étapes peuvent être conçues comme des services distincts.

Services sans serveur basés sur des événements

Pour les tâches basées sur des événements qui peuvent bénéficier d'un scaling automatique sans serveur, utilisez Cloud Run ou Cloud Run Functions. Ces services sont idéaux pour les tâches asynchrones telles que le prétraitement ou pour les tâches d'inférence plus petites. Déclenchez des fonctions Cloud Run sur des événements, tels que la création d'un fichier de données dans Cloud Storage ou les mises à jour de modèles dans Artifact Registry. Pour les tâches ou services de webhook qui nécessitent un environnement de conteneur, utilisez Cloud Run.

Les services Cloud Run et les fonctions Cloud Run peuvent évoluer rapidement à la hausse et à la baisse (jusqu'à zéro), ce qui permet de garantir la rentabilité des charges de travail fluctuantes. Ces services conviennent aux composants modulaires des workflows Vertex AI Agents. Vous pouvez orchestrer des séquences de composants avec Workflows ou Application Integration.

Services gérés Vertex AI

Les services Vertex AI sont modulaires et vous aident à simplifier le développement et le déploiement de vos systèmes d'IA et de ML. Les services font abstraction des complexités de l'infrastructure pour vous permettre de vous concentrer sur la logique de l'application.

  • Pour orchestrer des workflows créés à partir d'étapes modulaires, utilisez Vertex AI Pipelines.
  • Pour exécuter du code d'IA et de ML personnalisé, empaquetez le code dans des conteneurs Docker pouvant s'exécuter sur des services gérés tels que l'entraînement personnalisé Vertex AI et la prédiction Vertex AI.
  • Pour les pipelines d'extraction de caractéristiques modulaires, utilisez Vertex AI Feature Store.
  • Pour l'exploration et le prototypage modulaires, utilisez des environnements de notebook tels que Vertex AI Workbench ou Colab Enterprise. Organisez votre code en fonctions, classes et scripts réutilisables.

Applications agentives

Pour les agents d'IA, l'Agent Development Kit (ADK) fournit des fonctionnalités modulaires telles que les outils et l'état. Pour activer l'interopérabilité entre des frameworks tels que LangChain, LangGraph, LlamaIndex et Vertex AI, vous pouvez combiner l'ADK avec le protocole Agent2Agent (A2A) et le protocole de contexte de modèle (MCP). Cette interopérabilité vous permet de composer des workflows agentiques à l'aide de divers composants.

Vous pouvez déployer des agents sur Vertex AI Agent Engine, qui est un environnement d'exécution géré et optimisé pour le déploiement d'agents évolutifs. Pour exécuter des agents conteneurisés, vous pouvez exploiter les capacités d'autoscaling de Cloud Run.

Concevoir des interfaces bien définies

Pour créer des systèmes logiciels robustes et faciles à entretenir, il est essentiel de s'assurer que les composants d'un système sont faiblement couplés et modularisés. Cette approche offre des avantages considérables, car elle réduit au minimum les dépendances entre les différentes parties du système. Lorsque les modules sont faiblement couplés, les modifications apportées à un module ont un impact minimal sur les autres modules. Cette isolation permet des mises à jour et des workflows de développement indépendants pour chaque module.

Les sections suivantes fournissent des conseils pour assurer une communication et une intégration fluides entre les modules de vos systèmes d'IA et de ML.

Choix du protocole

  • Pour un accès universel, utilisez des API HTTP, respectez les principes RESTful et utilisez JSON pour l'échange de données indépendant du langage. Concevez les points de terminaison de l'API pour représenter les actions sur les ressources.
  • Pour une communication interne performante entre les microservices, utilisez gRPC avec Protocol Buffers (ProtoBuf) pour une sérialisation efficace et un typage strict. Définissez des structures de données telles que ModelInput, PredictionResult ou les données de l'outil ADK à l'aide de fichiers .proto, puis générez des liaisons de langage.
  • Pour les cas d'utilisation où les performances sont essentielles, utilisez le streaming gRPC pour les grands ensembles de données ou pour les flux continus tels que les applications de synthèse vocale ou vidéo en direct. Déployez les services gRPC sur GKE.

Documentation standardisée et complète

Quel que soit le protocole d'interface que vous choisissez, une documentation standardisée est essentielle. La spécification OpenAPI décrit les API RESTful. Utilisez OpenAPI pour documenter vos API d'IA et de ML : chemins d'accès, méthodes, paramètres, formats de requête/réponse liés aux schémas JSON et sécurité. Une documentation API complète permet d'améliorer la détectabilité et l'intégration des clients. Pour la création et la visualisation d'API, utilisez des outils d'UI tels que Swagger Editor. Pour accélérer le développement et assurer la cohérence, vous pouvez générer des SDK clients et des stubs de serveur à l'aide d'outils de programmation assistée par l'IA tels que Gemini Code Assist. Intégrez la documentation OpenAPI à votre flux CI/CD.

Interaction avec les services gérés Google Cloud tels que Vertex AI

Choisissez entre l'abstraction plus élevée du SDK Vertex AI, qui est préférable pour la productivité du développement, et le contrôle précis fourni par l'API REST.

  • Le SDK Vertex AI simplifie les tâches et l'authentification. Utilisez le SDK lorsque vous devez interagir avec Vertex AI.
  • L'API REST est une alternative puissante, en particulier lorsque l'interopérabilité est requise entre les couches de votre système. Elle est utile pour les outils dans des langages qui ne disposent pas de SDK ou lorsque vous avez besoin d'un contrôle précis.

Utiliser des API pour isoler les modules et abstraire les détails d'implémentation

Pour assurer la sécurité, l'évolutivité et la visibilité, il est essentiel d'implémenter une gestion robuste des API pour vos services d'IA et de ML. Pour implémenter la gestion des API pour vos interfaces définies, utilisez les produits suivants :

  • API Gateway : pour les API exposées et gérées en externe, API Gateway fournit un point d'entrée centralisé et sécurisé. Il simplifie l'accès aux services de backend sans serveur, tels que les API de prédiction, d'entraînement et de données. API Gateway permet de regrouper les points d'accès, d'appliquer les contrats d'API et de gérer les fonctionnalités de sécurité telles que les clés API et OAuth 2.0. Pour protéger les backends contre la surcharge et assurer leur fiabilité, implémentez des limitation du débit et des quotas d'utilisation dans API Gateway.
  • Cloud Endpoints : pour simplifier le développement et le déploiement d'API sur GKE et Cloud Run, utilisez Cloud Endpoints, qui offre une solution conviviale pour les développeurs afin de générer des clés API. Il fournit également une surveillance et un traçage intégrés pour les appels d'API, et automatise la génération de spécifications OpenAPI, ce qui simplifie la documentation et l'intégration des clients. Vous pouvez utiliser Cloud Endpoints pour gérer l'accès aux API d'IA et de ML internes ou contrôlées, par exemple pour déclencher l'entraînement et gérer les feature stores.
  • Apigee : Apigee fournit une gestion avancée et complète des API pour l'IA et le ML à l'échelle de l'entreprise, en particulier pour les API d'IA générative sophistiquées. Utilisez Apigee pour une sécurité avancée (protection contre les menaces et OAuth 2.0, par exemple), pour la gestion du trafic (mise en cache, quotas et médiation, par exemple) et pour les données analytiques. Apigee peut vous aider à obtenir des insights approfondis sur les modèles d'utilisation, les performances et l'engagement des API, qui sont essentiels pour comprendre l'utilisation des API d'IA générative.

Planifier la dégradation élégante

Dans les systèmes d'IA et de ML de production, les défaillances de composants sont inévitables, tout comme dans les autres systèmes. La dégradation progressive garantit que les fonctions essentielles continuent de fonctionner, potentiellement avec des performances réduites. Cette approche permet d'éviter les pannes complètes et d'améliorer la disponibilité globale. La dégradation progressive est essentielle pour l'inférence sensible à la latence, l'entraînement distribué et l'IA générative.

Les sections suivantes décrivent les techniques que vous utilisez pour planifier et implémenter la dégradation progressive.

Isolement des défaillances

  • Pour isoler les composants défectueux dans les architectures distribuées, implémentez le modèle de disjoncteur à l'aide de bibliothèques de résilience, telles que Resilience4j en Java et CircuitBreaker en Python.
  • Pour éviter les défaillances en cascade, configurez des seuils basés sur les métriques de charge de travail d'IA et de ML, comme les taux d'erreur et la latence, et définissez des solutions de secours comme des modèles plus simples et des données mises en cache.

Redondance des composants

Pour les composants critiques, implémentez la redondance et le basculement automatique. Par exemple, utilisez des clusters GKE multizones ou régionaux, et déployez des services Cloud Run de manière redondante dans différentes régions. Pour acheminer le trafic vers des instances opérationnelles lorsque des instances non opérationnelles sont détectées, utilisez Cloud Load Balancing.

Assurez la redondance des données en utilisant des buckets Cloud Storage multirégionaux. Pour l'entraînement distribué, implémentez la création de points de contrôle asynchrones pour reprendre l'entraînement après des échecs. Pour un entraînement résilient et élastique, utilisez Pathways.

Surveillance proactive

La dégradation progressive permet d'assurer la disponibilité du système en cas de défaillance, mais vous devez également mettre en œuvre des mesures proactives pour les vérifications d'état continues et la surveillance complète. Collectez des métriques spécifiques à l'IA et au ML, telles que la latence, le débit et l'utilisation du GPU. Collectez également des métriques de dégradation des performances du modèle, comme la dérive des modèles et des données, à l'aide de Cloud Monitoring et de Vertex AI Model Monitoring.

Les vérifications de l'état peuvent déclencher la nécessité de remplacer les nœuds défectueux, de déployer davantage de capacité ou de déclencher automatiquement le réentraînement continu ou l'ajustement précis des pipelines qui utilisent des données mises à jour. Cette approche proactive permet d'éviter à la fois la dégradation de la précision et la dégradation progressive au niveau du système, et contribue à améliorer la fiabilité globale.

Pratiques SRE

Pour surveiller l'état de vos systèmes, envisagez d'adopter les pratiques SRE afin d'implémenter des objectifs de niveau de service (SLO). Les alertes concernant la perte de marge d'erreur et le taux de consommation peuvent être des indicateurs précoces de problèmes de fiabilité du système. Pour en savoir plus sur les pratiques SRE, consultez le livre sur l'ingénierie SRE de Google.

Créer une plate-forme MLOps de bout en bout automatisée

Un système d'IA et de ML robuste, évolutif et fiable sur Google Cloud nécessite une plate-forme MLOps de bout en bout automatisée pour le cycle de vie du développement de modèles. Le cycle de vie du développement inclut la gestion initiale des données, l'entraînement continu des modèles, le déploiement et la surveillance en production. En automatisant ces étapes sur Google Cloud, vous établissez des processus reproductibles, réduisez la pénibilité manuelle, minimisez les erreurs et accélérez le rythme de l'innovation.

Une plate-forme MLOps automatisée est essentielle pour établir une fiabilité de niveau production pour vos applications. L'automatisation permet de garantir la qualité des modèles et la reproductibilité, et d'assurer l'intégration et la diffusion continues des artefacts d'IA et de ML.

Pour créer une plate-forme MLOps de bout en bout automatisée, tenez compte des recommandations suivantes.

Automatiser le cycle de vie du développement de modèles

L'orchestration de l'ensemble du workflow d'IA et de ML en tant que série d'étapes automatisées et connectées est un élément essentiel d'une plate-forme MLOps automatisée. Cela inclut la préparation et la validation des données, ainsi que l'entraînement, l'évaluation, le déploiement et la surveillance des modèles.

  • Utilisez Vertex AI Pipelines comme orchestrateur central :
    • Définissez des workflows de bout en bout avec des composants modulaires pour le traitement, l'entraînement, l'évaluation et le déploiement des données.
    • Automatisez les exécutions de pipeline à l'aide de planifications ou de déclencheurs tels que de nouvelles données ou des modifications de code.
    • Implémenter la paramétrisation et la gestion des versions automatisées pour chaque exécution du pipeline et créer un historique des versions
    • Surveillez la progression des pipelines et l'utilisation des ressources à l'aide de la journalisation et du traçage intégrés, et intégrez-les aux alertes Cloud Monitoring.
  • Définissez vos pipelines de ML de manière programmatique à l'aide du SDK Kubeflow Pipelines (KFP) ou du SDK TensorFlow Extended. Pour en savoir plus, consultez Interfaces pour Vertex AI Pipelines.
  • Orchestrez les opérations à l'aide de services Google Cloud tels que Dataflow, l'entraînement personnalisé Vertex AI, Vertex AI Model Registry et les points de terminaison Vertex AI.
  • Pour les workflows d'IA générative, orchestrez les étapes de gestion des requêtes, d'inférence par lot, d'évaluation human-in-the-loop (HITL) et de coordination des composants ADK.

Gérer l'infrastructure en tant que code

L'Infrastructure as Code (IaC) est essentielle pour gérer l'infrastructure des systèmes d'IA et de ML, et pour permettre des déploiements reproductibles, évolutifs et faciles à entretenir. Les besoins en infrastructure des systèmes d'IA et de ML sont dynamiques et complexes. Ces systèmes nécessitent souvent du matériel spécialisé, comme des GPU et des TPU. L'IaC permet d'atténuer les risques liés à la gestion manuelle de l'infrastructure en assurant la cohérence, en permettant les rollbacks et en rendant les déploiements reproductibles.

Pour gérer efficacement vos ressources d'infrastructure en tant que code, utilisez les techniques suivantes.

Automatiser le provisionnement des ressources

Pour gérer efficacement l'IaC sur Google Cloud, définissez et provisionnez vos ressources d'infrastructure d'IA et de ML à l'aide de Terraform. L'infrastructure peut inclure des ressources telles que les suivantes :

  • Clusters GKE configurés avec des pools de nœuds. Les pools de nœuds peuvent être optimisés en fonction des exigences des charges de travail. Par exemple, vous pouvez utiliser des GPU A100, H100, H200 ou B200 pour l'entraînement, et des GPU L4 pour l'inférence.
  • Points de terminaison Vertex AI configurés pour la diffusion de modèles, avec des types de machines et des règles de scaling définis.
  • Buckets Cloud Storage pour les données et les artefacts.

Utiliser des modèles de configuration

Organisez vos configurations Terraform sous forme de modèles modulaires. Pour accélérer le provisionnement des ressources d'IA et de ML, vous pouvez utiliser Cluster Toolkit. Le kit d'outils fournit des plans types, qui sont des modèles Terraform sélectionnés par Google que vous pouvez utiliser pour déployer des clusters HPC, d'IA et de ML prêts à l'emploi dans Slurm ou GKE. Vous pouvez personnaliser le code Terraform et le gérer dans votre système de contrôle des versions. Pour automatiser le workflow de provisionnement et de mise à jour des ressources, vous pouvez intégrer le code dans vos pipelines CI/CD à l'aide de Cloud Build.

Automatiser les modifications de configuration

Après avoir provisionné votre infrastructure, gérez les modifications de configuration en cours de manière déclarative :

  • Dans les environnements axés sur Kubernetes, gérez vos ressources Google Clouden tant qu'objets Kubernetes à l'aide de Config Connector.
  • Définissez et gérez des ressources Vertex AI telles que des ensembles de données, des modèles et des points de terminaison, des instances Cloud SQL, des thèmes Pub/Sub et des buckets Cloud Storage à l'aide de fichiers manifestes YAML.
  • Déployez les fichiers manifestes sur votre cluster GKE afin d'intégrer la configuration de l'application et de l'infrastructure.
  • Automatisez les mises à jour de configuration à l'aide de pipelines CI/CD et utilisez des modèles pour gérer les différences d'environnement.
  • Implémentez des configurations pour les stratégies Identity and Access Management (IAM) et les comptes de service à l'aide d'IaC.

Intégrer à la CI/CD

  • Automatisez le cycle de vie des ressources d'infrastructure Google Cloud en intégrant l'IaC aux pipelines CI/CD à l'aide d'outils tels que Cloud Build et Infrastructure Manager.
  • Définissez des déclencheurs pour les mises à jour automatiques des commits de code.
  • Implémentez des tests et des validations automatisés dans le pipeline. Par exemple, vous pouvez créer un script pour exécuter automatiquement les commandes Terraform validate et plan.
  • Stockez les configurations en tant qu'artefacts et activez le contrôle des versions.
  • Définissez des environnements distincts (développement, préproduction et production, par exemple) avec des configurations distinctes dans le contrôle des versions, et automatisez la promotion des environnements.

Valider le comportement du modèle

Pour maintenir la précision et la pertinence des modèles au fil du temps, automatisez le processus d'entraînement et d'évaluation au sein de votre plate-forme MLOps. Cette automatisation, associée à une validation rigoureuse, permet de s'assurer que les modèles se comportent comme prévu avec les données pertinentes avant d'être déployés en production.

  • Configurez des pipelines d'entraînement continu, qui sont déclenchés par de nouvelles données et des signaux de surveillance tels que la dérive des données, ou qui s'exécutent selon une planification.
    • Pour gérer les tâches d'entraînement automatisées, telles que les essais de réglage des hyperparamètres et les configurations d'entraînement distribué pour les modèles plus volumineux, utilisez l'entraînement personnalisé Vertex AI.
    • Pour affiner les modèles de fondation, automatisez le processus d'affinage et intégrez les jobs dans vos pipelines.
  • Implémentez le versioning automatique des modèles et stockez de manière sécurisée les artefacts de modèles entraînés après chaque cycle d'entraînement réussi. Vous pouvez stocker les artefacts dans Cloud Storage ou les enregistrer dans Model Registry.
  • Définissez des métriques d'évaluation et des seuils clairs, tels que la précision minimale, le taux d'erreur maximal et le score F1 minimal.
    • Assurez-vous qu'un modèle respecte les seuils pour réussir automatiquement l'évaluation et être pris en compte pour le déploiement.
    • Automatisez l'évaluation à l'aide de services tels que l'évaluation de modèles dans Vertex AI.
    • Assurez-vous que l'évaluation inclut des métriques spécifiques à la qualité des résultats générés, à l'exactitude factuelle, aux attributs de sécurité et au respect du style ou du format spécifiés.
  • Pour enregistrer et suivre automatiquement les paramètres, les versions de code, les versions de l'ensemble de données et les résultats de chaque exécution d'entraînement et d'évaluation, utilisez Vertex AI Experiments. Cette approche fournit un historique utile pour la comparaison, le débogage et la reproductibilité.
  • Pour optimiser le réglage des hyperparamètres et automatiser la recherche des configurations de modèle optimales en fonction de l'objectif que vous avez défini, utilisez Vertex AI Vizier.
  • Pour visualiser les métriques d'entraînement et déboguer pendant le développement, utilisez Vertex AI TensorBoard.

Valider les entrées et les sorties des pipelines d'IA et de ML

Pour garantir la fiabilité et l'intégrité de vos systèmes d'IA et de ML, vous devez valider les données lorsqu'elles entrent dans les systèmes et transitent par les pipelines. Vous devez également valider les entrées et les sorties aux limites des composants. Une validation robuste de toutes les entrées et sorties (données brutes, données traitées, configurations, arguments et fichiers) permet d'éviter les comportements inattendus et de maintenir la qualité du modèle tout au long du cycle de vie MLOps. Lorsque vous intégrez cette approche proactive à votre plate-forme MLOps, elle vous aide à détecter les erreurs avant qu'elles ne se propagent dans un système, ce qui vous permet de gagner du temps et des ressources.

Pour valider efficacement les entrées et les sorties de vos pipelines d'IA et de ML, utilisez les techniques suivantes.

Automatiser la validation des données

  • Implémentez la validation automatique des données dans vos pipelines d'ingestion et de prétraitement des données à l'aide de TensorFlow Data Validation (TFDV).
    • Pour les contrôles de la qualité des données à grande échelle basés sur SQL, utilisez des services de traitement évolutifs tels que BigQuery.
    • Pour une validation programmatique complexe des données par flux ou par lot, utilisez Dataflow.
  • Surveillez les distributions de données au fil du temps grâce aux fonctionnalités TFDV.
    • Visualisez les tendances à l'aide d'outils intégrés à Cloud Monitoring pour détecter la dérive des données. Vous pouvez déclencher automatiquement des pipelines de réentraînement de modèles lorsque les modèles de données changent de manière significative.
  • Stockez les résultats et les métriques de validation dans BigQuery pour l'analyse et le suivi historique, et archivez les artefacts de validation dans Cloud Storage.

Valider les configurations de pipeline et les données d'entrée

Pour éviter les échecs de pipeline ou les comportements inattendus causés par des paramètres incorrects, implémentez une validation stricte pour toutes les configurations de pipeline et tous les arguments de ligne de commande :

  • Définissez des schémas clairs pour vos fichiers de configuration tels que YAML ou JSON en utilisant des bibliothèques de validation de schéma comme jsonschema pour Python. Validez les objets de configuration par rapport à ces schémas avant le début de l'exécution d'un pipeline et avant l'exécution d'un composant.
  • Implémentez la validation des entrées pour tous les arguments de ligne de commande et les paramètres de pipeline à l'aide de bibliothèques d'analyse d'arguments telles que argparse. La validation doit vérifier les types de données corrects, les valeurs valides et les arguments requis.
  • Dans Vertex AI Pipelines, définissez les types et propriétés attendus des paramètres de composant à l'aide des fonctionnalités de validation des entrées de composant intégrées.
  • Pour garantir la reproductibilité des exécutions de pipeline et conserver un journal d'audit, stockez les fichiers de configuration validés et versionnés dans Cloud Storage ou Artifact Registry.

Valider les fichiers d'entrée et de sortie

Validez l'intégrité et le format des fichiers d'entrée et de sortie, tels que les ensembles de données, les artefacts de modèle et les rapports d'évaluation :

  • Validez les formats de fichier tels que CSV, Parquet et les types d'image à l'aide de bibliothèques.
  • Pour les fichiers volumineux ou les artefacts critiques, validez la taille des fichiers et les sommes de contrôle afin de détecter toute corruption ou tout transfert incomplet à l'aide de la validation des données et de la détection des modifications de Cloud Storage.
  • Validez les fichiers à l'aide de Cloud Run Functions (par exemple, en fonction des événements d'importation de fichiers) ou dans les pipelines Dataflow.
  • Stockez les résultats de la validation dans BigQuery pour les récupérer et les analyser plus facilement.

Automatiser le déploiement et implémenter la surveillance continue

Le déploiement automatisé et la surveillance continue des modèles en production permettent d'assurer la fiabilité, d'effectuer des mises à jour rapides et de détecter rapidement les problèmes. Cela implique la gestion des versions de modèles, le déploiement contrôlé, le déploiement automatisé à l'aide de CI/CD et une surveillance complète, comme décrit dans les sections suivantes.

Gérer les versions de modèle

Gérez les itérations de modèle et les artefacts associés à l'aide des outils de gestion des versions :

  • Pour suivre les versions et les métadonnées des modèles, et pour créer des liens vers les artefacts de modèle sous-jacents, utilisez Model Registry.
  • Implémentez un schéma de gestion des versions clair (par exemple, la gestion sémantique des versions). Pour chaque version du modèle, associez des métadonnées complètes telles que les paramètres d'entraînement, les métriques d'évaluation des pipelines de validation et la version de l'ensemble de données.
  • Stockez les artefacts de modèle tels que les fichiers de modèle, les poids préentraînés et les images de conteneur de diffusion dans Artifact Registry, et utilisez ses fonctionnalités de gestion des versions et d'ajout de tags.
  • Pour répondre aux exigences de sécurité et de gouvernance, définissez des règles de contrôle des accès strictes pour Model Registry et Artifact Registry.
  • Pour enregistrer et gérer des versions de manière programmatique, et pour les intégrer dans des pipelines CI/CD automatisés, utilisez le SDK ou l'API Vertex AI.

Effectuer un déploiement contrôlé

Contrôlez le déploiement des versions de modèle sur les points de terminaison à l'aide des fonctionnalités de gestion du trafic de votre plate-forme de diffusion.

  • Implémentez un déploiement continu en utilisant la fonctionnalité de répartition du trafic des points de terminaison Vertex AI.
  • Si vous déployez votre modèle sur GKE, utilisez des techniques avancées de gestion du trafic, comme le déploiement Canary :
    1. Routez un petit sous-ensemble du trafic de production vers une nouvelle version du modèle.
    2. Surveillez en continu les performances et les taux d'erreur à l'aide de métriques.
    3. Établissez que le modèle est fiable.
    4. Déployez la version pour tout le trafic.
  • Effectuez des tests A/B sur les agents d'IA :
    1. Déployez deux versions différentes d'un modèle-agent ou des modèles entièrement différents sur le même point de terminaison.
    2. Répartissez le trafic entre les déploiements.
    3. Analysez les résultats par rapport aux objectifs commerciaux.
  • Implémentez des mécanismes de rollback automatisés qui peuvent rapidement rétablir le trafic des points de terminaison vers une version stable précédente du modèle si des alertes de surveillance sont déclenchées ou si les seuils de performances ne sont pas atteints.
  • Configurez les paramètres de répartition du trafic et de déploiement de manière programmatique à l'aide du SDK ou de l'API Vertex AI.
  • Utilisez Cloud Monitoring pour suivre les performances et le trafic entre les versions.
  • Automatisez le déploiement avec des pipelines CI/CD. Vous pouvez utiliser Cloud Build pour créer des conteneurs, versionner des artefacts et déclencher le déploiement sur des points de terminaison Vertex AI.
  • Assurez-vous que les pipelines CI/CD gèrent les versions et extraient les données d'Artifact Registry.
  • Avant de transférer le trafic, effectuez des tests de points de terminaison automatisés pour vérifier l'exactitude des prédictions, la latence, le débit et la fonction d'API.
  • Stockez toutes les configurations dans le contrôle des versions.

Surveillance continue

  • Utilisez Model Monitoring pour détecter automatiquement la dégradation des performances, la dérive des données (modifications de la distribution des entrées par rapport à l'entraînement) et la dérive de prédiction (modifications des sorties du modèle).
    • Configurez des jobs de détection de dérive avec des seuils et des alertes.
    • Surveillez les performances en temps réel : latence des prédictions, débit, taux d'erreur.
  • Définissez des métriques personnalisées dans Cloud Monitoring pour les KPI d'activité.
  • Intégrez les résultats de la surveillance des modèles et les métriques personnalisées à Cloud Monitoring pour les alertes et les tableaux de bord.
  • Configurez des canaux de notification tels que les e-mails, Slack ou PagerDuty, et configurez la correction automatique.
  • Pour déboguer les journaux de prédiction, utilisez Cloud Logging.
  • Intégrez la surveillance à la gestion des incidents.

Pour les points de terminaison d'IA générative, surveillez les caractéristiques de sortie telles que la toxicité et la cohérence :

  • Surveillez la dérive de la diffusion des caractéristiques.
  • Implémentez une validation précise des prédictions : validez les résultats par rapport aux plages et formats attendus à l'aide d'une logique personnalisée.
  • Surveillez les distributions de prédictions pour détecter les changements.
  • Validez le schéma de sortie.
  • Configurer des alertes pour les résultats et les changements inattendus
  • Suivez les événements de validation en temps réel et répondez-y à l'aide de Pub/Sub.

Assurez-vous que les résultats de la surveillance complète sont réinjectés dans l'entraînement continu.

Préserver la confiance et le contrôle grâce à la gouvernance des données et des modèles

La fiabilité de l'IA et du ML ne se limite pas à la disponibilité technique. Cela inclut la confiance, ainsi qu'une gouvernance robuste des données et des modèles. Les résultats de l'IA peuvent être inexacts, biaisés ou obsolètes. Ces problèmes érodent la confiance et peuvent être préjudiciables. Une traçabilité complète, contrôle des accès strict, une validation automatisée et des pratiques transparentes permettent de garantir que les résultats de l'IA sont fiables, dignes de confiance et respectent les normes éthiques.

Pour maintenir la confiance et le contrôle grâce à la gouvernance des données et des modèles, tenez compte des recommandations suivantes.

Établir des catalogues de données et de modèles pour la traçabilité

Pour faciliter le traçage, l'audit et la compréhension de la provenance de vos ressources d'IA et de ML, conservez un enregistrement robuste et centralisé des versions de données et de modèles tout au long de leur cycle de vie. Un catalogue de données et de modèles fiable sert de source unique de référence pour tous les artefacts utilisés et produits par vos pipelines d'IA et de ML, des sources de données brutes et des ensembles de données traités aux versions de modèles entraînés et aux points de terminaison déployés.

Utilisez les produits, outils et techniques suivants pour créer et gérer des catalogues pour vos composants de données :

  • Créez un catalogue d'entreprise de vos composants de données à l'aide de Dataplex Universal Catalog. Pour découvrir et créer automatiquement des inventaires des assets de données, intégrez le catalogue universel Dataplex à vos systèmes de stockage, tels que BigQuery, Cloud Storage et Pub/Sub.
  • Assurez-vous que vos données sont disponibilité élevée et durables en les stockant dans des buckets Cloud Storage multirégionaux ou birégionaux. Les données que vous importez dans ces buckets sont stockées de manière redondante dans au moins deux zones géographiques distinctes. Cette redondance offre une résilience intégrée contre les pannes régionales et contribue à garantir l'intégrité des données.
  • Taggez et annotez vos ensembles de données avec les métadonnées métier pertinentes, les informations sur la propriété, les niveaux de sensibilité et les détails sur la traçabilité. Par exemple, associez un ensemble de données traité à sa source brute et au pipeline qui l'a créé.
  • Créez un dépôt central pour les versions de modèle à l'aide de Model Registry. Enregistrez chaque version de modèle entraîné et associez-la aux métadonnées correspondantes. Les métadonnées peuvent inclure les éléments suivants :
    • Paramètres d'entraînement.
    • Métriques d'évaluation issues des pipelines de validation.
    • Version de l'ensemble de données utilisée pour l'entraînement, avec la traçabilité remontant à l'entrée Dataplex Universal Catalog correspondante.
    • Version du code ayant produit l'ensemble de données.
    • Détails sur le framework ou le modèle de fondation utilisé.
  • Avant d'importer un modèle dans le registre de modèles, stockez les artefacts de modèle tels que les fichiers de modèle et les poids préentraînés dans un service tel que Cloud Storage. Stockez les images de conteneurs personnalisées pour les jobs d'entraînement ou de diffusion personnalisés dans un dépôt sécurisé tel qu'Artifact Registry.
  • Pour vous assurer que les données et les ressources de modèle sont automatiquement enregistrées et mises à jour dans les catalogues respectifs lors de leur création ou modification, implémentez des processus automatisés dans vos pipelines MLOps. Ce catalogage complet permet une traçabilité de bout en bout, des données brutes à la prédiction. Vous pouvez ainsi auditer les entrées et les processus qui ont conduit à une version ou une prédiction de modèle spécifique. La fonctionnalité d'audit est essentielle pour déboguer les comportements inattendus, assurer la conformité avec les règles d'utilisation des données et comprendre l'impact des modifications apportées aux données ou aux modèles au fil du temps.
  • Pour l'IA générative et les modèles de fondation, votre catalogue doit également suivre les détails concernant le modèle de fondation spécifique utilisé, les paramètres de réglage précis et les résultats d'évaluation spécifiques à la qualité et à la sécurité des résultats générés.

Implémenter des contrôles des accès et des journaux d'audit robustes

Pour maintenir la confiance et le contrôle dans vos systèmes d'IA et de ML, il est essentiel de protéger les données et les modèles sensibles contre les accès non autorisés et de garantir la responsabilité de toutes les modifications.

  • Implémentez des contrôles d'accès stricts et conservez des journaux d'audit détaillés pour tous les composants de vos systèmes d'IA et de ML dans Google Cloud.
  • Définissez des autorisations précises dans IAM pour les utilisateurs, les groupes et les comptes de service qui interagissent avec vos ressources d'IA et de ML.
  • Suivez rigoureusement le principe du moindre privilège.
  • N'accordez que les autorisations minimales nécessaires pour des tâches spécifiques. Par exemple, un compte de service d'entraînement a besoin d'un accès en lecture aux données d'entraînement et d'un accès en écriture aux artefacts de modèle, mais il n'a peut-être pas besoin d'un accès en écriture aux points de terminaison de diffusion en production.

Appliquez les règles IAM de manière cohérente à tous les composants et ressources pertinents de vos systèmes d'IA et de ML, y compris les suivants :

  • Buckets Cloud Storage contenant des données sensibles ou des artefacts de modèle.
  • Ensembles de données BigQuery.
  • Ressources Vertex AI, telles que les dépôts de modèles, les points de terminaison, les pipelines et les ressources Feature Store.
  • Ressources de calcul, telles que les clusters GKE et les services Cloud Run.

Utilisez l'audit et les journaux pour capturer, surveiller et analyser l'activité d'accès :

  • Activez Cloud Audit Logs pour tous les services Google Cloud utilisés par votre système d'IA et de ML.
  • Configurez les journaux d'audit pour capturer des informations détaillées sur les appels d'API, les événements d'accès aux données et les modifications de configuration apportées à vos ressources. Surveillez les journaux pour détecter toute activité suspecte, tentative d'accès non autorisée ou modification inattendue des données critiques ou des composants du modèle.
  • Pour l'analyse, les alertes et la visualisation en temps réel, diffusez les journaux d'audit vers Cloud Logging.
  • Pour un stockage à long terme économique et une analyse rétrospective de la sécurité ou des audits de conformité, exportez les journaux vers BigQuery.
  • Pour une surveillance centralisée de la sécurité, intégrez les journaux d'audit à vos systèmes de gestion des informations et des événements de sécurité (SIEM). Examinez régulièrement les règles d'accès et les journaux d'audit pour vous assurer qu'ils correspondent à vos exigences de gouvernance et détecter les éventuels cas de non-respect des règles.
  • Pour les applications qui traitent des données sensibles, telles que les informations permettant d'identifier personnellement l'utilisateur (PII) pour l'entraînement ou l'inférence, utilisez les vérifications de la protection des données sensibles dans les pipelines ou sur le stockage de données.
  • Pour les solutions d'IA générative et agentiques, utilisez des journaux d'audit pour suivre qui a accédé à des modèles ou outils spécifiques, quelles données ont été utilisées pour l'affinage ou les requêtes, et quelles requêtes ont été envoyées aux points de terminaison de production. Les journaux d'audit vous aident à garantir la responsabilité et fournissent des données essentielles pour enquêter sur l'utilisation abusive des données ou les cas de non-respect des règles.

Lutter contre les biais, améliorer la transparence et l'explicabilité

Pour créer des systèmes d'IA et de ML fiables, vous devez traiter les biais potentiels inhérents aux données et aux modèles, vous efforcer d'assurer la transparence du comportement du système et fournir des explications pour les résultats du modèle. Il est particulièrement important de créer des systèmes fiables dans les domaines sensibles ou lorsque vous utilisez des modèles complexes comme ceux qui sont généralement utilisés pour les applications d'IA générative.

  • Mettez en œuvre des pratiques proactives pour identifier et atténuer les biais tout au long du cycle de vie MLOps.
  • Analysez les données d'entraînement pour détecter les biais à l'aide d'outils qui détectent les asymétries dans les distributions de caractéristiques pour différents groupes démographiques ou attributs sensibles.
  • Évaluez les performances globales du modèle et celles des tranches de données prédéfinies. Cette évaluation vous aide à identifier les différences de performances ou les biais qui affectent des sous-groupes spécifiques.

Pour la transparence et l'explicabilité des modèles, utilisez des outils qui aident les utilisateurs et les développeurs à comprendre pourquoi un modèle a fait une prédiction particulière ou produit un résultat spécifique.

  • Pour les modèles tabulaires déployés sur des points de terminaison Vertex AI, générez des attributions de caractéristiques à l'aide de Vertex Explainable AI. Les attributions de caractéristiques indiquent les caractéristiques d'entrée qui ont le plus contribué à la prédiction.
  • Explorez de manière interactive le comportement du modèle et les biais potentiels sur un ensemble de données à l'aide d'outils indépendants du modèle tels que l'outil de simulation What-If, qui s'intègre à TensorBoard.
  • Intégrez l'explicabilité à vos tableaux de bord de surveillance. Dans les situations où il est important de comprendre le raisonnement du modèle pour établir une relation de confiance ou prendre des décisions, fournissez des données d'explication directement aux utilisateurs finaux via les interfaces de votre application.
  • Pour les modèles complexes tels que les LLM utilisés pour les modèles d'IA générative, expliquez le processus suivi par un agent, par exemple en utilisant des journaux de trace. L'explicabilité est relativement difficile pour de tels modèles, mais elle reste essentielle.
  • Dans les applications RAG, fournissez des citations pour les informations récupérées. Vous pouvez également utiliser des techniques telles que le prompt engineering pour guider le modèle afin qu'il fournisse des explications ou montre ses étapes de raisonnement.
  • Détectez les changements de comportement ou de résultats du modèle qui pourraient indiquer un biais ou une injustice émergents en implémentant une surveillance continue en production. Documentez les limites du modèle, les cas d'utilisation prévus et les biais potentiels connus dans les métadonnées du modèle dans le registre de modèles.

Mettre en œuvre des pratiques holistiques d'observabilité et de fiabilité de l'IA et du ML

L'observabilité holistique est essentielle pour gérer les systèmes complexes d'IA et de ML en production. Elle est également essentielle pour mesurer la fiabilité des systèmes complexes d'IA et de ML, en particulier pour l'IA générative, en raison de sa complexité, de son intensité en ressources et de son potentiel de résultats imprévisibles. L'observabilité holistique consiste à observer l'infrastructure, le code d'application, les données et le comportement des modèles pour obtenir des insights permettant de détecter, diagnostiquer et résoudre les problèmes de manière proactive. Cette observabilité permet en fin de compte d'obtenir des systèmes fiables et performants. Pour obtenir une observabilité holistique, vous devez procéder comme suit :

  • Adoptez les principes de l'ingénierie SRE.
  • Définissez des objectifs de fiabilité clairs.
  • Suivez les métriques dans les différentes couches du système.
  • Utilisez les insights issus de l'observabilité pour améliorer en continu et gérer de manière proactive.

Pour implémenter des pratiques d'observabilité et de fiabilité holistiques pour les charges de travail d'IA et de ML dans Google Cloud, tenez compte des recommandations suivantes.

Définir des objectifs de fiabilité et des métriques commerciales

Identifiez les indicateurs clés de performance (KPI) que votre système d'IA et de ML affecte directement. Les KPI peuvent inclure les revenus influencés par les recommandations de l'IA, le taux de perte de clients que les systèmes d'IA ont prédit ou atténué, ainsi que les taux d'engagement et de conversion des utilisateurs générés par les fonctionnalités d'IA générative.

Pour chaque KPI, définissez les métriques de fiabilité technique correspondantes qui l'affectent. Par exemple, si le KPI est "satisfaction client avec un assistant IA conversationnel", les métriques de fiabilité correspondantes peuvent inclure les éléments suivants :

  • Taux de réussite des requêtes utilisateur.
  • Latence des réponses : délai avant le premier jeton (TTFT) et diffusion de jetons pour les LLM.
  • Taux de réponses non pertinentes ou nuisibles.
  • Taux de réussite des tâches par l'agent.

Pour l'entraînement de l'IA et du ML, les métriques de fiabilité peuvent inclure l'utilisation des FLOPS du modèle (MFU), les itérations par seconde, les jetons par seconde et les jetons par appareil.

Pour mesurer et améliorer efficacement la fiabilité de l'IA et du ML, commencez par définir des objectifs de fiabilité clairs qui sont alignés sur les objectifs commerciaux généraux. Adoptez l'approche SRE en définissant des SLO qui quantifient les niveaux acceptables de fiabilité et de performances pour vos services d'IA et de ML du point de vue des utilisateurs. Quantifiez ces métriques de fiabilité technique avec des cibles de SLO spécifiques.

Voici des exemples de cibles de SLO :

  • 99,9 % des appels d'API doivent renvoyer une réponse positive.
  • La latence d'inférence au 95e centile doit être inférieure à 300 ms.
  • Le TTFT doit être inférieur à 500 ms pour 99 % des requêtes.
  • Le taux de résultats nuisibles doit être inférieur à 0,1 %.

En alignant directement les SLO sur les besoins de l'entreprise, vous vous assurez que les efforts de fiabilité sont axés sur le comportement du système le plus critique qui affecte les utilisateurs et l'entreprise. Cette approche permet de transformer la fiabilité en une propriété d'ingénierie mesurable et exploitable.

Surveiller les performances de l'infrastructure et des applications

Suivez les métriques d'infrastructure pour toutes les ressources utilisées par vos systèmes d'IA et de ML. Les métriques incluent l'utilisation du processeur (CPU, GPU et TPU), de la mémoire, le débit et la latence du réseau, ainsi que les E/S du disque. Suivez les métriques pour les environnements gérés tels que l'entraînement et le service Vertex AI, ainsi que pour les ressources autogérées telles que les nœuds GKE et les instances Cloud Run.

Surveillez les quatre signaux clés pour vos applications d'IA et de ML :

  • Latence : temps nécessaire pour répondre aux requêtes.
  • Trafic : volume de requêtes ou charge de travail.
  • Taux d'erreur : taux de requêtes ou d'opérations ayant échoué.
  • Saturation : utilisation des ressources critiques telles que le processeur, la mémoire et les accélérateurs GPU ou TPU, qui indique à quel point votre système est proche des limites de capacité.

Effectuez la surveillance à l'aide des techniques suivantes :

  • Collectez, stockez et visualisez les métriques d'infrastructure et d'application à l'aide de Cloud Monitoring. Vous pouvez utiliser des tableaux de bord prédéfinis pour les services Google Cloud et créer des tableaux de bord personnalisés adaptés aux indicateurs de performances spécifiques de votre charge de travail et à l'état de l'infrastructure.
  • Collectez des journaux détaillés à partir de vos applications d'IA et de ML, ainsi que de l'infrastructure sous-jacente à l'aide de Cloud Logging. Ces journaux sont essentiels pour résoudre les problèmes et analyser les performances. Ils fournissent un contexte autour des événements et des erreurs.
  • Identifiez précisément les problèmes de latence et comprenez les flux de requêtes dans les microservices d'IA et de ML distribués à l'aide de Cloud Trace. Cette fonctionnalité est essentielle pour déboguer les interactions complexes des agents Vertex AI ou les pipelines d'inférence multicomposants.
  • Identifiez les goulots d'étranglement de performances dans les blocs de fonctions du code d'application à l'aide de Cloud Profiler. Identifier les goulots d'étranglement des performances peut vous aider à optimiser l'utilisation des ressources et le temps d'exécution.
  • Collectez des métriques spécifiques aux accélérateurs, comme l'utilisation détaillée du GPU par processus, l'utilisation de la mémoire par processus et la température, à l'aide d'outils tels que NVIDIA Data Center GPU Manager (DCGM).

Implémenter l'observabilité des données et des modèles

Les systèmes d'IA générative fiables nécessitent une observabilité robuste des données et des modèles, qui commence par la surveillance de l'ensemble du pipeline.

  • Suivez les taux d'ingestion de données, les volumes traités et les latences de transformation à l'aide de services tels que Dataflow.
  • Surveillez les taux de réussite et d'échec des jobs dans vos pipelines MLOps, y compris ceux gérés par Vertex AI Pipelines.

Il est essentiel d'évaluer en permanence la qualité des données.

  • Gérez et contrôlez les données à l'aide de Dataplex Universal Catalog :
    • Évaluez la précision en validant les résultats par rapport à la vérité terrain ou en suivant les taux de détection des valeurs aberrantes.
    • Surveillez la fraîcheur en fonction de l'ancienneté des données et de la fréquence des mises à jour par rapport aux SLA.
    • Évaluez l'exhaustivité en suivant les pourcentages de valeurs nulles et les taux de remplissage des champs obligatoires.
    • Assurez la validité et la cohérence grâce à des vérifications de l'adhérence au schéma et des doublons.
  • Détectez les anomalies de manière proactive à l'aide des alertes Cloud Monitoring et grâce à une traçabilité claire de la provenance des données.
  • Pour les systèmes RAG, examinez la pertinence du contexte récupéré et l'ancrage (attribution à la source) des réponses.
  • Surveillez le débit des requêtes de base de données vectorielle.

Les métriques clés d'observabilité des modèles incluent le nombre de jetons d'entrée et de sortie, ainsi que les taux d'erreur spécifiques aux modèles, tels que les échecs d'hallucination ou de résolution de requêtes. Pour suivre ces métriques, utilisez Model Monitoring.

  • Surveillez en permanence les scores de toxicité des résultats et les évaluations des utilisateurs.
  • Automatisez l'évaluation des résultats du modèle par rapport à des critères définis à l'aide de Gen AI Evaluation Service.
  • Assurez des performances durables en surveillant systématiquement la dérive des données et des concepts à l'aide de métriques complètes sur le taux d'erreur.

Pour suivre les métriques du modèle, vous pouvez utiliser TensorBoard ou MLflow. Pour une analyse et un profilage approfondis permettant de résoudre les problèmes de performances, vous pouvez utiliser le profilage PyTorch/XLA ou NVIDIA Nsight.

Contributeurs

Auteurs :

Autres contributeurs :

Précédent
Sécurité
Suivant
Optimisation des coûts