Flux de travail des développeurs d’applications IA génératives

Le développement d’une application IA générative robuste (application IA de génération) nécessite une planification délibérée, une boucle d’évaluation rapide des commentaires et une infrastructure de production évolutive. Ce flux de travail décrit une séquence d’étapes recommandée pour vous guider de la preuve de concept initiale (POC) au déploiement de production.

0. Conditions préalables

• Rassemblez les exigences pour valider l’ajustement de l’IA de génération et identifier les contraintes.
• Concevez votre architecture de solution. Voir Modèles de conception du système d’agent.

1. Générer

• Préparez les sources de données et créez les outils nécessaires.
• Générer et valider le prototype initial (POC).
• Effectuer un déploiement dans l’environnement de préproduction.

2. Évaluer et itérer

• Collecter les commentaires des utilisateurs et mesurer la qualité
• Corrigez les problèmes de qualité en affinant la logique et les outils de l’agent en fonction de l’évaluation.
• Incorporez une entrée d’expert technique (PME) pour améliorer continuellement la qualité du système d’agent.

3. Production

• Déployez l’application IA gen dans l’environnement de production.
• Surveillez les performances et la qualité.
• Maintenir et améliorer en fonction de l’utilisation réelle.

Ce flux de travail doit être itératif : après chaque cycle de déploiement ou d’évaluation, revenez aux étapes antérieures pour affiner les pipelines de données ou mettre à jour la logique de l’agent. Par exemple, la surveillance de la production peut révéler de nouvelles exigences, déclencher des mises à jour de la conception de l’agent et une autre série d’évaluation. En suivant ces étapes systématiquement et en tirant parti des fonctionnalités de suivi Databricks MLflow, Agent Framework et Évaluation de l’agent, vous pouvez créer des applications IA de haute qualité qui répondent de manière fiable aux besoins des utilisateurs, respectent les exigences de sécurité et de conformité, et continuent à s’améliorer au fil du temps.

0. Conditions préalables

Avant de commencer à développer votre application d'IA générative, on ne saurait trop insister sur l'importance de prendre le temps de faire correctement les actions suivantes : collecte des exigences et conception de la solution.

Configuration requise pour la collecte comprend les étapes suivantes :

• Vérifiez si l’IA de génération correspond à votre cas d’usage.
• Définissez l’expérience utilisateur.
• Identifiez les sources de données.
• Définissez des contraintes de performances.
• Capturer les contraintes de sécurité.

Conception de solution inclut les éléments suivants :

• Planifier des flux de données.
• Identifiez les outils nécessaires.
• Décrivez l’architecture système globale.

En plaçant ce travail de base, vous définissez une direction claire pour les étapes de Génération, d’Évaluationet de Production qui suivront.

Collecter les exigences

La définition de conditions d’utilisation claires et complètes est une première étape essentielle pour développer votre application IA de génération réussie. Ces exigences répondent aux besoins suivants :

• Ils permettent de déterminer si une approche IA de génération est appropriée pour votre cas d’usage.
• Ils guident la conception, l’implémentation et les décisions d’évaluation des solutions.

Investir du temps au début pour recueillir des exigences détaillées peut empêcher des défis importants plus tard dans le processus de développement et s’assurer que la solution résultante répond aux besoins des utilisateurs finaux et des parties prenantes. Les exigences bien définies constituent la base des étapes suivantes du cycle de vie de votre application.

Le cas d’usage est-il adapté à l’IA de génération ?

Avant de vous engager dans une solution IA de génération, déterminez si ses forces inhérentes s’alignent sur vos exigences. Voici quelques exemples où une solution d’IA générative est adaptée :

• génération de contenu : La tâche nécessite de générer du contenu nouveau ou créatif qui ne peut pas être obtenu avec des modèles statiques ou une logique simple basée sur des règles.
• gestion dynamique des requêtes : Les requêtes utilisateur sont ouvertes ou complexes et nécessitent des réponses flexibles et sensibles au contexte.
• Synthèse des informations : Le cas d’usage tire parti de la combinaison ou de la synthèse de diverses sources d’information pour produire une sortie cohérente.
• Systèmes d’agent : L’application nécessite davantage que simplement générer du texte en réponse à une requête. Il peut être nécessaire d’être capable de :
  • planification et prise de décision : la formulation d’une stratégie multi-étapes pour atteindre un objectif spécifique.
  • Effectuer des actions : déclencher des processus externes ou appeler différents outils pour effectuer des tâches (par exemple, récupérer des données, effectuer des appels d’API, exécuter des requêtes SQL, exécuter du code).
  • Maintien de l’état : Suivre l’historique des conversations ou le contexte de tâche dans plusieurs interactions pour permettre la continuité.
  • Production de sorties adaptatives : Génération de réponses qui évoluent en fonction des actions précédentes, des informations mises à jour ou des conditions changeantes.

À l’inverse, une approche d'intelligence artificielle générative n’est peut-être pas idéale dans les situations suivantes :

• La tâche est hautement déterministe et peut être résolue efficacement avec des modèles prédéfinis ou des systèmes basés sur des règles.
• L’ensemble des informations requises est déjà statique ou s’adapte à une infrastructure simple et fermée.
• Les réponses nécessitent une latence extrêmement faible (en millisecondes) et la surcharge du traitement génératif ne peut pas être supportée.
• Les réponses simples et modèles sont suffisantes pour le cas d’usage prévu.

Important

Les sections ci-dessous utilisent des étiquettes P0, P1et étiquettes P2 pour indiquer la priorité relative.

• 🟢 [P0] éléments sont essentiels ou critiques. Celles-ci doivent être traitées immédiatement.
• 🟡 [P1] éléments sont importants, mais peuvent suivre après les exigences P0.
• ⚪ [P2] éléments sont des considérations de moindre priorité ou des améliorations pouvant être traitées en fonction du temps et des ressources disponibles.

Ces étiquettes aident les équipes à voir rapidement quelles exigences nécessitent une attention immédiate par rapport à celles qui peuvent être différées.

Expérience utilisateur

Définissez la façon dont les utilisateurs interagiront avec l’application IA de génération et le type de réponses attendus.

• 🟢 [P0] Requête classique : Qu’est-ce qu’une demande utilisateur classique ressemblera-t-elle ? Rassemblez des exemples auprès des parties prenantes.
• 🟢 [P0] Réponses attendues : Quel type de réponses le système doit-il générer (par exemple, réponses courtes, explications de longue durée, narrations créatives) ?
• 🟡 modalité d’interaction [P1] : Comment les utilisateurs interagiront-ils avec l’application (par exemple, interface de conversation, barre de recherche, assistant vocal) ?
• 🟡 [P1] Ton, style, structure : Quel ton, style et structure les sorties générées doivent-elles adopter (formel, conversationnel, technique, points à puces ou prose continue) ?
• 🟡 [P1]Gestion des erreurs : Comment l’application doit-elle gérer des requêtes ambiguës, incomplètes ou hors cible ? Doit-il fournir des commentaires ou demander des clarifications ?
• ⚪ [P2] Conditions de mise en forme : Existe-t-il des instructions de mise en forme ou de présentation spécifiques pour les sorties (y compris les métadonnées ou les informations supplémentaires) ?

Données

Déterminez la nature, les sources et la qualité des données qui seront utilisées dans l’application IA de génération.

• sources de données 🟢[P0] : Quelles sources de données sont disponibles ?
  • Pour chaque source, déterminez :
    • Les données sont-elles structurées ou non structurées ?
    • Quel est le format source (par exemple, PDF, HTML, JSON, XML) ?
    • Où résident les données ?
    • Combien de données sont disponibles ?
    • Comment les données doivent-elles être consultées ?
• 🟡les mises à jour des données [P1] : à quelle fréquence les données sont-elles mises à jour ? Quels sont les mécanismes en place pour la gestion des mises à jour ?
• 🟡qualité des données [P1] : Existe-t-il des problèmes de qualité connus ou des incohérences ?
  • Déterminez si une surveillance de la qualité sur les sources de données sera nécessaire.

Envisagez de créer une table d’inventaire pour consolider ces informations, par exemple :

