azure-ai-evaluation 1.0.0b4__py3-none-any.whl → 1.0.1__py3-none-any.whl

azure/ai/evaluation/_evaluators/_fluency/_fluency.py

@@ -3,71 +3,102 @@
 # ---------------------------------------------------------
 
 import os
-from typing import Optional
+from typing import Dict, List, Union
 
-from typing_extensions import override
+from typing_extensions import overload, override
 
 from azure.ai.evaluation._evaluators._common import PromptyEvaluatorBase
+from azure.ai.evaluation._model_configurations import Conversation
 
 
-class FluencyEvaluator(PromptyEvaluatorBase):
+class FluencyEvaluator(PromptyEvaluatorBase[Union[str, float]]):
     """
-    Initialize a fluency evaluator configured for a specific Azure OpenAI model.
+    Evaluates the fluency of a given response or a multi-turn conversation, including reasoning.
+
+    The fluency measure assesses the extent to which the generated text conforms to grammatical rules, syntactic
+    structures, and appropriate vocabulary usage, resulting in linguistically correct responses.
+
+    Fluency scores range from 1 to 5, with 1 being the least fluent and 5 being the most fluent.
 
     :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
+    .. admonition:: Example:
 
-        eval_fn = FluencyEvaluator(model_config)
-        result = eval_fn(
-            query="What is the capital of Japan?",
-            response="The capital of Japan is Tokyo.")
+        .. literalinclude:: ../samples/evaluation_samples_evaluate.py
+            :start-after: [START fluency_evaluator]
+            :end-before: [END fluency_evaluator]
+            :language: python
+            :dedent: 8
+            :caption: Initialize and call a FluencyEvaluator.
 
-    **Output format**
+    .. note::
 
-    .. code-block:: python
-
-        {
-            "gpt_fluency": 4.0
-        }
+        To align with our support of a diverse set of models, an output key without the `gpt_` prefix has been added.
+        To maintain backwards compatibility, the old key with the `gpt_` prefix is still be present in the output;
+        however, it is recommended to use the new key moving forward as the old key will be deprecated in the future.
     """
 
-    PROMPTY_FILE = "fluency.prompty"
-    RESULT_KEY = "gpt_fluency"
+    _PROMPTY_FILE = "fluency.prompty"
+    _RESULT_KEY = "fluency"
+
+    id = "azureml://registries/azureml/models/Fluency-Evaluator/versions/4"
+    """Evaluator identifier, experimental and to be used only with evaluation in cloud."""
 
     @override
-    def __init__(self, model_config: dict):
+    def __init__(self, model_config):
         current_dir = os.path.dirname(__file__)
-        prompty_path = os.path.join(current_dir, self.PROMPTY_FILE)
-        super().__init__(model_config=model_config, prompty_file=prompty_path, result_key=self.RESULT_KEY)
+        prompty_path = os.path.join(current_dir, self._PROMPTY_FILE)
+        super().__init__(model_config=model_config, prompty_file=prompty_path, result_key=self._RESULT_KEY)
 
-    @override
+    @overload
+    def __call__(
+        self,
+        *,
+        response: str,
+    ) -> Dict[str, Union[str, float]]:
+        """Evaluate fluency in given response
+
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :return: The fluency score
+        :rtype: Dict[str, float]
+        """
+
+    @overload
     def __call__(
         self,
         *,
-        query: Optional[str] = None,
-        response: Optional[str] = None,
-        conversation: Optional[dict] = None,
+        conversation: Conversation,
+    ) -> Dict[str, Union[float, Dict[str, List[Union[str, float]]]]]:
+        """Evaluate fluency for a conversation
+
+        :keyword conversation: The conversation to evaluate. Expected to contain a list of conversation turns under the
+            key "messages", and potentially a global context under the key "context". Conversation turns are expected
+            to be dictionaries with keys "content", "role", and possibly "context".
+        :paramtype conversation: Optional[~azure.ai.evaluation.Conversation]
+        :return: The fluency score
+        :rtype: Dict[str, Union[float, Dict[str, List[float]]]]
+        """
+
+    @override
+    def __call__(  # pylint: disable=docstring-missing-param
+        self,
+        *args,
         **kwargs,
     ):
         """
-        Evaluate fluency. Accepts either a query and response for a single evaluation,
+        Evaluate fluency. Accepts either a response for a single evaluation,
         or a conversation for a multi-turn evaluation. If the conversation has more than one turn,
         the evaluator will aggregate the results of each turn.
 
-        :keyword query: The query to be evaluated.
-        :paramtype query: str
-        :keyword response: The response to be evaluated.
-        :paramtype response: str
+        :keyword response: The response to be evaluated. Mutually exclusive with the "conversation" parameter.
+        :paramtype response: Optional[str]
         :keyword conversation: The conversation to evaluate. Expected to contain a list of conversation turns under the
-            key "messages". Conversation turns are expected
-            to be dictionaries with keys "content" and "role".
-        :paramtype conversation: Optional[Dict]
+            key "messages". Conversation turns are expected to be dictionaries with keys "content" and "role".
+        :paramtype conversation: Optional[~azure.ai.evaluation.Conversation]
         :return: The fluency score.
-        :rtype: Dict[str, float]
+        :rtype: Union[Dict[str, float], Dict[str, Union[float, Dict[str, List[float]]]]]
         """
