azure-ai-evaluation 1.0.0b2__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

azure/ai/evaluation/_evaluators/_common/_base_prompty_eval.py

@@ -0,0 +1,76 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import math
+import re
+from typing import Dict
+
+from promptflow.core import AsyncPrompty
+from typing_extensions import override
+
+from ..._common.utils import construct_prompty_model_config, validate_model_config
+from . import EvaluatorBase
+
+try:
+    from ..._user_agent import USER_AGENT
+except ImportError:
+    USER_AGENT = "None"
+
+
+class PromptyEvaluatorBase(EvaluatorBase[float]):
+    """Base class for all evaluators that make use of context as an input. It's also assumed that such evaluators
+    make use of a prompty file, and return their results as a dictionary, with a single key-value pair
+    linking the result name to a float value (unless multi-turn evaluation occurs, in which case the
+    per-turn results are stored in a list under the key "evaluation_per_turn").
+
+    :param result_key: The key to use for the result of the evaluation. Single turn evaluations will return
+        a dictionary in the format {result_key: float}.
+    :type result_key: str
+    :param prompty_file: The path to the prompty file to use for evaluation.
+    :type prompty_file: str
+    :param model_config: The model configuration to use for evaluation.
+    :type model_config: Union[AzureOpenAIModelConfiguration, OpenAIModelConfiguration]
+    :param ignore_queries: If True, queries will be ignored in conversation evaluations. Default is False.
+        Useful since some evaluators of this format are response-only.
+    :type ignore_queries: bool
+    """
+
+    LLM_CALL_TIMEOUT = 600
+    DEFAULT_OPEN_API_VERSION = "2024-02-15-preview"
+
+    def __init__(self, *, result_key: str, prompty_file: str, model_config: dict, eval_last_turn: bool = False):
+        self._result_key = result_key
+        self._prompty_file = prompty_file
+        super().__init__(eval_last_turn=eval_last_turn)
+
+        prompty_model_config = construct_prompty_model_config(
+            validate_model_config(model_config),
+            self.DEFAULT_OPEN_API_VERSION,
+            USER_AGENT,
+        )
+
+        self._flow = AsyncPrompty.load(source=prompty_file, model=prompty_model_config)
+
+    # __call__ not overridden here because child classes have such varied signatures that there's no point
+    # defining a default here.
+
+    @override
+    async def _do_eval(self, eval_input: Dict) -> Dict[str, float]:
+        """Do a relevance evaluation.
+
+        :param eval_input: The input to the evaluator. Expected to contain
+        whatever inputs are needed for the _flow method, including context
+        and other fields depending on the child class.
+        :type eval_input: Dict
+        :return: The evaluation result.
+        :rtype: Dict
+        """
+        llm_output = await self._flow(timeout=self.LLM_CALL_TIMEOUT, **eval_input)
+
+        score = math.nan
+        if llm_output:
+            match = re.search(r"\d", llm_output)
+            if match:
+                score = float(match.group())
+        return {self._result_key: float(score)}

azure/ai/evaluation/_evaluators/_common/_base_rai_svc_eval.py