Source de données	Source	Type(s) de fichier	Taille	Fréquence de mise à jour
Source de données 1	Volume du catalogue Unity	JSON	10 Go	Quotidiennement
Source de données 2	API publique	XML	N/A (API)	En temps réel
Source de données 3	SharePoint	PDF, .docx	500 Mo	Mensuelle

Contraintes de performances

Capturez les performances et les besoins en ressources pour l’application IA de génération.

latence

• 🟢[P0] Temps jusqu'au premier jeton : Quel est le délai maximal acceptable avant de livrer le premier jeton de sortie ?
  • Remarque : latence est généralement mesurée à l’aide de p50 (médiane) et de p95 (95e centile) pour capturer les performances moyennes et les pires cas.
• 🟢[P0] Délai d’achèvement : Quelle est la durée de réponse acceptable (délai d’achèvement) pour les utilisateurs ?
• 🟢la latence de diffusion en continu [P0] : Si les réponses sont diffusées, une latence globale plus élevée est-elle acceptable ?

Scalabilité

• 🟡[P1]utilisateurs simultanés & demandes : combien d’utilisateurs simultanés ou de demandes le système doit-il prendre en charge ?
  • Remarque : l’extensibilité est souvent mesurée en termes de QPS (requêtes par seconde) ou de QPM (requêtes par minute).
• 🟡[P1] Modèles d’utilisation : Quels sont les modèles de trafic attendus, les pics de charge ou les pics d’utilisation basés sur le temps ?

contraintes de coût

• 🟢[P0] Limitations des coûts d’inférence : Quelles sont les contraintes de coût ou les limitations budgétaires pour les ressources de calcul d’inférence ?

Évaluation

Établissez la façon dont l’application IA de génération sera évaluée et améliorée au fil du temps.

• 🟢[P0] Indicateurs de performance clés métier: quel objectif métier ou indicateur de performance clé doit-il avoir un impact sur l’application ? Définissez vos valeurs et cibles de référence.
• 🟢[P0] Commentaires des parties prenantes: qui fournira des commentaires initiaux et continus sur les performances et les sorties des applications ? Identifiez des groupes d’utilisateurs ou des experts de domaine spécifiques.
• 🟢[P0] Mesure de la qualité: quelles métriques (par exemple, précision, pertinence, sécurité, scores humains) seront utilisées pour évaluer la qualité des sorties générées ?
  • Comment ces métriques seront-elles calculées pendant le développement (par exemple, par rapport aux données synthétiques, aux jeux de données organisés manuellement) ?
  • Comment la qualité sera-t-elle mesurée en production (par exemple, journalisation et analyse des réponses aux requêtes utilisateur réelles) ?
  • Quelle est votre tolérance globale pour l’erreur ? (par exemple, accepter un certain pourcentage d’inexactitudes factuelles mineures ou exiger une% exactitude proche de 100 pour les cas d’usage critiques.)
  • L’objectif est de créer un ensemble d’évaluations à partir de requêtes utilisateur réelles, de données synthétiques ou d’une combinaison des deux. Cet ensemble offre un moyen cohérent d’évaluer les performances à mesure que le système évolue.
• 🟡[P1] Boucles de rétroaction: Comment collecter les retours des utilisateurs (par exemple, les pouces haut/bas, les formulaires d’enquête) et les utiliser pour améliorer les processus itératifs ?
  • Planifiez la fréquence à laquelle les commentaires seront examinés et incorporés.

Sécurité

Identifiez les considérations relatives à la sécurité et à la confidentialité.

• 🟢 [P0] Confidentialité des données : Existe-t-il des éléments de données sensibles ou confidentiels qui nécessitent une gestion spéciale ?
• 🟡 [P1] Contrôles d’accès : Devez-vous implémenter des contrôles d’accès pour restreindre certaines données ou fonctionnalités ?
• 🟡[P1] Évaluation du risque & atténuation : Votre application devra-t-elle se protéger contre les menaces courantes de l'IA générative, telles que l'injection d'invite ou les entrées utilisateur malveillantes ?

Déploiement

Découvrez comment la solution IA de génération sera intégrée, déployée, surveillée et gérée.

• intégration 🟡[P1] : Comment la solution d’IA de génération doit-elle s’intégrer aux systèmes et flux de travail existants ?
  • Identifiez les points d’intégration (par exemple, Slack, CRM, outils de BI) et les connecteurs de données requis.
  • Déterminez comment les demandes et les réponses circuleront entre l’application IA de génération et les systèmes en aval (par exemple, les API REST, les webhooks).
• 🟡[P1] Déploiement : Quelles sont les conditions requises pour le déploiement, la mise à l’échelle et le contrôle de version de l’application ? Cet article explique comment le cycle de vie de bout en bout peut être géré sur Databricks à l’aide de MLflow, du catalogue Unity, du Agent Framework, de l’évaluation de l’agent et du service de modèle.
• 🟡[P1] Surveillance de la production & observabilité : Comment surveiller l’application une fois qu’elle est en production ?
  • Enregistrement et traces : capturez les traces d’exécution complètes.
  • Métriques de qualité : évaluez en continu les métriques clés (telles que la correction, la latence, la pertinence) sur le trafic en direct.
  • Alertes pour le tableau de bord & : configurez des alertes pour les problèmes critiques.
  • Boucle de commentaires : incorporez les commentaires des utilisateurs en production (pouces vers le haut ou vers le bas) pour détecter les problèmes tôt et générer des améliorations itératives.

Exemple :

Par exemple, tenez compte de la façon dont ces considérations et exigences s’appliquent à une application RAG agentique hypothétique utilisée par une équipe de support technique Databricks :

Domaine	Considérations	Spécifications
Expérience utilisateur	Modalité d’interaction. Exemples de requêtes utilisateur classiques. Format et style de réponse attendus. Gestion des requêtes ambiguës ou non pertinentes.	Interface de conversation intégrée à Slack. Exemples de requêtes : « Comment réduire le temps de démarrage du cluster ? » « Quel type de plan de soutien ai-je ? » Réponses techniques claires avec des extraits de code et des liens vers la documentation pertinente, le cas échéant. Fournissez des suggestions contextuelles et augmentez-les pour prendre en charge les ingénieurs en cas de besoin.
Logique de l’agent	Compréhension et classification des requêtes. Planification à plusieurs étapes et prise de décision. Sélection et exécution d’outils autonomes. Gestion de l’état et du contexte entre les interactions. Mécanismes de gestion des erreurs et de secours.	Planification alimentée par LLM avec des solutions de secours déterministes. Intégrer à un ensemble d’outils prédéfinis (tels que la récupération de documents ou l’outil de récupération Salesforce). Conservez l’état de la conversation pour des interactions multitours cohérentes et une récupération efficace des erreurs.
Données	Nombre et type de sources de données. Format et emplacement des données. Taille des données et fréquence de mise à jour. Qualité et cohérence des données.	Quatre sources de données. Documentation de l’entreprise (HTML, PDF). Tickets de support résolus (JSON). Publications du forum communautaire (table Delta). Connecteur Salesforce. Données stockées dans le catalogue Unity et mises à jour hebdomadairement. Taille totale des données : 5 Go. Structure et qualité des données cohérentes gérées par les équipes de support et de documentation dédiées.
Performances	Latence maximale acceptable. Contraintes de coût. Utilisation prévisible et simultanéité attendue.	Exigence de latence maximale. Contraintes de coût. Charge maximale attendue.
Évaluation	Disponibilité du jeu de données d’évaluation. Métriques de qualité. Collecte des commentaires des utilisateurs.	Les experts en matière de chaque domaine de produit aident à passer en revue les sorties et à ajuster les réponses incorrectes pour créer le jeu de données d’évaluation. Indicateurs de performance clés métier. Augmentation du taux de résolution des tickets de support. Diminuez le temps passé par utilisateur par ticket de support. Métriques de qualité. Pertinence et exactitude de la réponse jugée par le LLM. Précision de récupération jugée par le LLM. Vote positif ou négatif de l'utilisateur. Collecte de commentaires. Slack sera instrumenté pour fournir une approbation ou un rejet.
Sécurité	Gestion des données sensibles. Exigences de contrôle d’accès.	Aucune donnée client sensible ne doit se trouver dans la source de récupération. Authentification des utilisateurs via le SSO Databricks Community.
Déploiement	Intégration à des systèmes existants. Déploiement et contrôle de version.	Intégration avec le système de gestion de tickets de support. Agent déployé en tant que point de terminaison Databricks Model Serving.