-        return super().__call__(query=query, response=response, conversation=conversation, **kwargs)
+        return super().__call__(*args, **kwargs)

azure/ai/evaluation/_evaluators/_fluency/fluency.prompty

@@ -5,7 +5,7 @@ model:
   api: chat
   parameters:
     temperature: 0.0
-    max_tokens: 1
+    max_tokens: 800
     top_p: 1.0
     presence_penalty: 0
     frequency_penalty: 0
@@ -13,44 +13,74 @@ model:
       type: text
 
 inputs:
-  query:
-    type: string
   response:
     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.
+# Instruction
+## Goal
+### You are an expert in evaluating the quality of a RESPONSE from an intelligent system based on provided definition and data. Your goal will involve answering the questions below using the information provided.
+- **Definition**: You are given a definition of the communication trait that is being evaluated to help guide your Score.
+- **Data**: Your input data include a RESPONSE.
+- **Tasks**: To complete your evaluation you will be asked to evaluate the Data in different ways.
+
 user:
-Fluency measures the quality of individual sentences in the answer, and whether they are well-written and grammatically correct. Consider the quality of individual sentences when evaluating fluency. Given the question and answer, score the fluency of the answer between one to five stars using the following rating scale:
-One star: the answer completely lacks fluency
-Two stars: the answer mostly lacks fluency
-Three stars: the answer is partially fluent
-Four stars: the answer is mostly fluent
-Five stars: the answer has perfect fluency
-
-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.
-
-question: What did you have for breakfast today?
-answer: Breakfast today, me eating cereal and orange juice very good.
-stars: 1
-
-question: How do you feel when you travel alone?
-answer: Alone travel, nervous, but excited also. I feel adventure and like its time.
-stars: 2
-
-question: When was the last time you went on a family vacation?
-answer: Last family vacation, it took place in last summer. We traveled to a beach destination, very fun.
-stars: 3
-
-question: What is your favorite thing about your job?
-answer: My favorite aspect of my job is the chance to interact with diverse people. I am constantly learning from their experiences and stories.
-stars: 4
-
-question: Can you describe your morning routine?
-answer: Every morning, I wake up at 6 am, drink a glass of water, and do some light stretching. After that, I take a shower and get dressed for work. Then, I have a healthy breakfast, usually consisting of oatmeal and fruits, before leaving the house around 7:30 am.
-stars: 5
-
-question: {{query}}
-answer: {{response}}
-stars:
+# Definition
+**Fluency** refers to the effectiveness and clarity of written communication, focusing on grammatical accuracy, vocabulary range, sentence complexity, coherence, and overall readability. It assesses how smoothly ideas are conveyed and how easily the text can be understood by the reader.
+
+# Ratings
+## [Fluency: 1] (Emergent Fluency)
+**Definition:** The response shows minimal command of the language. It contains pervasive grammatical errors, extremely limited vocabulary, and fragmented or incoherent sentences. The message is largely incomprehensible, making understanding very difficult.
+
+**Examples:**
+  **Response:** Free time I. Go park. Not fun. Alone.
+
+  **Response:** Like food pizza. Good cheese eat.
+
+## [Fluency: 2] (Basic Fluency)
+**Definition:** The response communicates simple ideas but has frequent grammatical errors and limited vocabulary. Sentences are short and may be improperly constructed, leading to partial understanding. Repetition and awkward phrasing are common.
+
+**Examples:**
+  **Response:** I like play soccer. I watch movie. It fun.
+
+  **Response:** My town small. Many people. We have market.
+
+## [Fluency: 3] (Competent Fluency)
+**Definition:** The response clearly conveys ideas with occasional grammatical errors. Vocabulary is adequate but not extensive. Sentences are generally correct but may lack complexity and variety. The text is coherent, and the message is easily understood with minimal effort.
+
+**Examples:**
+  **Response:** I'm planning to visit friends and maybe see a movie together.
+
+  **Response:** I try to eat healthy food and exercise regularly by jogging.
+
+## [Fluency: 4] (Proficient Fluency)
+**Definition:** The response is well-articulated with good control of grammar and a varied vocabulary. Sentences are complex and well-structured, demonstrating coherence and cohesion. Minor errors may occur but do not affect overall understanding. The text flows smoothly, and ideas are connected logically.
+
+**Examples:**
+  **Response:** My interest in mathematics and problem-solving inspired me to become an engineer, as I enjoy designing solutions that improve people's lives.
+
+  **Response:** Environmental conservation is crucial because it protects ecosystems, preserves biodiversity, and ensures natural resources are available for future generations.
+
+## [Fluency: 5] (Exceptional Fluency)
+**Definition:** The response demonstrates an exceptional command of language with sophisticated vocabulary and complex, varied sentence structures. It is coherent, cohesive, and engaging, with precise and nuanced expression. Grammar is flawless, and the text reflects a high level of eloquence and style.
+
+**Examples:**
+  **Response:** Globalization exerts a profound influence on cultural diversity by facilitating unprecedented cultural exchange while simultaneously risking the homogenization of distinct cultural identities, which can diminish the richness of global heritage.
+
+  **Response:** Technology revolutionizes modern education by providing interactive learning platforms, enabling personalized learning experiences, and connecting students worldwide, thereby transforming how knowledge is acquired and shared.
+
+
+# Data
+RESPONSE: {{response}}
+
+
+# Tasks
+## Please provide your assessment Score for the previous RESPONSE based on the Definitions above. Your output should include the following information:
+- **ThoughtChain**: To improve the reasoning process, think step by step and include a step-by-step explanation of your thought process as you analyze the data based on the definitions. Keep it brief and start your ThoughtChain with "Let's think step by step:".
+- **Explanation**: a very short explanation of why you think the input Data should get that Score.
+- **Score**: based on your previous analysis, provide your Score. The Score you give MUST be a integer score (i.e., "1", "2"...) based on the levels of the definitions.
+
+
+## Please provide your answers between the tags: <S0>your chain of thoughts</S0>, <S1>your explanation</S1>, <S2>your Score</S2>.
+# Output

