Test des composants d’IA non déterministes dans Power Apps (version préliminaire)

Le test d’applications alimentées par l’IA présente des défis uniques, car les résultats de l’IA peuvent varier d’une exécution à l’autre, même avec des entrées identiques. Ce comportement non déterministe nécessite des approches de test spéciales. Ce guide explique comment valider efficacement les composants d’IA dans vos applications Power Platform.

Comprendre les résultats non déterministes

Les tests traditionnels reposent sur des entrées déterministes produisant des sorties cohérentes. Cependant, les systèmes d’IA produisent souvent des résultats légèrement différents à chaque fois en raison de :

• Réglages du modèle de température et méthodes d'échantillonnage
• Sélection de différentes versions de modèles
• Variations mineures dans le traitement du langage naturel
• Scores de confiance qui fluctuent à l’intérieur des plages normales
• Raisonnement dépendant du contexte qui peut emprunter des chemins différents

Stratégies pour tester l’IA non déterministe

Power Apps Test Engine propose plusieurs stratégies pour tester efficacement les composants alimentés par l’IA :

Utiliser la fonction Aperçu.AIExecutePrompt

La fonction Aperçu.AIExecutePrompt permet l’exécution contrôlée d’invites d’IA dans vos tests. L’exemple suivant montre comment l'utiliser :

Response: ParseJSON(
  Preview.AIExecutePrompt("CustomPrompt",
  {
    Context: "You are a helpful assistant.",
    Question: "What is the capital of France?"
  }).Text)

Cette approche vous permet d’effectuer ce qui suit :

• Exécuter des invites avec des entrées contrôlées
• Analyser et valider les réponses structurées
• Comparaison des résultats aux valeurs prévues

Implémenter la validation basée sur les tolérances

Au lieu d’attendre des correspondances exactes, vérifiez que les résultats répondent aux critères dans des seuils acceptables. Le code suivant est un exemple :

// Validate that the sentiment score is within appropriate range
Assert(Response.SentimentScore >= 0.7, "Sentiment score should be positive")

Tester les fonctionnalités de base plutôt que les résultats exacts

Concentrez les tests sur la validation que le composant d’IA remplit son objectif essentiel, comme illustré dans l’exemple suivant :

// Check that the classification happens (not the exact classification)
Assert(
  Response.Category = "Positive" || 
  Response.Category = "Neutral" || 
  Response.Category = "Negative", 
  "Response should include a valid sentiment category"
)

Utiliser la validation structurelle pour les sorties complexes

Pour les réponses IA complexes, validez la structure de la réponse plutôt qu’un contenu spécifique, comme illustré dans l’exemple suivant :

// Verify all expected fields exist in the response
Assert(!IsBlank(Response.Rating), "Rating should be present")
Assert(!IsBlank(Response.Explanation), "Explanation should be present")
Assert(!IsBlank(Response.NextSteps), "Next steps should be present")

Utilisation de Preview.AIExecutePrompt

Test Engine fournit la fonction Preview.AIExecutePrompt spécifiquement pour tester les interactions avec l’IA.

Signature de la fonction

Preview.AIExecutePrompt(
  PromptName: Text, 
  PromptContext: Record
): Record

Paramètres

• PromptName : nom du modèle d’invite à utiliser
• PromptContext : données de contexte pour l’invite, contenant généralement :
  • Message système ou contextuel
  • Questions ou entrées utilisateur
  • Tous les autres paramètres du modèle

Valeur renvoyée

Un enregistrement contenant :

• Texte : le texte brut de la réponse
• Autres propriétés en fonction du gabarit d'invite et du modèle

Activation de la fonction

Pour utiliser cette fonction, activez le module Fonctions IA dans vos paramètres de test :

testSettings:
  extensionModules:
    enable: true
    parameters:
      enableAIFunctions: true

Exemple : Test d’un composant d’analyse des sentiments

L’exemple suivant illustre le test d’une fonctionnalité d’analyse des sentiments alimentée par l’IA :

EvaluateSentimentPrompt(Input: Text): TestResult =
  With({
    Response: ParseJSON(
      Preview.AIExecutePrompt("SentimentAnalyzer",
      {
        Text: Input
      }).Text)
  },
  {
    Result: Response.Sentiment,
    Score: Response.ConfidenceScore,
    IsPositive: Response.Sentiment = "Positive" && Response.ConfidenceScore > 0.7,
    IsValid: !IsBlank(Response.Sentiment) && !IsBlank(Response.ConfidenceScore)
  })

Exemple : Note d'évaluation de l’IA

L’exemple suivant illustre l’utilisation de Preview.AIExecutePrompt pour tester un système d’évaluation alimenté par l’IA :

EvaluateTestQuestionPrompt(Prompt: TestQuestion): TestResult =
  With({
    Response: ParseJSON(
      Preview.AIExecutePrompt("PromptEvaluator",
      {
        Context: "You are a helpful agent asking about external customer service questions.",
        Question: Prompt.Question
      }).Text)
  },If(
    IsError(AssertNotError(Prompt.ExpectedRating=Response.Rating, Prompt.Question & ", Expected " & Prompt.ExpectedRating & ", Actual " & Response.Rating)),
    {PassFail: 1, Summary: Prompt.Question & ", Expected " & Prompt.ExpectedRating & ", Actual " & Response.Rating}, 
    {PassFail: 0, Summary: "Pass " & Prompt.Question}
  ))

Vous pouvez explorer une implémentation complète dans l’exemple d’invite d’IA.

Meilleures pratiques pour les tests de composants d’IA

Pour créer des tests efficaces pour les composants alimentés par l’IA :

• Définir des plages acceptables au lieu de valeurs exactes pour les sorties numériques
• Créer des garde-fous pour vérifier que les sorties répondent aux exigences structurelles
• Testez avec diverses entrées y compris les cas limites et les conditions de délimitation
• Inclure des cas de test négatifs pour s’assurer que l’IA traite les entrées non valides de manière appropriée
• Segmentez vos tests par fonctionnalité plutôt que par contenu spécifique
• Utilisez des tolérances appropriées en fonction de la criticité du composant

Modèles courants pour les tests d’IA

Les exemples suivants illustrent des approches courantes pour tester des fonctionnalités basées sur l’IA dans les applications Power Platform. Ces modèles vous aident à valider la classification du contenu, les conditions aux limites et d’autres scénarios où les résultats de l’IA peuvent varier.

Tests de classification de contenu

// Test that a content classifier produces valid categories
ClassifyContent(Text: Text): Record = 
  With({
    Result: ParseJSON(Preview.AIExecutePrompt("Classifier", { Content: Text }).Text)
  },
  Assert(
    Result.Category In ["News", "Opinion", "Advertisement"], 
    "Content should be classified into valid category"
  ))

Test des limites

// Test AI Builder form processing with edge cases
TestFormProcessing(FormType: Text): TestResult =
  With({
    Result: ParseJSON(Preview.AIExecutePrompt("FormProcessor", { FormType: FormType }).Text)
  },
  Assert(
    !IsBlank(Result.Fields),
    "Form processing should extract fields even with poor quality input"
  ))

Articles associés

En savoir plus sur les fonctions de test Power Fx
Explorer la création de test assistée par l'IA
Comprendre le Protocole de contexte de modèle
Parcourir le catalogue d’exemples Test Engine