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

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, sélectionner des données, concevoir des invites optimales, ajuster des 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 base 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 cadre du machine learning.

Qu'est-ce que 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 promeut la collaboration, l'automatisation et l'amélioration continue pour simplifier le cycle de 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 tendances et effectuer 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 du modèle

Qu'est-ce qu'un modèle 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 base 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édictive, 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 base pour développer des applications pour de nombreux cas d'utilisation différents. Les modèles de fondation présentent 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, la création et l'exploitation des modèles de base sont difficiles et vous devez adapter vos processus DevOps et MLOps.

Le développement d'un modèle de base 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 base 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 base le plus adapté à leur cas d'utilisation. Il tient 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 test:les développeurs utilisent l'ingénierie des requêtes pour créer et affiner des requêtes d'entrée afin d'obtenir la sortie requise. Lorsque disponibles, l'apprentissage par quelques exemples, le réglage fin (PEFT) avec optimisation des paramètres et le chaînage de modèles aident à guider le comportement du modèle. Le chaî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 dans le processus de déploiement, y compris des modèles d'invite, des définitions de chaîne, des modèles intégrés, des magasins de données de récupération et des adaptateurs de modèle 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 de l'application 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 en veillant à l'équité, à la transparence et à la responsabilité des résultats du modèle.
• Amélioration continue:les développeurs ajustent constamment les modèles de base à l'aide de techniques d'incitation, en remplaçant les modèles par des versions plus récentes, voire en combinant plusieurs modèles pour améliorer les performances, la rentabilité ou la latence. L'entraînement continu classique reste pertinent dans les scénarios où un ajustement récurrent ou l'intégration de boucles de rétroaction humaine 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 sorties fiables, vous devez disposer d'une base factuelle (qui garantit que les sorties du modèle sont basées sur des informations précises et à jour) et de données récentes provenant de systèmes internes et d'entreprise. Le réglage des données permet 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 base est gourmande en ressources, la plupart des entreprises préfèrent utiliser un modèle de base existant qui est optimal pour leur cas d'utilisation. Trouver le bon modèle de fondation est difficile, car il existe de nombreux modèles de fondation. Chaque modèle a des architectures, tailles, ensembles de données d'entraînement et licences différentes. 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 invites de test pour évaluer la qualité des résultats.
• Latence et débit:déterminez la latence et le débit appropriés pour 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 résumé traitées par lot.
• Temps de développement et de maintenance:prenez en compte le temps d'investissement pour le 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:prenez en compte les 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 correspondent pas aux attentes, vous pouvez collecter plus de données, les enrichir ou les organiser davantage. De plus, vous devrez peut-être optimiser les requêtes, appliquer des techniques d'ajustement ou passer à un autre modèle de base. Ce cycle d'amélioration 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 multi-usages. Au lieu d'être entraînés à des fins uniques sur des données spécifiques à cette tâche, les modèles de base sont entraînés sur des ensembles de données étendus, ce qui vous permet d'appliquer un modèle de base à de nombreux cas d'utilisation différents.

Les modèles de fondation sont également très sensibles aux modifications de leur entrée. 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 base peut traduire du texte, générer des vidéos ou classer des données simplement en modifiant l'entrée. Même des modifications insignifiantes de l'entrée peuvent affecter la capacité du modèle à effectuer correctement cette tâche.

Ces propriétés des modèles de base nécessitent des pratiques de développement et d'exploitation différentes. Bien que les modèles dans le contexte de l'IA prédictive soient autonomes et spécifiques aux tâches, les modèles de base sont polyvalents et nécessitent un élément supplémentaire en plus 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 d'invite est un ensemble d'instructions et d'exemples, ainsi que d'espaces réservés pour accueillir les entrées utilisateur. L'application peut combiner le modèle d'invite et les données dynamiques (telles que la saisie utilisateur) pour créer une invite complète, qui est le texte transmis en entrée au modèle de base.

Composant du modèle avec requête

La présence de l'invite 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 avec invite. Le composant de modèle invité est le plus petit composant indépendant qui suffit à créer une application d'IA générative. La requête n'a pas besoin d'être compliquée. Il peut s'agir d'une instruction simple, comme "Traduire 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 base n'effectuera pas la tâche de traduction requise. Par conséquent, une invite, même une instruction de base, est nécessaire avec l'entrée pour que le modèle de base effectue la tâche requise par l'application.

