Déployer et exploiter des applications d'IA générative

Last reviewed 2024-11-19 UTC

L'IA générative a introduit une nouvelle façon de créer et d'exploiter des applications d'IA, différente de l'IA prédictive. Pour créer une application d'IA générative, vous devez choisir parmi un large éventail d'architectures et de tailles, organiser les données, concevoir des requêtes optimales, ajuster les modèles pour des tâches spécifiques et ancrer les sorties de modèle dans des données réelles.

Ce document explique comment adapter les processus DevOps et MLOps pour développer, déployer et exploiter des applications d'IA générative sur des modèles de fondation existants. Pour en savoir plus sur le déploiement de l'IA prédictive, consultez MLOps : pipelines de livraison continue et d'automatisation dans le machine learning.

Que sont le DevOps et le MLOps ?

Le DevOps est une méthodologie d'ingénierie logicielle qui relie le développement et les opérations. DevOps favorise la collaboration, l'automatisation et l'amélioration continue pour rationaliser le cycle de vie du développement logiciel, en utilisant des pratiques telles que l'intégration et la livraison continues (CI/CD).

Le MLOps s'appuie sur les principes DevOps pour relever les défis liés à la création et à l'exploitation de systèmes de machine learning (ML). Les systèmes de machine learning utilisent généralement l'IA prédictive pour identifier des modèles et faire des prédictions. Le workflow MLOps comprend les éléments suivants :

• Validation des données
• Entraînement du modèle
• Évaluation et itération du modèle
• Déploiement et exécution d'un modèle
• Surveillance des modèles

Que sont les modèles de fondation ?

Les modèles de fondation sont le composant principal d'une application d'IA générative. Ces modèles sont de grands programmes qui utilisent des ensembles de données pour apprendre et prendre des décisions sans intervention humaine. Les modèles de fondation sont entraînés sur de nombreux types de données, y compris du texte, des images, de l'audio et des vidéos. Les modèles de fondation incluent les grands modèles de langage (LLM) tels que Llama 3.1 et les modèles multimodaux tels que Gemini.

Contrairement aux modèles d'IA prédictifs, qui sont entraînés pour des tâches spécifiques sur des ensembles de données ciblés, les modèles de fondation sont entraînés sur des ensembles de données volumineux et diversifiés. Cette formation vous permet d'utiliser des modèles de fondation pour développer des applications pour de nombreux cas d'utilisation différents. Les modèles de fondation possèdent des propriétés émergentes (PDF), qui leur permettent de fournir des réponses à des entrées spécifiques sans entraînement explicite. En raison de ces propriétés émergentes, les modèles de base sont difficiles à créer et à exploiter, et vous devez adapter vos processus DevOps et MLOps.

Le développement d'un modèle de fondation nécessite d'importantes ressources de données, du matériel spécialisé, un investissement important et une expertise spécialisée. Par conséquent, de nombreuses entreprises préfèrent utiliser des modèles de fondation existants pour simplifier le développement et le déploiement de leurs applications d'IA générative.

Cycle de vie d'une application d'IA générative

Le cycle de vie d'une application d'IA générative comprend les phases suivantes :

• Découverte : les développeurs et les ingénieurs en IA identifient le modèle de fondation le plus adapté à leur cas d'utilisation. Ils tiennent compte des points forts, des points faibles et des coûts de chaque modèle pour prendre une décision éclairée.
• Développement et expérimentation : les développeurs utilisent l'ingénierie des requêtes pour créer et affiner les requêtes d'entrée afin d'obtenir le résultat souhaité. Lorsqu'ils sont disponibles, l'apprentissage à partir de quelques exemples, l'affinage des paramètres avec optimisation (PEFT) et l'enchaînement de modèles permettent de guider le comportement du modèle. L'enchaînement de modèles consiste à orchestrer les appels à plusieurs modèles dans une séquence spécifique pour créer un workflow.
• Déploiement : les développeurs doivent gérer de nombreux artefacts lors du déploiement, y compris les modèles d'invite, les définitions de chaînes, les modèles intégrés, les magasins de données de récupération et les adaptateurs de modèles affinés. Ces artefacts ont leurs propres exigences de gouvernance et nécessitent une gestion minutieuse tout au long du développement et du déploiement. Le déploiement d'applications d'IA générative doit également tenir compte des capacités techniques de l'infrastructure cible, en veillant à ce que les exigences matérielles des applications soient respectées.
• Surveillance continue en production : les administrateurs améliorent les performances des applications et respectent les normes de sécurité grâce à des techniques d'IA responsable, comme l'équité, la transparence et la responsabilité dans les résultats du modèle.
• Amélioration continue : les développeurs ajustent constamment les modèles de fondation à l'aide de techniques d'incitation, en remplaçant les modèles par des versions plus récentes ou même en combinant plusieurs modèles pour améliorer les performances, la rentabilité ou réduire la latence. L'entraînement continu conventionnel reste pertinent pour les scénarios où un réglage fin récurrent ou l'intégration de boucles de feedback humain sont nécessaires.

Les pratiques d'ingénierie des données jouent un rôle essentiel à toutes les étapes du développement. Pour créer des résultats fiables, vous devez disposer d'un ancrage factuel (qui garantit que les résultats du modèle sont basés sur des informations exactes et à jour) et de données récentes provenant de systèmes internes et d'entreprise. Les données de réglage permettent d'adapter les modèles à des tâches et des styles spécifiques, et de corriger les erreurs persistantes.

Trouver le modèle de fondation adapté à votre cas d'utilisation