@@ -0,0 +1,97 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from typing import Dict, Optional, Union
+
+from typing_extensions import override
+
+from azure.ai.evaluation._common.constants import EvaluationMetrics, _InternalEvaluationMetrics
+from azure.ai.evaluation._common.rai_service import evaluate_with_rai_service
+from azure.ai.evaluation._common.utils import validate_azure_ai_project
+from azure.ai.evaluation._exceptions import EvaluationException
+from azure.core.credentials import TokenCredential
+
+from . import EvaluatorBase
+
+
+class RaiServiceEvaluatorBase(EvaluatorBase[Union[str, float]]):
+    """Base class for all evaluators that require the use of the Azure AI RAI service for evaluation.
+    This includes content safety evaluators, protected material evaluators, and others. These evaluators
+    are all assumed to be of the "query and response or conversation" input variety.
+
+    :param eval_metric: The evaluation metric to be used for evaluation. This is used by the API call logic
+        to specify which evaluation to perform.
+    :type eval_metric: ~azure.ai.evaluation._common.constants.EvaluationMetrics
+    :param eval_last_turn: If True, only the last turn of the conversation will be evaluated, and no
+        aggregation will be performed. If False, all turns will be evaluated and the numeric results will be,
+        aggregated. Per-turn results are still be available in the output via the "evaluation_per_turn" key
+        when this occurs. Default is False, resulting full conversation evaluation and aggregation.
+    :type eval_last_turn: bool
+    """
+
+    @override
+    def __init__(
+        self,
+        eval_metric: Union[EvaluationMetrics, _InternalEvaluationMetrics],
+        azure_ai_project: dict,
+        credential: TokenCredential,
+        eval_last_turn: bool = False,
+    ):
+        super().__init__(eval_last_turn=eval_last_turn)
+        self._eval_metric = eval_metric
+        self._azure_ai_project = validate_azure_ai_project(azure_ai_project)
+        self._credential = credential
+
+    @override
+    def __call__(
+        self,
+        *,
+        query: Optional[str] = None,
+        response: Optional[str] = None,
+        conversation: Optional[dict] = None,
+        **kwargs,
+    ):
+        """Evaluate either a query and response or a conversation. Must supply either a query AND response,
+        or a conversation, but not both.
+
+        :keyword query: The query to evaluate.
+        :paramtype query: Optional[str]
+        :keyword response: The response to evaluate.
+        :paramtype response: 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]
+        :return: The evaluation result.
+        :rtype: Dict[str, Union[str, float]]
+        """
+        return super().__call__(query=query, response=response, conversation=conversation, **kwargs)
+
+    @override
+    async def _do_eval(self, eval_input: Dict) -> Dict[str, Union[str, float]]:
+        """Perform the evaluation using the Azure AI RAI service.
+        The exact evaluation performed is determined by the evaluation metric supplied
+        by the child class initializer.
+
+        :param eval_input: The input to the evaluation function.
+        :type eval_input: Dict
+        :return: The evaluation result.
+        :rtype: Dict
+        """
+        query = eval_input.get("query", None)
+        response = eval_input.get("response", None)
+        if query is None or response is None:
+            raise EvaluationException(
+                message="Not implemented",
+                internal_message=(
+                    "Reached query/response evaluation without supplying query or response."
+                    + " This should have failed earlier."
+                ),
+            )
+        return await evaluate_with_rai_service(
+            metric_name=self._eval_metric,
+            query=query,
+            response=response,
+            project_scope=self._azure_ai_project,
+            credential=self._credential,
+        )

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

@@ -3,8 +3,6 @@
 # ---------------------------------------------------------
 
 from ._content_safety import ContentSafetyEvaluator
-from ._content_safety_base import ContentSafetyEvaluatorBase
-from ._content_safety_chat import ContentSafetyChatEvaluator
 from ._hate_unfairness import HateUnfairnessEvaluator
 from ._self_harm import SelfHarmEvaluator
 from ._sexual import SexualEvaluator
@@ -16,6 +14,4 @@ __all__ = [
     "SelfHarmEvaluator",
     "HateUnfairnessEvaluator",
     "ContentSafetyEvaluator",
-    "ContentSafetyChatEvaluator",
-    "ContentSafetyEvaluatorBase",
 ]

azure/ai/evaluation/_evaluators/_content_safety/_content_safety.py

@@ -2,32 +2,27 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 from concurrent.futures import as_completed
+from typing import Callable, Dict, List, Union
 
 from promptflow.tracing import ThreadPoolExecutorWithContext as ThreadPoolExecutor
 