Le composant de modèle invité 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 invité. Le cycle d'expérimentation de l'IA générative commence généralement par tester des variantes de l'invite (en modifiant le libellé 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 comprend les étapes itératives suivantes:

• Incitation:créez et affinez des requêtes pour susciter les comportements souhaités à partir d'un modèle de base 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 son succès dans l'exécution des 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 l'invite elle-même est un élément essentiel du processus d'ingénierie des invites, elle devient l'artefact le plus important parmi ceux qui font partie de l'expérience.

Toutefois, pour tester 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 garde-fous 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 :

• Invite en tant que données:certaines parties de l'invite fonctionnent comme des données. Les éléments tels que les exemples à quelques exemples, les bases de connaissances et les requêtes des utilisateurs 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 dérive et la gestion du cycle de vie.
• Invite en tant que code:d'autres composants tels que le contexte, les modèles d'invite et les garde-fous sont similaires au code. Ces composants définissent la structure et les règles de l'invite elle-même et nécessitent des pratiques plus axées sur le code, telles que les processus d'approbation, le contrôle des versions du code et les tests.

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

Chaînage et augmentation des modèles

Les modèles d'IA générative, en particulier les grands modèles de langage (LLM), font face à des défis inhérents pour maintenir la récence et éviter les hallucinations. L'encodage de nouvelles informations dans des LLM nécessite un pré-entraînement coûteux et gourmand en données avant de pouvoir les déployer. Selon le cas d'utilisation, il se peut que l'utilisation d'un seul modèle avec requête pour effectuer une génération particulière ne soit pas suffisante. Pour résoudre ce problème, vous pouvez connecter plusieurs modèles avec des invites, ainsi que des appels à des API externes et une logique exprimée sous forme de code. Une séquence de composants de modèle déclenché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 des effets de la récence et des hallucinations

Deux modèles basés sur des chaînes courants 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.

• RAG améliore les modèles pré-entraînés avec des connaissances extraites de bases de données, ce qui évite le pré-entraînement. Le RAG permet de s'ancrer et de réduire les hallucinations en intégrant directement des informations factuelles à jour dans le processus de génération.
• Les agents, popularisés par la technique d'invite ReAct (PDF), utilisent des LLM en tant que 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, qui agit 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 des requêtes sophistiquées et de prendre des décisions en temps réel.

L'orchestration de différents modèles, de différentes logiques et d'API n'est pas nouvelle dans 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 est que vous ne pouvez pas caractériser la distribution des entrées des composants à l'avance, ce qui rend les composants individuels beaucoup plus difficiles à évaluer et à gérer individuellement. 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.

Avec 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 sur la chaîne de bout en bout et itérez les stratégies de chaînage, les invites, les modèles de base 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 le libellé du modèle d'invite.

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

• Évaluation:en raison du couplage étroit des chaînes, elles 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 à l'évaluation des modèles avec requêtes.
• Gestion des versions:vous devez gérer une chaîne en tant qu'artefact complet. Vous devez suivre la configuration de la chaîne avec son propre historique des révisions à des fins d'analyse, de reproductibilité et de compréhension des 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 la dégradation des performances, la dérive des données ou un comportement inattendu dans la chaîne, vous devez configurer des systèmes de surveillance proactifs. La surveillance continue permet d'identifier rapidement les problèmes potentiels afin de maintenir la qualité de la sortie générée.
• 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 fournissant une visibilité sur les données qui circulent dans la chaîne et sur le contenu généré, 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 avec requête et l'ajustement du 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 sélectionnées, les modèles sont ajustés et des 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 base, il peut être difficile, en particulier pour les tâches complexes, de s'appuyer uniquement sur l'ingénierie rapide et le chaînage pour résoudre le cas d'utilisation. Pour améliorer les performances des tâches, les développeurs doivent souvent ajuster 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. Les méthodes les plus courantes pour ajuster un modèle sont les suivantes:

