azure-ai-evaluation 0.0.0b0__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

azure/ai/evaluation/_evaluators/_qa/_qa.py

@@ -0,0 +1,111 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+from concurrent.futures import as_completed
+from typing import Union
+
+from promptflow.tracing import ThreadPoolExecutorWithContext as ThreadPoolExecutor
+
+from .._coherence import CoherenceEvaluator
+from .._f1_score import F1ScoreEvaluator
+from .._fluency import FluencyEvaluator
+from .._groundedness import GroundednessEvaluator
+from ..._model_configurations import AzureOpenAIModelConfiguration, OpenAIModelConfiguration
+from .._relevance import RelevanceEvaluator
+from .._similarity import SimilarityEvaluator
+
+
+class QAEvaluator:
+    """
+    Initialize a question-answer evaluator configured for a specific Azure OpenAI model.
+
+    :param model_config: Configuration for the Azure OpenAI model.
+    :type model_config: Union[~azure.ai.evaluation.AzureOpenAIModelConfiguration,
+        ~azure.ai.evaluation.OpenAIModelConfiguration]
+    :return: A function that evaluates and generates metrics for "question-answering" scenario.
+    :rtype: Callable
+
+    **Usage**
+
+    .. code-block:: python
+
+        eval_fn = QAEvaluator(model_config)
+        result = qa_eval(
+            query="Tokyo is the capital of which country?",
+            response="Japan",
+            context="Tokyo is the capital of Japan.",
+            ground_truth="Japan"
+        )
+
+    **Output format**
+
+    .. code-block:: python
+
+        {
+            "gpt_groundedness": 3.5,
+            "gpt_relevance": 4.0,
+            "gpt_coherence": 1.5,
+            "gpt_fluency": 4.0,
+            "gpt_similarity": 3.0,
+            "f1_score": 0.42
+        }
+    """
+
+    def __init__(
+        self, model_config: dict, parallel: bool = True
+    ):
+        self._parallel = parallel
+
+        self._evaluators = [
+            GroundednessEvaluator(model_config),
+            RelevanceEvaluator(model_config),
+            CoherenceEvaluator(model_config),
+            FluencyEvaluator(model_config),
+            SimilarityEvaluator(model_config),
+            F1ScoreEvaluator(),
+        ]
+
+    def __call__(self, *, query: str, response: str, context: str, ground_truth: str, **kwargs):
+        """
+        Evaluates question-answering scenario.
+
+        :keyword query: The query to be evaluated.
+        :paramtype query: str
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :keyword context: The context to be evaluated.
+        :paramtype context: str
+        :keyword ground_truth: The ground truth to be evaluated.
+        :paramtype ground_truth: str
+        :keyword parallel: Whether to evaluate in parallel. Defaults to True.
+        :paramtype parallel: bool
+        :return: The scores for QA scenario.
+        :rtype: dict
+        """
+        results = {}
+        if self._parallel:
+            with ThreadPoolExecutor() as executor:
+                futures = {
+                    executor.submit(
+                        evaluator,
+                        query=query,
+                        response=response,
+                        context=context,
+                        ground_truth=ground_truth,
+                        **kwargs
+                    ): evaluator
+                    for evaluator in self._evaluators
+                }
+
+                # Collect results as they complete
+                for future in as_completed(futures):
+                    results.update(future.result())
+        else:
+            for evaluator in self._evaluators:
+                result = evaluator(
+                    query=query, response=response, context=context, ground_truth=ground_truth, **kwargs
+                )
+                results.update(result)
+
+        return results

azure/ai/evaluation/_evaluators/_relevance/__init__.py

@@ -0,0 +1,9 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+from ._relevance import RelevanceEvaluator
+
+__all__ = [
+    "RelevanceEvaluator",
+]

azure/ai/evaluation/_evaluators/_relevance/_relevance.py