Étant donné que la création de modèles de fondation nécessite de nombreuses ressources, la plupart des entreprises préfèrent utiliser un modèle de fondation existant qui est optimal pour leur cas d'utilisation. Il est difficile de trouver le bon modèle de fondation, car il en existe de nombreux. Chaque modèle possède des architectures, des tailles, des ensembles de données d'entraînement et des licences différents. De plus, chaque cas d'utilisation présente des exigences uniques, ce qui vous oblige à analyser les modèles disponibles selon plusieurs dimensions.

Tenez compte des facteurs suivants lorsque vous évaluez des modèles :

• Qualité : exécutez des requêtes de test pour évaluer la qualité des résultats.
• Latence et débit : déterminez la latence et le débit adaptés à votre cas d'utilisation, car ces facteurs ont un impact direct sur l'expérience utilisateur. Par exemple, un chatbot nécessite une latence plus faible que les tâches de synthèse traitées par lots.
• Temps de développement et de maintenance : tenez compte du temps nécessaire au développement initial et à la maintenance continue. Les modèles gérés nécessitent souvent moins d'efforts que les modèles disponibles publiquement que vous déployez vous-même.
• Coût d'utilisation : tenez compte des coûts d'infrastructure et de consommation associés au modèle.
• Conformité : évaluez la capacité du modèle à respecter les réglementations et les conditions de licence applicables.

Développer et tester

Lorsque vous créez des applications d'IA générative, le développement et l'expérimentation sont itératifs et orchestrés. Chaque itération expérimentale implique d'affiner les données, d'adapter le modèle de base et d'évaluer les résultats. L'évaluation fournit des commentaires qui guident les itérations suivantes dans une boucle de rétroaction continue. Si les performances ne répondent pas à vos attentes, vous pouvez collecter davantage de données, les augmenter ou les affiner. De plus, vous devrez peut-être optimiser les requêtes, appliquer des techniques d'affinage ou passer à un autre modèle de fondation. Ce cycle d'affinage itératif, basé sur les insights d'évaluation, est tout aussi important pour optimiser les applications d'IA générative que pour le machine learning et l'IA prédictive.

Paradigme du modèle de fondation

Les modèles de fondation diffèrent des modèles prédictifs, car ils sont polyvalents. Au lieu d'être entraînés pour un seul objectif sur des données spécifiques à cette tâche, les modèles de fondation sont entraînés sur de grands ensembles de données, ce qui vous permet de les appliquer à de nombreux cas d'utilisation différents.

Les modèles de fondation sont également très sensibles aux modifications de leurs entrées. La sortie du modèle et la tâche qu'il effectue sont déterminées par l'entrée du modèle. Un modèle de fondation peut traduire du texte, générer des vidéos ou classer des données en modifiant simplement l'entrée. Même des modifications insignifiantes apportées à l'entrée peuvent affecter la capacité du modèle à effectuer correctement cette tâche.

Ces propriétés des modèles de fondation nécessitent des pratiques de développement et opérationnelles différentes. Bien que les modèles dans le contexte de l'IA prédictive soient autonomes et spécifiques à une tâche, les modèles de fondation sont polyvalents et nécessitent un élément supplémentaire au-delà de l'entrée utilisateur. Les modèles d'IA générative nécessitent une invite, et plus précisément un modèle d'invite. Un modèle de requête est un ensemble d'instructions et d'exemples, ainsi que des espaces réservés pour les saisies utilisateur. L'application peut combiner le modèle de requête et les données dynamiques (telles que la saisie de l'utilisateur) pour créer une requête complète, c'est-à-dire le texte transmis en entrée au modèle de fondation.

Composant de modèle sollicité

La présence d'une requête est une caractéristique distinctive des applications d'IA générative. Le modèle et la requête ne suffisent pas à générer du contenu. L'IA générative a besoin des deux. La combinaison du modèle et de l'invite est appelée composant de modèle sollicité. Le composant de modèle sollicité est le plus petit composant indépendant suffisant pour créer une application d'IA générative. La requête n'a pas besoin d'être compliquée. Par exemple, il peut s'agir d'une instruction simple, telle que "traduis la phrase suivante de l'anglais vers le français", suivie de la phrase à traduire. Toutefois, sans cette instruction préliminaire, un modèle de fondation n'effectuera pas la tâche de traduction requise. Une requête, même une simple instruction, est donc nécessaire en plus de l'entrée pour que le modèle de fondation effectue la tâche requise par l'application.

Le composant de modèle sollicité crée une distinction importante pour les pratiques MLOps lors du développement d'applications d'IA générative. Lors du développement d'une application d'IA générative, l'expérimentation et l'itération doivent être effectuées dans le contexte d'un composant de modèle incité. Le cycle d'expérimentation de l'IA générative commence généralement par tester des variantes de la requête (en modifiant la formulation des instructions, en fournissant un contexte supplémentaire ou en incluant des exemples pertinents) et en évaluant l'impact de ces modifications. Cette pratique est communément appelée prompt engineering.

L'ingénierie des requêtes implique les étapes itératives suivantes :

• Ingénierie des prompts : créez et affinez des requêtes pour obtenir les comportements souhaités d'un modèle de fondation pour un cas d'utilisation spécifique.
• Évaluation : évaluez les sorties du modèle, idéalement de manière programmatique, pour évaluer sa compréhension et sa capacité à répondre aux instructions de la requête.

Pour suivre les résultats de l'évaluation, vous pouvez éventuellement enregistrer les résultats d'un test. Étant donné que la requête elle-même est un élément essentiel du processus d'ingénierie des requêtes, elle devient l'artefact le plus important parmi ceux qui font partie de l'expérience.

Toutefois, pour expérimenter une application d'IA générative, vous devez identifier les types d'artefacts. Dans l'IA prédictive, les données, les pipelines et le code sont différents. Toutefois, avec le paradigme des requêtes dans l'IA générative, les requêtes peuvent inclure du contexte, des instructions, des exemples, des consignes et des données internes ou externes réelles extraites d'ailleurs.

