{
 "cells": [
  {
   "cell_type": "raw",
   "id": "5046d96f-d578-4d5b-9a7e-43b28cafe61d",
   "metadata": {},
   "source": [
    "---\n",
    "sidebar_position: 2\n",
    "title: Custom pairwise evaluator\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "657d2c8c-54b4-42a3-9f02-bdefa0ed6728",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/guides/evaluation/comparison/custom.ipynb)\n",
    "\n",
    "You can make your own pairwise string evaluators by inheriting from `PairwiseStringEvaluator` class and overwriting the `_evaluate_string_pairs` method (and the `_aevaluate_string_pairs` method if you want to use the evaluator asynchronously).\n",
    "\n",
    "In this example, you will make a simple custom evaluator that just returns whether the first prediction has more whitespace tokenized 'words' than the second.\n",
    "\n",
    "You can check out the reference docs for the [PairwiseStringEvaluator interface](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.schema.PairwiseStringEvaluator.html#langchain.evaluation.schema.PairwiseStringEvaluator) for more info.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "93f3a653-d198-4291-973c-8d1adba338b2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from typing import Any, Optional\n",
    "\n",
    "from langchain.evaluation import PairwiseStringEvaluator\n",
    "\n",
    "\n",
    "class LengthComparisonPairwiseEvaluator(PairwiseStringEvaluator):\n",
    "    \"\"\"\n",
    "    Custom evaluator to compare two strings.\n",
    "    \"\"\"\n",
    "\n",
    "    def _evaluate_string_pairs(\n",
    "        self,\n",
    "        *,\n",
    "        prediction: str,\n",
    "        prediction_b: str,\n",
    "        reference: Optional[str] = None,\n",
    "        input: Optional[str] = None,\n",
    "        **kwargs: Any,\n",
    "    ) -> dict:\n",
    "        score = int(len(prediction.split()) > len(prediction_b.split()))\n",
    "        return {\"score\": score}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7d4a77c3-07a7-4076-8e7f-f9bca0d6c290",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'score': 1}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluator = LengthComparisonPairwiseEvaluator()\n",
    "\n",
    "evaluator.evaluate_string_pairs(\n",
    "    prediction=\"The quick brown fox jumped over the lazy dog.\",\n",
    "    prediction_b=\"The quick brown fox jumped over the dog.\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d90f128f-6f49-42a1-b05a-3aea568ee03b",
   "metadata": {},
   "source": [
    "## LLM-Based Example\n",
    "\n",
    "That example was simple to illustrate the API, but it wasn't very useful in practice. Below, use an LLM with some custom instructions to form a simple preference scorer similar to the built-in [PairwiseStringEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain.html#langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain). We will use `ChatAnthropic` for the evaluator chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b4b43098-4d96-417b-a8a9-b3e75779cfe8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# %pip install anthropic\n",
    "# %env ANTHROPIC_API_KEY=YOUR_API_KEY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b6e978ab-48f1-47ff-9506-e13b1a50be6e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from typing import Any, Optional\n",
    "\n",
    "from langchain.chains import LLMChain\n",
    "from langchain.chat_models import ChatAnthropic\n",
    "from langchain.evaluation import PairwiseStringEvaluator\n",
    "\n",
    "\n",
    "class CustomPreferenceEvaluator(PairwiseStringEvaluator):\n",
    "    \"\"\"\n",
    "    Custom evaluator to compare two strings using a custom LLMChain.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self) -> None:\n",
    "        llm = ChatAnthropic(model=\"claude-2\", temperature=0)\n",
    "        self.eval_chain = LLMChain.from_string(\n",
    "            llm,\n",
    "            \"\"\"Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C\n",
    "\n",
    "Input: How do I get the path of the parent directory in python 3.8?\n",
    "Option A: You can use the following code:\n",
    "```python\n",
    "import os\n",
    "\n",
    "os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n",
    "```\n",
    "Option B: You can use the following code:\n",
    "```python\n",
    "from pathlib import Path\n",
    "Path(__file__).absolute().parent\n",
    "```\n",
    "Reasoning: Both options return the same result. However, since option B is more concise and easily understand, it is preferred.\n",
    "Preference: B\n",
    "\n",
    "Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C\n",
    "Input: {input}\n",
    "Option A: {prediction}\n",
    "Option B: {prediction_b}\n",
    "Reasoning:\"\"\",\n",
    "        )\n",
    "\n",
    "    @property\n",
    "    def requires_input(self) -> bool:\n",
    "        return True\n",
    "\n",
    "    @property\n",
    "    def requires_reference(self) -> bool:\n",
    "        return False\n",
    "\n",
    "    def _evaluate_string_pairs(\n",
    "        self,\n",
    "        *,\n",
    "        prediction: str,\n",
    "        prediction_b: str,\n",
    "        reference: Optional[str] = None,\n",
    "        input: Optional[str] = None,\n",
    "        **kwargs: Any,\n",
    "    ) -> dict:\n",
    "        result = self.eval_chain(\n",
    "            {\n",
    "                \"input\": input,\n",
    "                \"prediction\": prediction,\n",
    "                \"prediction_b\": prediction_b,\n",
    "                \"stop\": [\"Which option is preferred?\"],\n",
    "            },\n",
    "            **kwargs,\n",
    "        )\n",
    "\n",
    "        response_text = result[\"text\"]\n",
    "        reasoning, preference = response_text.split(\"Preference:\", maxsplit=1)\n",
    "        preference = preference.strip()\n",
    "        score = 1.0 if preference == \"A\" else (0.0 if preference == \"B\" else None)\n",
    "        return {\"reasoning\": reasoning.strip(), \"value\": preference, \"score\": score}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5cbd8b1d-2cb0-4f05-b435-a1a00074d94a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "evaluator = CustomPreferenceEvaluator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2c0a7fb7-b976-4443-9f0e-e707a6dfbdf7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'reasoning': 'Option B is preferred over option A for importing from a relative directory, because it is more straightforward and concise.\\n\\nOption A uses the importlib module, which allows importing a module by specifying the full name as a string. While this works, it is less clear compared to option B.\\n\\nOption B directly imports from the relative path using dot notation, which clearly shows that it is a relative import. This is the recommended way to do relative imports in Python.\\n\\nIn summary, option B is more accurate and helpful as it uses the standard Python relative import syntax.',\n",
       " 'value': 'B',\n",
       " 'score': 0.0}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluator.evaluate_string_pairs(\n",
    "    input=\"How do I import from a relative directory?\",\n",
    "    prediction=\"use importlib! importlib.import_module('.my_package', '.')\",\n",
    "    prediction_b=\"from .sibling import foo\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f13a1346-7dbe-451d-b3a3-99e8fc7b753b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CustomPreferenceEvaluator requires an input string.\n"
     ]
    }
   ],
   "source": [
    "# Setting requires_input to return True adds additional validation to avoid returning a grade when insufficient data is provided to the chain.\n",
    "\n",
    "try:\n",
    "    evaluator.evaluate_string_pairs(\n",
    "        prediction=\"use importlib! importlib.import_module('.my_package', '.')\",\n",
    "        prediction_b=\"from .sibling import foo\",\n",
    "    )\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7829cc3-ebd1-4628-ae97-15166202e9cc",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