@@ -0,0 +1,131 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import os
+import re
+from typing import Union
+
+import numpy as np
+
+from promptflow._utils.async_utils import async_run_allowing_running_loop
+from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
+from promptflow.core import AsyncPrompty
+
+from ..._model_configurations import AzureOpenAIModelConfiguration, OpenAIModelConfiguration
+from ..._common.utils import (
+    check_and_add_api_version_for_aoai_model_config,
+    check_and_add_user_agent_for_aoai_model_config,
+)
+
+try:
+    from ..._user_agent import USER_AGENT
+except ImportError:
+    USER_AGENT = None
+
+
+class _AsyncRelevanceEvaluator:
+    # Constants must be defined within eval's directory to be save/loadable
+    PROMPTY_FILE = "relevance.prompty"
+    LLM_CALL_TIMEOUT = 600
+    DEFAULT_OPEN_API_VERSION = "2024-02-15-preview"
+
+    def __init__(self, model_config: dict):
+        check_and_add_api_version_for_aoai_model_config(model_config, self.DEFAULT_OPEN_API_VERSION)
+
+        prompty_model_config = {"configuration": model_config, "parameters": {"extra_headers": {}}}
+
+        # Handle "RuntimeError: Event loop is closed" from httpx AsyncClient
+        # https://github.com/encode/httpx/discussions/2959
+        prompty_model_config["parameters"]["extra_headers"].update({"Connection": "close"})
+
+        check_and_add_user_agent_for_aoai_model_config(
+            model_config,
+            prompty_model_config,
+            USER_AGENT,
+        )
+
+        current_dir = os.path.dirname(__file__)
+        prompty_path = os.path.join(current_dir, self.PROMPTY_FILE)
+        self._flow = AsyncPrompty.load(source=prompty_path, model=prompty_model_config)
+
+    async def __call__(self, *, query: str, response: str, context: str, **kwargs):
+        # Validate input parameters
+        query = str(query or "")
+        response = str(response or "")
+        context = str(context or "")
+
+        if not (query.strip() and response.strip() and context.strip()):
+            msg = "'query', 'response' and 'context' must be non-empty strings."
+            raise EvaluationException(
+                message=msg,
+                internal_message=msg,
+                error_category=ErrorCategory.MISSING_FIELD,
+                error_blame=ErrorBlame.USER_ERROR,
+                error_target=ErrorTarget.RELEVANCE_EVALUATOR,
+            )
+
+        # Run the evaluation flow
+        llm_output = await self._flow(
+            query=query, response=response, context=context, timeout=self.LLM_CALL_TIMEOUT, **kwargs
+        )
+
+        score = np.nan
+        if llm_output:
+            match = re.search(r"\d", llm_output)
+            if match:
+                score = float(match.group())
+
+        return {"gpt_relevance": float(score)}
+
+
+class RelevanceEvaluator:
+    """
+    Initialize a relevance evaluator configured for a specific Azure OpenAI model.
+
+    :param model_config: Configuration for the Azure OpenAI model.
+    :type model_config: Union[~azure.ai.evaluation.AzureOpenAIModelConfiguration,
+        ~azure.ai.evaluation.OpenAIModelConfiguration]
+
+    **Usage**
+
+    .. code-block:: python
+
+        eval_fn = RelevanceEvaluator(model_config)
+        result = eval_fn(
+            query="What is the capital of Japan?",
+            response="The capital of Japan is Tokyo.",
+            context="Tokyo is Japan's capital, known for its blend of traditional culture \
+                and technological advancements.")
+
+    **Output format**
+
+    .. code-block:: python
+
+        {
+            "gpt_relevance": 3.0
+        }
+    """
+
+    def __init__(self, model_config: dict):
+        self._async_evaluator = _AsyncRelevanceEvaluator(model_config)
+
+    def __call__(self, *, query: str, response: str, context: str, **kwargs):
+        """
+        Evaluate relevance.
+
+        :keyword query: The query to be evaluated.
+        :paramtype query: str
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :keyword context: The context to be evaluated.
+        :paramtype context: str
+        :return: The relevance score.
+        :rtype: dict
+        """
+        return async_run_allowing_running_loop(
+            self._async_evaluator, query=query, response=response, context=context, **kwargs
+        )
+
+    def _to_async(self):
+        return self._async_evaluator

azure/ai/evaluation/_evaluators/_relevance/relevance.prompty