Pour déterminer le type d'artefact, vous devez reconnaître qu'une invite comporte différents composants et nécessite différentes stratégies de gestion. Réfléchissez aux éléments suivants :

• Requête en tant que données : certaines parties de la requête agissent comme des données. Les éléments tels que les exemples few-shot, les bases de connaissances et les requêtes utilisateur sont essentiellement des points de données. Ces composants nécessitent des pratiques MLOps axées sur les données, telles que la validation des données, la détection de la dérive et la gestion du cycle de vie.
• Le prompt en tant que code : les autres composants tels que le contexte, les modèles de prompts et les garde-fous sont semblables au code. Ces composants définissent la structure et les règles de la requête elle-même, et nécessitent des pratiques plus axées sur le code, telles que les processus d'approbation, le versionnage du code et les tests.

Par conséquent, lorsque vous appliquez des pratiques MLOps à l'IA générative, vous devez disposer de processus qui permettent aux développeurs de stocker, de récupérer, de suivre et de modifier facilement les requêtes. Ces processus permettent une itération rapide et une expérimentation basée sur des principes. Il arrive souvent qu'une version d'une requête fonctionne bien avec une version spécifique du modèle, mais pas avec une autre. Lorsque vous suivez les résultats d'un test, vous devez enregistrer la requête, les versions des composants, la version du modèle, les métriques et les données de sortie.

Chaînage et augmentation de modèles

Les modèles d'IA générative, en particulier les grands modèles de langage (LLM), sont confrontés à des défis inhérents pour maintenir l'actualité et éviter les hallucinations. L'encodage de nouvelles informations dans les LLM nécessite un pré-entraînement coûteux et gourmand en données avant de pouvoir être déployé. Selon le cas d'utilisation, il peut être insuffisant d'utiliser un seul modèle sollicité pour effectuer une génération particulière. Pour résoudre ce problème, vous pouvez connecter plusieurs modèles sollicités, ainsi que des appels à des API externes et une logique exprimée sous forme de code. Une séquence de composants de modèle sollicités connectés de cette manière est communément appelée chaîne.

Le schéma suivant montre les composants d'une chaîne et le processus de développement associé.

Atténuation de la récence et des hallucinations

Deux modèles courants basés sur des chaînes qui peuvent atténuer la récence et les hallucinations sont la génération augmentée par récupération (RAG, PDF) et les agents.

• Le RAG augmente les modèles pré-entraînés avec des connaissances extraites de bases de données, ce qui évite le pré-entraînement. La génération augmentée par récupération (RAG) permet d'ancrer les informations et de réduire les hallucinations en intégrant des informations factuelles à jour directement dans le processus de génération.
• Les agents, popularisés par la technique d'incitation ReAct (PDF), utilisent des LLM comme médiateurs qui interagissent avec divers outils, y compris des systèmes RAG, des API internes ou externes, des extensions personnalisées ou même d'autres agents. Les agents permettent d'effectuer des requêtes complexes et des actions en temps réel en sélectionnant et en utilisant de manière dynamique des sources d'informations pertinentes. Le LLM, agissant en tant qu'agent, interprète la requête de l'utilisateur, décide de l'outil à utiliser et formule la réponse en fonction des informations récupérées.

Vous pouvez utiliser le RAG et les agents pour créer des systèmes multi-agents connectés à de grands réseaux d'informations, ce qui permet de gérer les requêtes de manière sophistiquée et de prendre des décisions en temps réel.

L'orchestration de différents modèles, logiques et API n'est pas nouvelle pour les applications d'IA générative. Par exemple, les moteurs de recommandations combinent des modèles de filtrage collaboratif, des modèles basés sur le contenu et des règles métier pour générer des recommandations de produits personnalisées pour les utilisateurs. De même, dans la détection des fraudes, les modèles de machine learning sont intégrés à des systèmes basés sur des règles et à des sources de données externes pour identifier les activités suspectes.

Ce qui différencie ces chaînes de composants d'IA générative, c'est que vous ne pouvez pas caractériser la distribution des entrées de composants à l'avance, ce qui rend les composants individuels beaucoup plus difficiles à évaluer et à gérer de manière isolée. L'orchestration entraîne un changement de paradigme dans la façon dont vous développez des applications d'IA pour l'IA générative.

Dans l'IA prédictive, vous pouvez itérer sur les modèles et composants distincts de manière isolée, puis les enchaîner dans l'application d'IA. Dans l'IA générative, vous développez une chaîne lors de l'intégration, effectuez des tests de bout en bout sur la chaîne et itérez les stratégies d'enchaînement, les requêtes, les modèles de fondation et d'autres API de manière coordonnée pour atteindre un objectif spécifique. Vous n'avez souvent pas besoin d'extraction de caractéristiques, de collecte de données ni d'autres cycles d'entraînement du modèle. Il vous suffit de modifier la formulation du modèle de requête.

Le passage des MLOps pour l'IA prédictive aux MLOps pour l'IA générative entraîne les différences suivantes :

• Évaluation : en raison du couplage étroit des chaînes, celles-ci nécessitent une évaluation de bout en bout, et pas seulement pour chaque composant, afin d'évaluer leurs performances globales et la qualité de leur sortie. En termes de techniques et de métriques d'évaluation, l'évaluation des chaînes est semblable à celle des modèles sollicités.
• Gestion des versions : vous devez gérer une chaîne comme un artefact complet dans son intégralité. Vous devez suivre la configuration de la chaîne avec son propre historique des révisions pour l'analyse, la reproductibilité et pour comprendre les effets des modifications sur la sortie. Vos journaux doivent inclure les entrées, les sorties, les états intermédiaires de la chaîne et toutes les configurations de chaîne utilisées lors de chaque exécution.
• Surveillance continue : pour détecter une dégradation des performances, une dérive des données ou un comportement inattendu dans la chaîne, vous devez configurer des systèmes de surveillance proactive. La surveillance continue permet d'identifier rapidement les problèmes potentiels afin de maintenir la qualité des résultats générés.
• Introspection : vous devez inspecter les flux de données internes d'une chaîne (c'est-à-dire les entrées et les sorties de chaque composant), ainsi que les entrées et les sorties de l'ensemble de la chaîne. En offrant une visibilité sur les données qui transitent par la chaîne et sur le contenu qui en résulte, les développeurs peuvent identifier les sources d'erreurs, de biais ou de comportements indésirables.