• Ajustement supervisé:vous entraînez le modèle de manière supervisée, en lui apprenant à prédire la séquence de sortie appropriée 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 inciter le LLM dans la bonne direction lors du processus de réglage. Ce processus est semblable à un jury d'humains qui 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, l'ajustement fin partage les fonctionnalités suivantes avec l'entraînement du modèle:

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

Entraînement et réglage continus

En MLOps, l'entraînement continu consiste à réentraîner plusieurs fois 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 correctement à mesure que les tendances des données réelles changent au fil du temps. Pour les modèles d'IA générative, le réglage continu des modèles est souvent plus pratique qu'un processus de réentraînement en raison des coûts de données et de calcul élevés.

L'approche d'ajustement continu dépend de votre cas d'utilisation et de vos objectifs spécifiques. Pour des tâches relativement statiques telles que le résumé de texte, les exigences d'ajustement 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, qui sont basées sur les commentaires humains, est nécessaire.

Pour déterminer la stratégie de réglage continu appropriée, vous devez évaluer la nature de votre cas d'utilisation et l'évolution des données d'entrée au fil du temps. Le coût est également un facteur important, car l'infrastructure de calcul a une incidence importante sur la vitesse et les dépenses de réglage. Les processeurs graphiques (GPU) et les TPU (Tensor Processing Units) sont des éléments matériels requis pour le réglage fin. 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. En revanche, les TPU sont spécialement conçus par Google pour accélérer les tâches de machine learning. Les TPU excellent à gérer les opérations de grande matrice couramment rencontrées dans les réseaux de neurones de deep learning.

Gestion des données

Auparavant, le comportement du 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 à 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 de réglage des instructions
• Ensembles de données de réglage de la sécurité
• Données sur les préférences humaines

Les applications d'IA générative sont adaptées à des données telles que:

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

