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

Last reviewed 2026-10-29 UTC

Ce document du Framework d'architecture deGoogle Cloud  : perspective IA et ML présente les principes et les 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é avancées et l'observabilité dans vos plans d'architecture. Les recommandations de ce document sont conformes au pilier de fiabilité du Well-Architected Framework.

Dans un paysage de l'IA et du ML en constante évolution, des systèmes fiables sont essentiels pour garantir la satisfaction client 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 les complexités des MLOps, du développement au déploiement et à l'amélioration continue, vous devez adopter une approche axée sur la fiabilité. Google Cloud propose une infrastructure d'IA spécialement conçue, alignée sur les principes de l'ingénierie de la fiabilité des sites (SRE) et qui fournit une base puissante pour des systèmes d'IA et de ML fiables.

Les recommandations de ce document sont mises en correspondance avec les principes fondamentaux suivants :

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

Pour que les systèmes d'IA et de ML dans le cloud soient fiables, ils ont besoin d'une infrastructure évolutive et hautement disponible. Ces systèmes ont des exigences dynamiques, des besoins en ressources divers 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 requêtes d'inférence. La haute disponibilité permet d'assurer la résilience contre les défaillances 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 fonctionnalités de scaling automatique et dynamique

Les charges de travail d'IA et de ML sont dynamiques, et la demande 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. Le scaling automatique et dynamique adapte les ressources d'infrastructure de manière fluide aux fluctuations de la demande. Le scaling 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 effectuer l'autoscaling de 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 des pipelines et des données en attente. Vous pouvez configurer les paramètres d'autoscaling via les options de pipeline lorsque vous lancez des jobs.
  • Jobs d'entraînement : automatisez le scaling des jobs d'entraînement à l'aide de l'entraînement personnalisé sur Gemini Enterprise Agent Platform. Vous pouvez définir des spécifications de pool de nœuds de calcul, telles que le type de machine, le type et le nombre d'accélérateurs, ainsi que le nombre de pools de nœuds de calcul. Pour les jobs qui peuvent tolérer des interruptions et pour les jobs où le code d'entraînement implémente des 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 Agent Platform. Pour activer l'autoscaling, configurez le nombre minimal et maximal d'instances répliquées. Spécifiez au moins deux instances répliquées pour la haute disponibilité. La plate-forme d'agent 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 requêtes de ressources de pods en attente, telles que le processeur, la mémoire, le GPU et le Cloud TPU. Utilisez l'autoscaler horizontal des 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 l'utilisation 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 des GPU ou des Cloud 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 effectuer l'autoscaling des instances compatibles avec les GPU en spécifiant le type d'accélérateur. Cloud Run effectue un scaling automatique des instances entre les limites minimale et maximale configurées en fonction des requêtes entrantes. En l'absence de requêtes, il effectue un scaling efficace jusqu'à zéro instance. Vous pouvez exploiter le scaling automatique basé sur les requêtes de Cloud Run pour déployer des agents et des charges de travail tierces, comme des modèles quantifiés à l'aide d'Ollama et l'inférence de LLM à l'aide de vLLM.

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 mettre en œuvre la haute disponibilité et la tolérance aux pannes, vous devez intégrer la redondance et la réplication dans votre architecture sur Google Cloud. Cette approche permet de s'assurer que la défaillance d'un composant individuel n'entraîne pas la défaillance du système complet.

Implémentez la redondance pour les composants d'IA et de ML critiques dans Google Cloud. Voici des exemples de produits et de fonctionnalités qui vous permettent de mettre en œuvre 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 multirégionaux ou birégionaux Cloud Storage.
  • Utilisez Spanner pour stocker les métadonnées de manière cohérente à l'échelle mondiale et avec disponibilité élevée.
  • Configurez des instances répliquées avec accès en lecture Cloud SQL pour les bases de données opérationnelles.
  • Assurez-vous que les bases de données vectorielles pour la génération augmentée par 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 Cloud TPU est élevée. Il est donc essentiel d'appliquer une gestion proactive des ressources et de garantir leur disponibilité.