Le schéma suivant montre comment les chaînes, les composants de modèle sollicités et l'ajustement de modèle fonctionnent ensemble dans une application d'IA générative pour réduire la récence et les hallucinations. Les données sont organisées, les modèles sont réglés et les chaînes sont ajoutées pour affiner davantage les réponses. Une fois les résultats évalués, les développeurs peuvent consigner le test et continuer à itérer.

Affinage

Lorsque vous développez un cas d'utilisation de l'IA générative impliquant des modèles de fondation, il peut être difficile, en particulier pour les tâches complexes, de s'appuyer uniquement sur l'ingénierie et l'enchaînement des requêtes pour résoudre le cas d'utilisation. Pour améliorer les performances des tâches, les développeurs doivent souvent affiner directement le modèle. L'affinage vous permet de modifier activement toutes les couches ou un sous-ensemble de couches (affinage efficace des paramètres) du modèle pour optimiser sa capacité à effectuer une tâche spécifique. Voici les méthodes les plus courantes pour ajuster un modèle :

• Réglage fin supervisé : vous entraînez le modèle de manière supervisée, en lui apprenant à prédire la bonne séquence de sortie pour une entrée donnée.
• Apprentissage par renforcement qui utilise le feedback humain (RLHF) : vous entraînez un modèle de récompense pour prédire ce que les humains préféreraient comme réponse. Vous utilisez ensuite ce modèle de récompense pour orienter le LLM dans la bonne direction lors du processus d'ajustement. Ce processus est semblable à celui où un panel de juges humains guide l'apprentissage du modèle.

Le schéma suivant montre comment le réglage permet d'affiner le modèle pendant le cycle d'expérimentation.

Dans MLOps, le réglage fin partage les fonctionnalités suivantes avec l'entraînement de modèles :

• La possibilité de suivre les artefacts qui font partie du job d'optimisation. Par exemple, les artefacts incluent les données d'entrée ou les paramètres utilisés pour ajuster le modèle.
• La possibilité de mesurer l'impact de l'optimisation. Cette fonctionnalité vous permet d'évaluer le modèle ajusté pour les tâches spécifiques pour lesquelles il a été entraîné et de comparer les résultats avec les modèles ajustés ou figés précédents pour la même tâche.

Entraînement et réglage continus

Dans le MLOps, l'entraînement continu consiste à réentraîner à plusieurs reprises des modèles de machine learning dans un environnement de production. L'entraînement continu permet de s'assurer que le modèle reste à jour et qu'il fonctionne bien à mesure que les tendances des données réelles évoluent au fil du temps. Pour les modèles d'IA générative, l'ajustement continu des modèles est souvent plus pratique qu'un processus de réentraînement en raison des coûts élevés de données et de calcul impliqués.

L'approche du réglage continu dépend de votre cas d'utilisation et de vos objectifs spécifiques. Pour les tâches relativement statiques comme la synthèse de texte, les exigences de réglage continu peuvent être moins élevées. Toutefois, pour les applications dynamiques telles que les chatbots qui nécessitent un alignement humain constant, un réglage plus fréquent à l'aide de techniques telles que le RLHF (apprentissage par renforcement à partir du feedback humain) est nécessaire.

Pour déterminer la stratégie d'ajustement continu appropriée, vous devez évaluer la nature de votre cas d'utilisation et la façon dont les données d'entrée évoluent au fil du temps. Le coût est également un facteur majeur, car l'infrastructure de calcul a une incidence considérable sur la vitesse et les dépenses d'ajustement. Les processeurs graphiques (GPU) et les Tensor Processing Units (TPU) sont des composants matériels nécessaires pour l'affinage. Les GPU, connus pour leur puissance de traitement parallèle, sont très efficaces pour gérer les charges de travail intensives en calcul et sont souvent associés à l'entraînement et à l'exécution de modèles de machine learning complexes. Les TPU, quant à eux, sont spécifiquement conçus par Google pour accélérer les tâches de machine learning. Les TPU excellent dans la gestion des opérations matricielles de grande taille courantes dans les réseaux de neurones de deep learning.

Pratiques en matière de données

Auparavant, le comportement d'un modèle de ML était dicté uniquement par ses données d'entraînement. Bien que cela reste vrai pour les modèles de fondation, le comportement du modèle pour les applications d'IA générative basées sur des modèles de fondation est déterminé par la façon dont vous adaptez le modèle avec différents types de données d'entrée.

Les modèles de fondation sont entraînés sur des données telles que les suivantes :

• Ensembles de données de préentraînement (par exemple, C4, The Pile ou données propriétaires)
• Ensembles de données pour le réglage des instructions
• Ensembles de données de réglage de la sécurité
• Données de préférences humaines

Les applications d'IA générative sont adaptées aux données suivantes :

• Requêtes
• Données augmentées ou ancrées (par exemple, sites Web, documents, PDF, bases de données ou API)
• Données spécifiques à une tâche pour PEFT
• Évaluations spécifiques à une tâche
• Données de préférences humaines

