faiss_index_ivfflat_experiment_for_Second_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/h0s060n/Documents/anaconda3/envs/sem_env/lib/python3.8/site-packages/tqdm/auto.py:22: 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",
    "import re\n",
    "import time\n",
    "import gzip\n",
    "import faiss\n",
    "import string\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "from typing import List\n",
    "from collections import Counter\n",
    "from nltk.corpus import stopwords\n",
    "from sklearn.metrics import accuracy_score\n",
    "from nltk.tokenize import word_tokenize as tokenize\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sentence_transformers import SentenceTransformer\n",
    "from sklearn.metrics import classification_report,confusion_matrix\n",
    "\n",
    "pd.set_option('display.max_rows', None)\n",
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_colwidth', None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LOAD Data is skipped as we will be using train and test files from befor notebook "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    
    "# For this semantic search classification we have taken 4 categories\n",
    "\n",
    "# def parse(path):\n",
    "#   g = gzip.open(path, 'rb')\n",
    "#   for l in g:\n",
    "#     yield eval(l)\n",
    "\n",
    "# def getDF(path):\n",
    "#   i = 0\n",
    "#   df = {}\n",
    "#   for d in parse(path):\n",
    "#     df[i] = d\n",
    "#     i += 1\n",
    "#   return pd.DataFrame.from_dict(df, orient='index')\n",
    "\n",
    "# cat1_baby = getDF('./data/reviews_Baby_5.json.gz')\n",
    "# cat2_beauty = getDF('./data/reviews_Beauty_5.json.gz')\n",
    "# cat3_grocery=getDF('./data/reviews_Grocery_and_Gourmet_Food_5.json.gz')\n",
    "# cat4_music=getDF('./data/reviews_Musical_Instruments_5.json.gz')\n",
    "\n",
    "# # create category column for each file (dataframe)\n",
    "# cat1_baby[\"category\"]=\"baby\"\n",
    "# cat2_beauty[\"category\"]=\"beauty\"\n",
    "# cat3_grocery[\"category\"]=\"grocery\"\n",
    "# cat4_music[\"category\"]=\"music\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cat1_baby.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Take Uneven Samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## randomly take few samples from each dataframe and just to test mis-imblanced scenario we have taken uneven numbers\n",
    "# cat1_baby=cat1_baby[[\"reviewText\",\"category\"]].sample(900)\n",
    "# cat2_beauty=cat2_beauty[[\"reviewText\",\"category\"]].sample(1200)\n",
    "# cat3_grocery=cat3_grocery[[\"reviewText\",\"category\"]].sample(1500)\n",
    "# cat4_music=cat4_music[[\"reviewText\",\"category\"]].sample(3000)\n",
    "# df = pd.concat([cat1_baby,cat2_beauty,cat3_grocery,cat4_music],axis=0).reset_index()[[\"reviewText\",\"category\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"Total Data\",len(df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clean the dataframe "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop_words=stopwords.words('english')\n",
    "def clean(text):\n",
    "    text=text.lower()\n",
    "    url_removed=re.sub(r'https\\S+','',text,flags=re.MULTILINE)\n",
    "    text=re.sub(\"[^a-zA-Z]\",\" \",url_removed)\n",
    "    text=re.sub(\"\\.+\",\" \",text)\n",
    "    word_tokens=tokenize(text)\n",
    "    text=[word for word in word_tokens if word  not in stop_words]\n",
    "    text=[word for word in text if word not in string.punctuation]\n",
    "    return \" \".join(text)\n",
    "\n",
    "# df[\"cleaned_review_data\"]=df[\"reviewText\"].apply(lambda x:clean(x))\n",
    "# df[\"category\"].dropna(inplace=True)\n",
    "# df.drop_duplicates(inplace=True)\n",
    "\n",
    "# clean(\"This is  good day . ! ! , I IS  #\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6599"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split the Dataframe to train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train,test= train_test_split(df,stratify=df[[\"category\"]],test_size=0.2)\n",
    "train=pd.read_csv(\"./data/train_data.csv\") # using the file from previous notebook created step\n",
    "test=pd.read_csv(\"./data/test_data.csv\") # using the file from previous notebook created step\n",
    "train.reset_index(drop=True,inplace=True)\n",
    "test.reset_index(drop=True,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "music      2399\n",
       "grocery    1200\n",
       "beauty      960\n",
       "baby        720\n",
       "Name: category, dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['category'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# save the train and test to csv file for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.to_csv(\"./data/train_data.csv\",index=False)\n",
    "test.to_csv(\"./data/test_data.csv\",index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Embeddings for train and create mappings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model=SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')\n",
    "#using earlier obtained files\n",
    "# train_cleaned_texts = train[\"cleaned_review_data\"].tolist()\n",
    "# train_cleaned_texts = list(map(str, train_cleaned_texts))\n",
    "\n",
    "\n",
    "# def get_embeddings(model, sentences: List[str], parallel: bool = True):\n",
    "#     start = time.time()\n",
    "#     if parallel:\n",
    "#         # Start the multi-process pool on all cores\n",
    "#         os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
    "#         pool = model.start_multi_process_pool(target_devices=[\"cpu\"] * 5)\n",
    "#         embeddings = model.encode_multi_process(sentences, pool, batch_size=16)\n",
    "#         model.stop_multi_process_pool(pool)\n",
    "#     else:\n",
    "#         os.environ[\"TOKENIZERS_PARALLELISM\"] = \"true\"\n",
    "#         embeddings = model.encode(\n",
    "#             sentences,\n",
    "#             batch_size=32,\n",
    "#             show_progress_bar=True,\n",
    "#             convert_to_tensor=True,\n",
    "#         )\n",
    "#     print(f\"Time taken to encode {len(sentences)} items: {round(time.time() - start, 2)}\")\n",
    "#     return embeddings.detach().numpy()\n",
    "\n",
    "# train_embeddings = get_embeddings(model=model, sentences=train_cleaned_texts, parallel=False)\n",
    "# print(train_embeddings.shape)\n",
    "\n",
    "# #save embeddings of idea texts\n",
    "# cleaned_train_texts_embeddings_file = f\"./data/train_embeddings_all_minilm_l6_v2.pkl\"\n",
    "# pickle.dump(train_embeddings, open(cleaned_train_texts_embeddings_file, \"wb\"))\n",
    "\n",
    "\n",
    "# #create mappings for index and category this will be later used for faiss\n",
    "# train_category_index_mapping=dict(zip(train.index,train.category))\n",
    "# with open('./data/train_category_index.pickle', 'wb') as handle:\n",
    "#     pickle.dump(train_category_index_mapping, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Index "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the mappings file which is used for printing category as output\n",
    "def get_mappings(file_name):\n",
    "    with open(file_name, 'rb') as handle:\n",
    "        category_mapping_dict = pickle.load(handle)\n",
    "    return category_mapping_dict\n",
    "\n",
    "#read the embeddings created at earlier step\n",
    "def read_embeddings(file_name):\n",
    "    cleaned_texts_embeddings_file = file_name\n",
    "    if os.path.exists(cleaned_texts_embeddings_file):\n",
    "        with open(cleaned_texts_embeddings_file, \"rb\") as f:\n",
    "            embeddings = pickle.load(f)\n",
    "    temp1=np.asarray(embeddings,dtype=\"float32\")\n",
    "    return temp1\n",
    "\n",
    "#save the index once its created\n",
    "def save_index(index):\n",
    "    path = os.path.join(\"./data/\",\"review_category_train_index_ivf_flat\")\n",
    "    faiss.write_index(index, path)\n",
    "\n",
    "\n",
    "nlist = 5  # number of clusters\n",
    "dimension=384 # embeddings dimension\n",
    "\n",
    "# we have used flat Index and with Inner product\n",
    "def create_index(mappings,samples,nlist=nlist,dimension=dimension):\n",
    "    quantiser = faiss.IndexFlatL2(dimension)  \n",
    "    index = faiss.IndexIVFFlat(quantiser, dimension, nlist,   faiss.METRIC_L2)\n",
    "    index.train(samples)\n",
    "    index.add(samples)   # add the vectors and update the index\n",
    "    print(index.is_trained)  # True\n",
    "    print(index.ntotal)  \n",
    "    index.add_with_ids(samples,np.array(list(mappings.keys())))\n",
    "    save_index(index)\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## call the above functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "5279\n"
     ]
    }
   ],
   "source": [
    "mappings = get_mappings(file_name='./data/train_category_index.pickle')\n",
    "samples = read_embeddings(file_name=f\"./data/train_embeddings_all_minilm_l6_v2.pkl\")\n",
    "create_index(mappings=mappings,samples=samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print top 2 categories among top5 nearest neighbours returned from index search\n",
    "def most_frequent(result):\n",
    "    top2 = Counter(result)\n",
    "    return top2.most_common(2)\n",
    "\n",
    "\n",
    "#read the index\n",
    "index = faiss.read_index(\"./data/review_category_train_index_ivf_flat\")\n",
    "\n",
    "# embeddings for query\n",
    "def predict_embeddings(query):\n",
    "    query_embedding=model.encode(query)\n",
    "    query_embedding=np.asarray([query_embedding],dtype=\"float32\")\n",
    "    return query_embedding\n",
    "    \n",
    "\n",
    "#predict for given query\n",
    "def predict(query,mappings):\n",
    "    cleaned_query= clean(query)\n",
    "    query_embedding=predict_embeddings(cleaned_query)\n",
    "    faiss.normalize_L2(query_embedding)\n",
    "    D, I = index.search(query_embedding, 5) # d is the distance and I is the index number \n",
    "    for values in I:\n",
    "        for distance in D:\n",
    "            details= {'cleaned_text':train.iloc[values][\"reviewText\"],\n",
    "            'category':train.iloc[values][\"category\"],\n",
    "            'score':distance\n",
    "            }\n",
    "            print(\"===============================================\")\n",
    "            print(pd.DataFrame(details))\n",
    "            print(\"===============================================\")\n",
    "    return most_frequent([mappings[id_] for id_ in I[0]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============================================\n",
      "                                                                                                                                                                                                                               cleaned_text  \\\n",
      "3545                                            I bought this tuner because I am learning to play guitar and want to keep my guitar in tuneGreat little tuner that looks good and works even better It works really well, but not perfectly   \n",
      "3545                                            I bought this tuner because I am learning to play guitar and want to keep my guitar in tuneGreat little tuner that looks good and works even better It works really well, but not perfectly   \n",
      "2504  This little tuner is so easy to use and see...I bought two more as presents. The price point was just unbeatable for such a stellar performing tuner. If you don't have a tuner or are looking for a new one, you NEED this one. A+++   \n",
      "2504  This little tuner is so easy to use and see...I bought two more as presents. The price point was just unbeatable for such a stellar performing tuner. If you don't have a tuner or are looking for a new one, you NEED this one. A+++   \n",
      "2511                                                                                         This is a very versatile tuner!  I use it all the time to check my instruments, and keep things sounding good.  Highly recommend this product.   \n",
      "\n",
      "     category     score  \n",
      "3545    music  0.933976  \n",
      "3545    music  0.933976  \n",
      "2504    music  0.953960  \n",
      "2504    music  0.953960  \n",
      "2511    music  0.971377  \n",
      "===============================================\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('music', 5)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(query=\"tune your groove\",mappings=mappings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============================================\n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cleaned_text  \\\n",
      "4177                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           NaN   \n",
      "4177                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           NaN   \n",
      "5069  Blah.  I wanted to like this pail so much.  We are exclusive GroVia diaper users and I had to have this pail, the concept was perfect for our needs.  However, the plastic boning wore a hole in the material and fell out after about 2-3 months.  Customer service was awesome.  They acknowledged there was an issue with some pails and sent a new one right away and I returned the old one.  Unfortunately the same thing happened with the replacement.  This time they offered to send another or give me store credit.  I took the store credit and they let me keep the pail.  I've only had the second one a few months and along with the fraying hole from the plastic boning, the zipper is a really inferior quality for something I use so regularly.  I really liked the concept, but the quality is severely lacking compared to their diapers.  A high quality zipper and a fix for that plastic boning issue and I'd buy another one.  Until then, I'm sticking with the Planet Wise hanging diaper bag.   \n",
      "5069  Blah.  I wanted to like this pail so much.  We are exclusive GroVia diaper users and I had to have this pail, the concept was perfect for our needs.  However, the plastic boning wore a hole in the material and fell out after about 2-3 months.  Customer service was awesome.  They acknowledged there was an issue with some pails and sent a new one right away and I returned the old one.  Unfortunately the same thing happened with the replacement.  This time they offered to send another or give me store credit.  I took the store credit and they let me keep the pail.  I've only had the second one a few months and along with the fraying hole from the plastic boning, the zipper is a really inferior quality for something I use so regularly.  I really liked the concept, but the quality is severely lacking compared to their diapers.  A high quality zipper and a fix for that plastic boning issue and I'd buy another one.  Until then, I'm sticking with the Planet Wise hanging diaper bag.   \n",
      "766                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Just plastic crap   \n",
      "\n",
      "     category     score  \n",
      "4177    music  1.519575  \n",
      "4177    music  1.519575  \n",
      "5069     baby  1.578009  \n",
      "5069     baby  1.578009  \n",
      "766    beauty  1.581359  \n",
      "===============================================\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('music', 2), ('baby', 2)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(query=\"quinoa\",mappings=mappings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict function for test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def most_frequent_test(result):\n",
    "    top2 = Counter(result)\n",
    "    return top2.most_common(1)\n",
    "\n",
    "\n",
    "def test_predict(query,mappings=mappings):\n",
    "    cleaned_query= clean(query)\n",
    "    query_embedding=predict_embeddings(cleaned_query)\n",
    "    faiss.normalize_L2(query_embedding)\n",
    "    D, I = index.search(query_embedding, 5) # d is the distance and I is the index number \n",
    "    return most_frequent([mappings[id_] for id_ in I[0]])[0][0]\n",
    "\n",
    "\n",
    "test[\"predict\"]=test[\"reviewText\"].apply(lambda x:test_predict(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "music 0.015559911727905273\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "print(test_predict(\"quinoa\",mappings),time.time()-start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classification Report for test file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "        baby       0.88      0.91      0.89       180\n",
      "      beauty       0.91      0.93      0.92       240\n",
      "     grocery       0.98      0.97      0.97       300\n",
      "       music       0.98      0.96      0.97       600\n",
      "\n",
      "    accuracy                           0.95      1320\n",
      "   macro avg       0.94      0.94      0.94      1320\n",
      "weighted avg       0.95      0.95      0.95      1320\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(test['category'],test[\"predict\"]))\n",
    "cm = confusion_matrix(test['category'],test[\"predict\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels = ['baby','beauty','grocery','music']\n",
    "sns.heatmap(cm, fmt='d', annot=True, square=True,\n",
    "            cmap='gray_r', vmin=0, vmax=0,  # set all to white\n",
    "            linewidths=0.5, linecolor='w',  # draw black grid lines\n",
    "            xticklabels=labels,yticklabels=labels)                     # disable colorbar\n",
    "\n",
    "# re-enable outer spines\n",
    "sns.despine(left=False, right=False, top=False, bottom=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy Score 0.9507575757575758\n"
     ]
    }
   ],
   "source": [
    "acc_score = accuracy_score(test['category'],test[\"predict\"])\n",
    "print(\"Test Accuracy Score\",acc_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#conclusion - IVF Index results are bit not accurate like flat index but this is slightly faster compared to flat index"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "sem_env",
   "name": "sem_env"
  },
  "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.8.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}