diff --git a/examples/semantic_entropy_demo.ipynb b/examples/semantic_entropy_demo.ipynb index 0cbb3a04..31df0514 100644 --- a/examples/semantic_entropy_demo.ipynb +++ b/examples/semantic_entropy_demo.ipynb @@ -62,12 +62,23 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/c767873/Library/Caches/pypoetry/virtualenvs/uqlm-m1pshusV-py3.9/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ + "import os\n", + "\n", "import numpy as np\n", "from sklearn.metrics import precision_score, recall_score, f1_score\n", "\n", @@ -92,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "tags": [] }, @@ -101,7 +112,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Loading dataset - svamp...\n", + "Loading dataset - gsm8k...\n", "Processing dataset...\n", "Dataset ready!\n" ] @@ -134,28 +145,28 @@ " \n", " \n", " 0\n", - " There are 87 oranges and 290 bananas in Philip...\n", - " 145\n", + " Natalia sold clips to 48 of her friends in Apr...\n", + " 72\n", " \n", " \n", " 1\n", - " Marco and his dad went strawberry picking. Mar...\n", - " 19\n", + " Weng earns $12 an hour for babysitting. Yester...\n", + " 10\n", " \n", " \n", " 2\n", - " Edward spent $ 6 to buy 2 books each book cost...\n", - " 3\n", + " Betty is saving money for a new wallet which c...\n", + " 5\n", " \n", " \n", " 3\n", - " Frank was reading through his favorite book. T...\n", - " 198\n", + " Julie is reading a 120-page book. Yesterday, s...\n", + " 42\n", " \n", " \n", " 4\n", - " There were 78 dollars in Olivia's wallet. She ...\n", - " 63\n", + " James writes a 3-page letter to 2 different fr...\n", + " 624\n", " \n", " \n", "\n", @@ -163,27 +174,27 @@ ], "text/plain": [ " question answer\n", - "0 There are 87 oranges and 290 bananas in Philip... 145\n", - "1 Marco and his dad went strawberry picking. Mar... 19\n", - "2 Edward spent $ 6 to buy 2 books each book cost... 3\n", - "3 Frank was reading through his favorite book. T... 198\n", - "4 There were 78 dollars in Olivia's wallet. She ... 63" + "0 Natalia sold clips to 48 of her friends in Apr... 72\n", + "1 Weng earns $12 an hour for babysitting. Yester... 10\n", + "2 Betty is saving money for a new wallet which c... 5\n", + "3 Julie is reading a 120-page book. Yesterday, s... 42\n", + "4 James writes a 3-page letter to 2 different fr... 624" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Load example dataset (SVAMP)\n", - "svamp = load_example_dataset(\"svamp\", n=100)\n", + "svamp = load_example_dataset(\"gsm8k\", n=100)\n", "svamp.head()" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "tags": [] }, @@ -198,22 +209,34 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this example, we use `ChatVertexAI` to instantiate our LLM, but any [LangChain Chat Model](https://js.langchain.com/docs/integrations/chat/) may be used. Be sure to **replace with your LLM of choice.**" + "In this example, we use `AzureChatOpenAI` to instantiate our LLM, but any [LangChain Chat Model](https://js.langchain.com/docs/integrations/chat/) may be used. Be sure to **replace with your LLM of choice.**" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "tags": [] }, "outputs": [], "source": [ "# import sys\n", - "# !{sys.executable} -m pip install langchain-google-vertexai\n", - "from langchain_google_vertexai import ChatVertexAI\n", + "# !{sys.executable} -m pip install python-dotenv\n", + "# !{sys.executable} -m pip install langchain-openai\n", "\n", - "llm = ChatVertexAI(model=\"gemini-1.5-flash\")" + "# # User to populate .env file with API credentials\n", + "from dotenv import load_dotenv, find_dotenv\n", + "from langchain_openai import AzureChatOpenAI\n", + "\n", + "load_dotenv(find_dotenv())\n", + "llm = AzureChatOpenAI(\n", + " deployment_name=os.getenv(\"DEPLOYMENT_NAME\"),\n", + " openai_api_key=os.getenv(\"API_KEY\"),\n", + " azure_endpoint=os.getenv(\"API_BASE\"),\n", + " openai_api_type=os.getenv(\"API_TYPE\"),\n", + " openai_api_version=os.getenv(\"API_VERSION\"),\n", + " temperature=1, # User to set temperature\n", + ")" ] }, { @@ -340,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "tags": [] }, @@ -349,7 +372,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Using cuda device\n" + "Using mps device\n" ] } ], @@ -368,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "tags": [] }, @@ -386,7 +409,7 @@ "source": [ "se = SemanticEntropy(\n", " llm=llm,\n", - " max_calls_per_min=250, # set value to avoid rate limit error\n", + " max_calls_per_min=100, # set value to avoid rate limit error\n", " device=device, # use if GPU available\n", ")" ] @@ -437,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "tags": [] }, @@ -446,6 +469,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "UQLM: Using logprobs to compute response probabilities for semantic entropy score\n", "Generating responses...\n", "Generating candidate responses...\n", "Computing confidence scores...\n" @@ -459,9 +483,18 @@ "# results = se.score(responses=responses, sampled_responses=sampled_responses)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The LLM instance used here, returns token probabilities during the response generation. In such scenario, `SemanticEntropy` class computes response probabilty in two ways: 1) Discrete Semantic Entropy: Equal probability to each sampled response and 2) Uses token probability to compute probability of each sampled response. The final results contains semantic entropy scores based on both approach\n", + "\n", + "Note: When token probabilities are avaliable `best_response` is returned based on token probability based Semantic Entropy scores." + ] + }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": { "tags": [] }, @@ -488,81 +521,100 @@ " \n", " \n", " response\n", - " entropy_value\n", - " confidence_score\n", + " discrete_entropy_value\n", + " discrete_confidence_score\n", " sampled_responses\n", " prompt\n", + " tokenprob_entropy_value\n", + " tokenprob_confidence_score\n", " \n", " \n", " \n", " \n", " 0\n", - " 145\n", - " 0.000000\n", - " 1.000000\n", - " [145, 145, 145, 145, 145, 145, 145, 145, 145, ...\n", + " 72\n", + " 0.0\n", + " 1.0\n", + " [72, 72, 72, 72, 72, 72, 72, 72, 72, 72]\n", " When you solve this math problem only return t...\n", + " 0.0\n", + " 1.0\n", " \n", " \n", " 1\n", - " 19 pounds\n", - " 0.000000\n", - " 1.000000\n", - " [Nineteen pounds. , 19, 19, 19 pounds, 19, 19 ...\n", + " $10\n", + " 0.0\n", + " 1.0\n", + " [$10, $10, $10, $10, $10, $10, $10, $10, $10, ...\n", " When you solve this math problem only return t...\n", + " 0.0\n", + " 1.0\n", " \n", " \n", " 2\n", - " $3\n", - " 0.600166\n", - " 0.749711\n", - " [$ 9, $3, $3.00, $3, $3.00, $3, $ 3.00 \\n \\n \\...\n", + " $20\n", + " 0.0\n", + " 1.0\n", + " [$20, $20, $20, $20, $20, $20, $20, $20, $20, ...\n", " When you solve this math problem only return t...\n", + " 0.0\n", + " 1.0\n", " \n", " \n", " 3\n", - " 198\n", - " 0.000000\n", - " 1.000000\n", - " [198, 198, 198, 198, 198, 198, 198, 198, 198, ...\n", + " 48\n", + " 0.0\n", + " 1.0\n", + " [48, 48, 48, 48, 48, 48, 48, 48, 48, 48]\n", " When you solve this math problem only return t...\n", + " 0.0\n", + " 1.0\n", " \n", " \n", " 4\n", - " 63\n", - " 0.000000\n", - " 1.000000\n", - " [63, 63, 63, 63, 63.0, 63 dollars, 63, 63 doll...\n", + " 624\n", + " 0.0\n", + " 1.0\n", + " [624, 624, 624, 624, 624, 624, 624, 624, 624, ...\n", " When you solve this math problem only return t...\n", + " 0.0\n", + " 1.0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " response entropy_value confidence_score \\\n", - "0 145 0.000000 1.000000 \n", - "1 19 pounds 0.000000 1.000000 \n", - "2 $3 0.600166 0.749711 \n", - "3 198 0.000000 1.000000 \n", - "4 63 0.000000 1.000000 \n", + " response discrete_entropy_value discrete_confidence_score \\\n", + "0 72 0.0 1.0 \n", + "1 $10 0.0 1.0 \n", + "2 $20 0.0 1.0 \n", + "3 48 0.0 1.0 \n", + "4 624 0.0 1.0 \n", "\n", " sampled_responses \\\n", - "0 [145, 145, 145, 145, 145, 145, 145, 145, 145, ... \n", - "1 [Nineteen pounds. , 19, 19, 19 pounds, 19, 19 ... \n", - "2 [$ 9, $3, $3.00, $3, $3.00, $3, $ 3.00 \\n \\n \\... \n", - "3 [198, 198, 198, 198, 198, 198, 198, 198, 198, ... \n", - "4 [63, 63, 63, 63, 63.0, 63 dollars, 63, 63 doll... \n", + "0 [72, 72, 72, 72, 72, 72, 72, 72, 72, 72] \n", + "1 [$10, $10, $10, $10, $10, $10, $10, $10, $10, ... \n", + "2 [$20, $20, $20, $20, $20, $20, $20, $20, $20, ... \n", + "3 [48, 48, 48, 48, 48, 48, 48, 48, 48, 48] \n", + "4 [624, 624, 624, 624, 624, 624, 624, 624, 624, ... \n", + "\n", + " prompt tokenprob_entropy_value \\\n", + "0 When you solve this math problem only return t... 0.0 \n", + "1 When you solve this math problem only return t... 0.0 \n", + "2 When you solve this math problem only return t... 0.0 \n", + "3 When you solve this math problem only return t... 0.0 \n", + "4 When you solve this math problem only return t... 0.0 \n", "\n", - " prompt \n", - "0 When you solve this math problem only return t... \n", - "1 When you solve this math problem only return t... \n", - "2 When you solve this math problem only return t... \n", - "3 When you solve this math problem only return t... \n", - "4 When you solve this math problem only return t... " + " tokenprob_confidence_score \n", + "0 1.0 \n", + "1 1.0 \n", + "2 1.0 \n", + "3 1.0 \n", + "4 1.0 " ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -572,6 +624,120 @@ "result_df.head(5)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets, look at the correlation between \"discrete_confidence_score\" and \"tokenprob_confidence_score\", where entropy value is not equal to 1." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
discrete_confidence_scoretokenprob_confidence_score
50.3877380.719830
70.4300370.813432
110.1775090.402457
120.8729570.982329
130.6413660.796315
\n", + "
" + ], + "text/plain": [ + " discrete_confidence_score tokenprob_confidence_score\n", + "5 0.387738 0.719830\n", + "7 0.430037 0.813432\n", + "11 0.177509 0.402457\n", + "12 0.872957 0.982329\n", + "13 0.641366 0.796315" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "index = result_df[\"discrete_confidence_score\"] != 1\n", + "tmp = result_df.loc[index][[\"discrete_confidence_score\", \"tokenprob_confidence_score\"]]\n", + "tmp.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Correlation matrix:\n", + " discrete_confidence_score \\\n", + "discrete_confidence_score 1.000000 \n", + "tokenprob_confidence_score 0.868044 \n", + "\n", + " tokenprob_confidence_score \n", + "discrete_confidence_score 0.868044 \n", + "tokenprob_confidence_score 1.000000 \n" + ] + } + ], + "source": [ + "corr_matrix = tmp.corr()\n", + "print(\"\\nCorrelation matrix:\")\n", + "print(corr_matrix)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -589,7 +755,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "tags": [] }, @@ -616,10 +782,12 @@ " \n", " \n", " response\n", - " entropy_value\n", - " confidence_score\n", + " discrete_entropy_value\n", + " discrete_confidence_score\n", " sampled_responses\n", " prompt\n", + " tokenprob_entropy_value\n", + " tokenprob_confidence_score\n", " answer\n", " response_correct\n", " \n", @@ -627,52 +795,62 @@ " \n", " \n", " 0\n", - " 145\n", - " 0.000000\n", - " 1.000000\n", - " [145, 145, 145, 145, 145, 145, 145, 145, 145, ...\n", + " 72\n", + " 0.0\n", + " 1.0\n", + " [72, 72, 72, 72, 72, 72, 72, 72, 72, 72]\n", " When you solve this math problem only return t...\n", - " 145\n", + " 0.0\n", + " 1.0\n", + " 72\n", " True\n", " \n", " \n", " 1\n", - " 19 pounds\n", - " 0.000000\n", - " 1.000000\n", - " [Nineteen pounds. , 19, 19, 19 pounds, 19, 19 ...\n", + " $10\n", + " 0.0\n", + " 1.0\n", + " [$10, $10, $10, $10, $10, $10, $10, $10, $10, ...\n", " When you solve this math problem only return t...\n", - " 19\n", + " 0.0\n", + " 1.0\n", + " 10\n", " True\n", " \n", " \n", " 2\n", - " $3\n", - " 0.600166\n", - " 0.749711\n", - " [$ 9, $3, $3.00, $3, $3.00, $3, $ 3.00 \\n \\n \\...\n", + " $20\n", + " 0.0\n", + " 1.0\n", + " [$20, $20, $20, $20, $20, $20, $20, $20, $20, ...\n", " When you solve this math problem only return t...\n", - " 3\n", - " True\n", + " 0.0\n", + " 1.0\n", + " 5\n", + " False\n", " \n", " \n", " 3\n", - " 198\n", - " 0.000000\n", - " 1.000000\n", - " [198, 198, 198, 198, 198, 198, 198, 198, 198, ...\n", + " 48\n", + " 0.0\n", + " 1.0\n", + " [48, 48, 48, 48, 48, 48, 48, 48, 48, 48]\n", " When you solve this math problem only return t...\n", - " 198\n", - " True\n", + " 0.0\n", + " 1.0\n", + " 42\n", + " False\n", " \n", " \n", " 4\n", - " 63\n", - " 0.000000\n", - " 1.000000\n", - " [63, 63, 63, 63, 63.0, 63 dollars, 63, 63 doll...\n", + " 624\n", + " 0.0\n", + " 1.0\n", + " [624, 624, 624, 624, 624, 624, 624, 624, 624, ...\n", " When you solve this math problem only return t...\n", - " 63\n", + " 0.0\n", + " 1.0\n", + " 624\n", " True\n", " \n", " \n", @@ -680,29 +858,36 @@ "" ], "text/plain": [ - " response entropy_value confidence_score \\\n", - "0 145 0.000000 1.000000 \n", - "1 19 pounds 0.000000 1.000000 \n", - "2 $3 0.600166 0.749711 \n", - "3 198 0.000000 1.000000 \n", - "4 63 0.000000 1.000000 \n", + " response discrete_entropy_value discrete_confidence_score \\\n", + "0 72 0.0 1.0 \n", + "1 $10 0.0 1.0 \n", + "2 $20 0.0 1.0 \n", + "3 48 0.0 1.0 \n", + "4 624 0.0 1.0 \n", "\n", " sampled_responses \\\n", - "0 [145, 145, 145, 145, 145, 145, 145, 145, 145, ... \n", - "1 [Nineteen pounds. , 19, 19, 19 pounds, 19, 19 ... \n", - "2 [$ 9, $3, $3.00, $3, $3.00, $3, $ 3.00 \\n \\n \\... \n", - "3 [198, 198, 198, 198, 198, 198, 198, 198, 198, ... \n", - "4 [63, 63, 63, 63, 63.0, 63 dollars, 63, 63 doll... \n", + "0 [72, 72, 72, 72, 72, 72, 72, 72, 72, 72] \n", + "1 [$10, $10, $10, $10, $10, $10, $10, $10, $10, ... \n", + "2 [$20, $20, $20, $20, $20, $20, $20, $20, $20, ... \n", + "3 [48, 48, 48, 48, 48, 48, 48, 48, 48, 48] \n", + "4 [624, 624, 624, 624, 624, 624, 624, 624, 624, ... \n", + "\n", + " prompt tokenprob_entropy_value \\\n", + "0 When you solve this math problem only return t... 0.0 \n", + "1 When you solve this math problem only return t... 0.0 \n", + "2 When you solve this math problem only return t... 0.0 \n", + "3 When you solve this math problem only return t... 0.0 \n", + "4 When you solve this math problem only return t... 0.0 \n", "\n", - " prompt answer response_correct \n", - "0 When you solve this math problem only return t... 145 True \n", - "1 When you solve this math problem only return t... 19 True \n", - "2 When you solve this math problem only return t... 3 True \n", - "3 When you solve this math problem only return t... 198 True \n", - "4 When you solve this math problem only return t... 63 True " + " tokenprob_confidence_score answer response_correct \n", + "0 1.0 72 True \n", + "1 1.0 10 True \n", + "2 1.0 5 False \n", + "3 1.0 42 False \n", + "4 1.0 624 True " ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -716,7 +901,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "tags": [] }, @@ -725,7 +910,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Baseline LLM accuracy: 0.68\n" + "Baseline LLM accuracy: 0.53\n" ] } ], @@ -749,16 +934,50 @@ "We will plot the filtered accuracy across various confidence score thresholds to visualize the relationship between confidence and LLM accuracy. This analysis helps in understanding the trade-off between response coverage (measured by sample size below) and LLM accuracy, providing insights into the reliability of the LLM’s outputs. " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Discrete Semantic Entropy" + ] + }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_model_accuracies(scores=result_df.discrete_confidence_score, correct_indicators=result_df.response_correct)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Token-probability based Semantic Entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -768,7 +987,7 @@ } ], "source": [ - "plot_model_accuracies(scores=result_df.confidence_score, correct_indicators=result_df.response_correct)" + "plot_model_accuracies(scores=result_df.tokenprob_confidence_score, correct_indicators=result_df.response_correct)" ] }, { @@ -785,9 +1004,16 @@ "Lastly, we compute the optimal threshold for binarizing confidence scores, using F1-score as the objective. Using this threshold, we compute precision, recall, and F1-score for black box scorer predictions of whether responses are correct." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Results for Discrete Semantic Entrpoy" + ] + }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": { "tags": [] }, @@ -796,7 +1022,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Semantic entropy F1-optimal threshold: 0.54\n" + "Semantic entropy F1-optimal threshold: 0.5700000000000001\n" ] } ], @@ -805,7 +1031,7 @@ "t = Tuner()\n", "\n", "# Define score vector and corresponding correct indicators (i.e. ground truth)\n", - "y_scores = result_df[\"confidence_score\"] # confidence score\n", + "y_scores = result_df[\"discrete_confidence_score\"] # confidence score\n", "correct_indicators = (result_df.response_correct) * 1 # Whether responses is actually correct\n", "\n", "# Solve for threshold that maximizes F1-score\n", @@ -816,7 +1042,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": { "tags": [] }, @@ -825,9 +1051,65 @@ "name": "stdout", "output_type": "stream", "text": [ - "Semantic entropy precision: 0.7951807228915663\n", - "Semantic entropy recall: 0.9705882352941176\n", - "Semantic entropy f1-score: 0.8741721854304636\n" + "Semantic entropy precision: 0.7936507936507936\n", + "Semantic entropy recall: 0.9433962264150944\n", + "Semantic entropy f1-score: 0.8620689655172413\n" + ] + } + ], + "source": [ + "# evaluate precision, recall, and f1-score of semantic entropy predictions of correctness\n", + "print(f\"Semantic entropy precision: {precision_score(y_true=correct_indicators, y_pred=y_pred)}\")\n", + "print(f\"Semantic entropy recall: {recall_score(y_true=correct_indicators, y_pred=y_pred)}\")\n", + "print(f\"Semantic entropy f1-score: {f1_score(y_true=correct_indicators, y_pred=y_pred)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Results for Token-probability based Semantic Entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Semantic entropy F1-optimal threshold: 0.78\n" + ] + } + ], + "source": [ + "# instantiate UQLM tuner object for threshold selection\n", + "t = Tuner()\n", + "\n", + "# Define score vector and corresponding correct indicators (i.e. ground truth)\n", + "y_scores = result_df[\"tokenprob_confidence_score\"] # confidence score\n", + "correct_indicators = (result_df.response_correct) * 1 # Whether responses is actually correct\n", + "\n", + "# Solve for threshold that maximizes F1-score\n", + "best_threshold = t.tune_threshold(y_scores=y_scores, correct_indicators=correct_indicators, thresh_objective=\"fbeta_score\")\n", + "y_pred = [(s > best_threshold) * 1 for s in y_scores] # predicts whether response is correct based on confidence score\n", + "print(f\"Semantic entropy F1-optimal threshold: {best_threshold}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Semantic entropy precision: 0.8064516129032258\n", + "Semantic entropy recall: 0.9433962264150944\n", + "Semantic entropy f1-score: 0.8695652173913043\n" ] } ], @@ -854,9 +1136,9 @@ "uri": "us-docker.pkg.dev/deeplearning-platform-release/gcr.io/workbench-notebooks:m125" }, "kernelspec": { - "display_name": "uqlm", + "display_name": "uqlm-m1pshusV-py3.9", "language": "python", - "name": "uqlm" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -868,7 +1150,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.21" + "version": "3.9.22" } }, "nbformat": 4, diff --git a/tests/test_nli.py b/tests/test_nli.py index e2f78958..3accc443 100644 --- a/tests/test_nli.py +++ b/tests/test_nli.py @@ -47,7 +47,8 @@ def test_nli(text1, text2, nli_model): def test_nli2(text1, nli_model_cpu): result = nli_model_cpu._observed_consistency_i(original=text1, candidates=[text1] * 5, use_best=False, compute_entropy=False) assert result["nli_score_i"] == 1 - assert result["semantic_negentropy"] is None + assert result["discrete_semantic_entropy"] is None + assert result["tokenprob_semantic_entropy"] is None def test_nli3(text1, text2, nli_model_cpu): @@ -59,10 +60,20 @@ def test_nli3(text1, text2, nli_model_cpu): gc.collect() -def test_nli4(text1, nli_model_cpu): - with pytest.raises(ValueError) as value_error: - nli_model_cpu._semantic_entropy_process(candidates=[text1] * 5, i=1, discrete=False) - assert "SemanticEntropy currently only supports discrete evaluations" == str(value_error.value) - +def test_nli4(nli_model_cpu): + text1 = "Capital of France is Paris" + text2 = " Paris is the capital of France" + text3 = "Rome is the capital of Italy" + logprobs_results = [ + [{"token": "Capital", "logprob": 0.6}, {"token": "of", "logprob": 0.5}, {"token": "France", "logprob": 0.3}, {"token": "is", "logprob": 0.3}, {"token": "Paris", "logprob": 0.3}], + [{"token": "Paris", "logprob": 0.75}, {"token": "is", "logprob": 0.8}, {"token": "the", "logprob": 0.9}, {"token": "capital", "logprob": 0.6}, {"token": "of", "logprob": 0.6}, {"token": "France", "logprob": 0.6}], + [{"token": "Rome", "logprob": 0.75}, {"token": "is", "logprob": 0.8}, {"token": "the", "logprob": 0.9}, {"token": "capital", "logprob": 0.6}, {"token": "of", "logprob": 0.6}, {"token": "Italy", "logprob": 0.6}], + ] + best_response, semantic_negentropy, nli_scores, tokenprob_semantic_entropy = nli_model_cpu._semantic_entropy_process(candidates=[text1, text2, text3], i=1, logprobs_results=logprobs_results) + + assert best_response == text2 + assert pytest.approx(semantic_negentropy, abs=1e-5) == 0.6365141682948128 + assert pytest.approx(list(nli_scores.values()), abs=1e-5) == [0.9997053, 0.9997053, 0.24012965, 0.24012965] + assert pytest.approx(tokenprob_semantic_entropy, abs=1e-5) == 0.6918935849478249 del nli_model_cpu gc.collect() diff --git a/tests/test_semanticentropy.py b/tests/test_semanticentropy.py index 79f6a715..4906eb57 100644 --- a/tests/test_semanticentropy.py +++ b/tests/test_semanticentropy.py @@ -48,10 +48,11 @@ async def mock_generate_candidate_responses(*args, **kwargs): monkeypatch.setattr(se_object, "generate_candidate_responses", mock_generate_candidate_responses) se_results = await se_object.generate_and_score(prompts=PROMPTS) + se_object.logprobs = None se_results = se_object.score(responses=MOCKED_RESPONSES, sampled_responses=MOCKED_SAMPLED_RESPONSES) assert se_results.data["responses"] == data["responses"] assert se_results.data["sampled_responses"] == data["sampled_responses"] assert se_results.data["prompts"] == data["prompts"] - assert all([abs(se_results.data["entropy_values"][i] - data["entropy_values"][i]) < 1e-5 for i in range(len(PROMPTS))]) - assert all([abs(se_results.data["confidence_scores"][i] - data["confidence_scores"][i]) < 1e-5 for i in range(len(PROMPTS))]) + assert all([abs(se_results.data["discrete_entropy_values"][i] - data["entropy_values"][i]) < 1e-5 for i in range(len(PROMPTS))]) + assert all([abs(se_results.data["discrete_confidence_scores"][i] - data["confidence_scores"][i]) < 1e-5 for i in range(len(PROMPTS))]) assert se_results.metadata == metadata diff --git a/uqlm/black_box/nli.py b/uqlm/black_box/nli.py index 8a31e39b..f1326b81 100644 --- a/uqlm/black_box/nli.py +++ b/uqlm/black_box/nli.py @@ -83,7 +83,7 @@ def predict(self, response1: str, response2: str) -> Any: probabilites = np.exp(np_logits) / np.exp(np_logits).sum(axis=-1, keepdims=True) return probabilites - def evaluate(self, responses: List[str], sampled_responses: List[List[str]], use_best: bool, compute_entropy: bool = False) -> Dict[str, Any]: + def evaluate(self, responses: List[str], sampled_responses: List[List[str]], responses_logprobs: List[List[Dict[str, Any]]] = None, sampled_responses_logprobs: List[List[List[Dict[str, Any]]]] = None, use_best: bool = False, compute_entropy: bool = False, best_response_selection: str = "discrete") -> Dict[str, Any]: """ Evaluate confidence scores on LLM responses. @@ -95,6 +95,12 @@ def evaluate(self, responses: List[str], sampled_responses: List[List[str]], use sampled_responses : list of list of strings Sampled candidate responses to be compared to the original response + responses_logprobs : list of list of dicts, default=None + Log probabilities of the original response + + sampled_responses_logprobs : list of list of list of dicts, default=None + Log probabilities of the sampled responses + use_best : bool Specifies whether to swap the original response for the uncertainty-minimized response based on semantic entropy clusters. @@ -102,6 +108,9 @@ def evaluate(self, responses: List[str], sampled_responses: List[List[str]], use compute_entropy : bool, default=False Specifies whether to include semantic entropy in returned result + best_response_selection : str, default="discrete" + Specifies the type of entropy confidence score to compute best response. Must be one of "discrete" or "token-based". + Returns ------- Dict @@ -109,11 +118,13 @@ def evaluate(self, responses: List[str], sampled_responses: List[List[str]], use The dictionary will also contain original and multiple responses, updated if `use_best` is True """ self.num_responses = len(sampled_responses[0]) - observed_consistency_data = {"noncontradiction": [], "semantic_negentropy": [], "responses": responses, "sampled_responses": sampled_responses} + self.logprobs, self.multiple_logprobs = responses_logprobs, sampled_responses_logprobs + observed_consistency_data = {"noncontradiction": [], "discrete_semantic_entropy": [], "tokenprob_semantic_entropy": [], "responses": responses, "sampled_responses": sampled_responses} for i, response in enumerate(responses): - oc_result_i = self._observed_consistency_i(original=response, candidates=sampled_responses[i], use_best=use_best, compute_entropy=compute_entropy) + oc_result_i = self._observed_consistency_i(original=response, candidates=sampled_responses[i], i=i, use_best=use_best, compute_entropy=compute_entropy) observed_consistency_data["noncontradiction"].append(oc_result_i["nli_score_i"]) - observed_consistency_data["semantic_negentropy"].append(oc_result_i["semantic_negentropy"]) + observed_consistency_data["discrete_semantic_entropy"].append(oc_result_i["discrete_semantic_entropy"]) + observed_consistency_data["tokenprob_semantic_entropy"].append(oc_result_i["tokenprob_semantic_entropy"]) responses[i] = oc_result_i["response"] # Replace with optimized response if use_best sampled_responses[i] = oc_result_i["candidates"] # Replace with updated candidates if use_best @@ -122,18 +133,19 @@ def evaluate(self, responses: List[str], sampled_responses: List[List[str]], use observed_consistency_data["sampled_responses"] = sampled_responses return observed_consistency_data - def _observed_consistency_i(self, original: str, candidates: List[str], use_best: bool = False, compute_entropy: bool = False) -> Dict[str, Any]: + def _observed_consistency_i(self, original: str, candidates: List[str], i: int = None, use_best: bool = False, compute_entropy: bool = False) -> Dict[str, Any]: """ Compute observed consistency score on the provided original response and multiple candidates. """ scores = {} nli_scores = [] best_response = original - semantic_negentropy = None + discrete_semantic_entropy, tokenprob_semantic_entropy = None, None if compute_entropy or use_best: all_responses = [original] + candidates - tmp = self._semantic_entropy_process(candidates=all_responses) - best_response, semantic_negentropy, scores = tmp + all_logprobs = [self.logprobs[i]] + self.multiple_logprobs[i] if (self.logprobs and self.multiple_logprobs) else None + tmp = self._semantic_entropy_process(candidates=all_responses, i=i, logprobs_results=all_logprobs) + best_response, discrete_semantic_entropy, scores, tokenprob_semantic_entropy = tmp if use_best: all_responses.remove(best_response) candidates = all_responses @@ -145,25 +157,48 @@ def _observed_consistency_i(self, original: str, candidates: List[str], use_best nli_score = self._get_nli_results(response1=best_response, response2=candidate)["score"] nli_scores.append(nli_score) - return {"nli_score_i": np.mean(nli_scores), "candidates": candidates, "response": best_response, "semantic_negentropy": semantic_negentropy} + return {"nli_score_i": np.mean(nli_scores), "candidates": candidates, "response": best_response, "discrete_semantic_entropy": discrete_semantic_entropy, "tokenprob_semantic_entropy": tokenprob_semantic_entropy} - def _semantic_entropy_process(self, candidates: List[str], i: int = None, discrete=True) -> Any: + def _semantic_entropy_process(self, candidates: List[str], i: int = None, logprobs_results: List[List[Dict[str, Any]]] = None, best_response_selection: str = "discrete") -> Any: """ Executes complete process for semantic entropy and returns best response, SE score, and dictionary of NLI scores for response pairs """ - if self.verbose: + if self.verbose and i is not None: print("Question No. - ", i + 1) - clustered_responses, nli_scores = self._cluster_responses(responses=candidates) - if discrete: - response_probabilities = [[1] * len(cluster_i) for cluster_i in clustered_responses] - cluster_probabilities = self._compute_cluster_probability(response_probabilities=response_probabilities) - best_response = clustered_responses[cluster_probabilities.index(max(cluster_probabilities))][0] - semantic_negentropy = self._compute_semantic_entropy(cluster_probabilities=cluster_probabilities) - else: - # TODO: enable continuous semantic entropy - raise ValueError("SemanticEntropy currently only supports discrete evaluations") - return (best_response, semantic_negentropy, nli_scores) + tokenprob_response_probabilities, response_probabilities = self._compute_response_probabilities(logprobs_results=logprobs_results, num_responses=len(candidates)) + clustered_responses, cluster_indices, nli_scores = self._cluster_responses(responses=candidates) + # Compute discrete semantic entropy + cluster_probabilities = self._compute_cluster_probabilities(response_probabilities=response_probabilities, cluster_indices=cluster_indices) + best_response = self._default_best_response_selection(clustered_responses=clustered_responses, cluster_probabilities=cluster_probabilities) + discrete_semantic_entropy = self._compute_semantic_entropy(cluster_probabilities=cluster_probabilities) + + # Compute token-level semantic entropy + tokenprob_semantic_entropy = None + if tokenprob_response_probabilities: + tokenprob_cluster_probabilities = self._compute_cluster_probabilities(response_probabilities=tokenprob_response_probabilities, cluster_indices=cluster_indices) + tokenprob_semantic_entropy = self._compute_semantic_entropy(cluster_probabilities=tokenprob_cluster_probabilities) + if best_response_selection == "token-based": + best_response = self._default_best_response_selection(clustered_responses=clustered_responses, cluster_probabilities=tokenprob_cluster_probabilities) + + return (best_response, discrete_semantic_entropy, nli_scores, tokenprob_semantic_entropy) + + def _default_best_response_selection(self, clustered_responses: List[List[str]], cluster_probabilities: List[float]) -> str: + """Select the best response from the clustered responses based on the cluster probabilities""" + return clustered_responses[cluster_probabilities.index(max(cluster_probabilities))][0] + + def _compute_cluster_probabilities(self, response_probabilities: List[float], cluster_indices: List[List[int]]) -> List[float]: + """Compute cluster probabilities""" + cluster_probabilities = [0] * len(cluster_indices) + for i, cluster_index in enumerate(cluster_indices): + cluster_probabilities[i] = sum([response_probabilities[j] for j in cluster_index]) + return self._normalize_cluster_probabilities(cluster_probabilities=cluster_probabilities) + + def _compute_response_probabilities(self, logprobs_results: List[List[Dict[str, Any]]], num_responses: int = None) -> List[float]: + """Compute response probabilities""" + uniform_response_probabilities = [1 / num_responses] * num_responses + tokenprob_response_probabilities = [self.avg_logprob(logprobs_i) if logprobs_i else np.nan for logprobs_i in logprobs_results] if logprobs_results else None + return tokenprob_response_probabilities, uniform_response_probabilities def _get_nli_results(self, response1: str, response2: str) -> Dict[str, Any]: """This method computes mean NLI score and determines whether entailment exists.""" @@ -194,12 +229,12 @@ def _cluster_responses(self, responses: List[str]) -> Any: ---------- A list of lists, where each list represents a cluster. """ - clusters = [deque([responses[0]])] + clusters, cluster_indices = [deque([responses[0]])], [deque([0])] nli_scores = {} entailments = {} for i in range(1, len(responses)): new_cluster_indicator = True - for cluster in clusters: + for j, cluster in enumerate(clusters): key, rev_key = (cluster[0], responses[i]), (responses[i], cluster[0]) if key in nli_scores: # Do not recompute if pair already assessed @@ -213,29 +248,39 @@ def _cluster_responses(self, responses: List[str]) -> Any: if entailment: new_cluster_indicator = False cluster.append(responses[i]) + cluster_indices[j].append(i) if new_cluster_indicator: clusters.append(deque([responses[i]])) + cluster_indices.append(deque([i])) # Arrange cluster so that first element is mode (if exists) else longest clusters = [self._sort_responses(list(cluster)) for cluster in clusters] - return clusters, nli_scores - def _compute_semantic_entropy(self, cluster_probabilities: List[float]) -> float: + # Normalize cluster probabilities + # cluster_probabilities = self._normalize_cluster_probabilities(cluster_probabilities=cluster_probabilities) + return clusters, cluster_indices, nli_scores + + def _normalize_entropy(self, entropy_values): + return [e / math.log(self.num_responses + 1) for e in entropy_values] + + @staticmethod + def _compute_semantic_entropy(cluster_probabilities: List[float]) -> float: """ Helper function to compute semantic entropy score from cluster probabilities """ - return abs(sum([p * math.log(p) for p in cluster_probabilities])) + return abs(sum([p * math.log(p) if p > 0.0 else 0 for p in cluster_probabilities])) - def _normalize_entropy(self, entropy_values): - return [e / math.log(self.num_responses + 1) for e in entropy_values] + @staticmethod + def avg_logprob(logprobs: List[Dict[str, Any]]) -> float: + "Compute average logprob" + return np.prod([np.exp(d["logprob"]) for d in logprobs]) @staticmethod - def _compute_cluster_probability(response_probabilities: List[float]) -> float: - """Computes cluster probabilities from response probabilities""" - total_probability = sum(map(sum, response_probabilities)) - cluster_probabilities = [sum(rp_i) / total_probability for rp_i in response_probabilities] - return cluster_probabilities + def _normalize_cluster_probabilities(cluster_probabilities: List[float]) -> float: + """Normalize cluster probabilities""" + total_probability = sum(cluster_probabilities) + return [cp_i / total_probability for cp_i in cluster_probabilities] @staticmethod def _sort_responses(responses: List[str]) -> List[str]: diff --git a/uqlm/scorers/black_box.py b/uqlm/scorers/black_box.py index 9f1b090a..8d42ba4c 100644 --- a/uqlm/scorers/black_box.py +++ b/uqlm/scorers/black_box.py @@ -161,7 +161,7 @@ def score(self, responses: List[str], sampled_responses: List[List[str]]) -> UQR for key in ["semantic_negentropy", "noncontradiction"]: if key in self.scorers: if key == "semantic_negentropy": - nli_scores[key] = [1 - s for s in self.nli_scorer._normalize_entropy(nli_scores[key])] # Convert to confidence score + nli_scores[key] = [1 - s for s in self.nli_scorer._normalize_entropy(nli_scores["discrete_semantic_entropy"])] # Convert to confidence score self.scores_dict[key] = nli_scores[key] # similarity scorers that follow the same pattern diff --git a/uqlm/scorers/entropy.py b/uqlm/scorers/entropy.py index 482392a8..2a9cb09b 100644 --- a/uqlm/scorers/entropy.py +++ b/uqlm/scorers/entropy.py @@ -14,15 +14,17 @@ from typing import Any, List, Optional +import warnings from uqlm.scorers.baseclass.uncertainty import UncertaintyQuantifier, UQResult class SemanticEntropy(UncertaintyQuantifier): - def __init__(self, llm=None, postprocessor: Any = None, device: Any = None, use_best: bool = True, system_prompt: str = "You are a helpful assistant.", max_calls_per_min: Optional[int] = None, use_n_param: bool = False, sampling_temperature: float = 1.0, verbose: bool = False, nli_model_name: str = "microsoft/deberta-large-mnli", max_length: int = 2000, discrete: bool = True) -> None: + def __init__( + self, llm=None, postprocessor: Any = None, device: Any = None, use_best: bool = True, best_response_selection: str = "discrete", system_prompt: str = "You are a helpful assistant.", max_calls_per_min: Optional[int] = None, use_n_param: bool = False, sampling_temperature: float = 1.0, verbose: bool = False, nli_model_name: str = "microsoft/deberta-large-mnli", max_length: int = 2000 + ) -> None: """ - Class for computing Discrete Semantic Entropy-based confidence scores. For more on semantic entropy, - refer to Farquhar et al.(2024) :footcite:`farquhar2024detectinghallucinations`. + Class for computing discrete and token-probability-based semantic entropy and associated confidence scores. For more on semantic entropy, refer to Farquhar et al.(2024) :footcite:`farquhar2024detectinghallucinations`. Parameters ---------- @@ -42,6 +44,9 @@ def __init__(self, llm=None, postprocessor: Any = None, device: Any = None, use_ Specifies whether to swap the original response for the uncertainty-minimized response based on semantic entropy clusters. + best_response_selection : str, default="discrete" + Specifies the type of entropy confidence score to compute best response. Must be one of "discrete" or "token-based". + system_prompt : str or None, default="You are a helpful assistant." Optional argument for user to provide custom system prompt @@ -75,7 +80,7 @@ def __init__(self, llm=None, postprocessor: Any = None, device: Any = None, use_ self.sampling_temperature = sampling_temperature self.prompts = None self._setup_nli(nli_model_name) - self.nli_scorer.discrete = discrete + self.best_response_selection = best_response_selection async def generate_and_score(self, prompts: List[str], num_responses: int = 5) -> UQResult: """ @@ -98,6 +103,11 @@ async def generate_and_score(self, prompts: List[str], num_responses: int = 5) - self.num_responses = num_responses self.nli_scorer.num_responses = num_responses + if hasattr(self.llm, "logprobs"): + self.llm.logprobs = True + else: + warnings.warn("The provided LLM does not support logprobs access. Only discrete semantic entropy will be computed.") + responses = await self.generate_original_responses(prompts) sampled_responses = await self.generate_candidate_responses(prompts) return self.score(responses=responses, sampled_responses=sampled_responses) @@ -126,21 +136,28 @@ def score(self, responses: List[str] = None, sampled_responses: List[List[str]] self.nli_scorer.num_responses = self.num_responses n_prompts = len(self.responses) - semantic_entropy = [None] * n_prompts + discrete_semantic_entropy = [None] * n_prompts best_responses = [None] * n_prompts + tokenprob_semantic_entropy = [None] * n_prompts print("Computing confidence scores...") for i in range(n_prompts): candidates = [self.responses[i]] + self.sampled_responses[i] - tmp = self.nli_scorer._semantic_entropy_process(candidates=candidates, i=i) - best_responses[i], semantic_entropy[i], scores = tmp - confidence_scores = [1 - ne for ne in self.nli_scorer._normalize_entropy(semantic_entropy)] + candidate_logprobs = [self.logprobs[i]] + self.multiple_logprobs[i] if (self.logprobs and self.multiple_logprobs) else None + tmp = self.nli_scorer._semantic_entropy_process(candidates=candidates, i=i, logprobs_results=candidate_logprobs, best_response_selection=self.best_response_selection) + best_responses[i], discrete_semantic_entropy[i], _, tokenprob_semantic_entropy[i] = tmp + + confidence_scores = [1 - ne for ne in self.nli_scorer._normalize_entropy(discrete_semantic_entropy)] result = { - "data": {"responses": best_responses if self.use_best else self.responses, "entropy_values": semantic_entropy, "confidence_scores": confidence_scores, "sampled_responses": self.sampled_responses}, + "data": {"responses": best_responses if self.use_best else self.responses, "discrete_entropy_values": discrete_semantic_entropy, "discrete_confidence_scores": confidence_scores, "sampled_responses": self.sampled_responses}, "metadata": {"parameters": {"temperature": None if not self.llm else self.llm.temperature, "sampling_temperature": None if not self.sampling_temperature else self.sampling_temperature, "num_responses": self.num_responses}}, } if self.prompts: result["data"]["prompts"] = self.prompts + if tokenprob_semantic_entropy[0] is not None: + result["data"]["tokenprob_entropy_values"] = tokenprob_semantic_entropy + result["data"]["tokenprob_confidence_scores"] = [1 - ne for ne in self.nli_scorer._normalize_entropy(tokenprob_semantic_entropy)] + return UQResult(result)