Conception de solution

Pour des considérations supplémentaires de conception, consultez les modèles de conception de système à agents .

Sources de données et outils

Lors de la conception d’une application IA de génération, il est important d’identifier et de mapper les différentes sources de données et outils nécessaires pour piloter votre solution. Celles-ci peuvent impliquer des jeux de données structurés, des pipelines de traitement de données non structurés ou l’interrogation d’API externes. Voici les approches recommandées pour incorporer différentes sources de données ou outils dans votre application IA de génération :

Données structurées

Les données structurées résident généralement dans des formats tabulaires bien définis (par exemple, une table Delta ou un fichier CSV) et sont idéales pour les tâches où les requêtes sont prédéterminées ou doivent être générées dynamiquement en fonction de l’entrée utilisateur. Consultez les outils de l'agent IA de récupération structurée pour obtenir des recommandations sur l’ajout de données structurées à votre application d'IA générative.

Données non structurées

Les données non structurées incluent des documents bruts, des fichiers PDF, des e-mails, des images et d’autres formats qui ne sont pas conformes à un schéma fixe. Ces données nécessitent généralement un traitement supplémentaire, généralement via une combinaison d’analyse, de segmentation et d’incorporation, pour être interrogées et utilisées efficacement dans une application IA de génération. Consultez Outils d’agent IA de récupération non structurée pour obtenir des recommandations sur l’ajout de données structurées à votre application d’IA générative.

API externes et actions

Dans certains scénarios, votre application IA de génération peut avoir besoin d’interagir avec des systèmes externes pour récupérer des données ou effectuer des actions. Dans les cas où votre application nécessite l’appel d’outils ou l’interaction avec des API externes, nous vous recommandons les éléments suivants :

• Gérer les informations d’identification de l’API avec une connexion à Unity Catalog : utilisez une connexion à Unity Catalog pour régir en toute sécurité les informations d’identification de l’API. Cette méthode garantit que les jetons et les secrets sont gérés de manière centralisée et contrôlés par un contrôle d'accès.
• Appeler via le kit de développement logiciel (SDK) Databricks :
  Envoyez des requêtes HTTP à des services externes à l’aide de la fonction http_request à partir de la bibliothèque databricks-sdk. Cette fonction tire parti d’une connexion de catalogue Unity pour l’authentification et prend en charge les méthodes HTTP standard.
• Tirer parti des fonctions de Unity Catalog :
  Enveloppez les connexions externes dans une fonction du catalogue Unity pour ajouter une logique de pré-traitement ou de post-traitement personnalisée.
• outil d’exécuteur Python:
  Pour exécuter dynamiquement du code pour la transformation de données ou les interactions d’API à l’aide de fonctions Python, utilisez l’outil d’exécuteur Python intégré.

Exemple :

Une application d’analytique interne récupère des données de marché dynamiques à partir d’une API financière externe. L’application utilise :

• Connexion externe du catalogue Unity pour stocker en toute sécurité les identifiants API.
• Une fonction de catalogue Unity personnalisée encapsule l’appel d’API pour ajouter un prétraitement (comme la normalisation des données) et un post-traitement (par exemple, gestion des erreurs).
• En outre, l’application peut directement appeler l’API via le Kit de développement logiciel (SDK) Databricks.

Approche de mise en œuvre

Lors du développement d’une application IA de génération, vous avez deux options principales pour implémenter la logique de votre agent : tirer parti d’une infrastructure open source ou créer une solution personnalisée à l’aide du code Python. Vous trouverez ci-dessous une répartition des avantages et des inconvénients pour chaque approche.

Utilisation d’une infrastructure (par exemple, LangChain, LlamaIndex, CrewAI ou AutoGen)

Avantages :

• Composants prêts à l’emploi : les frameworks sont fournis avec des outils prêts à l’emploi pour la gestion rapide des tâches, le chaînage des appels, et l’intégration à différentes sources de données, ce qui peut accélérer le développement.
• Communauté et documentation : Bénéficiez du support communautaire, des didacticiels et des mises à jour régulières.
• modèles de conception courants : frameworks fournissent généralement une structure claire et modulaire pour orchestrer les tâches courantes, ce qui peut simplifier la conception globale de l’agent.

Inconvénients :

• Ajout d’abstraction : infrastructures open source introduisent souvent des couches d’abstraction qui peuvent être inutiles pour votre cas d’usage spécifique.
• Dépendances sur les mises à jour : Vous pouvez dépendre des responsables de la maintenance de l’infrastructure pour les correctifs de bogues et les mises à jour des fonctionnalités, ce qui peut ralentir votre capacité à s’adapter rapidement aux nouvelles exigences.
• Surcharge potentielle : L'abstraction supplémentaire peut poser des défis de personnalisation si votre application prouve un besoin de contrôle plus précis.

Utilisation de Python pur

Avantages :

• Flexibilité : Développement en Python pur vous permet d’adapter votre implémentation exactement à vos besoins sans être contraint par les décisions de conception d’un framework.
• Adaptation rapide : Vous pouvez ajuster rapidement votre code et incorporer des modifications en fonction des besoins, sans attendre les mises à jour d’une infrastructure externe.
• simplicité : Éviter les couches inutiles d’abstraction, pour une solution potentiellement plus élégante et plus performante.

Inconvénients :

• Effort accru de développement : Création à partir de zéro peut nécessiter plus de temps et d’expertise pour implémenter des fonctionnalités qu’un framework dédié peut fournir autrement.
• Réinventer la roue : vous devrez peut-être développer des fonctionnalités courantes (telles que la chaînage d’outils ou la gestion rapide) par vous-même.
• responsabilité de maintenance : toutes les mises à jour et correctifs de bogues deviennent votre responsabilité, ce qui peut être difficile pour les systèmes complexes.

En fin de compte, votre décision doit être guidée par la complexité, les besoins en performances et le niveau de contrôle dont vous avez besoin. Aucune approche n’est intrinsèquement supérieure ; chacun offre des avantages distincts en fonction de vos préférences de développement et de vos priorités stratégiques.

1. Construire

Au cours de cette étape, vous transformez votre conception de solution en application IA de génération opérationnelle. Plutôt que de perfectionner tout à l’avance, commencez petit avec une preuve de concept minimale (POC) qui peut être testée rapidement. Cela vous permet de déployer dans un environnement de préproduction dès que possible, de collecter des requêtes représentatives à partir d’utilisateurs ou de PME réels, et d’affiner en fonction des commentaires réels.

Le processus de génération suit les étapes clés suivantes :

a. Préparer les données & : Assurez-vous que les données requises sont accessibles, préparées et prêtes à être extraites. Implémentez ou inscrivez les fonctions et connexions du catalogue Unity (par exemple, les API de récupération ou les appels d’API externes) dont votre agent a besoin. b. Agent de build : Orchestrer la logique principale, en commençant par une approche simple de POC. c. Vérification de la qualité : Valider les fonctionnalités essentielles avant d’exposer l’application à d’autres utilisateurs. d. Déployer l’agent de préproduction : Rendre le POC disponible pour tester les utilisateurs et les experts en matière pour obtenir des commentaires initiaux. e. Collecter les commentaires des utilisateurs : Utiliser l’utilisation réelle pour identifier les domaines d’amélioration, les données ou outils supplémentaires nécessaires et les affinements potentiels pour l’itération suivante.

a. Préparer des données et des outils

À partir de la phase de conception de solution, vous aurez une idée initiale des sources de données et des outils requis pour votre application. À ce stade, gardez-le minimal : concentrez-vous sur suffisamment de données pour valider votre POC. Cela garantit une itération rapide sans investissements initiaux lourds dans des pipelines complexes.

Données