La principale différence entre les pratiques de données du ML prédictif et de l'IA générative se situe au début du processus de 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, quelques instructions et peut-être quelques exemples d'entrées (comme l'apprentissage en contexte). Vous pouvez créer un prototype 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.

Prenons l'exemple des types de données suivants:

• Incitations de conditionnement:instructions données au modèle de base pour guider sa sortie et définir les limites de ce qu'il peut générer.
• Exemples few-shot:moyen de montrer au modèle ce que vous souhaitez accomplir à l'aide de paires entrée/sortie. Ces exemples aident le modèle à comprendre les tâches spécifiques et, dans de nombreux cas, 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 maintenir les réponses à 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 d'API et de sources de données internes.
• Ensembles de données spécifiques à une tâche:ensembles de données qui aident à affiner un modèle de base existant pour une tâche spécifique, en améliorant 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'aient pas nécessairement accès à ces éléments ni aux tokenizers, les informations encodées dans le modèle lui-même influencent la sortie 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 la 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 d'invite. Une application basée sur RAG vous oblige à gérer plusieurs types de données, y compris les requêtes des utilisateurs, les bases de données vectorielles avec des exemples de few-shot sélectionnés et des informations sur l'entreprise, ainsi que des modèles d'invites.

Chaque type de données doit être organisé et entretenu avec soin. Par exemple, une base de données vectorielle nécessite de traiter les données en représentations vectorielles continues, 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 des utilisateurs doivent être réécrites. Les bonnes pratiques MLOps et DevOps peuvent vous aider à accomplir 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'ajustement 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. Il est toutefois important de faire vérifier les résultats par des humains pour assurer la qualité. Vous trouverez ci-dessous des 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 étroitement 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 tendances 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 annotés existants. En utilisant 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 variantes diverses tout en préservant les caractéristiques et les relations essentielles. L'IA générative peut rencontrer un plus grand nombre 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, il est difficile d'évaluer l'IA générative. Par exemple, vous ne connaissez peut-être pas la distribution des données d'entraînement des modèles de base. 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 exceptionnels. Comme pour les données de réglage fin, vous pouvez utiliser des LLM puissants pour générer, sélectionner et enrichir des données afin de créer des ensembles de données d'évaluation robustes.

Évaluation

Le processus d'évaluation est une activité de base du développement d'applications d'IA générative. L'évaluation peut avoir différents degrés d'automatisation, allant d'une évaluation entièrement gérée par des humains à une évaluation entièrement automatisée par un processus.

Lorsque vous effectuez le prototypage d'un projet, l'évaluation est souvent un processus manuel. Les développeurs examinent les sorties du modèle, ce qui leur donne une idée qualitative de ses performances. Toutefois, à mesure que le projet évolue 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'aller plus vite et de rendre les évaluations plus fiables. Elle élimine également la subjectivité humaine de l'équation, ce qui permet de garantir que les résultats sont reproductibles.

Toutefois, 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 (invites) et les sorties peuvent être extrêmement complexes. Une invite 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 sorties 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. Par conséquent, vous pouvez 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 de l'IA générative sont subjectives. Ce qui rend un résultat meilleur qu'un 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 proxy fiable de ce que les utilisateurs pensent. Pour assurer la comparabilité entre les tests, vous devez déterminer votre approche d'évaluation et vos métriques au 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 que vous pourrez affiner au fil du temps avec des commentaires humains.
• Une évaluation complète est essentielle pour protéger les applications d'IA générative contre les attaques antagonistes. Des 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 traiter spécifiquement ces vecteurs d'attaque, à l'aide de techniques telles que le fuzzing des requêtes (en fournissant au modèle des variations aléatoires sur les requêtes) et les tests de fuite d'informations.

Pour évaluer les applications d'IA générative, procédez comme suit:

• Automatisez le processus d'évaluation pour garantir la rapidité, l'évolutivité et la reproductibilité. Vous pouvez considérer l'automatisation comme un proxy du jugement humain.
• Personnalisez le processus d'évaluation en fonction de vos cas d'utilisation.
• Pour assurer la comparabilité, stabilisez l'approche d'évaluation, les métriques et les données de vérité terrain dès que possible lors de la phase de développement.
• Générez des données de vérité terrain synthétiques pour pallier l'absence de données de vérité terrain réelles.
• Incluez des cas de test d'invites malveillantes dans l'ensemble d'évaluation pour tester la fiabilité du système lui-même contre ces attaques.

Déployer

Les applications d'IA générative au niveau de la 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 seule application peut utiliser plusieurs LLM avec une base de données, tous alimentés 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 au déploiement 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 le 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 une gestion stricte des versions pour tous les composants modifiables. Ces composants comprennent les éléments suivants :

• Modèles d'invite:sauf si vous utilisez des solutions de gestion des invites spécifiques, utilisez des outils de contrôle des versions pour suivre les versions.
• Définitions de chaîne:utilisez des outils de contrôle des versions pour suivre les versions du code qui définissent 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 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 la fusion afin de détecter les problèmes rapidement. 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 de:

• Assurer 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 dès le début:identifier les problèmes grâce aux tests permet d'éviter qu'ils ne causent des problèmes plus importants en aval. Détecter les bugs à un stade précoce rend le système plus robuste et résilient aux cas limites et aux entrées inattendues.
• Réduction des coûts de maintenance:les 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 une intégration continue à tous les éléments du système, y compris les modèles d'invites, la chaîne, la logique de chaînage, 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 sorties d'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é:obtenir des résultats déterministes et reproductibles est délicat, car les modèles génératifs présentent souvent une variabilité et un caractère aléatoire intrinsèque dans leurs sorties, même pour des entrées identiques. Cette aleatorité rend plus difficile le test cohérent des comportements attendus.

Ces défis sont étroitement liés à la question plus large de la façon d'évaluer les 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 à déplacer le code compilé et testé dans des environnements qui ressemblent étroitement à la production pour des tests supplémentaires avant le déploiement final.

Comme décrit dans la section Développer et tester, 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 du cas d'utilisation (par lot ou en ligne).

Les cas d'utilisation par lot nécessitent de déployer un processus par lot exécuté selon un calendrier en production. Le processus de livraison se concentre sur le test de l'ensemble du pipeline d'intégration dans un environnement semblable à celui de 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 de code).

Les cas d'utilisation en ligne nécessitent de déployer une API, qui est l'application qui contient la chaîne et qui peut répondre aux utilisateurs avec une faible latence. Votre processus de livraison implique de tester l'API en intégration dans un environnement semblable à celui de production. Ces tests vérifient 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) via 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:implémentez des pratiques de contrôle des versions pour les déploiements de modèles. Le contrôle des versions vous permet de revenir à des versions précédentes si nécessaire et de suivre les modifications apportées au modèle ou à la configuration de déploiement.
• Optimisez le modèle:effectuez des tâches d'optimisation du modèle (distillation, quantification et élagage) avant de le empaqueter ou de le déployer.
• Conteneurisez le modèle:empaquetez le modèle entraîné dans un conteneur.
• Définir les exigences matérielles cibles:assurez-vous que l'environnement de déploiement cible répond aux exigences requises 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éfinir le point de terminaison du modèle:spécifiez le conteneur du modèle, le format d'entrée, le format de sortie et d'autres paramètres de configuration.
• Allouer des ressources:allouez les ressources de calcul appropriées au point de terminaison en fonction du trafic et des exigences de performances prévus.
• 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 stratégies 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 au point de terminaison et de recevoir des réponses du modèle.
• Configurez 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 aux techniques de surveillance que vous utilisez pour les MLOps classiques. Vous devez journaliser et surveiller votre application de bout en bout, ce qui inclut la journalisation et la surveillance des entrées et des sorties globales de votre application et de chaque composant.

Les entrées de l'application déclenchent plusieurs composants pour produire les sorties. Si la sortie d'une entrée donnée est factuellement inexacte, vous devez déterminer lequel des composants n'a pas bien fonctionné. Vous avez besoin d'une lignée dans votre journalisation pour tous les composants exécutés. Vous devez également mapper les entrées et les composants avec tous 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, priorisez-la au niveau de l'application. Si la surveillance au niveau de l'application prouve que l'application fonctionne correctement, cela implique que tous les composants fonctionnent également correctement. Ensuite, appliquez la surveillance aux composants de modèle demandés pour obtenir des résultats plus précis et une meilleure compréhension de votre application.

Comme pour la surveillance classique dans MLOps, vous devez déployer un processus d'alerte pour avertir les propriétaires d'applications en cas de dérive, de biais ou de dégradation des performances. Pour configurer des alertes, vous devez intégrer des outils d'alerte et de notification à votre processus de surveillance.

Les sections suivantes décrivent la surveillance des biais et des dérives, ainsi que les tâches d'évaluation continue. De plus, la surveillance dans MLOps inclut la surveillance des métriques de l'état général du système, telles que 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

La détection de biais dans les systèmes de ML conventionnels fait référence au biais 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 la sortie, vous devez également mesurer le biais. Vous pouvez mesurer le décalage 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 se séparent, vous devez examiner plus en détail. 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 recherche des 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 des changements dans les 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 décalage et la dérive. En général, ces méthodes tentent d'identifier des changements significatifs dans les données de production, à la fois textuels (taille de l'entrée, par exemple) et conceptuels (thèmes de l'entrée, par exemple), par rapport au jeu de données d'évaluation. Toutes ces méthodes recherchent des modifications qui pourraient indiquer que l'application n'est peut-être pas prête à gérer correctement la nature des nouvelles données qui arrivent. Voici quelques méthodes courantes:

• Calculer des représentations vectorielles continues et des distances
• Compter la longueur du texte et le nombre de jetons
• Suivre les modifications de vocabulaire, les nouveaux concepts et intents, les invites et les sujets dans les ensembles de données
• En utilisant des approches statistiques telles que la différence de densité des moindres carrés (PDF), la discrépance moyenne maximale (MMD), la MMD du noyau appris (PDF) ou la MMD contextuelle.

Étant donné que les cas d'utilisation de l'IA générative sont très divers, vous devrez peut-être utiliser des 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 de 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 des commentaires directs des utilisateurs, tels que des notes, qui fournissent des insights immédiats 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 une analyse plus approfondie des performances. Vous pouvez collecter la vérité terrain via une évaluation humaine ou à la suite d'une approche de modèle d'IA en 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 que vous avez actuellement en production.

Gérer

Dans le contexte de MLOps, la gouvernance englobe toutes les pratiques et règles qui établissent le contrôle, la responsabilité et la transparence sur le développement, le déploiement et 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, la lignée 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 lignée 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 associées. 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 gérer le cycle de vie des données et des cycles de vie des composants d'IA générative à l'aide de pratiques MLOps et DevOps standards.

Étape suivante

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