Testando IA não determinística em Power Apps (prévia)

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

Compreendendo saídas não determinísticas

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

• Configurações de temperatura do modelo e métodos de amostragem
• Selecionando diferentes versões de modelos
• Pequenas variações no processamento da linguagem natural
• Pontuações de confiança que flutuam dentro das faixas 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 diversas estratégias para testar efetivamente componentes com tecnologia de 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)

Essa abordagem permite que você:

• Executar 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 dos 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")

Teste 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 validação estrutural para saídas complexas

Para respostas de IA complexas, valide a estrutura da resposta em vez do conteúdo específico, conforme 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 de 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, normalmente contendo:
  • Contexto ou mensagem do sistema
  • Perguntas ou contribuições do usuário
  • Quaisquer outros parâmetros para o modelo

Retornar valor

Um registro contendo:

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

Habilitando a função

Para usar esta função, ative o módulo de funções de IA nas suas configuraçõ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 sentimentos com tecnologia de 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 classificação de IA

O exemplo a seguir demonstra o uso de 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 do AI Prompt.

Melhores práticas para testes de componentes de IA

Para criar testes eficazes para componentes com tecnologia de IA:

• Defina 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 extremos e condições de contorno
• Incluir casos de teste negativos para garantir que a IA trate entradas inválidas adequadamente
• Segmente seus testes por funcionalidade em vez de conteúdo específico
• Use tolerâncias apropriadas com base na criticidade do componente

Padrões comuns para testes de IA

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

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

Teste de limite

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

Aprenda sobre funções de teste Power Fx
Explore a criação de testes assistida por IA
Entenda o Protocolo de Contexto do Modelo
Navegue pelo catálogo de amostras do Test Engine