La principale différence entre le ML prédictif et l'IA générative en termes de pratiques liées aux données se situe au début du cycle de vie. Dans le ML prédictif, vous passez beaucoup de temps à l'ingénierie des données. Si vous ne disposez pas des bonnes données, vous ne pouvez pas créer d'application. Dans l'IA générative, vous commencez par un modèle de base, des instructions et éventuellement quelques exemples d'entrées (comme l'apprentissage dans le contexte). Vous pouvez prototyper et lancer une application avec très peu de données.

Cependant, la facilité de prototypage s'accompagne du défi supplémentaire de la gestion de données diverses. L'IA prédictive s'appuie sur des ensembles de données bien définis. Dans l'IA générative, une seule application peut utiliser différents types de données provenant de sources de données complètement différentes, qui fonctionnent toutes ensemble.

Voici quelques types de données :

• Requêtes de conditionnement : instructions fournies au modèle de fondation pour guider sa sortie et définir les limites de ce qu'il peut générer.
• Exemples few-shot : méthode permettant de montrer au modèle ce que vous souhaitez obtenir à l'aide de paires entrée/sortie. Ces exemples aident le modèle à comprendre les tâches spécifiques. Dans de nombreux cas, ils peuvent améliorer les performances.
• Données d'ancrage ou d'augmentation : données qui permettent au modèle de fondation de produire des réponses pour un contexte spécifique et de les maintenir à jour et pertinentes sans réentraîner l'ensemble du modèle de fondation. Ces données peuvent provenir d'API externes (comme la recherche Google) ou de sources de données et d'API internes.
• Ensembles de données spécifiques à une tâche : ensembles de données qui permettent d'affiner un modèle de base existant pour une tâche particulière, ce qui améliore ses performances dans ce domaine spécifique.
• Ensembles de données de pré-entraînement complets : ensembles de données volumineux utilisés pour entraîner initialement les modèles de base. Bien que les développeurs d'applications n'y aient pas accès, les informations encodées dans le modèle lui-même influencent le résultat et les performances de l'application.

Cette diversité de types de données ajoute une couche de complexité en termes d'organisation, de suivi et de gestion du cycle de vie des données. Par exemple, une application basée sur RAG peut réécrire les requêtes des utilisateurs, collecter dynamiquement des exemples pertinents à l'aide d'un ensemble d'exemples sélectionnés, interroger une base de données vectorielle et combiner les informations avec un modèle de requête. Une application basée sur le RAG vous oblige à gérer plusieurs types de données, y compris les requêtes utilisateur, les bases de données vectorielles avec des exemples few-shot sélectionnés et des informations sur l'entreprise, ainsi que les modèles d'invite.

Chaque type de données doit être organisé et géré avec soin. Par exemple, une base de données vectorielle nécessite de traiter les données en embeddings, d'optimiser les stratégies de segmentation et de s'assurer que seules les informations pertinentes sont disponibles. Un modèle d'invite doit être versionné et suivi, et les requêtes utilisateur doivent être réécrites. Les bonnes pratiques MLOps et DevOps peuvent vous aider à effectuer ces tâches. Dans l'IA prédictive, vous créez des pipelines de données pour l'extraction, la transformation et le chargement. Dans l'IA générative, vous créez des pipelines pour gérer, faire évoluer, adapter et intégrer différents types de données de manière versionnable, traçable et reproductible.

L'affinage des modèles de fondation peut améliorer les performances des applications d'IA générative, mais les modèles ont besoin de données. Vous pouvez obtenir ces données en lançant votre application et en collectant des données réelles, en générant des données synthétiques ou en combinant les deux. L'utilisation de grands modèles pour générer des données synthétiques est de plus en plus populaire, car cette méthode accélère le processus de déploiement. Toutefois, il est toujours important que des humains vérifient les résultats pour s'assurer de leur qualité. Voici quelques exemples d'utilisation de grands modèles à des fins d'ingénierie des données :

• Génération de données synthétiques : ce processus consiste à créer des données artificielles qui ressemblent beaucoup aux données réelles en termes de caractéristiques et de propriétés statistiques. Les modèles volumineux et performants effectuent souvent cette tâche. Les données synthétiques servent de données d'entraînement supplémentaires pour l'IA générative, ce qui lui permet d'apprendre des schémas et des relations même lorsque les données réelles étiquetées sont rares.
• Correction des données synthétiques : cette technique vise à identifier et à corriger les erreurs et les incohérences dans les ensembles de données étiquetés existants. Grâce à la puissance de modèles plus grands, l'IA générative peut signaler les erreurs d'étiquetage potentielles et proposer des corrections pour améliorer la qualité et la fiabilité des données d'entraînement.
• Augmentation des données synthétiques : cette approche va au-delà de la génération de nouvelles données. L'augmentation des données synthétiques consiste à manipuler intelligemment les données existantes pour créer des variations diverses tout en préservant les caractéristiques et les relations essentielles. L'IA générative peut rencontrer un plus large éventail de scénarios que l'IA prédictive lors de l'entraînement, ce qui améliore la généralisation et la capacité à générer des résultats nuancés et pertinents.

Contrairement à l'IA prédictive, l'IA générative est difficile à évaluer. Par exemple, vous ne connaissez peut-être pas la distribution des données d'entraînement des modèles de fondation. Vous devez créer un ensemble de données d'évaluation personnalisé qui reflète tous vos cas d'utilisation, y compris les cas essentiels, moyens et extrêmes. Comme pour les données de réglage fin, vous pouvez utiliser des LLM puissants pour générer, organiser et augmenter les données afin de créer des ensembles de données d'évaluation robustes.

Évaluation

Le processus d'évaluation est une activité essentielle du développement d'applications d'IA générative. L'évaluation peut avoir différents degrés d'automatisation : elle peut être entièrement effectuée par des humains ou entièrement automatisée par un processus.