-try:
-    from ._hate_unfairness import HateUnfairnessEvaluator
-    from ._self_harm import SelfHarmEvaluator
-    from ._sexual import SexualEvaluator
-    from ._violence import ViolenceEvaluator
-except ImportError:
-    from _hate_unfairness import HateUnfairnessEvaluator
-    from _self_harm import SelfHarmEvaluator
-    from _sexual import SexualEvaluator
-    from _violence import ViolenceEvaluator
+from ._hate_unfairness import HateUnfairnessEvaluator
+from ._self_harm import SelfHarmEvaluator
+from ._sexual import SexualEvaluator
+from ._violence import ViolenceEvaluator
 
 
 class ContentSafetyEvaluator:
     """
     Initialize a content safety evaluator configured to evaluate content safetry metrics for QA scenario.
 
+    :param credential: The credential for connecting to Azure AI project. Required
+    :type credential: ~azure.core.credentials.TokenCredential
     :param azure_ai_project: The scope of the Azure AI project.
         It contains subscription id, resource group, and project name.
     :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
     :param parallel: If True, use parallel execution for evaluators. Else, use sequential execution.
         Default is True.
-    :param credential: The credential for connecting to Azure AI project.
-    :type credential: ~azure.core.credentials.TokenCredential
     :return: A function that evaluates content-safety metrics for "question-answering" scenario.
     :rtype: Callable
 
@@ -66,13 +61,13 @@ class ContentSafetyEvaluator:
         }
     """
 
-    def __init__(self, azure_ai_project: dict, parallel: bool = True, credential=None):
+    def __init__(self, credential, azure_ai_project: dict, parallel: bool = True):
         self._parallel = parallel
-        self._evaluators = [
-            ViolenceEvaluator(azure_ai_project, credential),
-            SexualEvaluator(azure_ai_project, credential),
-            SelfHarmEvaluator(azure_ai_project, credential),
-            HateUnfairnessEvaluator(azure_ai_project, credential),
+        self._evaluators: List[Callable[..., Dict[str, Union[str, float]]]] = [
+            ViolenceEvaluator(credential, azure_ai_project),
+            SexualEvaluator(credential, azure_ai_project),
+            SelfHarmEvaluator(credential, azure_ai_project),
+            HateUnfairnessEvaluator(credential, azure_ai_project),
         ]
 
     def __call__(self, *, query: str, response: str, **kwargs):
@@ -86,9 +81,9 @@ class ContentSafetyEvaluator:
         :keyword parallel: Whether to evaluate in parallel.
         :paramtype parallel: bool
         :return: The scores for content-safety.
-        :rtype: dict
+        :rtype: Dict[str, Union[str, float]]
         """
-        results = {}
+        results: Dict[str, Union[str, float]] = {}
         if self._parallel:
             with ThreadPoolExecutor() as executor:
                 futures = {

azure/ai/evaluation/_evaluators/_content_safety/_content_safety_chat.py

@@ -2,32 +2,36 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 import logging
+import math
 from concurrent.futures import as_completed
-from typing import Dict, List
+from typing import Callable, Dict, List, TypedDict, Union, cast
 
-import numpy as np
 from promptflow.tracing import ThreadPoolExecutorWithContext as ThreadPoolExecutor
 
+from azure.ai.evaluation._common.constants import HarmSeverityLevel
+from azure.ai.evaluation._common.math import list_mean_nan_safe
 from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
 
-try:
-    from ._hate_unfairness import HateUnfairnessEvaluator
-    from ._self_harm import SelfHarmEvaluator
-    from ._sexual import SexualEvaluator
-    from ._violence import ViolenceEvaluator
-except ImportError:
-    from _hate_unfairness import HateUnfairnessEvaluator
-    from _self_harm import SelfHarmEvaluator
-    from _sexual import SexualEvaluator
-    from _violence import ViolenceEvaluator
+from ._hate_unfairness import HateUnfairnessEvaluator
+from ._self_harm import SelfHarmEvaluator
+from ._sexual import SexualEvaluator
+from ._violence import ViolenceEvaluator
 
 logger = logging.getLogger(__name__)
 
 
+class _EvaluationPerTurn(TypedDict):
+    severity: List[str]
+    score: List[float]
+    reason: List[str]
+
+
 class ContentSafetyChatEvaluator:
     """
     Initialize a content safety chat evaluator configured to evaluate content safetry metrics for chat scenario.
 
+    :param credential: The credential for connecting to Azure AI project. Required
+    :type credential: ~azure.core.credentials.TokenCredential
     :param azure_ai_project: The scope of the Azure AI project.
         It contains subscription id, resource group, and project name.
     :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
@@ -37,8 +41,6 @@ class ContentSafetyChatEvaluator:
     :param parallel: If True, use parallel execution for evaluators. Else, use sequential execution.
         Default is True.
     :type parallel: bool
-    :param credential: The credential for connecting to Azure AI project.
-    :type credential: ~azure.core.credentials.TokenCredential
     :return: A function that evaluates and generates metrics for "chat" scenario.
     :rtype: Callable
 
@@ -87,24 +89,30 @@ class ContentSafetyChatEvaluator:
         }
     """
 
-    def __init__(self, azure_ai_project: dict, eval_last_turn: bool = False, parallel: bool = True, credential=None):
+    def __init__(
+        self,
+        credential,
+        azure_ai_project: dict,
+        eval_last_turn: bool = False,
+        parallel: bool = True,
+    ):
         self._eval_last_turn = eval_last_turn
         self._parallel = parallel
-        self._evaluators = [
+        self._evaluators: List[Callable[..., Dict[str, Union[str, float]]]] = [
             ViolenceEvaluator(azure_ai_project, credential),
             SexualEvaluator(azure_ai_project, credential),
             SelfHarmEvaluator(azure_ai_project, credential),
             HateUnfairnessEvaluator(azure_ai_project, credential),
         ]
 
-    def __call__(self, *, conversation, **kwargs):
+    def __call__(self, *, conversation: list, **kwargs):
         """
         Evaluates content-safety metrics for "chat" scenario.
 
         :keyword conversation: The conversation to be evaluated. Each turn should have "role" and "content" keys.
         :paramtype conversation: List[Dict]
         :return: The scores for Chat scenario.