1. Identifier un sous-ensemble représentatif de données
   • Pour de données structurées, sélectionnez les tables ou colonnes clés les plus pertinentes pour votre scénario initial.
   • Pour données non structurées, hiérarchisez l’indexation uniquement d’un sous-ensemble de documents représentatifs. Utilisez un pipeline de segmentation/incorporation de base avec Vector Search de Mosaic AI afin que votre agent puisse récupérer des blocs de texte pertinents si nécessaire.
2. Configurer l'accès aux données
   • Si votre application doit faire des appels d’API externes, stockez les informations d’identification en toute sécurité à l’aide d’une Unity Catalog Connection.
3. Valider la couverture de base
   • Vérifiez que le ou les sous-ensembles de données choisis traitent correctement les requêtes utilisateur que vous envisagez de tester.
   • Enregistrez toutes les sources de données supplémentaires ou transformations complexes pour les itérations futures. Votre objectif actuel doit prouver la faisabilité de base et recueillir des commentaires.

Outils

Une fois vos sources de données configurées, l’étape suivante consiste à implémenter et à inscrire les outils que votre agent appellera au moment de l’exécution au catalogue Unity. Un outil est une fonction d’interaction unique, comme une requête SQL ou un appel d’API externe, que l’agent peut appeler pour la récupération, la transformation ou l’action.

outils de récupération de données

• requêtes de données contraintes et structurées : Si les requêtes sont corrigées, encapsulez-les dans une fonction SQL du catalogue Unity ou une fonction UDF Python. Cela permet de conserver la logique centralisée et détectable.
• requêtes de données structurées ouvertes : Si les requêtes sont plus ouvertes, envisagez de configurer un espace Génie pour gérer les requêtes texte-à-SQL.
• Fonctions d’assistance de données non structurées : Pour les données non structurées stockées dans la recherche vectorielle de Mosaic AI, créer un outil de récupération de données non structurées que l’agent peut appeler pour extraire des segments de texte pertinents.

outils d’appel d’API

• Appels d’API externes :des appels d’API peuvent être effectués directement à l’aide de la méthode du kit SDK Databrickshttp_request.
• Wrappers facultatifs : si vous devez implémenter une logique de pré-traitement ou de post-traitement (telle que la normalisation des données ou la gestion des erreurs), encapsulez l’appel d’API dans une fonction catalogue Unity.

Gardez-le minimaliste

• Démarrer avec les outils essentiels uniquement : Concentrez-vous sur un chemin d’extraction unique ou un ensemble limité d’appels d’API. Vous pouvez ajouter d’autres éléments lors de l’itération.
• Valider de manière interactive : Tester chaque outil indépendamment (par exemple, dans un notebook) avant de l’incorporer dans le système d’agent.

Une fois vos outils prototypes prêts, passez à la création de l’agent. L’agent orchestre ces outils pour répondre aux requêtes, extraire des données et effectuer des actions en fonction des besoins.

b. Agent de build

Une fois vos données et outils en place, vous pouvez générer l’agent qui répond aux requêtes entrantes, telles que les requêtes utilisateur. Pour créer un agent prototype initial, utilisez soit Python soit le laboratoire IA . Suivez ces étapes :

1. Démarrer simplement
   • Choisir un modèle de conception de base : For a POC, commencez par une chaîne de base (par exemple, une séquence fixe d’étapes) ou un seul agent d’appel d’outils (où le LLM peut appeler dynamiquement un ou deux outils essentiels).
     • Si votre scénario s’aligne sur l’un des exemples de notebooks fournis dans la documentation Databricks, adaptez ce code en tant que squelette.
   • Incitation minimale : Résister à l’envie de sur-complexifier les incitations à ce point. Conservez des instructions succinctes et directement pertinentes pour vos tâches initiales.
2. Incorporer des outils
   • Intégration de l’outil : Si vous utilisez un modèle de conception de chaîne, les étapes appelant chaque outil seront codées en dur. Dans un agent d’appel d’outils, vous fournissez un schéma afin que le LLM sache comment appeler la fonction.
     • Vérifiez que les outils isolés fonctionnent comme prévu, avant de les incorporer dans le système de l’agent et de tester de bout en bout.
   • garde-fous : Si votre agent peut modifier des systèmes externes ou exécuter du code, vérifiez que vous disposez de contrôles de sécurité de base et de garde-fous (par exemple, en limitant le nombre d’appels ou en limitant certaines actions). Implémentez-les dans une fonction de catalogue Unity .
3. Tracer et journaliser l’agent avec MLflow
   • Tracer chaque étape : Utilisez MLflow Tracing pour capturer les entrées, les sorties et le temps écoulé, afin de déboguer les problèmes et de mesurer les performances.
   • Journaliser l’agent : utilisez MLflow Tracking pour journaliser le code et la configuration de l’agent.

À ce stade, la perfection n’est pas l’objectif. Vous souhaitez un agent simple et fonctionnel que vous pouvez déployer pour obtenir des commentaires précoces des utilisateurs de test et des PME. L’étape suivante consiste à exécuter un contrôle de qualité rapide avant de le rendre disponible dans un environnement de préproduction.

c. Contrôle qualité

Avant d’exposer l’agent à un public de préproduction plus large, effectuez une vérification de qualité « satisfaisante » hors ligne pour détecter tous les problèmes majeurs avant de le déployer sur un point de terminaison. À ce stade, vous ne disposez généralement pas d’un jeu de données d’évaluation volumineux et robuste, mais vous pouvez toujours effectuer une passe rapide pour vous assurer que l’agent se comporte comme prévu sur une poignée d’exemples de requêtes.

1. Tester de manière interactive dans un carnet
   • Test manuel : Faites appel manuellement à votre agent avec des demandes représentatives. Attention à savoir si elle récupère les données appropriées, appelle correctement les outils et suit le format souhaité.
   • Inspecter les traces MLflow : si vous avez activé MLflow Tracing, passez en revue la télémétrie pas à pas. Vérifiez que l’agent sélectionne les outils appropriés, gère correctement les erreurs et ne génère pas de requêtes ou de résultats intermédiaires inattendus.
   • Vérifier la latence : notez le temps nécessaire à l’exécution de chaque requête. Si les temps de réponse ou l’utilisation des jetons sont trop élevés, vous devrez peut-être réduire les étapes ou simplifier la logique avant d’aller plus loin.
2. Vérification d’ambiance
   • Cela peut être effectué dans un bloc-notes ou dans AI Playground.
   • cohérence & exactitude : Les résultats de l’agent sont-ils logiques pour les requêtes que vous avez testées ? Y a-t-il des imprécisions ou des détails manquants ?
   • Cas limites : si vous avez essayé quelques requêtes hors des sentiers battus, l’agent a-t-il toujours répondu logiquement ou au moins échouer de manière élégante (par exemple, refuser poliment de répondre plutôt que de produire une réponse insensée) ?
   • Respect de la requête : si vous avez fourni des instructions générales telles que la tonalité ou la mise en forme souhaitées, l’agent suit-il ces instructions ?
3. Évaluer la qualité « satisfaisante »
   • Si vous êtes limité sur les requêtes de test à ce stade, envisagez de générer des données synthétiques. Consultez Créer un jeu d’évaluation.
   • Résoudre les problèmes majeurs : Si vous découvrez des défauts majeurs (par exemple, l’agent appelle à plusieurs reprises des outils non valides ou génère des non-sens), corrigez ces problèmes avant de les exposer à un public plus large. Consultez les problèmes de qualité courants et découvrez comment les résoudre .
   • Décider de la viabilité : Si l’agent répond à une barre de base de facilité d’utilisation et d’exactitude pour un petit ensemble de requêtes, vous pouvez continuer. Si ce n’est pas le cas, affinez les requêtes, corrigez les problèmes liés à l’outil ou aux données, puis retestez.
4. Planifier les étapes suivantes
   • Suivre les améliorations : Documenter les déficiences que vous décidez de retarder. Après avoir recueilli des commentaires réels en préproduction, vous pouvez les revisiter.