@@ -0,0 +1,69 @@
+---
+name: Relevance
+description: Evaluates relevance score for QA scenario
+model:
+  api: chat
+  configuration:
+    type: azure_openai
+    azure_deployment: ${env:AZURE_DEPLOYMENT}
+    api_key: ${env:AZURE_OPENAI_API_KEY}
+    azure_endpoint: ${env:AZURE_OPENAI_ENDPOINT}
+  parameters:
+    temperature: 0.0
+    max_tokens: 1
+    top_p: 1.0
+    presence_penalty: 0
+    frequency_penalty: 0
+    response_format:
+      type: text
+
+inputs:
+  query:
+    type: string
+  response:
+    type: string
+  context:
+    type: string
+
+---
+system:
+You are an AI assistant. You will be given the definition of an evaluation metric for assessing the quality of an answer in a question-answering task. Your job is to compute an accurate evaluation score using the provided evaluation metric. You should return a single integer value between 1 to 5 representing the evaluation metric. You will include no other text or information.
+user:
+Relevance measures how well the answer addresses the main aspects of the question, based on the context. Consider whether all and only the important aspects are contained in the answer when evaluating relevance. Given the context and question, score the relevance of the answer between one to five stars using the following rating scale:
+One star: the answer completely lacks relevance
+Two stars: the answer mostly lacks relevance
+Three stars: the answer is partially relevant
+Four stars: the answer is mostly relevant
+Five stars: the answer has perfect relevance
+
+This rating value should always be an integer between 1 and 5. So the rating produced should be 1 or 2 or 3 or 4 or 5.
+
+context: Marie Curie was a Polish-born physicist and chemist who pioneered research on radioactivity and was the first woman to win a Nobel Prize.
+question: What field did Marie Curie excel in?
+answer: Marie Curie was a renowned painter who focused mainly on impressionist styles and techniques.
+stars: 1
+
+context: The Beatles were an English rock band formed in Liverpool in 1960, and they are widely regarded as the most influential music band in history.
+question: Where were The Beatles formed?
+answer: The band The Beatles began their journey in London, England, and they changed the history of music.
+stars: 2
+
+context: The recent Mars rover, Perseverance, was launched in 2020 with the main goal of searching for signs of ancient life on Mars. The rover also carries an experiment called MOXIE, which aims to generate oxygen from the Martian atmosphere.
+question: What are the main goals of Perseverance Mars rover mission?
+answer: The Perseverance Mars rover mission focuses on searching for signs of ancient life on Mars.
+stars: 3
+
+context: The Mediterranean diet is a commonly recommended dietary plan that emphasizes fruits, vegetables, whole grains, legumes, lean proteins, and healthy fats. Studies have shown that it offers numerous health benefits, including a reduced risk of heart disease and improved cognitive health.
+question: What are the main components of the Mediterranean diet?
+answer: The Mediterranean diet primarily consists of fruits, vegetables, whole grains, and legumes.
+stars: 4
+
+context: The Queen's Royal Castle is a well-known tourist attraction in the United Kingdom. It spans over 500 acres and contains extensive gardens and parks. The castle was built in the 15th century and has been home to generations of royalty.
+question: What are the main attractions of the Queen's Royal Castle?
+answer: The main attractions of the Queen's Royal Castle are its expansive 500-acre grounds, extensive gardens, parks, and the historical castle itself, which dates back to the 15th century and has housed generations of royalty.
+stars: 5
+
+context: {{context}}
+question: {{query}}
+answer: {{response}}
+stars:

azure/ai/evaluation/_evaluators/_rouge/__init__.py

@@ -0,0 +1,10 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+from ._rouge import RougeScoreEvaluator, RougeType
+
+__all__ = [
+    "RougeScoreEvaluator",
+    "RougeType",
+]

azure/ai/evaluation/_evaluators/_rouge/_rouge.py