azure/ai/evaluation/_evaluators/_gleu/_gleu.py

@@ -24,31 +24,29 @@ class _AsyncGleuScoreEvaluator:
 
 class GleuScoreEvaluator:
     """
-    Evaluator that computes the BLEU Score between two strings.
+    Calculates the GLEU (Google-BLEU) score between a response and the ground truth.
 
     The GLEU (Google-BLEU) score evaluator measures the similarity between generated and reference texts by
     evaluating n-gram overlap, considering both precision and recall. This balanced evaluation, designed for
     sentence-level assessment, makes it ideal for detailed analysis of translation quality. GLEU is well-suited for
     use cases such as machine translation, text summarization, and text generation.
 
-    **Usage**
+    GLEU scores range from 0 to 1, where a value of 1 represents perfect overlap between the response and
+    the ground truth and a value of 0 indicates no overlap.
 
-    .. code-block:: python
+    .. admonition:: Example:
 
-        eval_fn = GleuScoreEvaluator()
-        result = eval_fn(
-            response="Tokyo is the capital of Japan.",
-            ground_truth="The capital of Japan is Tokyo.")
-
-    **Output format**
-
-    .. code-block:: python
-
-        {
-            "gleu_score": 0.41
-        }
+        .. literalinclude:: ../samples/evaluation_samples_evaluate.py
+            :start-after: [START gleu_score_evaluator]
+            :end-before: [END gleu_score_evaluator]
+            :language: python
+            :dedent: 8
+            :caption: Initialize and call a GleuScoreEvaluator.
     """
 
+    id = "azureml://registries/azureml/models/Gleu-Score-Evaluator/versions/3"
+    """Evaluator identifier, experimental and to be used only with evaluation in cloud."""
+
     def __init__(self):
         self._async_evaluator = _AsyncGleuScoreEvaluator()
 
@@ -61,7 +59,7 @@ class GleuScoreEvaluator:
         :keyword ground_truth: The ground truth to be compared against.
         :paramtype ground_truth: str
         :return: The GLEU score.