Si tout semble viable pour un déploiement limité, vous êtes prêt à déployer l’agent en préproduction. Un processus d'évaluation approfondi aura lieu dans phases ultérieures, en particulier après avoir obtenu des données plus concrètes, des retours des experts PME, et un jeu d'évaluation structuré. Pour l’instant, concentrez-vous sur la garantie que votre agent démontre de manière fiable ses fonctionnalités principales.

d. Déployer un agent de préproduction

Une fois que votre agent a atteint un seuil de qualité de référence, l’étape suivante consiste à l’héberger dans un environnement de préproduction afin de comprendre comment les utilisateurs interrogent l’application et recueillent leurs commentaires pour guider le développement. Cet environnement peut être votre environnement de développement pendant la phase POC. La principale exigence est que l’environnement soit accessible pour sélectionner des testeurs internes ou des experts de domaine.

1. Déployer l’agent
   • Journaliser et inscrire l’agent : Tout d’abord, journalisez l’agent en tant que modèle MLflow et inscrivez-le dans Unity Catalog.
   • Déployer à l’aide d’Agent Framework : utilisez Agent Framework pour prendre l’agent inscrit et le déployer en tant que point de terminaison de déploiement de modèle.
2. Tables d’inférence
   • Agent Framework stocke automatiquement les requêtes, les réponses et les traces, ainsi que les métadonnées d’une table d’inférence dans le catalogue Unity pour chaque point de terminaison de service.
3. Sécuriser et configurer
   • contrôle d’accès :restreindre l’accès au point de terminaison à votre groupe de tests (PME, utilisateurs d’alimentation). Cela garantit l’utilisation contrôlée et évite une exposition inattendue des données.
   • d’authentification : Vérifiez que les secrets, jetons d’API ou connexions de base de données requis sont correctement configurés.

Vous disposez maintenant d’un environnement contrôlé pour recueillir des commentaires sur des requêtes réelles. L’une des façons dont vous pouvez interagir rapidement avec l’agent se trouve dans ai Playground, où vous pouvez sélectionner le point de terminaison Model Serving nouvellement créé et interroger l’agent.

e. Collecter les commentaires des utilisateurs

Une fois que vous avez déployé votre agent dans un environnement de préproduction, l’étape suivante consiste à recueillir des commentaires des utilisateurs réels et des PME pour détecter les lacunes, repérer les inexactitudes et affiner votre agent plus loin.

1. Utiliser l’application de révision

   • Lorsque vous déployez votre agent avec Agent Framework, une application de revue simple de type conversationnel est créée. Il fournit une interface conviviale où les testeurs peuvent poser des questions et évaluer immédiatement les réponses de l’agent.
   • Toutes les demandes, réponses et commentaires des utilisateurs (pouces vers le haut/bas, commentaires écrits) sont automatiquement journalisées dans une table d’inférence , ce qui facilite l’analyse ultérieurement.

2. Utiliser l’interface utilisateur de surveillance pour inspecter les journaux d’activité

   • Suivez les votes positifs/négatifs ou les commentaires textuels dans l'interface de surveillance pour voir quelles réponses les testeurs ont trouvées particulièrement utiles, ou inutiles.

3. Engager des experts de domaine

   • Encouragez les PME à parcourir des scénarios typiques et inhabituels. Les connaissances de domaine permettent d’exposer des erreurs subtiles telles que des erreurs d’interprétation de stratégie ou des données manquantes.
   • Conservez un backlog de problèmes, des modifications mineures des invites aux refactorisations de pipeline de données plus volumineuses. Déterminez les correctifs à hiérarchiser avant de passer à l’ordre de priorité.

4. Organiser de nouvelles données d’évaluation

   • Convertissez des interactions notables ou problématiques en cas de test. Au fil du temps, ils constituent la base d’un jeu de données d’évaluation plus robuste.
   • Si possible, ajoutez des réponses correctes ou attendues à ces cas. Cela permet de mesurer la qualité dans les cycles d’évaluation suivants.

5. Itérer en fonction des commentaires

   • Appliquez des correctifs rapides tels que de petits changements d’invite ou de nouveaux garde-fous pour traiter les zones de friction immédiates.
   • Pour des problèmes plus complexes, tels que la nécessité d’une logique multi-étape avancée ou de nouvelles sources de données, recueillez suffisamment de preuves avant d’investir dans des changements architecturaux majeurs.

En tirant parti des commentaires de l’application de révision, des journaux de la table d’inférence et des insights sur les PME, cette phase de préproduction permet de faire apparaître des lacunes clés et d’affiner votre agent de manière itérative. Les interactions réelles rassemblées dans cette étape créent la base de la création d’un ensemble d’évaluations structurées, ce qui vous permet de passer d’améliorations ad hoc à une approche plus systématique de la mesure de la qualité. Une fois que les problèmes récurrents sont résolus et que les performances se stabilisent, vous serez bien préparé pour un déploiement de production avec une évaluation robuste en place.

 2. Évaluer et itérer

Une fois que votre application IA de génération a été testée dans un environnement de préproduction, l’étape suivante consiste à mesurer, diagnostiquer et affiner systématiquement sa qualité. Cette phase « évaluer et itérer » transforme les commentaires et journaux bruts et dans un jeu d’évaluation structuré, ce qui vous permet de tester à plusieurs reprises les améliorations et de garantir que votre application répond aux normes requises pour la précision, la pertinence et la sécurité.

Cette phase comprend les étapes suivantes :

• Collecter des requêtes réelles à partir de journaux : transformez les interactions à haute valeur ou problématiques de vos tables d’inférence en cas tests.
• Ajouter des étiquettes d’experts : Dans la mesure du possible, attachez des vérités terrain ou des directives de style et de politique à ces cas afin que vous puissiez mesurer l’exactitude, les fondements et d’autres dimensions de qualité de manière plus objective.
• tirer parti de l'évaluation des agents :utiliser des juges LLM intégrés ou des vérifications personnalisées pour quantifier la qualité des applications.
• Itérer : améliorez la qualité en affinant la logique, les pipelines de données ou les requêtes de votre agent. Réexécutez l’évaluation pour vérifier si vous avez résolu les problèmes clés.

Notez que ces fonctionnalités fonctionnent même si votre application d'IA générative s’exécute en dehors de Databricks. En instrumentant votre code avec le suivi MLflow, vous pouvez capturer des traces à partir de n’importe quel environnement et les unifier dans la plateforme Databricks Data Intelligence pour une évaluation et une surveillance cohérentes. Lorsque vous continuez à incorporer de nouvelles requêtes, commentaires et insights sur les PME, votre jeu de données d’évaluation devient une ressource vivante qui sous-tend un cycle d’amélioration continue, garantissant ainsi que votre application IA de génération reste robuste, fiable et alignée sur les objectifs métier.

a. Évaluer l’agent

Une fois que votre agent s’exécute dans un environnement de préproduction, l’étape suivante consiste à mesurer systématiquement ses performances au-delà des vérifications d’ambiance ad hoc. Mosaic AI Agent Evaluation vous permet de créer des jeux d’évaluation, d’exécuter des vérifications de qualité avec des juges LLM intégrés ou personnalisés, et d’itérer rapidement sur les domaines problématiques.

Évaluations hors ligne et en ligne

Lors de l’évaluation des applications IA de génération, il existe deux approches principales : l’évaluation hors connexion et l’évaluation en ligne. Cette phase du cycle de développement se concentre sur l’évaluation hors connexion, qui fait référence à une évaluation systématique en dehors des interactions utilisateur actives. L’évaluation en ligne est abordée plus tard lors de la supervision de votre agent en production.

Les équipes s’appuient souvent trop fortement et trop longtemps sur les « tests de ressenti » dans le flux de travail du développeur, essayant de façon informelle une poignée de requêtes et jugeant subjectivement si les réponses semblent raisonnables. Bien que cela fournisse un point de départ, il manque la rigueur et la couverture nécessaires pour créer des applications de qualité de production.

En revanche, un processus d’évaluation hors connexion approprié effectue les opérations suivantes :