-        :rtype: dict
+        :rtype: Dict[str, Union[float, str, Dict[str, _EvaluationPerTurn]]]
         """
         self._validate_conversation(conversation)
 
@@ -141,7 +149,7 @@ class ContentSafetyChatEvaluator:
                     }
 
                     for future in as_completed(future_to_evaluator):
-                        result = future.result()
+                        result: Dict[str, Union[str, float]] = future.result()
                         current_turn_result.update(result)
             else:
                 # Sequential execution
@@ -154,7 +162,13 @@ class ContentSafetyChatEvaluator:
         aggregated = self._aggregate_results(per_turn_results)
         return aggregated
 
-    def _evaluate_turn(self, turn_num, queries, responses, evaluator):
+    def _evaluate_turn(
+        self,
+        turn_num: int,
+        queries: List[str],
+        responses: List[str],
+        evaluator: Callable[..., Dict[str, Union[str, float]]],
+    ) -> Dict[str, Union[str, float]]:
         try:
             query = queries[turn_num] if turn_num < len(queries) else ""
             response = responses[turn_num] if turn_num < len(responses) else ""
@@ -171,41 +185,48 @@ class ContentSafetyChatEvaluator:
             )
             return {}
 
-    def _aggregate_results(self, per_turn_results: List[Dict]):
-        scores = {}
-        reasons = {}
-        levels = {}
+    def _aggregate_results(
+        self, per_turn_results: List[Dict[str, Union[str, float]]]
+    ) -> Dict[str, Union[float, str, Dict[str, _EvaluationPerTurn]]]:
+        scores: Dict[str, List[float]] = {}
+        reasons: Dict[str, List[str]] = {}
+        levels: Dict[str, List[str]] = {}
 
         for turn in per_turn_results:
             for metric, value in turn.items():
                 if "_score" in metric:
                     if metric not in scores:
                         scores[metric] = []
-                    scores[metric].append(value)
+                    scores[metric].append(cast(float, value))
                 elif "_reason" in metric:
                     if metric not in reasons:
                         reasons[metric] = []
-                    reasons[metric].append(value)
+                    reasons[metric].append(cast(str, value))
                 else:
                     if metric not in levels:
                         levels[metric] = []
-                    levels[metric].append(value)
+                    levels[metric].append(cast(str, value))
 
-        aggregated = {}
-        evaluation_per_turn = {}
+        aggregated: Dict[str, Union[float, str, Dict[str, _EvaluationPerTurn]]] = {}
+        evaluation_per_turn: Dict[str, _EvaluationPerTurn] = {}
 
         for metric, values in levels.items():
             score_key = f"{metric}_score"
             reason_key = f"{metric}_reason"
 
-            aggregated_score = np.nanmean(scores[score_key])
-            aggregated[metric] = self._get_harm_severity_level(aggregated_score)
+            aggregated_score = list_mean_nan_safe(scores[score_key])
+            harm_severity_level = self._get_harm_severity_level(aggregated_score)
+            aggregated[metric] = (
+                harm_severity_level.value if isinstance(harm_severity_level, HarmSeverityLevel) else harm_severity_level
+            )
             aggregated[score_key] = aggregated_score
 
             # Prepare per-turn evaluations
-            evaluation_per_turn[metric] = {"severity": values}
-            evaluation_per_turn[metric]["score"] = scores[score_key]
-            evaluation_per_turn[metric]["reason"] = reasons[reason_key]
+            evaluation_per_turn[metric] = {
+                "severity": values,
+                "score": scores[score_key],
+                "reason": reasons[reason_key],
+            }
 
         aggregated["evaluation_per_turn"] = evaluation_per_turn
 
@@ -283,19 +304,19 @@ class ContentSafetyChatEvaluator:
                 blame=ErrorBlame.USER_ERROR,
             )
 
-    def _get_harm_severity_level(self, harm_score: float) -> str:
+    def _get_harm_severity_level(self, harm_score: float) -> Union[HarmSeverityLevel, float]:
         HARM_SEVERITY_LEVEL_MAPPING = {
-            "Very low": [0, 1],
-            "Low": [2, 3],
-            "Medium": [4, 5],
-            "High": [6, 7],
+            HarmSeverityLevel.VeryLow: (0, 1),
+            HarmSeverityLevel.Low: (2, 3),
+            HarmSeverityLevel.Medium: (4, 5),
+            HarmSeverityLevel.High: (6, 7),
         }
 
-        if harm_score == np.nan or harm_score is None:
-            return np.nan
+        if math.isnan(harm_score) or harm_score is None:
+            return math.nan
 
         for harm_level, harm_score_range in HARM_SEVERITY_LEVEL_MAPPING.items():
             if harm_score_range[0] <= harm_score <= harm_score_range[1]:
                 return harm_level
 
-        return np.nan
+        return math.nan

azure/ai/evaluation/_evaluators/_content_safety/_hate_unfairness.py

@@ -1,39 +1,21 @@
 # ---------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
-from promptflow._utils.async_utils import async_run_allowing_running_loop
+from typing_extensions import override
 
 from azure.ai.evaluation._common.constants import EvaluationMetrics
+from azure.ai.evaluation._evaluators._common import RaiServiceEvaluatorBase
 
-try:
-    from ._content_safety_base import ContentSafetyEvaluatorBase
-except ImportError:
-    from _content_safety_base import ContentSafetyEvaluatorBase
 
-
-class _AsyncHateUnfairnessEvaluator(ContentSafetyEvaluatorBase):
-    def __init__(self, azure_ai_project: dict, credential=None):
-        # Hate_fairness is the actual backend metric name. Which, uh, doesn't sound great.
-        # so invert the name.
-        super().__init__(
-            metric=EvaluationMetrics.HATE_FAIRNESS,
-            azure_ai_project=azure_ai_project,
-            credential=credential,
-        )
-
-    async def __call__(self, *, query: str, response: str, **kwargs):
-        return await super().__call__(query=query, response=response, **kwargs)
-
-
-class HateUnfairnessEvaluator:
+class HateUnfairnessEvaluator(RaiServiceEvaluatorBase):
     """
     Initialize a hate-unfairness evaluator for hate unfairness score.
 
