Testando IA não determinística em Power Apps (visualização)

Testar aplicativos alimentados por IA introduz desafios exclusivos porque as saídas de IA podem variar entre execuções, mesmo com entradas idênticas. Este comportamento não determinístico requer abordagens de teste especiais. Este guia explica como validar componentes de IA em seus Power Platform aplicativos de forma eficaz.

Compreender os resultados não determinísticos

Os testes tradicionais dependem de entradas determinísticas que produzem resultados consistentes. No entanto, os sistemas de IA muitas vezes produzem resultados ligeiramente diferentes de cada vez devido a:

• Definições de temperatura do modelo e métodos de amostragem
• Seleção de diferentes versões de modelos
• Pequenas variações no processamento de linguagem natural
• Escores de confiança que flutuam dentro dos intervalos normais
• Raciocínio dependente do contexto que pode tomar caminhos diferentes

Estratégias para testar IA não determinística

Power Apps O Test Engine fornece várias estratégias para testar efetivamente componentes alimentados por IA:

Use a função Preview.AIExecutePrompt

A função Preview.AIExecutePrompt permite a execução controlada de prompts de IA em seus testes. O exemplo a seguir demonstra como usá-lo:

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

Esta abordagem permite-lhe:

• Execute prompts com entradas controladas
• Analisar e validar respostas estruturadas
• Comparar os resultados com os valores esperados

Implementar validação baseada em tolerância

Em vez de esperar correspondências exatas, verifique se as saídas atendem aos critérios dentro de limites aceitáveis. O código a seguir é um exemplo:

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

Testar a funcionalidade principal em vez de saídas exatas

Testes de foco na validação de que o componente de IA cumpre seu propósito essencial, conforme mostrado no exemplo a seguir:

// 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"
)

Use a validação estrutural para saídas complexas

Para respostas complexas de IA, valide a estrutura de resposta em vez de conteúdo específico, como mostrado no exemplo a seguir:

// 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")

Usando Preview.AIExecutePrompt

O Test Engine fornece a função Preview.AIExecutePrompt especificamente para testar interações de IA.

Assinatura da função

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

Parâmetros

• PromptName: O nome do modelo de prompt a ser usado
• PromptContext: Dados de contexto para o prompt, geralmente contendo:
  • Contexto ou mensagem do sistema
  • Perguntas ou entradas do utilizador
  • Quaisquer outros parâmetros para o modelo

Valor devolvido

Um registo que contenha:

• Texto: O texto bruto da resposta
• Outras propriedades, dependendo do modelo e do modelo de prompt

Ativando a função

Para usar essa função, ative o módulo de funções AI em suas definições de teste:

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

Exemplo: Testando um componente de análise de sentimento

O exemplo a seguir demonstra o teste de um recurso de análise de sentimento alimentado por 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)
  })

Exemplo: Avaliação de avaliação AI

O exemplo a seguir demonstra o uso Preview.AIExecutePrompt para testar um sistema de classificação alimentado por 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}
  ))

Você pode explorar uma implementação completa no exemplo AIPrompt.

Práticas recomendadas para testes de componentes de IA

Para criar testes eficazes para componentes alimentados por IA:

• Definir intervalos aceitáveis em vez de valores exatos para saídas numéricas
• Crie guarda-corpos para verificar se as saídas atendem aos requisitos estruturais
• Teste com diversas entradas, incluindo casos de borda e condições de contorno
• Inclua casos de teste negativos para garantir que a IA lide com entradas inválidas adequadamente
• Segmente seus testes por funcionalidade em vez de conteúdo específico
• Utilizar tolerâncias adequadas com base na criticidade do componente

Padrões comuns para testes de IA

Os exemplos a seguir ilustram abordagens comuns para testar recursos baseados em IA em Power Platform aplicativos. Esses padrões ajudam a validar a classificação de conteúdo, as condições de limite e outros cenários em que as saídas de IA podem variar.

Testes de classificação de conteúdo

// 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"
  ))

Testes de 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"
  ))

Artigos relacionados

Saiba mais sobre Power Fx as funções de teste
Explore a criação de testes assistida por IA
Compreender o protocolo de contexto do modelo
Navegue pelo catálogo de amostras do Test Engine