KNNonBertEmb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "KNNonBertEmb.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "ERTT0N6vDPwW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "009d1a07-b94c-429e-d018-238dbb33646f"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "# Get the GPU device name. \n",
        "device_name = tf.test.gpu_device_name()\n",
        "\n",
        "# The device name should look like the following:\n",
        "if device_name == '/device:GPU:0':\n",
        "    print('Found GPU at: {}'.format(device_name))\n",
        "else:\n",
        "    raise SystemError('GPU device not found')\n",
        "\n",
        "import os\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "import pandas as pd\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found GPU at: /device:GPU:0\n",
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UR9Fw19KvFjq",
        "colab_type": "text"
      },
      "source": [
        "# New Section"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LC2Dh9J13K2Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "embed_pick=pd.read_pickle(\"/content/drive/My Drive/title_embeddings.pkl\") #load the embeddings of the json page title\n",
        "brand_dict=pd.read_pickle(\"/content/drive/My Drive/brand_dict.pickle\") #load the embeddings of the json page title\n",
        "model_dict=pd.read_pickle(\"/content/drive/My Drive/model_dict.pkl\") #load the embeddings of the json page title"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "imQYrXQvDjzc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        },
        "outputId": "eac4a652-0cd3-4fef-a785-071dc3ee3a18"
      },
      "source": [
        "import pandas as pd\n",
        "non_match_pairs=set()\n",
        "non_match_pairs_by_brand=dict()\n",
        "match_pairs=set()\n",
        "t_data=pd.read_csv(\"/content/drive/My Drive/ground_truth.csv\")\n",
        "for index, row in t_data.iterrows():\n",
        "    if row['label']==1 and (brand_dict[row['left_spec_id']]!=brand_dict[row['right_spec_id']]):\n",
        "        print(\"Mismatch (which we fix)\")\n",
        "        print(row['left_spec_id'])\n",
        "        print(row['right_spec_id'])\n",
        "        t_data.loc[index,'label']=0#We fix it as we think it is an error from the ground truth...!\n",
        "    if row['label']==1:\n",
        "        match_pairs.add(row['left_spec_id']+\"SEPARATOR\"+row['right_spec_id'])\n",
        "    elif row['label']==0 and (brand_dict[row['left_spec_id']]==brand_dict[row['right_spec_id']]):\n",
        "        non_match_pairs.add(row['left_spec_id']+\"SEPARATOR\"+row['right_spec_id'])\n",
        "        if not brand_dict[row['left_spec_id']] in non_match_pairs_by_brand:\n",
        "            non_match_pairs_by_brand[brand_dict[row['left_spec_id']]]=1\n",
        "        else:\n",
        "            non_match_pairs_by_brand[brand_dict[row['left_spec_id']]]+=1\n",
        "match_pairs=list(match_pairs)\n",
        "non_match_pairs=list(non_match_pairs)\n",
        "print(len(match_pairs))\n",
        "print(len(non_match_pairs))\n",
        "print(non_match_pairs_by_brand)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mismatch (which we fix)\n",
            "www.ebay.com/21318\n",
            "www.ohc24.ch/797\n",
            "1073\n",
            "9010\n",
            "{'elo': 329, 'dell': 3013, 'nec': 340, 'philips': 1478, 'lg': 8, 'samsung': 381, 'apple': 143, 'rockwell': 374, 'AOC': 198, 'hp': 205, 'benq': 56, 'asus': 2239, 'lenovo': 6, '3M': 228, 'acer': 12}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rMRZ75--3XXP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_data=pd.DataFrame(columns=['Left_Title', 'Right_Title', 'Label'])#create a new dataframe"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MACWGs9Kvfjv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "1b9bd35a-a2b7-4983-b32e-17d415dfb5a1"
      },
      "source": [
        "import random\n",
        "from difflib import SequenceMatcher\n",
        "random.shuffle(non_match_pairs)\n",
        "random.shuffle(match_pairs)\n",
        "for_non_train=list()\n",
        "unexpected_count=0\n",
        "##repace the left and right page titles with their bert embeddings\n",
        "for row in match_pairs:\n",
        "    left=embed_pick.loc[embed_pick['spec'] == row.split(\"SEPARATOR\")[0].replace(\"/\",\"//\")].embeddings\n",
        "    right=embed_pick.loc[embed_pick['spec'] == row.split(\"SEPARATOR\")[1].replace(\"/\",\"//\")].embeddings\n",
        "    train_data=train_data.append({'Left_Title': list(left)[0], 'Right_Title': list(right)[0], 'Label': 1 }, ignore_index=True)\n",
        "    if model_dict[row.split(\"SEPARATOR\")[0]]!=model_dict[row.split(\"SEPARATOR\")[1]] and SequenceMatcher(None, model_dict[row.split(\"SEPARATOR\")[0]], model_dict[row.split(\"SEPARATOR\")[1]]).ratio() < 0.5:\n",
        "        print(model_dict[row.split(\"SEPARATOR\")[0]]+\"----\"+model_dict[row.split(\"SEPARATOR\")[1]]+\"-----\"+str(SequenceMatcher(None, model_dict[row.split(\"SEPARATOR\")[0]], model_dict[row.split(\"SEPARATOR\")[1]]).ratio()))\n",
        "        unexpected_count+=1\n",
        "for row in non_match_pairs:\n",
        "    left=embed_pick.loc[embed_pick['spec'] == row.split(\"SEPARATOR\")[0].replace(\"/\",\"//\")].embeddings\n",
        "    right=embed_pick.loc[embed_pick['spec'] == row.split(\"SEPARATOR\")[1].replace(\"/\",\"//\")].embeddings\n",
        "    if model_dict[row.split(\"SEPARATOR\")[0]]==model_dict[row.split(\"SEPARATOR\")[1]] or SequenceMatcher(None, model_dict[row.split(\"SEPARATOR\")[0]], model_dict[row.split(\"SEPARATOR\")[1]]).ratio() > 0.5:\n",
        "        train_data=train_data.append({'Left_Title': list(left)[0], 'Right_Title': list(right)[0], 'Label': 0 }, ignore_index=True)\n",
        "    #for_non_train.append({'Left_Title': list(left)[0], 'Right_Title': list(right)[0], 'Label': 0 })\n",
        "train_data = train_data.sample(frac=1).reset_index(drop=True)\n",
        "print(str(unexpected_count))\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "e178fp----lcd8205-----0.15384615384615385\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6k9Z9MxWxjNw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 419
        },
        "outputId": "2c6b3b1f-b476-43e9-d65b-4292c375c6d3"
      },
      "source": [
        "train_data"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Left_Title</th>\n",
              "      <th>Right_Title</th>\n",
              "      <th>Label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>[-0.14258593, 1.0876138, -0.7027058, 0.0245024...</td>\n",
              "      <td>[0.385037, 0.8773844, -0.7771925, -0.41962168,...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>[-0.14258593, 1.0876138, -0.7027058, 0.0245024...</td>\n",
              "      <td>[-0.2754211, 1.2161496, -0.81139195, -0.673738...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>[-0.045994535, 0.5719848, -0.054123655, 0.0637...</td>\n",
              "      <td>[0.22393546, 0.7994133, -0.54887587, 0.1251741...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>[-0.0017912617, 0.50674677, 0.2934466, 0.20736...</td>\n",
              "      <td>[-0.19513786, 0.4408024, -0.6041947, -0.052804...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>[-0.14807041, 0.71383655, 0.05326492, 0.045866...</td>\n",
              "      <td>[-0.14807041, 0.71383655, 0.05326492, 0.045866...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3760</th>\n",
              "      <td>[0.15827227, 0.89096004, 0.04024145, -0.352201...</td>\n",
              "      <td>[0.22063379, 0.77158785, -0.2285516, -0.348369...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3761</th>\n",
              "      <td>[0.041627787, 1.0514015, 0.7180133, -0.1084840...</td>\n",
              "      <td>[-0.10499406, 0.96824884, 0.890144, -0.1647403...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3762</th>\n",
              "      <td>[0.015242952, 0.5777541, 0.18430081, -0.052737...</td>\n",
              "      <td>[0.12678085, 1.2389818, 1.1932448, 0.30212384,...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3763</th>\n",
              "      <td>[0.3090158, 0.69809794, 0.10772467, -0.2525184...</td>\n",
              "      <td>[0.015242952, 0.5777541, 0.18430081, -0.052737...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3764</th>\n",
              "      <td>[-0.41546088, 1.0797614, 0.27010116, 0.2046675...</td>\n",
              "      <td>[-0.51076126, 0.5745804, -0.3125716, 0.0097757...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>3765 rows × 3 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "                                             Left_Title  ... Label\n",
              "0     [-0.14258593, 1.0876138, -0.7027058, 0.0245024...  ...     1\n",
              "1     [-0.14258593, 1.0876138, -0.7027058, 0.0245024...  ...     0\n",
              "2     [-0.045994535, 0.5719848, -0.054123655, 0.0637...  ...     0\n",
              "3     [-0.0017912617, 0.50674677, 0.2934466, 0.20736...  ...     1\n",
              "4     [-0.14807041, 0.71383655, 0.05326492, 0.045866...  ...     1\n",
              "...                                                 ...  ...   ...\n",
              "3760  [0.15827227, 0.89096004, 0.04024145, -0.352201...  ...     0\n",
              "3761  [0.041627787, 1.0514015, 0.7180133, -0.1084840...  ...     0\n",
              "3762  [0.015242952, 0.5777541, 0.18430081, -0.052737...  ...     1\n",
              "3763  [0.3090158, 0.69809794, 0.10772467, -0.2525184...  ...     0\n",
              "3764  [-0.41546088, 1.0797614, 0.27010116, 0.2046675...  ...     0\n",
              "\n",
              "[3765 rows x 3 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-62LDcPSE4n7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "##find the difference between the embeddings\n",
        "train_data['difference'] = [abs(x - y) for x,y in zip(train_data['Left_Title'], train_data['Right_Title'])]\n"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bWVgQQhWE5PI",
        "colab_type": "text"
      },
      "source": [
        "Resultant vector : Difference between left spec and right spec data\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kTFyPLF6E-TD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_data.head()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmrGqG9MFNLc",
        "colab_type": "text"
      },
      "source": [
        "# Simple KNN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PIqXVGvuFO0k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "\n"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N_WBCyudFbt5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "labels= train_data[\"Label\"].to_list()\n",
        "data_df = train_data[\"difference\"].to_list()"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kIfj_oXu47IK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fcde3dfc-a3f1-4ce7-a511-0acfac1b6bff"
      },
      "source": [
        "len(data_df[0])"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "768"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tITbZQ5gFllV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "##split the data set \n",
        "Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(data_df, labels, test_size=0.33, random_state=1000)\n",
        "for item in for_non_train:\n",
        "    Emb_test.append(list(abs(x - y) for x,y in zip(item['Left_Title'], item['Right_Title'])))\n",
        "    Emb_test_label.append(0)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SV8JDSxiFn9u",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "0c20ad03-5e76-48f6-b556-c5d25ffadf60"
      },
      "source": [
        "# k = 3\n",
        "#train\n",
        "classifier = KNeighborsClassifier(n_neighbors=5)\n",
        "classifier.fit(Emb_train, Emb_train_label)\n"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
              "                     metric_params=None, n_jobs=None, n_neighbors=5, p=2,\n",
              "                     weights='uniform')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VGk4hYgULse4",
        "colab_type": "text"
      },
      "source": [
        "Save File"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AZlvr_PCsGOc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pickle "
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJvIbWH1Lith",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "\n",
        "# Its important to use binary mode \n",
        "knnPickle = open('/content/drive/My Drive//knn', 'wb') \n",
        "\n",
        "# source, destination \n",
        "pickle.dump(classifier, knnPickle)                      \n",
        "\n",
        "\n"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nqQUoIP8BGA-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.experimental import enable_hist_gradient_boosting\n",
        "from sklearn.ensemble import HistGradientBoostingClassifier\n",
        "hgb=HistGradientBoostingClassifier(max_iter=100).fit(Emb_train, Emb_train_label)\n",
        "\n",
        "# Its important to use binary mode \n",
        "hgbPickle = open('/content/drive/My Drive//hgb', 'wb') \n",
        "\n",
        "# source, destination \n",
        "pickle.dump(hgb, hgbPickle)   "
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gaYSqtrGcLnL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# load the model from disk\n",
        "loaded_model = pickle.load(open('/content/drive/My Drive/knn', 'rb'))"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p28VWChR6CGY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#print(Emb_test[0])\n",
        "#print(Emb_test[2000])"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jNaB2A2JF6ek",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pred=loaded_model.predict(Emb_test)"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m8yRWYqvF8cV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "fab68d53-efb8-42d5-83ce-906fdba5c07d"
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.metrics import classification_report\n",
        "\n",
        "print('Accuracy is: ',accuracy_score(Emb_test_label, pred))\n",
        "con_mat = confusion_matrix(Emb_test_label, pred, [0, 1])\n",
        "\n",
        "print(classification_report(Emb_test_label,pred,target_names=[\"class_0\", \"class_1\"]))"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy is:  0.7393403057119872\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     class_0       0.79      0.87      0.82       873\n",
            "     class_1       0.58      0.44      0.50       370\n",
            "\n",
            "    accuracy                           0.74      1243\n",
            "   macro avg       0.68      0.65      0.66      1243\n",
            "weighted avg       0.72      0.74      0.73      1243\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "APvfpCw48-g_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "02a889ac-6a12-45b9-d397-3f2cf11905a9"
      },
      "source": [
        "pred=hgb.predict(Emb_test)\n",
        "print('Accuracy is: ',accuracy_score(Emb_test_label, pred))\n",
        "con_mat = confusion_matrix(Emb_test_label, pred, [0, 1])\n",
        "\n",
        "print(classification_report(Emb_test_label,pred,target_names=[\"class_0\", \"class_1\"]))"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy is:  0.7602574416733708\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     class_0       0.76      0.96      0.85       873\n",
            "     class_1       0.76      0.28      0.41       370\n",
            "\n",
            "    accuracy                           0.76      1243\n",
            "   macro avg       0.76      0.62      0.63      1243\n",
            "weighted avg       0.76      0.76      0.72      1243\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-H7x3Li9Hm7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "2175d35d-749b-4c92-ab36-ab1590bbceba"
      },
      "source": [
        "#Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(equal_data, equal_labels, test_size=0.50) #splitting on 50% data\n",
        "Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(data_df, labels, test_size=0.33, random_state=1000)\n",
        "classifier = KNeighborsClassifier(n_neighbors=3)\n",
        "classifier.fit(Emb_train, Emb_train_label)\n",
        "\n",
        "pred=classifier.predict(Emb_test)\n",
        "print('accuracy is: ',accuracy_score(Emb_test_label, pred))\n",
        "print(classification_report(Emb_test_label,pred,target_names=[\"class_0\", \"class_1\"]))"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "accuracy is:  0.7425583266291231\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     class_0       0.80      0.84      0.82       873\n",
            "     class_1       0.57      0.52      0.55       370\n",
            "\n",
            "    accuracy                           0.74      1243\n",
            "   macro avg       0.69      0.68      0.68      1243\n",
            "weighted avg       0.74      0.74      0.74      1243\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xrd3F_39aSz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "deeadc50-f25a-401e-993b-42413ebaa4ba"
      },
      "source": [
        "#Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(equal_data, equal_labels, test_size=0.30) #splitting on 50% data\n",
        "Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(data_df, labels, test_size=0.33, random_state=1000)\n",
        "classifier = KNeighborsClassifier(n_neighbors=5)\n",
        "classifier.fit(Emb_train, Emb_train_label)\n",
        "\n",
        "pred=classifier.predict(Emb_test)\n",
        "print('accuracy is: ',accuracy_score(Emb_test_label, pred))\n",
        "print(classification_report(Emb_test_label,pred,target_names=[\"class_0\", \"class_1\"]))"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "accuracy is:  0.7393403057119872\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     class_0       0.79      0.87      0.82       873\n",
            "     class_1       0.58      0.44      0.50       370\n",
            "\n",
            "    accuracy                           0.74      1243\n",
            "   macro avg       0.68      0.65      0.66      1243\n",
            "weighted avg       0.72      0.74      0.73      1243\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dvMnhIVF-Uf5",
        "colab_type": "text"
      },
      "source": [
        "#Try different splits"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FwrRJLRs-X02",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "20aab573-d6c5-46f2-91ed-de3e4027354d"
      },
      "source": [
        "#Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(equal_data, equal_labels, test_size=0.50) #splitting on 50% data\n",
        "Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(data_df, labels, test_size=0.50, random_state=1000)\n",
        "classifier = KNeighborsClassifier(n_neighbors=3)\n",
        "classifier.fit(Emb_train, Emb_train_label)\n",
        "\n",
        "pred=classifier.predict(Emb_test)\n",
        "print('accuracy is: ',accuracy_score(Emb_test_label, pred))\n",
        "print(classification_report(Emb_test_label,pred,target_names=[\"class_0\", \"class_1\"]))"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "accuracy is:  0.7360594795539034\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     class_0       0.81      0.83      0.82      1332\n",
            "     class_1       0.55      0.52      0.54       551\n",
            "\n",
            "    accuracy                           0.74      1883\n",
            "   macro avg       0.68      0.67      0.68      1883\n",
            "weighted avg       0.73      0.74      0.73      1883\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P9-ljK819Q9Z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "20c8addf-1ffd-4133-d499-111cda898f2f"
      },
      "source": [
        "#Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(equal_data, equal_labels, test_size=0.50) #splitting on 50% data\n",
        "Emb_train, Emb_test, Emb_train_label, Emb_test_label = train_test_split(data_df, labels, test_size=0.50, random_state=1000)\n",
        "classifier = KNeighborsClassifier(n_neighbors=5)\n",
        "classifier.fit(Emb_train, Emb_train_label)\n",
        "\n",
        "pred=classifier.predict(Emb_test)\n",
        "print('accuracy is: ',accuracy_score(Emb_test_label, pred))\n",
        "print(classification_report(Emb_test_label,pred,target_names=[\"class_0\", \"class_1\"]))"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "accuracy is:  0.7525225703664365\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     class_0       0.79      0.88      0.83      1332\n",
            "     class_1       0.60      0.45      0.52       551\n",
            "\n",
            "    accuracy                           0.75      1883\n",
            "   macro avg       0.70      0.66      0.68      1883\n",
            "weighted avg       0.74      0.75      0.74      1883\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3fmJulw3fsRe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "inference_data=pd.read_csv(\"/content/drive/My Drive/pairs_to_evaluate.csv\")"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2q0SLtmUsdHr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "output=pd.DataFrame(columns=['left_spec_id', 'right_spec_id'])#create a new dataframe\n",
        "print(\"left_spec_id\",\"right_spec_id\")\n",
        "for index, row in inference_data.iterrows():\n",
        "    a=row[\"left\"]\n",
        "    b=row[\"right\"]\n",
        "    left=embed_pick.loc[embed_pick['spec'] == a.replace(\"/\",\"//\")].embeddings\n",
        "    right=embed_pick.loc[embed_pick['spec'] == b.replace(\"/\",\"//\")].embeddings\n",
        "    difference=[abs(x - y) for x,y in zip(left, right)]\n",
        "    pred=hgb.predict(difference)\n",
        "    if pred==1:\n",
        "        output.append({'left_spec_id': a.replace(\"/\",\"//\"), 'right_spec_id': b.replace(\"/\",\"//\")}, ignore_index=True)\n",
        "        #print(a.replace(\"/\",\"//\")+\",\"+b.replace(\"/\",\"//\"))\n",
        "    if index%100==0:\n",
        "        print(index)\n",
        "output.to_csv(\"/content/output.csv\", sep=',',encoding='utf-8', index=False)\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}