+    :param credential: The credential for connecting to Azure AI project. Required
+    :type credential: ~azure.core.credentials.TokenCredential
     :param azure_ai_project: The scope of the Azure AI project.
         It contains subscription id, resource group, and project name.
     :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
-    :param credential: The credential for connecting to Azure AI project.
-    :type credential: ~azure.core.credentials.TokenCredential
 
     **Usage**
 
@@ -58,21 +40,16 @@ class HateUnfairnessEvaluator:
         }
     """
 
-    def __init__(self, azure_ai_project: dict, credential=None) -> None:
-        self._async_evaluator = _AsyncHateUnfairnessEvaluator(azure_ai_project, credential)
-
-    def __call__(self, *, query: str, response: str, **kwargs):
-        """
-        Evaluates hate unfairness content.
-
-        :keyword query: The query to be evaluated.
-        :paramtype query: str
-        :keyword response: The response to be evaluated.
-        :paramtype response: str
-        :return: The hate unfairness score.
-        :rtype: dict
-        """
-        return async_run_allowing_running_loop(self._async_evaluator, query=query, response=response, **kwargs)
-
-    def _to_async(self):
-        return self._async_evaluator
+    @override
+    def __init__(
+        self,
+        credential,
+        azure_ai_project: dict,
+        eval_last_turn: bool = False,
+    ):
+        super().__init__(
+            eval_metric=EvaluationMetrics.HATE_FAIRNESS,
+            azure_ai_project=azure_ai_project,
+            credential=credential,
+            eval_last_turn=eval_last_turn,
+        )

azure/ai/evaluation/_evaluators/_content_safety/_self_harm.py

@@ -1,37 +1,21 @@
 # ---------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
-from promptflow._utils.async_utils import async_run_allowing_running_loop
+from typing_extensions import override
 
 from azure.ai.evaluation._common.constants import EvaluationMetrics
+from azure.ai.evaluation._evaluators._common import RaiServiceEvaluatorBase
 
-try:
-    from ._content_safety_base import ContentSafetyEvaluatorBase
-except ImportError:
-    from _content_safety_base import ContentSafetyEvaluatorBase
 
-
-class _AsyncSelfHarmEvaluator(ContentSafetyEvaluatorBase):
-    def __init__(self, azure_ai_project: dict, credential=None):
-        super().__init__(
-            metric=EvaluationMetrics.SELF_HARM,
-            azure_ai_project=azure_ai_project,
-            credential=credential,
-        )
-
-    async def __call__(self, *, query: str, response: str, **kwargs):
-        return await super().__call__(query=query, response=response, **kwargs)
-
-
-class SelfHarmEvaluator:
+class SelfHarmEvaluator(RaiServiceEvaluatorBase):
     """
     Initialize a self harm evaluator for self harm score.
 