-        :rtype: dict
+        :rtype: Dict[str, float]
         """
         return async_run_allowing_running_loop(
             self._async_evaluator, ground_truth=ground_truth, response=response, **kwargs

azure/ai/evaluation/_evaluators/_groundedness/_groundedness.py

@@ -2,71 +2,143 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 import os
-from typing import Optional
+from typing import Dict, List, Optional, Union
 
-from typing_extensions import override
+from typing_extensions import overload, override
+from promptflow.core import AsyncPrompty
 
 from azure.ai.evaluation._evaluators._common import PromptyEvaluatorBase
+from azure.ai.evaluation._model_configurations import Conversation
+from ..._common.utils import construct_prompty_model_config, validate_model_config
 
+try:
+    from ..._user_agent import USER_AGENT
+except ImportError:
+    USER_AGENT = "None"
 
-class GroundednessEvaluator(PromptyEvaluatorBase):
+
+class GroundednessEvaluator(PromptyEvaluatorBase[Union[str, float]]):
     """
-    Initialize a groundedness evaluator configured for a specific Azure OpenAI model.
+    Evaluates groundedness score for a given query (optional), response, and context or a multi-turn conversation,
+    including reasoning.
 
-    :param model_config: Configuration for the Azure OpenAI model.
-    :type model_config: Union[~azure.ai.evalation.AzureOpenAIModelConfiguration,
-        ~azure.ai.evalation.OpenAIModelConfiguration]
+    The groundedness measure assesses the correspondence between claims in an AI-generated answer and the source
+    context, making sure that these claims are substantiated by the context. Even if the responses from LLM are
+    factually correct, they'll be considered ungrounded if they can't be verified against the provided sources
+    (such as your input source or your database). Use the groundedness metric when you need to verify that
+    AI-generated responses align with and are validated by the provided context.
 
-    **Usage**
+    Groundedness scores range from 1 to 5, with 1 being the least grounded and 5 being the most grounded.
 
-    .. code-block:: python
+    :param model_config: Configuration for the Azure OpenAI model.
+    :type model_config: Union[~azure.ai.evaluation.AzureOpenAIModelConfiguration,
+        ~azure.ai.evaluation.OpenAIModelConfiguration]
 
-        eval_fn = GroundednessEvaluator(model_config)
-        result = eval_fn(
-            response="The capital of Japan is Tokyo.",
-            context="Tokyo is Japan's capital, known for its blend of traditional culture \
-                and technological advancements.")
+    .. admonition:: Example:
 
-    **Output format**
+        .. literalinclude:: ../samples/evaluation_samples_evaluate.py
+            :start-after: [START groundedness_evaluator]
+            :end-before: [END groundedness_evaluator]
+            :language: python
+            :dedent: 8
+            :caption: Initialize and call a GroundednessEvaluator.
 
-    .. code-block:: python
+    .. note::
 