• Établir une base de référence de qualité avant un déploiement plus large, créant des métriques claires à cibler pour une amélioration.
• Identifie des faiblesses spécifiques qui nécessitent une attention particulière, en dépassant la limitation des cas d’usage uniquement attendus.
• Détecte les régressions de qualité lorsque vous affinez votre application en comparant automatiquement les performances entre les versions.
• Fournit des métriques quantitatives pour démontrer l'amélioration aux parties prenantes.
• Permet de découvrir les cas de périphérie et les modes d’échec potentiels avant que les utilisateurs ne le fassent.
• Réduit les risques de déploiement d’un agent sous-formé en production.

Investir du temps dans l’évaluation hors connexion paie des dividendes significatifs à long terme, ce qui vous aide à fournir des réponses cohérentes de haute qualité.

Créer un jeu d’évaluation

Un jeu d’évaluation sert de base pour mesurer les performances de votre application d’IA générative. À l’instar d’une suite de tests dans le développement logiciel traditionnel, cette collection de requêtes représentatives et de réponses attendues devient votre jeu de données de test de régression et de test de qualité.

Vous pouvez créer un jeu d’évaluation à l’aide de plusieurs approches complémentaires :

1. Transformer les journaux de table d’inférence en exemples d’évaluation

   Les données d’évaluation les plus précieuses proviennent directement de l’utilisation réelle. Votre déploiement de préproduction a généré des journaux de table d’inférence contenant des demandes, des réponses de l’agent, des appels d’outils et un contexte récupéré.

   La conversion de ces journaux de bord en un jeu d’évaluation offre plusieurs avantages :

   • Couverture dans le monde réel : Les comportements imprévisibles des utilisateurs que vous n’avez peut-être pas anticipés sont inclus.
   • focus sur le problème : Vous pouvez filtrer spécifiquement pour les commentaires négatifs ou les réponses lentes.
   • Distribution représentative : la fréquence réelle de différents types de requêtes est capturée.

2. Générer des données d’évaluation synthétiques

   Si vous n’avez pas d’ensemble organisé de requêtes utilisateur, vous pouvez générer automatiquement un jeu de données d’évaluation synthétique. Ce « jeu de démarrage » de requêtes vous permet d’évaluer rapidement si l’agent :

   • Retourne des réponses cohérentes et précises.
   • Répond au format approprié.
   • Respecte la structure, la tonalité et les directives de stratégie.
   • Récupère correctement le contexte (pour RAG).

   Les données synthétiques ne sont généralement pas parfaites. Considérez-le comme un pas à pas temporaire. Vous souhaiterez également :

   • Demandez aux PME ou aux experts du domaine de passer en revue et d’élaguer toutes les requêtes non pertinentes ou répétitives.
   • Les remplacer ou les augmenter plus tard avec des journaux d’utilisation réels.

3. Organiser manuellement les requêtes

   Si vous préférez ne pas vous appuyer sur des données synthétiques ou n’avez pas encore de journaux d’inférence, identifiez 10 à 15 requêtes réelles ou représentatives et créez un jeu d’évaluation à partir de ceux-ci. Les requêtes représentatives peuvent provenir d’entrevues d’utilisateurs ou de brainstorming de développeurs. Même une courte liste organisée peut exposer des défauts éclatants dans les réponses de votre agent.

Ces approches ne sont pas mutuellement exclusives, mais complémentaires. Un jeu d’évaluation efficace évolue au fil du temps et combine généralement des exemples de plusieurs sources, notamment les suivants :

• Commencez par des exemples organisés manuellement pour tester les fonctionnalités principales.
• Ajoutez éventuellement des données synthétiques pour élargir la couverture avant d’avoir des données utilisateur réelles.
• Incorporez progressivement les journaux du monde réel au fur et à mesure de leur disponibilité.
• Actualisez continuellement avec de nouveaux exemples qui reflètent la modification des modèles d’utilisation.

Meilleures pratiques pour les requêtes d’évaluation

Lors de l’élaboration de votre jeu d’évaluation, incluez délibérément différents types de requêtes, tels que les suivants :