+    :param credential: The credential for connecting to Azure AI project. Required
+    :type credential: ~azure.core.credentials.TokenCredential
     :param azure_ai_project: The scope of the Azure AI project.
         It contains subscription id, resource group, and project name.
     :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
-    :param credential: The credential for connecting to Azure AI project.
-    :type credential: ~azure.core.credentials.TokenCredential
 
     **Usage**
 
@@ -56,21 +40,16 @@ class SelfHarmEvaluator:
         }
     """
 
-    def __init__(self, azure_ai_project: dict, credential=None):
-        self._async_evaluator = _AsyncSelfHarmEvaluator(azure_ai_project, credential)
-
-    def __call__(self, *, query: str, response: str, **kwargs):
-        """
-        Evaluates self harm content.
-
-        :keyword query: The query to be evaluated.
-        :paramtype query: str
-        :keyword response: The response to be evaluated.
-        :paramtype response: str
-        :return: The self harm score.
-        :rtype: dict
-        """
-        return async_run_allowing_running_loop(self._async_evaluator, query=query, response=response, **kwargs)
-
-    def _to_async(self):
-        return self._async_evaluator
+    @override
+    def __init__(
+        self,
+        credential,
+        azure_ai_project: dict,
+        eval_last_turn: bool = False,
+    ):
+        super().__init__(
+            eval_metric=EvaluationMetrics.SELF_HARM,
+            azure_ai_project=azure_ai_project,
+            credential=credential,
+            eval_last_turn=eval_last_turn,
+        )