Custom Metric

Opik allows you to define your own metrics. This is useful if you have a specific metric that is not already implemented.

If you want to write an LLM as a Judge metric, you can use either the G-Eval metric or create your own from scratch.

Custom LLM as a Judge metric

Creating a custom metric using G-Eval

G-eval allows you to specify a set of criteria for your metric and it will use a Chain of Thought prompting technique to create some evaluation steps and return a score.

To use G-Eval, you will need to specify a task introduction and evaluation criteria:

1from opik.evaluation.metrics import GEval
2
3metric = GEval(
4    task_introduction="You are an expert judge tasked with evaluating the faithfulness of an AI-generated answer to the given context.",
5    evaluation_criteria="""
6        The OUTPUT must not introduce new information beyond what's provided in the CONTEXT.
7        The OUTPUT must not contradict any information given in the CONTEXT.
8
9        Return only a score between 0 and 1.
10    """,
11)

Writing your own custom metric

To define a custom heuristic metric, you need to subclass the BaseMetric class and implement the score method and an optional ascore method:

1from typing import Any
2from opik.evaluation.metrics import base_metric, score_result
3import json
4
5class MyCustomMetric(base_metric.BaseMetric):
6    def __init__(self, name: str):
7        self.name = name
8
9    def score(self, input: str, output: str, **ignored_kwargs: Any):
10        # Add you logic here
11
12        return score_result.ScoreResult(
13            value=0,
14            name=self.name,
15            reason="Optional reason for the score"
16        )

The score method should return a ScoreResult object. The ascore method is optional and can be used to compute asynchronously if needed.

You can also return a list of ScoreResult objects as part of your custom metric. This is useful if you want to return multiple scores for a given input and output pair.

This metric can now be used in the evaluate function as explained here: Evaluating LLMs.

Example: Creating a metric with OpenAI model

You can implement your own custom metric by creating a class that subclasses the BaseMetric class and implements the score method.

1from opik.evaluation.metrics import base_metric, score_result
2from openai import OpenAI
3from typing import Any
4
5class LLMJudgeMetric(base_metric.BaseMetric):
6    def __init__(self, name: str = "Factuality check", model_name: str = "gpt-4o"):
7        self.name = name
8        self.llm_client = OpenAI()
9        self.model_name = model_name
10        self.prompt_template = """
11        You are an impartial judge evaluating the following claim for factual accuracy.
12        Analyze it carefully and respond with a number between 0 and 1: 1 if completely
13        accurate, 0.5 if mixed accuracy, or 0 if inaccurate. The format of the your response
14        should be a single number with no other text.
15
16        The format of the your response should be a JSON object with no additional text or backticks that follows the format:
17        {{
18            "score": <score between 0 and 1>
19        }}
20
21        Claim to evaluate: {output}
22
23        Response:
24        """
25    def score(self, output: str, **ignored_kwargs: Any):
26        """
27        Score the output of an LLM.
28
29        Args:
30            output: The output of an LLM to score.
31            **ignored_kwargs: Any additional keyword arguments. This is important so that the metric can be used in the `evaluate` function.
32        """
33        # Construct the prompt based on the output of the LLM
34        prompt = self.prompt_template.format(output=output)
35        # Generate and parse the response from the LLM
36        response = self.llm_client.chat.completions.create(
37            model=self.model_name,
38            messages=[{"role": "user", "content": prompt}]
39        )
40        response_dict = json.loads(response.choices[0].message.content)
41
42        response_score = float(response_dict["score"])
43
44        return score_result.ScoreResult(
45            name=self.name,
46            value=response_score
47        )

You can then use this metric to score your LLM outputs:

1metric = LLMJudgeMetric()
2
3metric.score(output="Paris is the capital of France")

In this example, we used the OpenAI Python client to call the LLM. You don’t have to use the OpenAI Python client, you can update the code example above to use any LLM client you have access to.

Example: Adding support for many all LLM providers

In order to support a wide range of LLM providers, we recommend using the litellm library to call your LLM. This allows you to support hundreds of models without having to maintain a custom LLM client.

Opik providers a LitellmChatModel class that wraps the litellm library and can be used in your custom metric:

1from opik.evaluation.metrics import base_metric, score_result
2from opik.evaluation import models
3import json
4from typing import Any
5
6class LLMJudgeMetric(base_metric.BaseMetric):
7    def __init__(self, name: str = "Factuality check", model_name: str = "gpt-4o"):
8        self.name = name
9        self.llm_client = models.LiteLLMChatModel(model_name=model_name)
10        self.prompt_template = """
11        You are an impartial judge evaluating the following claim for factual accuracy. Analyze it carefully
12        and respond with a number between 0 and 1: 1 if completely accurate, 0.5 if mixed accuracy, or 0 if inaccurate.
13        Then provide one brief sentence explaining your ruling.
14
15        The format of the your response should be a JSON object with no additional text or backticks that follows the format:
16        {{
17            "score": <score between 0 and 1>,
18            "reason": "<reason for the score>"
19        }}
20
21        Claim to evaluate: {output}
22
23        Response:
24        """
25    def score(self, output: str, **ignored_kwargs: Any):
26        """
27        Score the output of an LLM.
28
29        Args:
30            output: The output of an LLM to score.
31            **ignored_kwargs: Any additional keyword arguments. This is important so that the metric can be used in the `evaluate` function.
32        """
33        # Construct the prompt based on the output of the LLM
34        prompt = self.prompt_template.format(output=output)
35
36        # Generate and parse the response from the LLM
37        response = self.llm_client.generate_string(input=prompt)
38
39        response_dict = json.loads(response)
40
41        return score_result.ScoreResult(
42            name=self.name,
43            value=response_dict["score"],
44            reason=response_dict["reason"]
45        )

You can then use this metric to score your LLM outputs:

1metric = LLMJudgeMetric()
2
3metric.score(output="Paris is the capital of France")

Example: Enforcing structured outputs

In the examples above, we ask the LLM to respond with a JSON object. However as this is not enforced, it is possible that the LLM returns a non-structured response. In order to avoid this, you can use the litellm library to enforce a structured output. This will make our custom metric more robust and less prone to failure.

For this we define the format of the response we expect from the LLM in the LLMJudgeResult class and pass it to the LiteLLM client:

1from opik.evaluation.metrics import base_metric, score_result
2from opik.evaluation import models
3from pydantic import BaseModel
4import json
5from typing import Any
6
7class LLMJudgeResult(BaseModel):
8    score: int
9    reason: str
10
11class LLMJudgeMetric(base_metric.BaseMetric):
12    def __init__(self, name: str = "Factuality check", model_name: str = "gpt-4o"):
13        self.name = name
14        self.llm_client = models.LiteLLMChatModel(model_name=model_name)
15        self.prompt_template = """
16        You are an impartial judge evaluating the following claim for factual accuracy. Analyze it carefully and respond with a number between 0 and 1: 1 if completely accurate, 0.5 if mixed accuracy, or 0 if inaccurate. Then provide one brief sentence explaining your ruling.
17
18         The format of the your response should be a json with no backticks that returns:
19
20        {{
21            "score": <score between 0 and 1>,
22            "reason": "<reason for the score>"
23        }}
24
25        Claim to evaluate: {output}
26
27        Response:
28        """
29
30    def score(self, output: str, **ignored_kwargs: Any):
31        """
32        Score the output of an LLM.
33
34        Args:
35            output: The output of an LLM to score.
36            **ignored_kwargs: Any additional keyword arguments. This is important so that the metric can be used in the `evaluate` function.
37        """
38        # Construct the prompt based on the output of the LLM
39        prompt = self.prompt_template.format(output=output)
40
41        # Generate and parse the response from the LLM
42        response = self.llm_client.generate_string(input=prompt, response_format=LLMJudgeResult)
43        response_dict = json.loads(response)
44
45        return score_result.ScoreResult(
46            name=self.name,
47            value=response_dict["score"],
48            reason=response_dict["reason"]
49        )

Similarly to the previous example, you can then use this metric to score your LLM outputs:

1metric = LLMJudgeMetric()
2
3metric.score(output="Paris is the capital of France")
Built with