Lorsque vous prototypez un projet, l'évaluation est souvent un processus manuel. Les développeurs examinent les résultats du modèle pour obtenir une idée qualitative de ses performances. Toutefois, à mesure que le projet mûrit et que le nombre de scénarios de test augmente, l'évaluation manuelle devient un goulot d'étranglement.

L'automatisation de l'évaluation présente deux grands avantages : elle vous permet d'avancer plus rapidement et rend les évaluations plus fiables. Il élimine également la subjectivité humaine, ce qui permet de garantir la reproductibilité des résultats.

Cependant, l'automatisation de l'évaluation des applications d'IA générative présente des défis qui lui sont propres. Nous vous conseillons, par exemple, de suivre les recommandations suivantes :

• Les entrées (requêtes) et les sorties peuvent être extrêmement complexes. Une même requête peut inclure plusieurs instructions et contraintes que le modèle doit gérer. Les sorties elles-mêmes sont souvent de grande dimension, comme une image générée ou un bloc de texte. Il est difficile de capturer la qualité de ces résultats dans une métrique simple. Certaines métriques établies, comme BLEU pour les traductions et ROUGE pour les résumés, ne sont pas toujours suffisantes. Vous pouvez donc utiliser des méthodes d'évaluation personnalisées ou un autre modèle de base pour évaluer votre système. Par exemple, vous pouvez demander à un grand modèle de langage (tel que AutoSxS) d'évaluer la qualité des textes générés selon différentes dimensions.
• De nombreuses métriques d'évaluation pour l'IA générative sont subjectives. Ce qui rend une sortie meilleure qu'une autre peut être une question d'opinion. Vous devez vous assurer que votre évaluation automatisée correspond au jugement humain, car vous souhaitez que vos métriques soient un indicateur fiable de ce que les utilisateurs penseraient. Pour garantir la comparabilité entre les tests, vous devez déterminer votre approche d'évaluation et vos métriques dès le début du processus de développement.
• Manque de données de vérité terrain, en particulier au début d'un projet. Une solution consiste à générer des données synthétiques qui serviront de vérité terrain temporaire et que vous pourrez affiner au fil du temps grâce aux commentaires des utilisateurs.
• Une évaluation complète est essentielle pour protéger les applications d'IA générative contre les attaques par prompts antagonistes. Les acteurs malveillants peuvent créer des requêtes pour tenter d'extraire des informations sensibles ou de manipuler les sorties du modèle. Les ensembles d'évaluation doivent spécifiquement traiter ces vecteurs d'attaque, grâce à des techniques telles que le fuzzing de requêtes (qui consiste à fournir au modèle des variations aléatoires de requêtes) et les tests de fuite d'informations.

Pour évaluer les applications d'IA générative, implémentez les éléments suivants :

• Automatisez le processus d'évaluation pour garantir la rapidité, l'évolutivité et la reproductibilité. Vous pouvez considérer l'automatisation comme un substitut au jugement humain.
• Personnalisez le processus d'évaluation en fonction de vos cas d'utilisation.
• Pour garantir la comparabilité, stabilisez l'approche d'évaluation, les métriques et les données de vérité terrain le plus tôt possible dans la phase de développement.
• Générez des données de vérité terrain synthétiques pour compenser le manque de données de vérité terrain réelles.
• Incluez des scénarios de test d'incitation contradictoire dans l'ensemble d'évaluation pour tester la fiabilité du système lui-même face à ces attaques.

Déployer

Les applications d'IA générative de niveau production sont des systèmes complexes comportant de nombreux composants interactifs. Pour déployer une application d'IA générative en production, vous devez gérer et coordonner ces composants avec les étapes précédentes du développement d'applications d'IA générative. Par exemple, une même application peut utiliser plusieurs LLM en parallèle d'une base de données, le tout alimenté par un pipeline de données dynamique. Chacun de ces composants peut nécessiter son propre processus de déploiement.

Le déploiement d'applications d'IA générative est semblable à celui d'autres systèmes logiciels complexes, car vous devez déployer des composants système tels que des bases de données et des applications Python. Nous vous recommandons d'utiliser des pratiques d'ingénierie logicielle standards, telles que le contrôle des versions et la CI/CD.

Contrôle des versions

L'expérimentation de l'IA générative est un processus itératif qui implique des cycles répétés de développement, d'évaluation et de modification. Pour garantir une approche structurée et gérable, vous devez implémenter un système de gestion des versions strict pour tous les composants modifiables. Ces composants comprennent les éléments suivants :