• Modèles d’utilisation attendus et inattendus (tels que des requêtes très longues ou courtes).
• Tentatives potentielles d’utilisation incorrecte ou attaques par injection de requêtes (telles que les tentatives de révéler la requête système).
• Requêtes complexes nécessitant plusieurs étapes de raisonnement ou appels d’outils.
• Situations limites avec des informations minimales ou ambiguës (comme des fautes d'orthographe ou des requêtes vagues).
• Exemples représentant différents niveaux de compétence utilisateur et arrière-plans.
• Requêtes qui testent les biais potentiels dans les réponses (telles que « comparer la société A et la société B »).

N’oubliez pas que votre jeu d’évaluation doit croître et évoluer en même temps que votre application. Lorsque vous découvrez de nouveaux modes d’échec ou comportements utilisateur, ajoutez des exemples représentatifs pour vous assurer que votre agent continue à s’améliorer dans ces domaines.

Ajouter des critères d’évaluation

Chaque exemple d’évaluation doit avoir des critères pour évaluer la qualité. Ces critères servent de normes sur lesquelles les réponses de l’agent sont mesurées, ce qui permet une évaluation objective sur plusieurs dimensions de qualité.

Vérités fondamentales ou réponses de référence

Lors de l’évaluation de l’exactitude des faits, il existe deux approches principales : les faits attendus ou les réponses de référence. Chacun sert un objectif différent dans votre stratégie d’évaluation.

Utiliser les faits attendus (recommandé)

L’approche expected_facts consiste à répertorier les faits clés qui doivent apparaître dans une réponse correcte. Pour obtenir un exemple, consultez Exemple de jeu d’évaluation avec request, response, guidelines, et expected_facts.

Cette approche offre des avantages significatifs :

• Permet une flexibilité dans la façon dont les faits sont exprimés dans la réponse.
• Facilite l’accès des PME à la vérité du terrain.
• Prend en charge différents styles de réponse tout en garantissant que les informations de base sont présentes.
• Permet une évaluation plus fiable entre les versions de modèle ou les paramètres.

Le juge d’exactitude intégré vérifie si la réponse de l’agent incorpore ces faits essentiels, quelle que soit la formulation, l’ordre ou le contenu supplémentaire.

Utiliser la réponse attendue (alternative)

Vous pouvez également fournir une réponse de référence complète. Cette approche fonctionne le mieux dans les situations suivantes :

• Vous avez des réponses standard créées par des experts.
• La formulation ou la structure exacte de la réponse est importante.
• Vous évaluez les réponses dans des contextes hautement réglementés.

Databricks recommande généralement d’utiliser expected_facts sur expected_response, car elle offre une plus grande flexibilité tout en garantissant la précision.

Recommandations en matière de conformité de style, de ton ou de stratégie

Au-delà de la précision factuelle, vous devrez peut-être évaluer si les réponses respectent un style, un ton ou des exigences de stratégie spécifiques.

Indications uniquement

Si votre préoccupation principale est d’appliquer des exigences de style ou de stratégie plutôt que de précision factuelle, vous pouvez fournir des instructions sans faits attendus:

# Per-query guidelines
eval_row = {
    "request": "How do I delete my account?",
    "guidelines": {
        "tone": ["The response must be supportive and non-judgmental"],
        "structure": ["Present steps chronologically", "Use numbered lists"]
    }
}

# Global guidelines (applied to all examples)
evaluator_config = {
    "databricks-agent": {
        "global_guidelines": {
            "rudeness": ["The response must not be rude."],
            "no_pii": ["The response must not include any PII information (personally identifiable information)."]
        }
    }
}

Le juge LLM interprète ces instructions en langage naturel et évalue si la réponse est conforme à ces instructions. Cela fonctionne particulièrement bien pour les dimensions de qualité subjective comme le ton, la mise en forme et l’adhésion aux stratégies organisationnelles.

Combiner la vérité de base et les instructions

Pour une évaluation complète, vous pouvez combiner des vérifications de précision factuelle avec des instructions de style. Consultez Exemple de jeu d’évaluation avec request, response, guidelines, et expected_facts. Cette approche garantit que les réponses sont exactes et conformes aux normes de communication de votre organisation.

Utiliser des réponses pré-capturées

Si vous avez déjà capturé des paires demande-réponse à partir du développement ou du test, vous pouvez les évaluer directement sans réinvoquer votre agent. Cela est utile pour :

• Analyse des modèles existants dans le comportement de votre agent.
• Évaluation des performances par rapport aux versions précédentes.
• Gagner du temps et des coûts en ne régénérant pas les réponses.
• Évaluation d’un agent servi en dehors de Databricks.

Pour obtenir des informations sur l'ajout des colonnes appropriées dans votre DataFrame d’évaluation, consultez l’exemple : Comment passer des sorties précédemment générées à l’évaluation de l’agent. Mosaïque AI Agent Evaluation utilise ces valeurs pré-capturées au lieu d’appeler à nouveau votre agent, tout en appliquant les mêmes vérifications et métriques de qualité.

Meilleures pratiques pour les critères d’évaluation

Lors de la définition de vos critères d’évaluation :

1. Être précis et objectif : Définir des critères clairs et mesurables que les différents évaluateurs interpréteraient de la même façon.
   • Envisagez d’ajouter des métriques personnalisées pour mesurer les critères de qualité dont vous vous souciez.
2. Concentrez-vous sur la valeur de l’utilisateur : hiérarchiser les critères qui s’alignent sur ce qui compte le plus pour vos utilisateurs.
3. Démarrer simple : Commencer par un ensemble de critères de base et développer à mesure que votre compréhension des besoins de qualité augmente.
4. Couverture équilibrée : Inclure des critères qui couvrent différents aspects de la qualité (par exemple, précision factuelle, style et sécurité).
5. itérer en fonction des commentaires : affiner vos critères en fonction des commentaires des utilisateurs et des exigences en constante évolution.

Consultez Meilleures pratiques pour développer un jeu d’évaluation pour plus d’informations sur la création de jeux de données d’évaluation de haute qualité.

Exécuter des évaluations

Maintenant que vous avez préparé un jeu d’évaluation avec des requêtes et des critères, vous pouvez exécuter une évaluation à l’aide de mlflow.evaluate(). Cette fonction gère l’ensemble du processus d’évaluation, de l’appel de votre agent à l’analyse des résultats.

Flux de travail d’évaluation de base

L’exécution d’une évaluation de base nécessite seulement quelques lignes de code. Pour plus d’informations, consultez Exécuter une évaluation.

Lorsque l’évaluation est déclenchée :

1. Pour chaque ligne de votre jeu d’évaluation, mlflow.evaluate() effectue les opérations suivantes :
   • Appelle votre agent avec la requête (si vous n’avez pas déjà fourni de réponse).
   • Utilise des évaluateurs LLM intégrés pour apprécier les aspects de qualité.
   • Calcule les métriques opérationnelles telles que l’utilisation des jetons et la latence.
   • Enregistre des justifications détaillées pour chaque évaluation.
2. Les résultats sont automatiquement consignés dans MLflow, en créant :
   • Évaluations de qualité par ligne.
   • Métriques agrégées dans tous les exemples.
   • Fichiers détaillés pour le débogage et l’analyse.

Personnaliser l’évaluation

Vous pouvez adapter l’évaluation à vos besoins spécifiques à l’aide de paramètres supplémentaires. Le paramètre evaluator_config vous permet d’effectuer les opérations suivantes :

• Sélectionnez les juges intégrés à exécuter.
• Définissez des instructions globales qui s’appliquent à tous les exemples.
• Configurer des seuils pour les juges.
• Fournissez quelques exemples pour guider les évaluations des juges.

Pour plus d’informations et d’exemples, consultez Exemples.

Évaluer des agents en dehors de Databricks

Une fonctionnalité puissante de l’évaluation de l’agent est sa capacité à évaluer les applications IA de génération déployées n’importe où, pas seulement sur Databricks.

Quels juges sont appliqués

Par défaut, l’évaluation de l’agent sélectionne automatiquement les juges LLM appropriés en fonction des données disponibles dans votre jeu d’évaluation. Pour plus d’informations sur la façon dont la qualité est évaluée, consultez Comment la qualité est évaluée par les juges LLM.

Analyser les résultats de l’évaluation

Après avoir exécuté une évaluation, l’interface utilisateur MLflow fournit des visualisations et des insights pour comprendre les performances de votre application. Cette analyse vous aide à identifier les modèles, diagnostiquer les problèmes et à hiérarchiser les améliorations.

Parcourir les résultats de l’évaluation

Lorsque vous ouvrez l’interface utilisateur MLflow après avoir exécuté mlflow.evaluate(), vous trouverez plusieurs vues interconnectées. Pour plus d’informations sur la navigation dans ces résultats dans l’interface utilisateur MLflow, consultez Vérifier la sortie à l’aide de l’interface utilisateur MLflow.

Pour obtenir des conseils sur l’interprétation des modèles d’échec, consultez b. Améliorer l’agent et les outils.

Juges d’IA personnalisés et métriques

Bien que les juges intégrés couvrent de nombreux contrôles courants (par exemple, l’exactitude, le style, la stratégie et la sécurité), vous devrez peut-être évaluer les aspects spécifiques au domaine des performances de votre application. Les juges personnalisés et les métriques vous permettent d’étendre les fonctionnalités d’évaluation pour répondre à vos exigences de qualité uniques.

Juges LLM personnalisés

Pour plus de détails sur la manière de créer un juge LLM personnalisé à partir d’une invite, veuillez consulter Création de juges IA à partir d’une invite.

Les juges sur mesure excellent dans l’évaluation des dimensions de qualité subjectives ou nuancées qui bénéficient d’un jugement semblable à celui des humains, comme :

• Conformité spécifique au domaine (juridique, médical, financier).
• Style de voix et de communication de marque.
• Sensibilité culturelle et pertinence.
• Qualité de raisonnement complexe.
• Conventions d’écriture spécialisées.

La sortie du juge apparaît dans l’interface utilisateur MLflow en même temps que les juges intégrés, avec les mêmes justifications détaillées expliquant les évaluations.

métriques personnalisées

Pour des évaluations plus programmatiques et déterministes, vous pouvez créer des métriques personnalisées à l’aide du décorateur @metric. Voir @metric décorateur.

Les métriques personnalisées sont idéales pour :

• Vérification des exigences techniques telles que la validation de format et la conformité des schémas.
• Vérification de la présence ou de l’absence de contenu spécifique.
• Effectuer des mesures quantitatives telles que la longueur de réponse ou les scores de complexité.
• Implémentation de règles de validation spécifiques à l’entreprise.
• Intégration à des systèmes de validation externes.

b. Améliorer l’agent et les outils

Après l’exécution de l’évaluation et l’identification des problèmes de qualité, l’étape suivante consiste à résoudre systématiquement ces problèmes pour améliorer les performances. Les résultats de l'évaluation fournissent des informations précieuses sur l'endroit et la manière dont échoue votre agent, ce qui vous permet d'apporter des améliorations bien ciblées plutôt que des ajustements aléatoires.

problèmes de qualité courants et comment les résoudre

Les évaluations des juges LLM de vos résultats d’évaluation pointent vers des types spécifiques d’échecs dans votre système d’agent. Cette section explore ces modèles d’échec courants et leurs solutions. Pour plus d’informations sur l’interprétation des sorties du juge LLM, consultez Sorties du juge IA.

Meilleures pratiques pour une itération de qualité

Au fur et à mesure que vous effectuez une itération sur les améliorations, conservez une documentation rigoureuse. Par exemple:

1. Versionnez vos modifications
   • Consignez chaque itération significative à l’aide du suivi MLflow.
   • Enregistrez les invites, les configurations et les paramètres clés dans un fichier de configuration central. Vérifiez que cela est enregistré avec l’agent.
   • Pour chaque nouvel agent déployé, conservez un journal des modifications dans votre dépôt détaillant ce qui a changé et pourquoi.
2. Documentez à la fois ce qui a fonctionné et n’a pas fonctionné
   • Documentez les approches réussies et infructueuses.
   • Notez l’impact spécifique de chaque modification sur les métriques. Revenez à l’exécution MLflow de l’évaluation de l’agent.
3. S'aligner avec les parties prenantes
   • Utilisez l’application De révision pour valider les améliorations apportées aux PME.
     • Communiquez les modifications aux réviseurs à l’aide des instructions du réviseur .
   • Pour une comparaison côte à côte de différentes versions d’un agent, envisagez de créer plusieurs points de terminaison d’agent et d’utiliser le modèle dans AI Playground. Cela permet aux utilisateurs d’envoyer la même requête à des points de terminaison distincts et d’examiner la réponse et les traces côte à côte.

 3. Production

Après avoir évalué et amélioré de façon itérative votre application, vous avez atteint un niveau de qualité qui répond à vos besoins et est prêt à être utilisé plus large. La phase de production implique le déploiement de votre agent affiné dans votre environnement de production et l’implémentation d’une surveillance continue pour maintenir la qualité au fil du temps.

La phase de production comprend les éléments suivants :

• Déployer un agent en production : configurer un point de terminaison prêt pour la production avec des paramètres de sécurité, de mise à l’échelle et d’authentification appropriés.
• Surveiller l’agent en production : Établir une évaluation continue de la qualité, un suivi des performances et des alertes pour garantir la haute qualité et la fiabilité de votre agent dans le monde réel.

Cela crée une boucle de rétroaction continue dans laquelle les insights de surveillance entraînent des améliorations supplémentaires, que vous pouvez tester, déployer et continuer à surveiller. Cette approche garantit que votre application reste de haute qualité, conforme et alignée sur les besoins métier en constante évolution tout au long de son cycle de vie.

a. Déployer l’agent en production

Une fois que vous avez effectué une évaluation approfondie et une amélioration itérative, vous êtes prêt à déployer votre agent dans un environnement de production. [Mosaïque AI Agent Framework](/générative-ai/agent-framework/build-gen AI-apps.md#agent-framework) simplifie ce processus en gérant automatiquement de nombreux problèmes de déploiement.

Processus de déploiement

Le déploiement de votre agent en production implique les étapes suivantes :

1. Enregistrer et inscrire votre agent comme modèle MLflow dans Unity Catalog.
2. Déployer l’agent à l’aide d’Agent Framework.
3. Configurer l'authentification pour toutes les ressources dépendantes que votre agent doit accéder.
4. Testez le déploiement pour vérifier les fonctionnalités dans l’environnement de production.
   • Une fois que le point de terminaison de service du modèle est prêt, vous pouvez interagir avec l’agent dans ai Playground, où vous pouvez tester et vérifier les fonctionnalités.

Pour obtenir des étapes d’implémentation détaillées, consultez Déployer un agent pour l’application IA générative.

Considérations relatives au déploiement de production

À mesure que vous passez à la production, gardez à l’esprit les considérations clés suivantes :

Performance et mise à l’échelle

• Équilibrez les coûts et les performances en fonction de vos modèles d’utilisation attendus.
• Envisagez d’activer la mise à l’échelle à zéro pour les agents utilisés par intermittence afin de réduire les coûts.
• Comprendre les exigences de latence en fonction des besoins de l’expérience utilisateur de votre application.

sécurité et gouvernance

• Veillez à ce que des contrôles d’accès appropriés soient en place au niveau de Unity Catalog pour tous les composants de l’agent.
• Utilisez le passthrough d’authentification intégré pour les ressources Databricks, le cas échéant.
• Configurez la gestion des informations d’identification appropriées pour les API externes ou les sources de données.

approche d’intégration

• Déterminez comment votre application interagit avec l’agent (par exemple, à l’aide d’une API ou d’une interface incorporée).
• Réfléchissez à la façon de gérer et d’afficher les réponses de l’agent dans votre application.
  • Si votre application cliente a besoin d’un contexte supplémentaire (par exemple, des références de documents sources ou des scores de confiance), concevez votre agent pour inclure ces métadonnées dans ses réponses (par exemple, en utilisant sorties personnalisées).
• Planifiez la gestion des erreurs et les mécanismes de secours pour le moment où l’agent n’est pas disponible.

collecte de commentaires

• Tirez parti de l’application de révision pour obtenir des commentaires sur les parties prenantes lors du déploiement initial.
• Mécanismes de conception pour collecter les commentaires des utilisateurs directement dans votre interface d’application.
  • Le point de terminaison de commentaires créé pour collecter des commentaires à partir de l’application de révision peut également être utilisé par des applications externes pour fournir des commentaires sur votre agent. Consultez Fournir des commentaires sur un agent déployé.
• Assurez-vous que les données de commentaires circulent dans votre processus d’évaluation et d’amélioration.

b. Surveiller l’agent en production

Une fois votre agent déployé en production, il est essentiel de surveiller en permanence ses performances, sa qualité et ses modèles d’utilisation. Contrairement aux logiciels traditionnels où les fonctionnalités sont déterministes, les applications d'IA générative peuvent présenter des dérives de qualité ou des comportements inattendus lorsqu'elles rencontrent des entrées réelles. Une surveillance efficace vous permet de détecter les problèmes précoces, de comprendre les modèles d’utilisation et d’améliorer en permanence la qualité de votre application.

Configurer la surveillance de l’agent

Mosaïque AI fournit des fonctionnalités de surveillance intégrées qui vous permettent de suivre les performances de votre agent sans créer d’infrastructure de supervision personnalisée :

1. Créer un moniteur pour votre agent déployé.
2. Configurer le taux d’échantillonnage et la fréquence en fonction des besoins en matière de volume de trafic et de surveillance.
3. Sélectionner des métriques de qualité pour évaluer automatiquement les demandes échantillonées.

Dimensions de surveillance clés

En général, la surveillance efficace doit couvrir trois dimensions critiques :

1. métriques opérationnelles

   • Demande de volume et de motifs.
   • Latence de réponse.
   • Taux d’erreur et types.
   • Utilisation et coûts des jetons.

2. Métriques de qualité

   • Pertinence des requêtes utilisateur.
   • Fondement dans le contexte retrouvé.
   • Respect de la sécurité et des directives.
   • Taux de réussite globale de qualité.

3. commentaires des utilisateurs

   • Commentaires explicites (pouce levé/baissé).
   • Signaux implicites (questions de suivi, conversations abandonnées).
   • Problèmes signalés aux canaux de support.

Utiliser l’interface utilisateur de surveillance

L’interface utilisateur de surveillance fournit des insights visualisées sur ces dimensions via deux onglets.

• onglet Graphiques: affichez les tendances dans le volume de requêtes, les métriques de qualité, la latence et les erreurs au fil du temps.
• onglet Logs: Examinez les demandes et réponses individuelles, y compris leurs résultats d’évaluation.

Les fonctionnalités de filtrage permettent aux utilisateurs de rechercher des requêtes spécifiques ou de filtrer par résultat d’évaluation. Pour plus d’informations, consultez Utiliser l’interface utilisateur de surveillance.

Créer des tableaux de bord et des alertes

Pour une surveillance complète :

• Créer des tableaux de bord personnalisés à l’aide des données de surveillance stockées dans la table de traces évaluées.
• configurer des alertes pour des seuils de qualité ou opérationnels critiques.
• Planifier des examens réguliers de la qualité avec les principales parties prenantes.

Cycle d’amélioration continue

La surveillance est la plus précieuse lorsqu’elle revient dans votre processus d’amélioration :

1. Identifier les problèmes via la surveillance des métriques et des commentaires des utilisateurs.
2. Exporter des exemples problématiques dans votre jeu d’évaluation.
3. Diagnostiquer les causes profondes à l'aide de l'analyse de trace de MLflow et des résultats du juge LLM (comme décrit dans Problèmes de qualité courants et comment les résoudre).
4. Développer et tester des améliorations par rapport à votre jeu d’évaluation élargi.
5. Déployer des mises à jour et surveiller l’impact.

Cette approche itérative de boucle fermée permet de garantir que votre agent continue à s’améliorer en fonction des modèles d’utilisation réels, en conservant une haute qualité tout en s’adaptant aux exigences et aux comportements des utilisateurs. Avec la supervision de l’agent, vous bénéficiez d’une visibilité sur la façon dont votre agent effectue en production, ce qui vous permet de résoudre de manière proactive les problèmes et d’optimiser la qualité et les performances.