-        {
-            "gpt_groundedness": 5
-        }
+        To align with our support of a diverse set of models, an output key without the `gpt_` prefix has been added.
+        To maintain backwards compatibility, the old key with the `gpt_` prefix is still be present in the output;
+        however, it is recommended to use the new key moving forward as the old key will be deprecated in the future.
     """
 
-    PROMPTY_FILE = "groundedness.prompty"
-    RESULT_KEY = "gpt_groundedness"
+    _PROMPTY_FILE_NO_QUERY = "groundedness_without_query.prompty"
+    _PROMPTY_FILE_WITH_QUERY = "groundedness_with_query.prompty"
+    _RESULT_KEY = "groundedness"
+    _OPTIONAL_PARAMS = ["query"]
+
+    id = "azureml://registries/azureml/models/Groundedness-Evaluator/versions/4"
+    """Evaluator identifier, experimental and to be used only with evaluation in cloud."""
 
     @override
-    def __init__(self, model_config: dict):
+    def __init__(self, model_config):
         current_dir = os.path.dirname(__file__)
-        prompty_path = os.path.join(current_dir, self.PROMPTY_FILE)
-        super().__init__(model_config=model_config, prompty_file=prompty_path, result_key=self.RESULT_KEY)
+        prompty_path = os.path.join(current_dir, self._PROMPTY_FILE_NO_QUERY)  # Default to no query
 
-    @override
+        super().__init__(model_config=model_config, prompty_file=prompty_path, result_key=self._RESULT_KEY)
+        self._model_config = model_config
+        # Needs to be set because it's used in call method to re-validate prompt if `query` is provided
+
+    @overload
+    def __call__(
+        self,
+        *,
+        response: str,
+        context: str,
+        query: Optional[str] = None,
+    ) -> Dict[str, Union[str, float]]:
+        """Evaluate groundedness for given input of response, context
+
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :keyword context: The context to be evaluated.
+        :paramtype context: str
+        :keyword query: The query to be evaluated. Optional parameter for use with the `response`
+            and `context` parameters. If provided, a different prompt template will be used for evaluation.
+        :paramtype query: Optional[str]
+        :return: The groundedness score.
+        :rtype: Dict[str, float]
+        """
+
+    @overload
     def __call__(
         self,
         *,
-        response: Optional[str] = None,
-        context: Optional[str] = None,
-        conversation: Optional[dict] = None,
+        conversation: Conversation,
+    ) -> Dict[str, Union[float, Dict[str, List[Union[str, float]]]]]:
+        """Evaluate groundedness for a conversation
+
+        :keyword conversation: The conversation to evaluate. Expected to contain a list of conversation turns under the
+            key "messages", and potentially a global context under the key "context". Conversation turns are expected
+            to be dictionaries with keys "content", "role", and possibly "context".
+        :paramtype conversation: Optional[~azure.ai.evaluation.Conversation]
+        :return: The groundedness score.
+        :rtype: Dict[str, Union[float, Dict[str, List[float]]]]
+        """
+
+    @override
+    def __call__(  # pylint: disable=docstring-missing-param
+        self,
+        *args,
         **kwargs,
     ):
-        """Evaluate groundedless. Accepts either a response and context a single evaluation,
+        """Evaluate groundedness. Accepts either a query, response, and context for a single evaluation,
         or a conversation for a multi-turn evaluation. If the conversation has more than one turn,
         the evaluator will aggregate the results of each turn.
 
-        :keyword response: The response to be evaluated.
+        :keyword query: The query to be evaluated. Mutually exclusive with `conversation`. Optional parameter for use
+            with the `response` and `context` parameters. If provided, a different prompt template will be used for
+            evaluation.
+        :paramtype query: Optional[str]
+        :keyword response: The response to be evaluated. Mutually exclusive with the `conversation` parameter.
         :paramtype response: Optional[str]
-        :keyword context: The context to be evaluated.
+        :keyword context: The context to be evaluated. Mutually exclusive with the `conversation` parameter.
         :paramtype context: Optional[str]
         :keyword conversation: The conversation to evaluate. Expected to contain a list of conversation turns under the
             key "messages", and potentially a global context under the key "context". Conversation turns are expected
             to be dictionaries with keys "content", "role", and possibly "context".
-        :paramtype conversation: Optional[Dict]
+        :paramtype conversation: Optional[~azure.ai.evaluation.Conversation]
         :return: The relevance score.
-        :rtype: Dict[str, float]
+        :rtype: Union[Dict[str, Union[str, float]], Dict[str, Union[float, Dict[str, List[Union[str, float]]]]]]
         """
-        return super().__call__(response=response, context=context, conversation=conversation, **kwargs)
+
+        if kwargs.get("query", None):
+            current_dir = os.path.dirname(__file__)
+            prompty_path = os.path.join(current_dir, self._PROMPTY_FILE_WITH_QUERY)
+            self._prompty_file = prompty_path
+            prompty_model_config = construct_prompty_model_config(
+                validate_model_config(self._model_config),
+                self._DEFAULT_OPEN_API_VERSION,
+                USER_AGENT,
+            )
+            self._flow = AsyncPrompty.load(source=self._prompty_file, model=prompty_model_config)
+
+        return super().__call__(*args, **kwargs)

azure/ai/evaluation/_evaluators/_groundedness/groundedness_with_query.prompty