@@ -0,0 +1,98 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from enum import Enum
+
+from rouge_score import rouge_scorer
+
+from promptflow._utils.async_utils import async_run_allowing_running_loop
+
+
+class RougeType(str, Enum):
+    """
+    Enumeration of ROUGE (Recall-Oriented Understudy for Gisting Evaluation) types.
+    """
+
+    ROUGE_1 = "rouge1"
+    """Overlap of unigrams (single words) between generated and reference text."""
+
+    ROUGE_2 = "rouge2"
+    """Overlap of bigrams (two consecutive words) between generated and reference text."""
+
+    ROUGE_3 = "rouge3"
+    """Overlap of trigrams (three consecutive words) between generated and reference text."""
+
+    ROUGE_4 = "rouge4"
+    """Overlap of four-grams (four consecutive words) between generated and reference text."""
+
+    ROUGE_5 = "rouge5"
+    """Overlap of five-grams (five consecutive words) between generated and reference text."""
+
+    ROUGE_L = "rougeL"
+    """Overlap of L-grams (L consecutive words) between generated and reference text."""
+
+
+class _AsyncRougeScoreEvaluator:
+    def __init__(self, rouge_type: RougeType):
+        self._rouge_type = rouge_type
+
+    async def __call__(self, *, ground_truth: str, response: str, **kwargs):
+        scorer = rouge_scorer.RougeScorer(rouge_types=[self._rouge_type])
+        metrics = scorer.score(ground_truth, response)[self._rouge_type]
+        return {
+            "rouge_precision": metrics.precision,
+            "rouge_recall": metrics.recall,
+            "rouge_f1_score": metrics.fmeasure,
+        }
+
+
+class RougeScoreEvaluator:
+    """
+    Evaluator for computes the ROUGE scores between two strings.
+
+    ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is a set of metrics used to evaluate automatic
+    summarization and machine translation. It measures the overlap between generated text and reference summaries.
+    ROUGE focuses on recall-oriented measures to assess how well the generated text covers the reference text. Text
+    summarization and document comparison are among optimal use cases for ROUGE, particularly in scenarios where text
+    coherence and relevance are critical.
+
+    **Usage**
+
+    .. code-block:: python
+
+        eval_fn = RougeScoreEvaluator(rouge_type=RougeType.ROUGE_1)
+        result = eval_fn(
+            response="Tokyo is the capital of Japan.",
+            ground_truth="The capital of Japan is Tokyo.")
+
+    **Output format**
+
+    .. code-block:: python
+
+        {
+            "rouge_precision": 1.0,
+            "rouge_recall": 1.0,
+            "rouge_f1_score": 1.0
+        }
+    """
+
+    def __init__(self, rouge_type: RougeType):
+        self._async_evaluator = _AsyncRougeScoreEvaluator(rouge_type)
+
+    def __call__(self, *, ground_truth: str, response: str, **kwargs):
+        """
+        Evaluate the ROUGE score between the response and the ground truth.
+
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :keyword ground_truth: The ground truth to be compared against.
+        :paramtype ground_truth: str
+        :return: The ROUGE score.
+        :rtype: dict
+        """
+        return async_run_allowing_running_loop(
+            self._async_evaluator, ground_truth=ground_truth, response=response, **kwargs
+        )
+
+    def _to_async(self):
+        return self._async_evaluator

azure/ai/evaluation/_evaluators/_similarity/__init__.py

@@ -0,0 +1,9 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+from ._similarity import SimilarityEvaluator
+
+__all__ = [
+    "SimilarityEvaluator",
+]

azure/ai/evaluation/_evaluators/_similarity/_similarity.py