Planifiez la capacité en fonction des données de surveillance historiques, telles que l'utilisation des GPU ou des Cloud TPU et les taux de débit, à 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 Data Studio, et prévoyez la demande future de GPU en fonction de la croissance ou des nouveaux modèles. L'analyse des modèles et des tendances d'utilisation des ressources vous aide à prévoir quand et où vous avez besoin d'accélérateurs spécialisés critiques.

  • Validez les estimations de capacité à l'aide de tests de charge rigoureux. Simulez le trafic sur les services d'IA et de ML, tels que la diffusion et les pipelines, à l'aide d'outils tels qu'Apache JMeter ou LoadView.
  • Analyser le comportement du système en cas de stress
    • Pour anticiper et répondre à l'augmentation des demandes de charges 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 Cloud TPU. Augmentez les quotas de ressources si nécessaire.
    • Pour la mise en service de l'IA générative, effectuez des tests sous des charges simultanées élevées et identifiez le niveau auquel la disponibilité de l'accélérateur limite les performances.
  • Surveillez en continu les requêtes de modèle et configurez des alertes proactives pour les agents.
    • Utilisez le tableau de bord d'observabilité du modèle pour afficher les métriques collectées par 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 la disponibilité des ressources en sélectionnant de manière stratégique 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, 7j/7 ou d'entraînement avec des exigences de capacité fixes ou prévisibles, utilisez des 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 fonctionnalités des VM Spot et de Dynamic Workload Scheduler (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 très demandés, vous pouvez améliorer l'obtention en utilisant le DWS.
      • Pour un entraînement par lot complexe nécessitant des GPU haut de gamme pour s'exécuter pendant sept jours maximum, utilisez le mode de démarrage flexible de DWS.
      • Pour les charges de travail de plus longue durée (jusqu'à trois mois), utilisez le mode Agenda pour réserver des GPU spécifiques (H100 et H200) et des Cloud TPU (Trillium).

  • Pour optimiser l'inférence d'IA sur GKE, vous pouvez exécuter un moteur vLLM qui utilise de manière dynamique Cloud TPU et des GPU pour répondre aux besoins fluctuants en termes de capacité et de performances. Pour en savoir plus, consultez Fongibilité 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 colocalisation 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 Gemini Enterprise Agent Platform fait abstraction de l'infrastructure de calcul distribué. Il permet aux applications de demander des ressources pour l'entraînement et la diffusion sans avoir à gérer directement les VM et les conteneurs.

Répartissez le trafic entrant sur plusieurs instances

Un équilibrage de charge efficace est crucial pour les applications d'IA dont les demandes fluctuent. L'équilibrage de charge répartit le trafic, optimise l'utilisation des ressources, assure 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. GKE Inference Gateway vous permet de déployer des modèles derrière un équilibreur de charge avec un routage tenant compte des modèles. La passerelle donne la priorité aux instances dotées d'accélérateurs GPU et Cloud TPU pour les tâches nécessitant beaucoup de ressources de calcul, telles que 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 de LLM, et intégrez-les dans Monitoring à l'aide de Google Cloud Managed Service pour Prometheus.
  • Charges de travail d'inférence nécessitant des GPU ou des Cloud TPU : pour vous assurer que les charges de travail d'inférence d'IA et de ML critiques s'exécutent de manière cohérente sur des machines adaptées aux exigences des charges de travail, en particulier lorsque la disponibilité des GPU et des Cloud 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 de GPU ou de Cloud TPU réservées. Le profil peut inclure un remplacement pour utiliser 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 nécessitant peu de ressources GPU vers Cloud Run et les tâches plus complexes et gourmandes en ressources 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 une journalisation et une surveillance cohérentes à l'aide de Logging et de Monitoring.
  • Répartition de charge globale : pour équilibrer la charge du trafic provenant d'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 Agent Platform ou GKE. Configurez Cloud CDN pour les éléments statiques. Surveillez le trafic et la latence au niveau mondial à l'aide de Monitoring.
  • Gestion du trafic de manière précise : pour les requêtes comportant des types de données ou une complexité divers, ainsi que pour les requêtes de longue durée, mettez en œuvre une gestion du trafic de manière précise.
    • 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 processeurs pour les modèles textuels.
    • Pour les requêtes d'IA générative de longue durée ou les charges de travail par lots, utilisez WebSockets ou gRPC. Implémenter la gestion du trafic pour gérer les délais avant expiration et la mise en mémoire tampon Configurez les délais avant expiration et les nouvelles tentatives de requêtes, 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 améliore la tolérance aux pannes en contenant les défaillances. L'approche modulaire est essentielle pour gérer la complexité, accélérer l'innovation et assurer la maintenance à 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 ultraprécise, implémentez des modules en tant que microservices orchestrés à l'aide de GKE. Empaquetez chaque étape distincte en tant que microservice individuel dans des conteneurs Docker. Ces différentes étapes incluent l'ingestion de données adaptée à différents formats, le prétraitement des données ou l'extraction de caractéristiques spécialisés, l'entraînement de modèles distribués ou l'ajustement de grands modèles de fondation, l'évaluation ou la diffusion.

Déployez les microservices conteneurisés sur GKE et exploitez le scaling automatique en fonction de l'utilisation du processeur et de l'utilisation 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 en utilisant la détection de services GKE. Pour les modèles asynchrones, utilisez des files d'attente de messages telles que 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 parfaits pour les tâches asynchrones telles que le prétraitement ou pour les jobs d'inférence plus petits. Déclenchez des fonctions Cloud Run lors d'événements, par exemple lorsqu'un nouveau fichier de données est créé dans Cloud Storage ou que des mises à jour de modèle sont effectuées dans Artifact Registry. Pour les tâches ou les 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 sont adaptés aux composants modulaires des workflows de conversation de l'agent. Vous pouvez orchestrer des séquences de composants avec Workflows ou Application Integration.

Services gérés Agent Platform

Les services Agent Platform 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 que vous puissiez vous concentrer sur la logique de l'application.

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

Applications agentiques

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

Vous pouvez déployer des agents sur Agent Runtime sur Gemini Enterprise Agent Platform, un environnement d'exécution géré optimisé pour le déploiement d'agents évolutifs. Pour exécuter des agents conteneurisés, vous pouvez exploiter les fonctionnalités d'autoscaling de Cloud Run.

Concevoir des interfaces bien définies

Pour créer des systèmes logiciels robustes et faciles à gérer, 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 significatifs, car elle réduit au maximum 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. 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 hautes performances entre les microservices, utilisez gRPC avec des tampons de protocole (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 critiques, exploitez le streaming gRPC pour les grands ensembles de données ou pour les flux continus tels que les applications de synthèse vocale ou de vidéo en direct. Déployer les services gRPC sur GKE.

Documentation complète et standardisée

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 associés à des schémas JSON et sécurité. Une documentation complète sur l'API permet d'améliorer la visibilité et l'intégration des clients. Pour la création et la visualisation d'API, utilisez des outils d'interface utilisateur tels que Swagger Editor. Pour accélérer le développement et garantir la cohérence, vous pouvez générer des SDK clients et des bouchons de serveur à l'aide d'outils de codage assistés 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 comme Agent Platform

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

  • Le SDK Agent Platform simplifie les tâches et l'authentification. Utilisez le SDK lorsque vous devez interagir avec Agent Platform.
  • 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 d'un SDK ou lorsque vous avez besoin d'un contrôle précis.

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

Pour des raisons de sécurité, d'évolutivité et de visibilité, il est essentiel de mettre en œuvre une gestion d'API robuste pour vos services d'IA et de ML. Pour implémenter la gestion d'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 consolider les points d'accès, d'appliquer des contrats d'API et de gérer des fonctionnalités de sécurité telles que les clés API et OAuth 2.0. Pour protéger les backends contre les surcharges et garantir la fiabilité, implémentez la 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 Endpoints, qui offre une solution conviviale pour 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 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 magasins de caractéristiques.
  • Apigee : pour l'IA et le ML à l'échelle de l'entreprise, en particulier les API d'IA générative sophistiquées, Apigee fournit une gestion d'API avancée et complète. Utilisez Apigee pour bénéficier de fonctionnalités de sécurité avancées, telles que la protection contre les menaces et OAuth 2.0, pour la gestion du trafic (mise en cache, quotas et médiation, par exemple) et pour l'analyse. Apigee peut vous aider à obtenir des insights approfondis sur les tendances d'utilisation, les performances et l'engagement des API, ce qui est crucial pour comprendre l'utilisation des API d'IA générative.

Planifier une 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 élégante 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 élégante 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 mettre en œuvre une dégradation élégante.

Isolation des pannes

  • 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 des charges de travail d'IA et de ML, telles que les taux d'erreur et la latence, et définissez des solutions de remplacement, 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 multizones ou régionaux GKE, 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 des points de contrôle asynchrones pour reprendre l'entraînement après une défaillance. Pour un entraînement résilient et élastique, utilisez Pathways.

Surveillance proactive

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

Les vérifications d'état peuvent déclencher le remplacement des nœuds défectueux, le déploiement d'une capacité supplémentaire, ou le réentraînement ou l'ajustement continu automatique des pipelines qui utilisent des données mises à jour. Cette approche proactive permet d'éviter à la fois la dégradation basée sur la précision et la dégradation élégante au niveau du système, et contribue à améliorer la fiabilité globale.

Pratiques d'ingénierie SRE

Pour surveiller l'état de vos systèmes, envisagez d'adopter des pratiques SRE afin de mettre en œuvre 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 d'ingénierie SRE, consultez le livre sur l'ingénierie SRE de Google.

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

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

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

Pour créer une plate-forme MLOps automatisée de bout en bout, 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 sous la forme d'une série d'étapes connectées et automatisées est un élément central d'une plate-forme MLOps automatisée : de la préparation et de la validation des données à l'entraînement, l'évaluation, le déploiement et la surveillance du modèle.

  • Utiliser les pipelines Agent Platform comme orchestrateur central :
    • Définissez des workflows de bout en bout avec des composants modulaires pour le traitement des données, l'entraînement, l'évaluation et le déploiement.
    • 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.
    • Mettre en place un paramétrage et une gestion des versions automatisés pour chaque exécution du pipeline, et créer un historique des versions.
    • Surveillez la progression du pipeline et l'utilisation des ressources à l'aide de la journalisation et du traçage intégrés, et intégrez les alertes 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 les pipelines de la plate-forme d'agent.
  • Orchestrez les opérations à l'aide de services Google Cloud tels que Dataflow, l'entraînement personnalisé Agent Platform, Model Registry sur Gemini Enterprise Agent Platform et les points de terminaison Agent Platform.
  • 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 (avec intervention humaine) 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 à gérer. Les besoins en infrastructure des systèmes d'IA et de ML sont dynamiques et complexes. Les systèmes nécessitent souvent du matériel spécialisé, comme des GPU et des Cloud TPU. L'IaC permet d'atténuer les risques liés à la gestion manuelle de l'infrastructure en garantissant 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.

Automatisation du 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 de la charge 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 de la plate-forme d'agent configurés pour la mise en service du modèle, 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 toolkit fournit des exemples de plans, 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 à 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 les ressources Agent Platform telles que les ensembles de données, les modèles et les points de terminaison, les instances Cloud SQL, les sujets Pub/Sub et les 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émenter des configurations pour les stratégies et les comptes de service Identity and Access Management (IAM) à l'aide de l'IaC.

Intégrer à l'intégration/la livraison continues (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éfinir des déclencheurs pour les mises à jour automatiques lors des commits de code.
  • Implémenter des tests et une validation automatisés dans le pipeline. Par exemple, vous pouvez créer un script pour exécuter automatiquement les commandes Terraform validate et plan.
  • Stocker les configurations en tant qu'artefacts et activer la gestion des versions.
  • Définissez des environnements distincts, tels que dev, staging et prod, 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 du modèle au fil du temps, automatisez le processus d'entraînement et d'évaluation sur 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 des 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 jobs d'entraînement automatisés, tels que les essais de réglage d'hyperparamètres et les configurations d'entraînement distribué pour les modèles plus volumineux, utilisez l'entraînement personnalisé Agent Platform.
    • Pour l'affinage des modèles de fondation, automatisez le processus d'affinage et intégrez les jobs à vos pipelines.
  • Implémentez la gestion automatique des versions de modèle et stockez de manière sécurisée les artefacts de modèle 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 Agent Platform.
    • Assurez-vous que l'évaluation inclut des métriques spécifiques à la qualité du résultat généré, à l'exactitude des faits, aux attributs de sécurité et au respect du style ou du format spécifié.
  • Pour consigner et suivre automatiquement les paramètres, les versions de code, les versions d'ensemble de données et les résultats de chaque exécution d'entraînement et d'évaluation, utilisez les tests sur Gemini Enterprise Agent Platform. 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 de configurations de modèle optimales en fonction de l'objectif que vous avez défini, utilisez Agent Platform Vizier.
  • Pour visualiser les métriques d'entraînement et déboguer pendant le développement, utilisez Agent Platform 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 vérifier 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, et vous fait 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 automatisée 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 qualité des données à grande échelle basés sur SQL, utilisez des services de traitement évolutifs tels que BigQuery.
    • Pour une validation programmatique complexe sur des données en flux continu ou par lot, utilisez Dataflow.
  • Surveillez les distributions de données au fil du temps grâce aux fonctionnalités de TFDV.
    • Visualisez les tendances à l'aide d'outils intégrés à Monitoring pour détecter la dérive des données. Vous pouvez déclencher automatiquement des pipelines de réentraînement de modèle 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 de l'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, mettez en œuvre 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 à l'aide de bibliothèques de validation de schémas telles que jsonschema pour Python. Validez les objets de configuration par rapport à ces schémas avant le démarrage d'une exécution de 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 paramètres de pipeline à l'aide de bibliothèques d'analyse d'arguments telles que argparse. La validation doit vérifier que les types de données sont corrects, que les valeurs sont valides et que les arguments requis sont présents.
  • Dans Agent Platform Pipelines, définissez les types et les 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 une piste 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 l'exactitude du 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 fichiers tels que CSV, Parquet et les types d'images à 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 les corruptions ou les transferts incomplets à l'aide de la validation des données et de la détection des modifications de Cloud Storage.
  • Effectuez la validation des 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 faciliter leur récupération et leur analyse.

Automatiser le déploiement et mettre en œuvre une surveillance continue

Le déploiement automatisé et la surveillance continue des modèles en production permettent de garantir la fiabilité, d'effectuer des mises à jour rapides et de détecter rapidement les problèmes. Cela implique de gérer les versions de modèle, le déploiement contrôlé, le déploiement automatisé à l'aide de l'intégration et du déploiement continus (CI/CD), ainsi qu'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 d'outils de gestion des versions :

  • Pour suivre les versions et les métadonnées du modèle, et pour lier 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 de 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 pondérations pré-entraînées et les images de conteneur de diffusion dans Artifact Registry, et utilisez ses fonctionnalités de gestion des versions et de taggage.
  • 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 automatisée, et pour intégrer des versions dans des pipelines CI/CD automatisés, utilisez le SDK ou l'API Agent Platform.

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 progressif à l'aide de la fonctionnalité de répartition du trafic des points de terminaison Agent Platform.
  • Si vous déployez votre modèle sur GKE, utilisez des techniques avancées de gestion du trafic, telles que le déploiement Canary :
    1. Acheminez 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. Établir que le modèle est fiable.
    4. Déployez la version pour l'ensemble du trafic.
  • Effectuez des tests A/B sur les agents IA :
    1. Déployez deux versions d'agent de modèle différentes 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 d'entreprise.
  • Mettez en œuvre des mécanismes de rollback automatisés capables de rediriger rapidement le trafic du point 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 Agent Platform.
  • Utilisez 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, gérer les versions des artefacts et déclencher le déploiement sur les points de terminaison de la plate-forme d'agent.
  • Assurez-vous que les pipelines CI/CD gèrent les versions et extraient les images d'Artifact Registry.
  • Avant de basculer le trafic, effectuez des tests de point de terminaison automatisés pour vérifier l'exactitude des prédictions, la latence, le débit et la fonction d'API.
  • Stocker toutes les configurations dans un système de contrôle des versions.

Surveiller en continu

  • Utilisez Model Monitoring sur Agent Platform pour détecter automatiquement la dégradation des performances, la dérive des données (changements dans la distribution des entrées par rapport à l'entraînement) et la dérive des prédictions (changements dans les sorties du modèle).
    • Configurer 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 Monitoring pour les KPI métier.
  • Intégrez les résultats et les métriques personnalisées d'Agent Platform Model Monitoring à Monitoring pour les alertes et les tableaux de bord.
  • Configurez des canaux de notification tels que les e-mails, Slack ou PagerDuty, ainsi que la correction automatisée.
  • Pour déboguer les journaux de prédiction, utilisez Logging.
  • Intégrer 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 :

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

Assurez-vous que le résultat de la surveillance complète est réinjecté dans l'entraînement continu.

Maintenir 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 va au-delà de la disponibilité technique. Il inclut une gouvernance fiable et 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 nuisibles. Une traçabilité complète, un contrôle des accès strict, une validation automatisée et des pratiques transparentes permettent de s'assurer que les résultats de l'IA sont fiables, dignes de confiance et conformes aux 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 traçabilité de vos éléments d'IA et de ML, tenez un registre centralisé et robuste 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 vérité 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ées 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 éléments de données :

  • Créez un catalogue de vos éléments de données à l'échelle de l'entreprise à l'aide de Knowledge Catalog. Pour découvrir et créer automatiquement des inventaires des éléments de données, intégrez Knowledge Catalog à 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 multirégionaux ou birégionaux Cloud Storage. Les données que vous importez dans ces buckets sont stockées de manière redondante dans au moins deux emplacements géographiques distincts. Cette redondance offre une résilience intégrée contre les pannes régionales et contribue à garantir l'intégrité des données.
  • Ajoutez des tags et des annotations à vos ensembles de données avec des métadonnées métier pertinentes, des informations sur la propriété, des niveaux de sensibilité et des 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 répertoire 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 des pipelines de validation.
    • Version de l'ensemble de données utilisée pour l'entraînement, avec traçabilité jusqu'à l'entrée Knowledge Catalog correspondante.
    • Version du code qui a 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 Model Registry, stockez les artefacts de modèle, tels que les fichiers de modèle et les pondérations pré-entraînées, dans un service comme Cloud Storage. Stockez les images de conteneurs personnalisées pour la diffusion ou les jobs d'entraînement personnalisés dans un dépôt sécurisé tel qu'Artifact Registry.
  • Pour vous assurer que les éléments de données et de modèle sont automatiquement enregistrés et mis à jour dans les catalogues respectifs lors de leur création ou de leur modification, implémentez des processus automatisés dans vos pipelines MLOps. Ce catalogage complet assure une traçabilité de bout en bout, des données brutes à la prédiction, ce qui vous permet d'auditer les entrées et les processus qui ont conduit à une version de modèle ou à une prédiction spécifique. La fonctionnalité d'audit est essentielle pour déboguer les comportements inattendus, garantir 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 du modèle de fondation spécifique utilisé, les paramètres de réglage et les résultats d'évaluation spécifiques à la qualité et à la sécurité du résultat généré.

Mettre en œuvre des contrôles des accès et des pistes d'audit robustes

Pour maintenir la confiance et le contrôle de 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.

  • Mettez en œuvre des contrôles d'accès stricts et tenez des pistes d'audit détaillées 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 des stratégies IAM de manière cohérente à tous les éléments 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 Agent Platform, 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 de données critiques ou d'éléments de modèle.
  • Pour l'analyse, les alertes et la visualisation en temps réel, diffusez les journaux d'audit vers Logging.
  • Pour un stockage à long terme économique et une analyse de sécurité rétrospective 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 pistes d'audit pour vous assurer qu'elles sont conformes à vos exigences de gouvernance et détecter les cas de non-respect des règles.
  • Pour les applications qui gèrent 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 Sensitive Data Protection dans les pipelines ou sur le datastore.
  • Pour l'IA générative et les solutions d'agents, utilisez des pistes d'audit pour suivre qui a accédé à des modèles ou des 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 pistes d'audit vous aident à garantir la responsabilité et fournissent des données cruciales pour enquêter sur l'utilisation abusive des données ou les cas de non-respect des règles.

Gérer les biais, la transparence et l'explicabilité

Pour créer des systèmes d'IA et de ML fiables, vous devez éliminer 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 une explicabilité pour les sorties du modèle. Il est particulièrement crucial de créer des systèmes fiables dans les domaines sensibles ou lorsque vous utilisez des modèles complexes, comme ceux 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 décalages dans les distributions de caractéristiques entre différents groupes démographiques ou attributs sensibles.
  • Évaluez les performances globales du modèle et les performances sur des segments de données prédéfinis. Cette évaluation vous aide à identifier les disparités de performances ou les biais qui affectent des sous-groupes spécifiques.

Pour assurer 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 effectué 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 Agent Platform, générez des attributions de caractéristiques, qui indiquent les caractéristiques d'entrée ayant 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 la confiance ou prendre des décisions, fournissez des données d'explicabilité 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 l'apparition de biais ou d'iniquité en mettant en place 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 Model Registry.

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

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

  • Adopter les principes d'ingénierie SRE
  • Définissez des objectifs de fiabilité clairs.
  • Suivez les métriques sur les différentes couches du système.
  • Utilisez les insights de l'observabilité pour une amélioration continue et une gestion proactive.

Pour mettre en œuvre des pratiques d'observabilité et de fiabilité globales pour les charges de travail d'IA et de ML dans Google Cloud, tenez compte des recommandations suivantes.

Établir des objectifs de fiabilité et des métriques d'entreprise

Identifiez les indicateurs clés de performance (KPI) directement affectés par votre système d'IA et de ML. Les KPI peuvent inclure les revenus influencés par les recommandations de l'IA, le taux de désabonnement des clients prédit ou atténué par les systèmes d'IA, ainsi que l'engagement utilisateur et les taux de conversion 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 :

  • Le taux de réussite des requêtes utilisateur.
  • La latence des réponses : délai d'émission du premier jeton (TTFT) et streaming de jetons pour les LLM.
  • Le 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 et alignés sur les objectifs d'entreprise globaux. Adoptez l'approche SRE en définissant des SLO qui quantifient les niveaux acceptables de fiabilité et de performances de vos services d'IA et de ML du point de vue des utilisateurs. Quantifiez ces métriques de fiabilité technique avec des objectifs 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 sorties nuisibles doit être inférieur à 0,1 %.

L'alignement des SLO directement sur les besoins de l'entreprise garantit 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 de 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 Cloud TPU), l'utilisation de la mémoire, le débit et la latence du réseau, ainsi que les E/S du disque. Suivez les métriques des environnements gérés, comme l'entraînement et la mise en service Agent Platform, et des ressources autogérées, comme 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 de réponse aux requêtes.
  • Trafic : volume de requêtes ou de 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 Cloud TPU, qui indique à quel point votre système est proche de ses 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 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 en fonction des indicateurs de performances spécifiques de votre charge de travail et de 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 Logging. Ces journaux sont essentiels pour le dépannage et l'analyse des performances. Ils fournissent du contexte sur les événements et les erreurs.
  • Identifiez les problèmes de latence et comprenez les flux de requêtes entre les microservices d'IA et de ML distribués à l'aide de Cloud Trace. Cette fonctionnalité est cruciale pour déboguer des interactions complexes de conversation d'agent ou des pipelines d'inférence à plusieurs composants.
  • Identifiez les goulots d'étranglement des performances dans les blocs de fonction du code d'application à l'aide de Cloud Profiler. L'identification des goulots d'étranglement des performances peut vous aider à optimiser l'utilisation des ressources et le temps d'exécution.
  • Recueillez des métriques spécifiques liées aux accélérateurs, telles que 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 le gestionnaire de GPU du centre de données NVIDIA (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 une surveillance de bout en bout des pipelines.

  • Suivez les taux d'ingestion des 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 Agent Platform Pipelines.

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

  • Gérer et gouverner les données à l'aide de Knowledge Catalog :
    • Évaluez la précision en validant par rapport à la vérité terrain ou en suivant les taux de détection des anomalies.
    • Surveillez la fraîcheur des données en fonction de leur ancienneté 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 des données en vérifiant l'adhérence au schéma et la duplication.
  • Détectez les anomalies de manière proactive à l'aide des alertes Monitoring et d'une traçabilité claire 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é du modèle incluent le nombre de jetons d'entrée et de sortie, ainsi que les taux d'erreur spécifiques au modèle, tels que les hallucinations ou les échecs de résolution des requêtes. Pour suivre ces métriques, utilisez Agent Platform Model Monitoring.

  • Surveillez en permanence les scores de toxicité des résultats et les évaluations des commentaires des utilisateurs.
  • Automatisez l'évaluation des sorties 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 afin de résoudre les problèmes de performances, vous pouvez profiler des modèles sur des VM Cloud TPU ou utiliser NVIDIA Nsight.

Contributeurs

Auteurs :

  • Rick (Rugui) Chen | Architecte de solutions sur le terrain pour l'infrastructure d'IA
  • Stef Ruinard | Architecte de solutions d'IA générative sur le terrain

Autres contributeurs :

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