@@ -0,0 +1,113 @@
+---
+name: Groundedness
+description: Evaluates groundedness score for RAG scenario
+model:
+  api: chat
+  parameters:
+    temperature: 0.0
+    max_tokens: 800
+    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:
+# Instruction
+## Goal
+### You are an expert in evaluating the quality of a RESPONSE from an intelligent system based on provided definition and data. Your goal will involve answering the questions below using the information provided.
+- **Definition**: You are given a definition of the communication trait that is being evaluated to help guide your Score.
+- **Data**: Your input data include CONTEXT, QUERY, and RESPONSE.
+- **Tasks**: To complete your evaluation you will be asked to evaluate the Data in different ways.
+
+user:
+# Definition
+**Groundedness** refers to how well an answer is anchored in the provided context, evaluating its relevance, accuracy, and completeness based exclusively on that context. It assesses the extent to which the answer directly and fully addresses the question without introducing unrelated or incorrect information. The scale ranges from 1 to 5, with higher numbers indicating greater groundedness.
+
+# Ratings
+## [Groundedness: 1] (Completely Unrelated Response)
+**Definition:** An answer that does not relate to the question or the context in any way. It fails to address the topic, provides irrelevant information, or introduces completely unrelated subjects.
+
+**Examples:**
+  **Context:** The company's annual meeting will be held next Thursday.
+  **Query:** When is the company's annual meeting?
+  **Response:** I enjoy hiking in the mountains during summer.
+
+  **Context:** The new policy aims to reduce carbon emissions by 20% over the next five years.
+  **Query:** What is the goal of the new policy?
+  **Response:** My favorite color is blue.
+
+## [Groundedness: 2] (Related Topic but Does Not Respond to the Query)
+**Definition:** An answer that relates to the general topic of the context but does not answer the specific question asked. It may mention concepts from the context but fails to provide a direct or relevant response.
+
+**Examples:**
+  **Context:** The museum will exhibit modern art pieces from various local artists.
+  **Query:** What kind of art will be exhibited at the museum?
+  **Response:** Museums are important cultural institutions.
+
+  **Context:** The new software update improves battery life and performance.
+  **Query:** What does the new software update improve?
+  **Response:** Software updates can sometimes fix bugs.
+
+## [Groundedness: 3] (Attempts to Respond but Contains Incorrect Information)
+**Definition:** An answer that attempts to respond to the question but includes incorrect information not supported by the context. It may misstate facts, misinterpret the context, or provide erroneous details.
+
+**Examples:**
+  **Context:** The festival starts on June 5th and features international musicians.
+  **Query:** When does the festival start?
+  **Response:** The festival starts on July 5th and features local artists.
+
+  **Context:** The recipe requires two eggs and one cup of milk.
+  **Query:** How many eggs are needed for the recipe?
+  **Response:** You need three eggs for the recipe.
+
+## [Groundedness: 4] (Partially Correct Response)
+**Definition:** An answer that provides a correct response to the question but is incomplete or lacks specific details mentioned in the context. It captures some of the necessary information but omits key elements needed for a full understanding.
+
+**Examples:**
+  **Context:** The bookstore offers a 15% discount to students and a 10% discount to senior citizens.
+  **Query:** What discount does the bookstore offer to students?
+  **Response:** Students get a discount at the bookstore.
+
+  **Context:** The company's headquarters are located in Berlin, Germany.
+  **Query:** Where are the company's headquarters?
+  **Response:** The company's headquarters are in Germany.
+
+## [Groundedness: 5] (Fully Correct and Complete Response)
+**Definition:** An answer that thoroughly and accurately responds to the question, including all relevant details from the context. It directly addresses the question with precise information, demonstrating complete understanding without adding extraneous information.
+
+**Examples:**
+  **Context:** The author released her latest novel, 'The Silent Echo', on September 1st.
+  **Query:** When was 'The Silent Echo' released?
+  **Response:** 'The Silent Echo' was released on September 1st.
+
+  **Context:** Participants must register by May 31st to be eligible for early bird pricing.
+  **Query:** By what date must participants register to receive early bird pricing?
+  **Response:** Participants must register by May 31st to receive early bird pricing.
+
+
+# Data
+CONTEXT: {{context}}
+QUERY: {{query}}
+RESPONSE: {{response}}
+
+
+# Tasks
+## Please provide your assessment Score for the previous RESPONSE in relation to the CONTEXT and QUERY based on the Definitions above. Your output should include the following information:
+- **ThoughtChain**: To improve the reasoning process, think step by step and include a step-by-step explanation of your thought process as you analyze the data based on the definitions. Keep it brief and start your ThoughtChain with "Let's think step by step:".
+- **Explanation**: a very short explanation of why you think the input Data should get that Score.
+- **Score**: based on your previous analysis, provide your Score. The Score you give MUST be a integer score (i.e., "1", "2"...) based on the levels of the definitions.
+
+
+## Please provide your answers between the tags: <S0>your chain of thoughts</S0>, <S1>your explanation</S1>, <S2>your Score</S2>.
+# Output