@@ -0,0 +1,130 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import os
+import re
+from typing import Union
+
+import numpy as np
+
+from promptflow._utils.async_utils import async_run_allowing_running_loop
+from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
+from promptflow.core import AsyncPrompty
+
+from ..._model_configurations import AzureOpenAIModelConfiguration, OpenAIModelConfiguration
+from ..._common.utils import (
+    check_and_add_api_version_for_aoai_model_config,
+    check_and_add_user_agent_for_aoai_model_config,
+)
+
+try:
+    from ..._user_agent import USER_AGENT
+except ImportError:
+    USER_AGENT = None
+
+
+class _AsyncSimilarityEvaluator:
+    # Constants must be defined within eval's directory to be save/loadable
+    PROMPTY_FILE = "similarity.prompty"
+    LLM_CALL_TIMEOUT = 600
+    DEFAULT_OPEN_API_VERSION = "2024-02-15-preview"
+
+    def __init__(self, model_config: dict):
+        check_and_add_api_version_for_aoai_model_config(model_config, self.DEFAULT_OPEN_API_VERSION)
+
+        prompty_model_config = {"configuration": model_config, "parameters": {"extra_headers": {}}}
+
+        # Handle "RuntimeError: Event loop is closed" from httpx AsyncClient
+        # https://github.com/encode/httpx/discussions/2959
+        prompty_model_config["parameters"]["extra_headers"].update({"Connection": "close"})
+
+        check_and_add_user_agent_for_aoai_model_config(
+            model_config,
+            prompty_model_config,
+            USER_AGENT,
+        )
+
+        current_dir = os.path.dirname(__file__)
+        prompty_path = os.path.join(current_dir, self.PROMPTY_FILE)
+        self._flow = AsyncPrompty.load(source=prompty_path, model=prompty_model_config)
+
+    async def __call__(self, *, query: str, response: str, ground_truth: str, **kwargs):
+        # Validate input parameters
+        query = str(query or "")
+        response = str(response or "")
+        ground_truth = str(ground_truth or "")
+
+        if not (query.strip() and response.strip() and ground_truth.strip()):
+            msg = "'query', 'response' and 'ground_truth' must be non-empty strings."
+            raise EvaluationException(
+                message=msg,
+                internal_message=msg,
+                error_category=ErrorCategory.MISSING_FIELD,
+                error_blame=ErrorBlame.USER_ERROR,
+                error_target=ErrorTarget.SIMILARITY_EVALUATOR,
+            )
+
+        # Run the evaluation flow
+        llm_output = await self._flow(
+            query=query, response=response, ground_truth=ground_truth, timeout=self.LLM_CALL_TIMEOUT, **kwargs
+        )
+
+        score = np.nan
+        if llm_output:
+            match = re.search(r"\d", llm_output)
+            if match:
+                score = float(match.group())
+
+        return {"gpt_similarity": float(score)}
+
+
+class SimilarityEvaluator:
+    """
+    Initialize a similarity evaluator configured for a specific Azure OpenAI model.
+
+    :param model_config: Configuration for the Azure OpenAI model.
+    :type model_config: Union[~azure.ai.evaluation.AzureOpenAIModelConfiguration,
+        ~azure.ai.evaluation.OpenAIModelConfiguration]
+
+    **Usage**
+
+    .. code-block:: python
+
+        eval_fn = SimilarityEvaluator(model_config)
+        result = eval_fn(
+            query="What is the capital of Japan?",
+            response="The capital of Japan is Tokyo.",
+            ground_truth="Tokyo is Japan's capital.")
+
+    **Output format**
+
+    .. code-block:: python
+
+        {
+            "gpt_similarity": 3.0
+        }
+    """
+
+    def __init__(self, model_config: dict):
+        self._async_evaluator = _AsyncSimilarityEvaluator(model_config)
+
+    def __call__(self, *, query: str, response: str, ground_truth: str, **kwargs):
+        """
+        Evaluate similarity.
+
+        :keyword query: The query to be evaluated.
+        :paramtype query: str
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :keyword ground_truth: The ground truth to be evaluated.
+        :paramtype ground_truth: str
+        :return: The similarity score.
+        :rtype: dict
+        """
+        return async_run_allowing_running_loop(
+            self._async_evaluator, query=query, response=response, ground_truth=ground_truth, **kwargs
+        )
+
+    def _to_async(self):
+        return self._async_evaluator

azure/ai/evaluation/_evaluators/_similarity/similarity.prompty