• Modèles de requêtes : sauf si vous utilisez des solutions de gestion des requêtes spécifiques, utilisez des outils de contrôle des versions pour suivre les versions.
• Définitions de chaîne : utilisez des outils de gestion des versions pour suivre les versions du code qui définit la chaîne (y compris les intégrations d'API, les appels de base de données et les fonctions).
• Ensembles de données externes : dans les systèmes RAG, les ensembles de données externes jouent un rôle important. Utilisez des solutions d'analyse de données existantes telles que BigQuery, AlloyDB pour PostgreSQL et Vertex AI Feature Store pour suivre ces modifications et les versions de ces ensembles de données.
• Modèles d'adaptateur : les techniques telles que le réglage LoRA pour les modèles d'adaptateur évoluent constamment. Utilisez des solutions de stockage de données établies (par exemple, Cloud Storage) pour gérer et versionner efficacement ces composants.

Intégration continue

Dans un framework d'intégration continue, chaque modification de code est soumise à des tests automatiques avant d'être fusionnée, afin de détecter les problèmes au plus tôt. Les tests unitaires et d'intégration sont importants pour la qualité et la fiabilité. Les tests unitaires se concentrent sur des éléments de code individuels, tandis que les tests d'intégration vérifient que différents composants fonctionnent ensemble.

L'implémentation d'un système d'intégration continue permet d'effectuer les opérations suivantes :

• Garantir des résultats fiables et de haute qualité : des tests rigoureux renforcent la confiance dans les performances et la cohérence du système.
• Détectez les bugs tôt : l'identification des problèmes par le biais de tests permet d'éviter qu'ils ne causent des problèmes plus importants en aval. Détecter les bugs tôt rend le système plus robuste et résilient face aux cas extrêmes et aux entrées inattendues.
• Réduction des coûts de maintenance : des cas de test bien documentés simplifient le dépannage et permettent des modifications plus fluides à l'avenir, ce qui réduit les efforts de maintenance globaux.

Ces avantages s'appliquent aux applications d'IA générative. Appliquez l'intégration continue à tous les éléments du système, y compris les modèles d'invite, la chaîne, la logique d'enchaînement, les modèles intégrés et les systèmes de récupération.

Toutefois, l'application de l'intégration continue à l'IA générative présente les défis suivants :

• Difficulté à générer des cas de test complets : la nature complexe et ouverte des résultats de l'IA générative rend difficile la définition et la création d'un ensemble exhaustif de cas de test couvrant toutes les possibilités.
• Problèmes de reproductibilité : il est difficile d'obtenir des résultats déterministes et reproductibles, car les modèles génératifs présentent souvent un caractère aléatoire et une variabilité intrinsèques dans leurs sorties, même pour des entrées identiques. Cette aléatoire rend plus difficile le test cohérent des comportements attendus.

Ces défis sont étroitement liés à la question plus générale de l'évaluation des applications d'IA générative. Vous pouvez appliquer de nombreuses techniques d'évaluation au développement de systèmes d'IC pour l'IA générative.

Livraison continue

Une fois le code fusionné, un processus de livraison continue commence pour déplacer le code compilé et testé dans des environnements qui ressemblent beaucoup à la production pour des tests supplémentaires avant le déploiement final.

Comme décrit dans Développer et expérimenter, les éléments de chaîne deviennent l'un des principaux composants à déployer, car ils constituent fondamentalement l'application d'IA générative. Le processus de diffusion de l'application d'IA générative contenant la chaîne peut varier en fonction des exigences de latence et selon que le cas d'utilisation est par lot ou en ligne.

Les cas d'utilisation par lot nécessitent le déploiement d'un processus par lot exécuté selon une planification en production. Le processus de diffusion se concentre sur le test de l'ensemble du pipeline en intégration dans un environnement semblable à la production avant le déploiement. Dans le cadre du processus de test, les développeurs peuvent affirmer des exigences spécifiques concernant le débit du processus par lot lui-même et vérifier que tous les composants de l'application fonctionnent correctement. (Par exemple, les développeurs peuvent vérifier les autorisations, l'infrastructure et les dépendances du code.)

Les cas d'utilisation en ligne nécessitent le déploiement d'une API, qui est l'application contenant la chaîne et capable de répondre aux utilisateurs avec une faible latence. Votre processus de livraison implique de tester l'API dans l'intégration dans un environnement semblable à la production. Ces tests permettent de vérifier que tous les composants de l'application fonctionnent correctement. Vous pouvez vérifier les exigences non fonctionnelles (par exemple, l'évolutivité, la fiabilité et les performances) à l'aide d'une série de tests, y compris des tests de charge.

Checklist de déploiement

La liste suivante décrit les étapes à suivre lorsque vous déployez une application d'IA générative à l'aide d'un service géré tel que Vertex AI :

• Configurer le contrôle des versions : mettez en œuvre des pratiques de contrôle des versions pour les déploiements de modèles. Le contrôle des versions vous permet de revenir aux versions précédentes si nécessaire et de suivre les modifications apportées à la configuration du modèle ou du déploiement.
• Optimisez le modèle : effectuez des tâches d'optimisation du modèle (distillation, quantification et élagage) avant d'empaqueter ou de déployer le modèle.
• Conteneurisez le modèle : packagez le modèle entraîné dans un conteneur.
• Définissez les exigences matérielles cibles : assurez-vous que l'environnement de déploiement cible répond aux exigences pour des performances optimales du modèle, telles que les GPU, les TPU et d'autres accélérateurs matériels spécialisés.
• Définissez le point de terminaison du modèle : spécifiez le conteneur du modèle, le format d'entrée, le format de sortie et tous les paramètres de configuration supplémentaires.
• Allouer des ressources : allouez les ressources de calcul appropriées au point de terminaison en fonction du trafic attendu et des exigences de performances.
• Configurer le contrôle des accès : configurez des mécanismes de contrôle des accès pour limiter l'accès au point de terminaison en fonction des règles d'authentification et d'autorisation. Le contrôle des accès permet de s'assurer que seuls les utilisateurs ou services autorisés peuvent interagir avec le modèle déployé.
• Créer un point de terminaison de modèle : créez un point de terminaison pour déployer le modèle en tant que service d'API REST. Le point de terminaison permet aux clients d'envoyer des requêtes et de recevoir des réponses du modèle.
• Configurer la surveillance et la journalisation : configurez des systèmes de surveillance et de journalisation pour suivre les performances, l'utilisation des ressources et les journaux d'erreurs du point de terminaison.
• Déployer des intégrations personnalisées : intégrez le modèle dans des applications ou des services personnalisés à l'aide du SDK ou des API du modèle.
• Déployez des applications en temps réel : créez un pipeline de streaming qui traite les données et génère des réponses en temps réel.

Journaliser et surveiller

La surveillance des applications d'IA générative et de leurs composants nécessite des techniques que vous pouvez ajouter à celles que vous utilisez pour les MLOps conventionnels. Vous devez consigner et surveiller votre application de bout en bout, y compris l'ensemble des entrées et sorties de votre application et de chaque composant.

Les entrées de l'application déclenchent plusieurs composants pour produire les sorties. Si la réponse à une entrée donnée est factuellement inexacte, vous devez déterminer lequel des composants n'a pas fonctionné correctement. Vous avez besoin de l'historique dans vos journaux pour tous les composants qui ont été exécutés. Vous devez également mapper les entrées et les composants avec les artefacts et paramètres supplémentaires dont ils dépendent afin de pouvoir analyser les entrées et les sorties.

Lorsque vous appliquez la surveillance, privilégiez la surveillance au niveau de l'application. Si la surveillance au niveau de l'application montre que l'application fonctionne correctement, cela signifie que tous les composants fonctionnent également correctement. Ensuite, appliquez la surveillance aux composants du modèle sollicités pour obtenir des résultats plus précis et mieux comprendre votre application.

Comme pour la surveillance conventionnelle dans MLOps, vous devez déployer un processus d'alerte pour avertir les propriétaires d'applications lorsque des dérives, des biais ou une baisse des performances sont détectés. Pour configurer des alertes, vous devez intégrer des outils d'alerte et de notification à votre processus de surveillance.

Les sections suivantes décrivent les tâches de surveillance des écarts et de la dérive, ainsi que d'évaluation continue. De plus, la surveillance dans MLOps inclut la surveillance des métriques pour l'état général du système, comme l'utilisation des ressources et la latence. Ces métriques d'efficacité s'appliquent également aux applications d'IA générative.

Détection des écarts

Dans les systèmes de ML conventionnels, la détection des écarts fait référence au décalage entraînement/diffusion qui se produit lorsque la distribution des données de caractéristiques en production s'écarte de la distribution des données de caractéristiques observée lors de l'entraînement du modèle. Pour les applications d'IA générative qui utilisent des modèles préentraînés dans des composants enchaînés pour produire le résultat, vous devez également mesurer le biais. Vous pouvez mesurer le biais en comparant la distribution des données d'entrée que vous avez utilisées pour évaluer votre application et la distribution des entrées de votre application en production. Si les deux distributions s'éloignent l'une de l'autre, vous devez approfondir votre analyse. Vous pouvez également appliquer le même processus aux données de sortie.

Détection des dérives

Comme la détection des décalages, la détection des dérives vérifie les différences statistiques entre deux ensembles de données. Toutefois, au lieu de comparer les évaluations et les entrées de diffusion, la dérive recherche les modifications apportées aux données d'entrée. La dérive vous permet d'évaluer les entrées et donc l'évolution du comportement de vos utilisateurs au fil du temps.

Étant donné que l'entrée de l'application est généralement du texte, vous pouvez utiliser différentes méthodes pour mesurer le biais et la dérive. En général, ces méthodes tentent d'identifier les changements importants dans les données de production, à la fois textuelles (comme la taille de l'entrée) et conceptuelles (comme les thèmes de l'entrée), par rapport au jeu de données d'évaluation. Toutes ces méthodes recherchent des changements qui pourraient indiquer que l'application n'est pas prête à gérer correctement la nature des nouvelles données qui arrivent. Voici quelques méthodes courantes :

• Calculer les embeddings et les distances
• Compter la longueur du texte et le nombre de jetons
• Suivi des changements de vocabulaire, des nouveaux concepts et intents, des requêtes et des thèmes dans les ensembles de données
• Utilisez des approches statistiques telles que la différence de densité des moindres carrés (PDF), la discrépance moyenne maximale (MMD), la MMD à noyau appris (PDF) ou la MMD tenant compte du contexte.

Les cas d'utilisation de l'IA générative étant très divers, vous pouvez avoir besoin de métriques personnalisées supplémentaires qui capturent mieux les changements inattendus dans vos données.

Évaluation continue

L'évaluation continue est une autre approche courante pour la surveillance des applications d'IA générative. Dans un système d'évaluation continue, vous capturez la sortie de production du modèle et exécutez une tâche d'évaluation à l'aide de cette sortie pour suivre les performances du modèle au fil du temps. Vous pouvez recueillir les commentaires directs des utilisateurs, comme les notes, qui fournissent des informations immédiates sur la qualité perçue des résultats. En parallèle, la comparaison des réponses générées par le modèle avec la vérité terrain établie permet d'analyser plus en détail les performances. Vous pouvez collecter la vérité terrain par le biais d'une évaluation humaine ou à l'aide d'une approche de modèle d'IA d'ensemble pour générer des métriques d'évaluation. Ce processus vous permet de voir comment vos métriques d'évaluation ont évolué depuis le développement de votre modèle jusqu'à ce qu'il soit en production aujourd'hui.

Gérer

Dans le contexte des MLOps, la gouvernance englobe toutes les pratiques et règles qui établissent le contrôle, la responsabilité et la transparence du développement, du déploiement et de la gestion continue des modèles de machine learning, y compris toutes les activités liées aux cycles de vie du code, des données et des modèles.

Dans les applications d'IA prédictive, le lineage se concentre sur le suivi et la compréhension du parcours complet d'un modèle de machine learning. Dans l'IA générative, la traçabilité va au-delà de l'artefact du modèle pour s'étendre à tous les composants de la chaîne. Le suivi inclut les données, les modèles, la lignée des modèles, le code, ainsi que les données et métriques d'évaluation relatives. Le suivi de la lignée peut vous aider à auditer, à déboguer et à améliorer vos modèles.

En plus de ces nouvelles pratiques, vous pouvez régir les cycles de vie des données et des composants d'IA générative à l'aide des pratiques standards de MLOps et DevOps.

Étapes suivantes

Déployer une application d'IA générative à l'aide de Vertex AI

Auteurs : Anant Nawalgaria, Christos Aniftos, Elia Secchi, Gabriela Hernandez Larios, Mike Styer et Onofrio Petragallo