lab_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "21b38396-4691-413b-9856-edd71a08c288",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Lab1 Intro\n",
    "In the retail industry, understanding the Voice of the Customer (VOC) is crucial for gaining insights into customer preferences and pain points. By analyzing and categorizing customer feedback, retailers can improve their products, services, and overall customer experience.\n",
    "\n",
    "This hands-on workshop guides participants through the process of classifying Voice of Customer (VOC) data using Amazon Foundation Model on Amazon Bedrock.\n",
    "You will be provided with sample data and will be tasked with classifying customer feedback into categories and generating a summary analysis report.\n",
    "\n",
    "- First, you will learn how to use Prompt Engineering to classify customer feedback.\n",
    "- Then, you will explore the concept of embedding techniques and use them to classify customer feedback by semantic comparison.\n",
    "- After that, you will be provided with additional example data. You will explore the concept of retrieval augmented generation (RAG) and use it to enhance the classification process by dynamically retrieving relevant few-shot examples.\n",
    "- At the end of the workshop, you will be able to generate a comprehensive analysis report that provides insights into the VOC data and helps retailers improve their products and services.\n",
    "\n",
    "### A task of developing a VoC Classifier has been assigned to you:\n",
    "You will be provided with a sample dataset in \"data/comments.csv\", each record represents a customer comment and its corresponding groundtruth category. You need to write prompt to perform the classification task using the Amazon Foundation Model, and then compare the prediction result with the groundtruth and calculate the accuracy.\n",
    "\n",
    "### Your objectives are:\n",
    "\n",
    "- Classify each customer feedback comment into 35+ categories\n",
    "- Provide the reasoning behind each classification\n",
    "- Summarize each customer comment in a brief description\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1885f205-3b90-4d03-8c9d-0e763047c192",
   "metadata": {},
   "source": [
    "## 1. Install dependencies\n",
    "- If you experince \"ERROR: pip's dependency resolver does not currently...\", please just ignore it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0f625de-1ca3-4167-a158-2628994ff090",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install --upgrade pip\n",
    "!pip install -q langchain==0.2.16 langchain_aws==0.1.17 pandas==2.2.2 openpyxl==3.1.5 termcolor==2.4.0 python-dotenv==1.0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b9a39f8-d017-4bd3-b289-dab163db7da2",
   "metadata": {},
   "source": [
    "## 2. Initialize Bedrock model using LangChain\n",
    "- First let's see what Amazon Foundation LLMs (Large Language Models) we have in Amazon Bedrock "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8723c73-8147-42ed-a5a0-bdb0851db0f7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import boto3\n",
    "import json\n",
    "import copy\n",
    "import pandas as pd\n",
    "from termcolor import colored\n",
    "# create clients of bedrock\n",
    "bedrock = boto3.client(service_name='bedrock')\n",
    "bedrock_runtime = boto3.client(service_name='bedrock-runtime') \n",
    "pd.set_option('display.max_rows', None)\n",
    "results = []\n",
    "\n",
    "available_models = bedrock.list_foundation_models()\n",
    "for model in available_models['modelSummaries']:\n",
    "    if 'Amazon' in model['providerName'] and 'TEXT' in model['outputModalities']: \n",
    "        results.append({\n",
    "            'Model Name': model['modelName'],\n",
    "            'Model ID': model['modelId'],  # Add Model ID column\n",
    "            'Provider': model['providerName'],\n",
    "            'Input Modalities': ', '.join(model['inputModalities']),\n",
    "            'Output Modalities': ', '.join(model['outputModalities']),\n",
    "            'Streaming': model.get('responseStreamingSupported', 'N/A'),\n",
    "            'Status': model['modelLifecycle']['status']\n",
    "        })\n",
    "\n",
    "df = pd.DataFrame(results)\n",
    "display(df)\n",
    "\n",
    "pd.reset_option('display.max_rows')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a80647c-214f-4b5b-bea1-5676af790fc3",
   "metadata": {},
   "source": [
    "We employ the Langchain SDK to configure and initiate a test interaction with the Amazon Foundation Model.\n",
    "- Import [Langchain](https://www.langchain.com/) SDK to build the application\n",
    "- Initialize a ChatBedrock object with Amzon Foundation model, the model id is <span style=\"color: blue;\">\"amazon.nova-pro-v1:0\"</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a1bd09a-381a-4a32-bc8c-e6f05137419d",
   "metadata": {},
   "source": [
    "#### Customzie a LangChain ChatModel Class\n",
    "- As the time of this event, LangChain has not supported the latest Amazon Foundation Model yet, we will customize a LangChain Chat Model Class, so that the latest model can be integrated with the chain prompting in LangChain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6e386d1-2ac3-4b34-b678-b8a0b2d08868",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import boto3\n",
    "import json\n",
    "from botocore.exceptions import ClientError\n",
    "import dotenv\n",
    "import os\n",
    "dotenv.load_dotenv()\n",
    "\n",
    "from typing import Any, AsyncIterator, Dict, Iterator, List, Optional\n",
    "\n",
    "from langchain_core.callbacks import (\n",
    "    AsyncCallbackManagerForLLMRun,\n",
    "    CallbackManagerForLLMRun,\n",
    ")\n",
    "from langchain_core.language_models import BaseChatModel, SimpleChatModel\n",
    "from langchain_core.messages import AIMessageChunk, BaseMessage, HumanMessage,AIMessage,SystemMessage\n",
    "from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult\n",
    "from langchain_core.runnables import run_in_executor\n",
    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
    "from langchain_core.output_parsers import StrOutputParser,XMLOutputParser\n",
    "from langchain_core.prompts import ChatPromptTemplate,MessagesPlaceholder,HumanMessagePromptTemplate\n",
    "\n",
    "\n",
    "class ChatModelNova(BaseChatModel):\n",
    "\n",
    "    model_name: str\n",
    "    br_runtime : Any = None\n",
    "    ak: str = None\n",
    "    sk: str = None\n",
    "    region:str = None\n",
    "\n",
    "    def _generate(\n",
    "        self,\n",
    "        messages: List[BaseMessage],\n",
    "        stop: Optional[List[str]] = None,\n",
    "        run_manager: Optional[CallbackManagerForLLMRun] = None,\n",
    "        **kwargs: Any,\n",
    "    ) -> ChatResult:\n",
    "\n",
    "        if not self.br_runtime:\n",
    "            if self.ak and self.sk:\n",
    "                self.br_runtime = boto3.client(service_name = 'bedrock-runtime',\n",
    "                                               region_name = self.region,\n",
    "                                              aws_access_key_id = self.ak,\n",
    "                                               aws_secret_access_key = self.sk\n",
    "                                              )\n",
    "            else:\n",
    "                self.br_runtime = boto3.client(service_name = 'bedrock-runtime')\n",
    "            \n",
    "        \n",
    "        new_messages = []\n",
    "        system_message = ''\n",
    "        for msg in messages:\n",
    "            if isinstance(msg,SystemMessage):\n",
    "                system_message = msg.content\n",
    "            elif isinstance(msg,HumanMessage):\n",
    "                new_messages.append({\n",
    "                        \"role\": \"user\",\n",
    "                        \"content\": [ {\"text\": msg.content}]\n",
    "                    })\n",
    "            elif isinstance(msg,AIMessage):\n",
    "                new_messages.append({\n",
    "                        \"role\": \"assistant\",\n",
    "                        \"content\": [ {\"text\": msg.content}]\n",
    "                    })\n",
    "\n",
    "        \n",
    "        temperature = kwargs.get('temperature',0.1)\n",
    "        maxTokens = kwargs.get('max_tokens',3000)\n",
    "\n",
    "        #Base inference parameters to use.\n",
    "        inference_config = {\"temperature\": temperature,\"maxTokens\":maxTokens}\n",
    "\n",
    "\n",
    "        # Send the message.\n",
    "        response = self.br_runtime.converse(\n",
    "            modelId=self.model_name,\n",
    "            messages=new_messages,\n",
    "            system=[{\"text\" : system_message}] if system_message else [],\n",
    "            inferenceConfig=inference_config\n",
    "        )\n",
    "        output_message = response['output']['message']\n",
    "\n",
    "        message = AIMessage(\n",
    "            content=output_message['content'][0]['text'],\n",
    "            additional_kwargs={},  # Used to add additional payload (e.g., function calling request)\n",
    "            response_metadata={  # Use for response metadata\n",
    "                **response['usage']\n",
    "            },\n",
    "        )\n",
    "        generation = ChatGeneration(message=message)\n",
    "        return ChatResult(generations=[generation])\n",
    "\n",
    "\n",
    "    def _stream(\n",
    "        self,\n",
    "        messages: List[BaseMessage],\n",
    "        stop: Optional[List[str]] = None,\n",
    "        run_manager: Optional[CallbackManagerForLLMRun] = None,\n",
    "        **kwargs: Any,\n",
    "    ) -> Iterator[ChatGenerationChunk]:\n",
    "        if not self.br_runtime:\n",
    "            if self.ak and self.sk:\n",
    "                self.br_runtime = boto3.client(service_name = 'bedrock-runtime',\n",
    "                                               region_name = self.region,\n",
    "                                              aws_access_key_id = self.ak,\n",
    "                                               aws_secret_access_key = self.sk\n",
    "                                              )\n",
    "\n",
    "            else:\n",
    "                self.br_runtime = boto3.client(service_name = 'bedrock-runtime')\n",
    "            \n",
    "        \n",
    "        new_messages = []\n",
    "        system_message = ''\n",
    "        for msg in messages:\n",
    "            if isinstance(msg,SystemMessage):\n",
    "                system_message = msg.content\n",
    "            elif isinstance(msg,HumanMessage):\n",
    "                new_messages.append({\n",
    "                        \"role\": \"user\",\n",
    "                        \"content\": [ {\"text\": msg.content}]\n",
    "                    })\n",
    "            elif isinstance(msg,AIMessage):\n",
    "                new_messages.append({\n",
    "                        \"role\": \"assistant\",\n",
    "                        \"content\": [ {\"text\": msg.content}]\n",
    "                    })\n",
    "\n",
    "        \n",
    "        temperature = kwargs.get('temperature',0.1)\n",
    "        maxTokens = kwargs.get('max_tokens',3000)\n",
    "\n",
    "        #Base inference parameters to use.\n",
    "        inference_config = {\"temperature\": temperature,\"maxTokens\":maxTokens}\n",
    "\n",
    "        # Send the message.\n",
    "        streaming_response = self.br_runtime.converse_stream(\n",
    "            modelId=self.model_name,\n",
    "            messages=new_messages,\n",
    "            system=[{\"text\" : system_message}] if system_message else [],\n",
    "            inferenceConfig=inference_config\n",
    "        )\n",
    "        # Extract and print the streamed response text in real-time.\n",
    "        for event in streaming_response[\"stream\"]:\n",
    "            if \"contentBlockDelta\" in event:\n",
    "                text = event[\"contentBlockDelta\"][\"delta\"][\"text\"]\n",
    "                # print(text, end=\"\")\n",
    "                chunk = ChatGenerationChunk(message=AIMessageChunk(content=[{\"type\":\"text\",\"text\":text}]))\n",
    "\n",
    "                if run_manager:\n",
    "                    # This is optional in newer versions of LangChain\n",
    "                    # The on_llm_new_token will be called automatically\n",
    "                    run_manager.on_llm_new_token(text, chunk=chunk)\n",
    "\n",
    "                yield chunk\n",
    "            if 'metadata' in event:\n",
    "                metadata = event['metadata']\n",
    "                # Let's add some other information (e.g., response metadata)\n",
    "                chunk = ChatGenerationChunk(\n",
    "                    message=AIMessageChunk(content=\"\", response_metadata={**metadata})\n",
    "                )\n",
    "                if run_manager:\n",
    "\n",
    "                    run_manager.on_llm_new_token('', chunk=chunk)\n",
    "                yield chunk\n",
    "\n",
    "    @property\n",
    "    def _llm_type(self) -> str:\n",
    "        \"\"\"Get the type of language model used by this chat model.\"\"\"\n",
    "        return \"echoing-chat-model-advanced\"\n",
    "\n",
    "    @property\n",
    "    def _identifying_params(self) -> Dict[str, Any]:\n",
    "        \"\"\"Return a dictionary of identifying parameters.\n",
    "\n",
    "        This information is used by the LangChain callback system, which\n",
    "        is used for tracing purposes make it possible to monitor LLMs.\n",
    "        \"\"\"\n",
    "        return {\n",
    "            \"model_name\": self.model_name,\n",
    "        }\n",
    "\n",
    "llm = ChatModelNova(model_name=\"amazon.nova-pro-v1:0\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03f18fa1-aa33-4585-956f-697225850adc",
   "metadata": {},
   "source": [
    "Now, we'll conduct a test run with the Amazon Foundation Model, tasking it to perform a language translation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7e72624-2669-441e-92b4-ade4d14229a2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "messages = [\n",
    "    (\n",
    "        \"system\",\n",
    "        \"You are a helpful assistant that translates English to French. Translate the user sentence.\",\n",
    "    ),\n",
    "    (\"human\", \"I love programming.\"),\n",
    "]\n",
    "llm.invoke(messages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2de2c96-c8ec-486a-ac7d-07e792132184",
   "metadata": {},
   "source": [
    "## 3. Preparing the Dataset to be classified. \n",
    "In this section, we will examine the provided Voice of Customers dataset, explore its contents, and identify all the groundtruth categories it includes.\n",
    "- The data (Voice of Customers) is subject to experiment usage only"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10536914-c87c-4677-b181-7751aec0cb60",
   "metadata": {},
   "source": [
    "### Load the customer review data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ce8465-7a4e-4bbf-8f0f-bb685b1cc7dd",
   "metadata": {},
   "source": [
    "- Load the examples data\n",
    "\n",
    "\n",
    "From the displayed dataset, we can observe that it consists of two columns: 'comment' and 'groundtruth'. The 'comment' column contains collected customer feedback, while the 'groundtruth' column specifies the categories to which each comment belongs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "991a2482-4559-4375-a542-dc109432cdb5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "comments_filepath = \"data/comments.csv\"\n",
    "comments = pd.read_csv(comments_filepath)\n",
    "display(comments)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e15bc7c0-158c-4d32-87e4-8482c46d8a30",
   "metadata": {},
   "source": [
    "- List categories values\n",
    "\n",
    "The printed output displays all the categories contained within this dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd36568b-b6b5-4637-b5d7-9b5ec6e96eef",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "category_definition = \"data/categories.csv\"\n",
    "categories = pd.read_csv(category_definition)\n",
    "display(categories['mappings'].values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59144bb2-f7e8-4bce-898b-b45db936f5f5",
   "metadata": {},
   "source": [
    "## 4. Define system prompt and user prompt template\n",
    "\n",
    "Below, we have outlined templates for both the system prompt and the user prompt. We will use it to guide the Amazon Foundataion model to perform the classification tasks.\n",
    "\n",
    "Examing the template, there are a few elements that make this prompt efffective for guiding the model in classifying customer feedback accurately. For both prompt, they clearly defines the role of the model as a professional customer feedback analyst and includes detailed, step-by-step instructions on how the classification should be conducted, the format of the output, the tone to be maintained, and specific guidance on handling ambiguous cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b545c922-9f9a-4b6e-8186-a8aa49ffeec7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "system = \"\"\"You are a professional  customer feedback analyst. Your daily task is to categorize user feedback.\n",
    "You will be given an input in the form of a JSON array. Each object in the array contains a comment ID and a 'c' field representing the user's comment content.\n",
    "Your role is to analyze these comments and categorize them appropriately.\n",
    "Please note:\n",
    "1. Only output valid XML format data.\n",
    "2. Do not include any explanations or additional text outside the XML structure.\n",
    "3. Ensure your categorization is accurate and consistent.\n",
    "4. If you encounter any ambiguous cases, use your best judgment based on the context provided.\n",
    "5. Maintain a professional and neutral tone in your categorizations.\n",
    "\"\"\"\n",
    "\n",
    "user = \"\"\"\n",
    "Please categorize user comments according to the following category tags library:\n",
    "<categories>\n",
    "{tags}\n",
    "</categories>\n",
    "\n",
    "Please follow these instructions for categorization:\n",
    "<instruction>\n",
    "1. Categorize each comment using the tags above. If no tags apply, output \"Others\".\n",
    "2. Summarize the comment content in no more than 50 words. Replace any double quotation marks with single quotation marks.\n",
    "</instruction>\n",
    "\n",
    "Below are the customer comments records to be categorized. The input is an array, where each element has an 'id' field representing the complaint ID and a 'c' field summarizing the complaint content.\n",
    "<comments>\n",
    "{input}\n",
    "</comments>\n",
    "\n",
    "For each record, summarize the comment, categorize according to the category explainations, and return the  ID, summary , reasons for tag matches, and category.\n",
    "\n",
    "Output format example:\n",
    "<output>\n",
    "  <item>\n",
    "    <id>xxx</id>\n",
    "    <summary>xxx</summary>\n",
    "    <reason>xxx</reason>\n",
    "    <category>xxx</category>\n",
    "  </item>\n",
    "</output>\n",
    "\n",
    "Skip the preamble and output only valid XML format data. Remember:\n",
    "- Avoid double quotation marks within quotation marks. Use single quotation marks instead.\n",
    "- Replace any double quotation marks in the content with single quotation marks.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f8c2fce-f45e-4037-bb65-fe971b6bf7ad",
   "metadata": {},
   "source": [
    "## 5. Define LangChain prompting chain"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dd087dc-4da6-4418-8109-9c395abec3d3",
   "metadata": {},
   "source": [
    "- Create a langchain chat template\n",
    "  \n",
    "We use the prompt templated provided above to create a Langchain chat template, which will be used later for the chat model. The categories contained within the dataset are passed into the template as variables.\n",
    "Then, using the prompt and Amazon foundation model we defined earlier, we construct a Langchain prompting chain to carry out the classification task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53018dbe-a33e-4d98-936c-760f520b2631",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "prompt = ChatPromptTemplate([\n",
    "    ('system',system),\n",
    "    ('user',user),\n",
    "    ],\n",
    "    partial_variables={'tags':categories['mappings'].values}\n",
    ")\n",
    "chain = prompt | llm | XMLOutputParser()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14de4ac3-debe-4236-8bbc-aa0bd04078a0",
   "metadata": {},
   "source": [
    "- convert the comments to data array\n",
    "\n",
    "In this step, we will transform the 'comment' column of the dataset into a structured data array. Each element of this array will include both an index and the corresponding comment content. This formatted data will then be used as input for the Amazon foundation model to classify."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "517c73ad-e2b2-4f01-93eb-3b2b2e161b04",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sample_data = [str({\"id\":'s_'+str(i),\"comment\":x[0]}) for i,x in enumerate(comments.values)]\n",
    "print(\"\\n\".join(sample_data[:3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e65ca1fe-ef73-4a87-bc70-9e56ecb228f3",
   "metadata": {
    "tags": []
   },
   "source": [
    "### We will run classfication in batches (20 records per batch)\n",
    "* This cell will take around 2 mins to complete\n",
    "* <span style=\"color: red;\">Hint!</span> Due to the uncertainly of LLM generation, the JSON output might fail occasionally, if you happen to experience error such as `KeyError: 'output'`, please re-run the cell again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c97e32d6-abca-4d0b-b1bf-e61608e21ddf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "import math,json,time\n",
    "batch_size = 20\n",
    "batch = math.ceil(comments.shape[0]/batch_size)\n",
    "i = 0\n",
    "resps = []\n",
    "for i in range(batch):\n",
    "    print(colored(f\"****[{i}]*****\\n\",\"blue\"))\n",
    "    data = sample_data[i*batch_size:(i+1)*batch_size]\n",
    "    resp = chain.invoke(data)\n",
    "    print(colored(f\"****response*****\\n{resp}\",\"green\"))\n",
    "    for item in resp['output']:\n",
    "        row={}\n",
    "        for it in item['item']:\n",
    "            row[list(it.keys())[0]]=list(it.values())[0]\n",
    "        resps.append(row)\n",
    "    time.sleep(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ee470b-95d3-40f9-b762-790233434503",
   "metadata": {},
   "source": [
    "- covert the data array to pandas dataframe\n",
    "\n",
    "We transform the data array, which now contains the output generated by the LLM, into a dataframe for further analysis and review."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06c9cf8a-8969-4e82-a703-3308e98ee31e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "prediction_df = pd.DataFrame(resps).rename(columns={\"category\":\"predict_label\"}).drop_duplicates(['id']).reset_index(drop='index')\n",
    "# convert the label value to lowercase\n",
    "prediction_df['predict_label'] = prediction_df['predict_label'].apply(lambda x: x.strip().lower().replace(\"'\",\"\"))\n",
    "prediction_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16bb6d79-8b21-49c6-a9f2-a513883af75e",
   "metadata": {},
   "source": [
    "### Merge the prediction result to ground truth dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64419307-5830-4cd3-85b9-25ad539a89a1",
   "metadata": {},
   "source": [
    "- copy comments to ground_truth dataframe\n",
    "- merge the date prediction to the groudtruth data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee2674b8-5dfc-4c00-bafc-bd5f7d2f5e9f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ground_truth = comments.copy()\n",
    "# convert the label value to lowercase\n",
    "ground_truth['groundtruth'] = ground_truth['groundtruth'].apply(lambda x: x.strip().lower())\n",
    "merge_df=pd.concat([ground_truth,prediction_df],axis=1)\n",
    "merge_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b078fe59-5de8-482b-ad5b-8a8c42eec6a3",
   "metadata": {},
   "source": [
    "## 6.Calculate the accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4177fd7-0899-4b6b-8227-1a2e6364985d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def check_contains(row):\n",
    "    return row['groundtruth'] in row['predict_label']\n",
    "matches = merge_df.apply(check_contains, axis=1)\n",
    "count = matches.sum()\n",
    "print(colored(f\"accuracy: {count/len(merge_df)*100:.2f}%\",\"green\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa44656-6704-4de1-a789-7cf9643ebe14",
   "metadata": {},
   "source": [
    "### List all wrong classified records\n",
    "\n",
    "The accuracy of our classification task has been calculated. To gain a better understanding and improve our model's performance, we can further investigate the instances where the classification was incorrect. This can be done by executing the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18bb628f-febd-434e-8aca-63f093960c6c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def check_not_contains(row):\n",
    "    return row['groundtruth'] not in row['predict_label']\n",
    "merge_df[merge_df.apply(check_not_contains, axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fbb8b9b-c7af-40ee-beab-e8cf6d01e094",
   "metadata": {},
   "source": [
    "### Save the result "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdeca0a7-df9f-46aa-a0f5-109505e1166e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "merge_df.to_csv('result_lab_1.csv',index=False)"
   ]
  },
  {
   "attachments": {
    "037d599e-195c-4a30-b4ec-1ac3fff5a709.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "d8b03147-7c32-446b-8854-3b6d479b1630",
   "metadata": {},
   "source": [
    "# If you want to view the detail, please right click the \"result_lab_1.csv\" file, download to local disk\n",
    "![image.png](attachment:037d599e-195c-4a30-b4ec-1ac3fff5a709.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43448bd3-8a72-4c09-82d6-0e37d87eccaa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89a755d4-47f5-4164-b629-fb5e7a50f05d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_python3",
   "language": "python",
   "name": "conda_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.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}