@@ -0,0 +1,71 @@
+---
+name: Similarity
+description: Evaluates similarity score for QA scenario
+model:
+  api: chat
+  configuration:
+    type: azure_openai
+    azure_deployment: ${env:AZURE_DEPLOYMENT}
+    api_key: ${env:AZURE_OPENAI_API_KEY}
+    azure_endpoint: ${env:AZURE_OPENAI_ENDPOINT}
+  parameters:
+    temperature: 0.0
+    max_tokens: 1
+    top_p: 1.0
+    presence_penalty: 0
+    frequency_penalty: 0
+    response_format:
+      type: text
+
+inputs:
+  query:
+    type: string
+  response:
+    type: string
+  ground_truth:
+    type: string
+
+---
+system:
+You are an AI assistant. You will be given the definition of an evaluation metric for assessing the quality of an answer in a question-answering task. Your job is to compute an accurate evaluation score using the provided evaluation metric. You should return a single integer value between 1 to 5 representing the evaluation metric. You will include no other text or information.
+user:
+Equivalence, as a metric, measures the similarity between the predicted answer and the correct answer. If the information and content in the predicted answer is similar or equivalent to the correct answer, then the value of the Equivalence metric should be high, else it should be low. Given the question, correct answer, and predicted answer, determine the value of Equivalence metric using the following rating scale:
+One star: the predicted answer is not at all similar to the correct answer
+Two stars: the predicted answer is mostly not similar to the correct answer
+Three stars: the predicted answer is somewhat similar to the correct answer
+Four stars: the predicted answer is mostly similar to the correct answer
+Five stars: the predicted answer is completely similar to the correct answer
+
+This rating value should always be an integer between 1 and 5. So the rating produced should be 1 or 2 or 3 or 4 or 5.
+
+The examples below show the Equivalence score for a question, a correct answer, and a predicted answer.
+
+question: What is the role of ribosomes?
+correct answer: Ribosomes are cellular structures responsible for protein synthesis. They interpret the genetic information carried by messenger RNA (mRNA) and use it to assemble amino acids into proteins.
+predicted answer: Ribosomes participate in carbohydrate breakdown by removing nutrients from complex sugar molecules.
+stars: 1
+
+question: Why did the Titanic sink?
+correct answer: The Titanic sank after it struck an iceberg during its maiden voyage in 1912. The impact caused the ship's hull to breach, allowing water to flood into the vessel. The ship's design, lifeboat shortage, and lack of timely rescue efforts contributed to the tragic loss of life.
+predicted answer: The sinking of the Titanic was a result of a large iceberg collision. This caused the ship to take on water and eventually sink, leading to the death of many passengers due to a shortage of lifeboats and insufficient rescue attempts.
+stars: 2
+
+question: What causes seasons on Earth?
+correct answer: Seasons on Earth are caused by the tilt of the Earth's axis and its revolution around the Sun. As the Earth orbits the Sun, the tilt causes different parts of the planet to receive varying amounts of sunlight, resulting in changes in temperature and weather patterns.
+predicted answer: Seasons occur because of the Earth's rotation and its elliptical orbit around the Sun. The tilt of the Earth's axis causes regions to be subjected to different sunlight intensities, which leads to temperature fluctuations and alternating weather conditions.
+stars: 3
+
+question: How does photosynthesis work?
+correct answer: Photosynthesis is a process by which green plants and some other organisms convert light energy into chemical energy. This occurs as light is absorbed by chlorophyll molecules, and then carbon dioxide and water are converted into glucose and oxygen through a series of reactions.
+predicted answer: In photosynthesis, sunlight is transformed into nutrients by plants and certain microorganisms. Light is captured by chlorophyll molecules, followed by the conversion of carbon dioxide and water into sugar and oxygen through multiple reactions.
+stars: 4
+
+question: What are the health benefits of regular exercise?
+correct answer: Regular exercise can help maintain a healthy weight, increase muscle and bone strength, and reduce the risk of chronic diseases. It also promotes mental well-being by reducing stress and improving overall mood.
+predicted answer: Routine physical activity can contribute to maintaining ideal body weight, enhancing muscle and bone strength, and preventing chronic illnesses. In addition, it supports mental health by alleviating stress and augmenting general mood.
+stars: 5
+
+question: {{query}}
+correct answer:{{ground_truth}}
+predicted answer: {{response}}
+stars:

azure/ai/evaluation/_evaluators/_xpia/__init__.py

@@ -0,0 +1,5 @@
+from .xpia import IndirectAttackEvaluator
+
+__all__ = [
+    "IndirectAttackEvaluator",
+]