notebooks/Record-Linkage-Example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Record Linkage Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boilerplate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from importlib import reload\n",
    "import logging\n",
    "reload(logging)\n",
    "logging.basicConfig(format='%(asctime)s %(levelname)s:%(message)s', level=logging.INFO, datefmt='%H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "sys.path.insert(0, '..')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import entity_embed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "random_seed = 42\n",
    "torch.manual_seed(random_seed)\n",
    "np.random.seed(random_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use the [Amazon-GoogleProducts](https://dbs.uni-leipzig.de/research/projects/object_matching/benchmark_datasets_for_entity_resolution). The dataset is stored in a ZIP file with 3 CSV files: Two are the entity source files, the third one is the perfect mapping.\n",
    "\n",
    "Let's download the ZIP:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib\n",
    "import tempfile\n",
    "\n",
    "dataset_url = 'https://dbs.uni-leipzig.de/file/Amazon-GoogleProducts.zip'\n",
    "tf = tempfile.NamedTemporaryFile(mode='r', delete=False)\n",
    "tf.close()\n",
    "\n",
    "urllib.request.urlretrieve(dataset_url, tf.name);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extracting the files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Amazon.csv', 'GoogleProducts.csv', 'Amzon_GoogleProducts_perfectMapping.csv']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import zipfile\n",
    "import os\n",
    "\n",
    "td = tempfile.TemporaryDirectory()\n",
    "\n",
    "with zipfile.ZipFile(tf.name, \"r\") as zf:\n",
    "    zf.extractall(td.name)\n",
    "\n",
    "os.listdir(td.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we must read the **two** CSV files `'Amazon.csv'` and `'GoogleProducts.csv'` into a **single** `dict` called `record_dict`. Therefore, `record_dict` will contain all records from the dataset, i.e., all records from both files.\n",
    "\n",
    "We'll dynamically attribute an `id` to each record using `enumerate`. Entity Embed needs that.\n",
    "\n",
    "Also, to keep track of what's source file of a record, we must keep a `__source`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "from entity_embed.data_utils.utils import Enumerator\n",
    "\n",
    "id_enumerator = Enumerator()\n",
    "record_dict = {}\n",
    "source_field = '__source'\n",
    "left_source = 'amazon'\n",
    "right_source = 'google'\n",
    "\n",
    "with open(f'{td.name}/Amazon.csv', newline='', encoding=\"latin1\") as f:\n",
    "    for record in csv.DictReader(f):\n",
    "        record['id'] = id_enumerator[record[\"id\"]]\n",
    "        record[source_field] = left_source\n",
    "        del record['description']  # drop description, for benchmarking\n",
    "        record_dict[record['id']] = record\n",
    "\n",
    "with open(f'{td.name}/GoogleProducts.csv', newline='', encoding=\"latin1\") as f:\n",
    "    for record in csv.DictReader(f):\n",
    "        record['id'] = id_enumerator[record[\"id\"]]\n",
    "        record['title'] = record.pop('name')  # in Google, title is called name\n",
    "        record[source_field] = right_source\n",
    "        del record['description']  # drop description, for benchmarking\n",
    "        record_dict[record['id']] = record"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we get the `pos_pair_set`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1300"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pos_pair_set = set()\n",
    "\n",
    "with open(f'{td.name}/Amzon_GoogleProducts_perfectMapping.csv', newline='') as f:\n",
    "    for row in csv.DictReader(f):\n",
    "        id_left = id_enumerator[row['idAmazon']]\n",
    "        id_right = id_enumerator[row['idGoogleBase']]\n",
    "        pos_pair_set.add((id_left, id_right))\n",
    "\n",
    "len(pos_pair_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note internally Entity Embed will use **clusters, not pairs**.\n",
    "\n",
    "For this dataset, the number of clusters is smaller than the number of pairs, because some clusters have more than 2 records. For example, a cluster with 3 records means 2 records from a file link to 1 record from the other file. This is not a problem for Entity Embed. In fact, it's important for Entity Embed to know the full clusters in order to learn better embeddings. See an example here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3290"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from entity_embed.data_utils import utils\n",
    "\n",
    "cluster_mapping, cluster_dict = utils.id_pairs_to_cluster_mapping_and_dict(pos_pair_set, record_dict)\n",
    "len(cluster_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[262, 2485, 2488]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cluster_dict[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 4, 4]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[cluster_mapping[id_] for id_ in cluster_dict[4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use clusters, we must assign them to each record on a `cluster_field` key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'id': 262,\n",
       " 'title': 'hp sp linux we 50 lic/cd 3.0c ( t3586a )',\n",
       " 'manufacturer': 'hewlett packard (consumables)',\n",
       " 'price': '0',\n",
       " '__source': 'amazon',\n",
       " 'cluster': 4}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "{'id': 2485,\n",
       " 'manufacturer': '',\n",
       " 'price': '69216.95',\n",
       " 'title': 'sp linux we 50 lic/cd 3.0c',\n",
       " '__source': 'google',\n",
       " 'cluster': 4}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "{'id': 2488,\n",
       " 'manufacturer': '',\n",
       " 'price': '69216.95',\n",
       " 'title': 'sp linux we 50 lic/cd 3.0c',\n",
       " '__source': 'google',\n",
       " 'cluster': 4}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cluster_field = 'cluster'\n",
    "utils.assign_clusters(record_dict, cluster_field, cluster_mapping)\n",
    "\n",
    "for id_ in cluster_dict[4]:\n",
    "    display(record_dict[id_])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there are additional pairs in clusters when compared to `pos_pair_set`. That's because it's useful for Entity Embed to also learn that cases like `(2485, 2488)` represent the same entity, even though they belong to the same dataset and won't be returned in the final pairwise results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "253"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from entity_embed.data_utils.utils import cluster_dict_to_id_pairs\n",
    "\n",
    "len(cluster_dict_to_id_pairs(cluster_dict) - pos_pair_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From all clusters, we'll use only 50% for training, and other 20% for validation, and the remaining 30% for test:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "20:07:59 INFO:Singleton cluster sizes (train, valid, test):(1092, 437, 656)\n",
      "20:07:59 INFO:Plural cluster sizes (train, valid, test):(552, 221, 332)\n"
     ]
    }
   ],
   "source": [
    "from entity_embed.data_utils import utils\n",
    "\n",
    "train_record_dict, valid_record_dict, test_record_dict = utils.split_record_dict_on_clusters(\n",
    "    record_dict=record_dict,\n",
    "    cluster_field=cluster_field,\n",
    "    train_proportion=0.5,\n",
    "    valid_proportion=0.2,\n",
    "    random_seed=random_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note we're splitting the data on **clusters**, not records, so the record counts vary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2307, 913, 1369)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_record_dict), len(valid_record_dict), len(test_record_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clean up the temporary files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "td.cleanup()\n",
    "os.remove(tf.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll perform a very minimal preprocessing of the dataset. We want to simply force ASCII chars, lowercase all chars, and strip leading and trailing whitespace.\n",
    "\n",
    "The fields we'll clean are the ones we'll use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "field_list = ['title', 'manufacturer', 'price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unidecode\n",
    "\n",
    "def clean_str(s):\n",
    "    return unidecode.unidecode(s).lower().strip()\n",
    "\n",
    "for record in record_dict.values():\n",
    "    for field in field_list:\n",
    "        record[field] = clean_str(record[field])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Forcing ASCII chars in this dataset is useful to improve recall because there's little difference between accented and not-accented chars here. Also, this dataset contains mostly latin chars."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configure Entity Embed fields"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will define how record fields will be numericalized and encoded by the neural network. First we set an `alphabet`, here we'll use ASCII numbers, letters, symbols and space:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0123456789abcdefghijklmnopqrstuvwxyz!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ '"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from entity_embed.data_utils.field_config_parser import DEFAULT_ALPHABET\n",
    "\n",
    "alphabet = DEFAULT_ALPHABET\n",
    "''.join(alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth noting you can use any alphabet you need, so the accent removal we performed is optional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we set an `field_config_dict`. It defines `field_type`s that determine how fields are processed in the neural network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "field_config_dict = {\n",
    "    'title': {\n",
    "        'field_type': \"MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'title_semantic': {\n",
    "        'key': 'title',\n",
    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'vocab': \"fasttext.en.300d\",\n",
    "    },\n",
    "    'manufacturer': {\n",
    "        'field_type': \"MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'price': {\n",
    "        'field_type': \"STRING\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we use our `field_config_dict` to get a `record_numericalizer`. This object will convert the strings from our records into tensors for the neural network.\n",
    "\n",
    "The same `record_numericalizer` must be used on ALL data: train, valid, test. This ensures numericalization will be consistent. Therefore, we pass `record_list=record_dict.values()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "20:07:59 INFO:For field=title, computing actual max_str_len\n",
      "20:07:59 INFO:For field=title, using actual_max_str_len=26\n",
      "20:07:59 INFO:Loading vectors from .vector_cache/wiki.en.vec.pt\n",
      "20:08:02 INFO:For field=manufacturer, computing actual max_str_len\n",
      "20:08:02 INFO:actual_max_str_len=15 must be even to enable NN pooling. Updating to 16\n",
      "20:08:02 INFO:For field=manufacturer, using actual_max_str_len=16\n",
      "20:08:02 INFO:For field=price, computing actual max_str_len\n",
      "20:08:02 INFO:For field=price, using actual_max_str_len=12\n"
     ]
    }
   ],
   "source": [
    "from entity_embed import FieldConfigDictParser\n",
    "\n",
    "record_numericalizer = FieldConfigDictParser.from_dict(field_config_dict, record_list=record_dict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Data Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under the hood, Entity Embed uses [pytorch-lightning](https://pytorch-lightning.readthedocs.io/en/latest/), so we need to create a datamodule object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from entity_embed import LinkageDataModule\n",
    "\n",
    "batch_size = 32\n",
    "eval_batch_size = 64\n",
    "datamodule = LinkageDataModule(\n",
    "    train_record_dict=train_record_dict,\n",
    "    valid_record_dict=valid_record_dict,\n",
    "    test_record_dict=test_record_dict,\n",
    "    source_field=source_field,\n",
    "    left_source=left_source,\n",
    "    cluster_field=cluster_field,\n",
    "    record_numericalizer=record_numericalizer,\n",
    "    batch_size=batch_size,\n",
    "    eval_batch_size=eval_batch_size,\n",
    "    random_seed=random_seed\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've used `LinkageDataModule` because we're doing Record Linkage of a multiple datasets/tables.\n",
    "\n",
    "We're NOT doing Deduplication of a single dataset here. Check the other notebook [Deduplication-Example](./Deduplication-Example.ipynb) if you want to learn how to do it with Entity Embed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the training process! Thanks to pytorch-lightning, it's easy to train, validate, and test with the same datamodule.\n",
    "\n",
    "We must choose the K of the Approximate Nearest Neighbors, i.e., the top K neighbors our model will use to find duplicates in the embedding space. Below we're setting it on `ann_k` and initializing the `LinkageEmbed` model object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from entity_embed import LinkageEmbed\n",
    "\n",
    "ann_k = 100\n",
    "model = LinkageEmbed(\n",
    "    record_numericalizer,\n",
    "    ann_k=ann_k,\n",
    "    source_field=source_field,\n",
    "    left_source=left_source,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To train, Entity Embed uses [pytorch-lightning Trainer](https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html) on it's `LinkageEmbed.fit` method.\n",
    "\n",
    "Since Entity Embed is focused in recall, we'll use `valid_recall_at_0.3` for early stopping. But we'll set `min_epochs = 5` to avoid a very low precision.\n",
    "\n",
    "`0.3` here is the threshold for **cosine similarity of embedding vectors**, so possible values are between -1 and 1. We're using a validation metric, and the training process will run validation on every epoch end due to `check_val_every_n_epoch=1`.\n",
    "\n",
    "We also set `tb_name` and `tb_save_dir` to use Tensorboard. Run `tensorboard --logdir notebooks/tb_logs` to check the train and valid metrics during and after training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "20:08:03 INFO:GPU available: True, used: True\n",
      "20:08:03 INFO:TPU available: False, using: 0 TPU cores\n",
      "20:08:03 INFO:Train positive pair count: 663\n",
      "20:08:03 INFO:Valid positive pair count: 256\n",
      "20:08:03 INFO:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "20:08:19 INFO:\n",
      "  | Name        | Type       | Params\n",
      "-------------------------------------------\n",
      "0 | blocker_net | BlockerNet | 7.4 M \n",
      "1 | loss_fn     | SupConLoss | 0     \n",
      "-------------------------------------------\n",
      "5.7 M     Trainable params\n",
      "1.7 M     Non-trainable params\n",
      "7.4 M     Total params\n",
      "29.454    Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation sanity check: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ceac78a9abc34eaca7f362f74966fa5b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "20:11:04 INFO:Loading the best validation model from tb_logs/amazon-google/version_8/checkpoints/epoch=13-step=1025.ckpt...\n"
     ]
    }
   ],
   "source": [
    "trainer = model.fit(\n",
    "    datamodule,\n",
    "    min_epochs=5,\n",
    "    max_epochs=100,\n",
    "    check_val_every_n_epoch=1,\n",
    "    early_stop_monitor=\"valid_recall_at_0.3\",\n",
    "    tb_save_dir='tb_logs',\n",
    "    tb_name='amazon-google',\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`LinkageEmbed.fit` keeps only the weights of the best validation model. With them, we can check the best performance on validation set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'valid_f1_at_0.3': 0.2175767918088737,\n",
       " 'valid_f1_at_0.5': 0.6325224071702945,\n",
       " 'valid_f1_at_0.7': 0.7824561403508772,\n",
       " 'valid_pair_entity_ratio_at_0.3': 2.2869660460021906,\n",
       " 'valid_pair_entity_ratio_at_0.5': 0.5750273822562979,\n",
       " 'valid_pair_entity_ratio_at_0.7': 0.343921139101862,\n",
       " 'valid_precision_at_0.3': 0.1221264367816092,\n",
       " 'valid_precision_at_0.5': 0.4704761904761905,\n",
       " 'valid_precision_at_0.7': 0.7101910828025477,\n",
       " 'valid_recall_at_0.3': 0.99609375,\n",
       " 'valid_recall_at_0.5': 0.96484375,\n",
       " 'valid_recall_at_0.7': 0.87109375}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.validate(datamodule)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can check which fields are most important for the final embedding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'title': 0.37132519483566284,\n",
       " 'title_semantic': 0.3634147346019745,\n",
       " 'manufacturer': 0.13500668108463287,\n",
       " 'price': 0.1302533894777298}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_pool_weights()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again with the best validation model, we can check the performance on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "20:11:06 INFO:Test positive pair count: 381\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'test_f1_at_0.3': 0.15837860426243208,\n",
       " 'test_f1_at_0.5': 0.5413870246085011,\n",
       " 'test_f1_at_0.7': 0.7184241019698725,\n",
       " 'test_pair_entity_ratio_at_0.3': 3.2176771365960555,\n",
       " 'test_pair_entity_ratio_at_0.5': 0.7012417823228634,\n",
       " 'test_pair_entity_ratio_at_0.7': 0.352081811541271,\n",
       " 'test_precision_at_0.3': 0.08603859250851305,\n",
       " 'test_precision_at_0.5': 0.378125,\n",
       " 'test_precision_at_0.7': 0.6431535269709544,\n",
       " 'test_recall_at_0.3': 0.994750656167979,\n",
       " 'test_recall_at_0.5': 0.952755905511811,\n",
       " 'test_recall_at_0.7': 0.8136482939632546}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.test(datamodule)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entity Embed achieves Recall of ~0.99 with Pair-Entity ratio below 100 on a variety of datasets. **Entity Embed aims for high recall at the expense of precision. Therefore, this library is suited for the Blocking/Indexing stage of an Entity Resolution pipeline.**  A scalabale and noise-tolerant Blocking procedure is often the main bottleneck for performance and quality on Entity Resolution pipelines, so this library aims to solve that. Note the ANN search on embedded records returns several candidate pairs that must be filtered to find the best matching pairs, possibly with a pairwise classifier. See [Matching](#Matching) section below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## t-sne visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize a small sample of the test embeddings and see if they look properly clustered. First, get the embedding vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a3381dd8e154475bb7b74089a2338914",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "# batch embedding:   0%|          | 0/22 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_left_vector_dict, test_right_vector_dict = model.predict(\n",
    "    record_dict=test_record_dict,\n",
    "    batch_size=eval_batch_size\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, produce the visualization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "vis_sample_size = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_vector_dict = {**test_left_vector_dict, **test_right_vector_dict}\n",
    "test_cluster_dict = utils.record_dict_to_cluster_dict(test_record_dict, cluster_field)\n",
    "vis_cluster_dict = dict(sorted(test_cluster_dict.items(), key=lambda x: len(x[1]), reverse=True)[:vis_sample_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "vis_x = np.stack([test_vector_dict[id_] for cluster in vis_cluster_dict.values() for id_ in cluster])\n",
    "vis_y = np.array([cluster_id for cluster_id, cluster in vis_cluster_dict.items() for __ in cluster])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.manifold import TSNE\n",
    "\n",
    "tnse = TSNE(metric='cosine', perplexity=20, square_distances=True, random_state=random_seed)\n",
    "tsne_results = tnse.fit_transform(vis_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import itertools\n",
    "\n",
    "plt.figure(figsize=(16,10))\n",
    "ax = sns.scatterplot(\n",
    "    x=tsne_results[:,0],\n",
    "    y=tsne_results[:,1],\n",
    "    hue=vis_y,\n",
    "    palette=sns.color_palette(\"hls\", len(vis_cluster_dict.keys())),\n",
    "    legend=\"full\",\n",
    "    alpha=0.8\n",
    ")\n",
    "for id_, (x, y) in zip(itertools.chain.from_iterable(vis_cluster_dict.values()), tsne_results):\n",
    "    # text = id_\n",
    "    text = test_record_dict[id_]['title'][:30]\n",
    "    ax.text(x + 2, y + 2, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing manually (like a production run)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When running in production, you only have access to the trained `model` object and the production `record_dict` (without the `cluster_field` filled, of course).\n",
    "\n",
    "So let's simulate that by removing `cluster_field` from the `test_record_dict`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "prod_test_record_dict = copy.deepcopy(test_record_dict)\n",
    "\n",
    "for record in prod_test_record_dict.values():\n",
    "    del record[cluster_field]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then call `predict_pairs` with some `ann_k` and `sim_threshold`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5e18e84aabbd4d8e9c0fbb8435cb0157",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "# batch embedding:   0%|          | 0/22 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4405"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim_threshold = 0.3\n",
    "\n",
    "found_pair_set = model.predict_pairs(\n",
    "    record_dict=prod_test_record_dict,\n",
    "    batch_size=eval_batch_size,\n",
    "    ann_k=ann_k,\n",
    "    sim_threshold=sim_threshold\n",
    ")\n",
    "len(found_pair_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check now the metrics of the found duplicate pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.2176771365960555"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from entity_embed.evaluation import pair_entity_ratio\n",
    "\n",
    "pair_entity_ratio(len(found_pair_set), len(prod_test_record_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.08603859250851305, 0.994750656167979)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from entity_embed.evaluation import precision_and_recall\n",
    "\n",
    "precision_and_recall(found_pair_set, datamodule.test_pos_pair_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same numbers of the `trainer.test`, so our manual testing is fine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can check the false positives and negatives to see if they're really difficult:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4026"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "false_positives = list(found_pair_set - datamodule.test_pos_pair_set)\n",
    "len(false_positives)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "false_negatives = list(datamodule.test_pos_pair_set - found_pair_set)\n",
    "len(false_negatives)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "cos_similarity = lambda a, b: np.dot(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.31519946,\n",
       " {'title': 'microsoft windows terminal server 2003 client additional license for users- 5 user',\n",
       "  'manufacturer': 'microsoft',\n",
       "  'price': '669'},\n",
       " {'title': 'microsoft academic microsoft office project 2003 standard',\n",
       "  'manufacturer': '',\n",
       "  'price': '69.95'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.3284967,\n",
       " {'title': 'captain america the complete comic collection win/mac',\n",
       "  'manufacturer': 'git corp',\n",
       "  'price': '49.95'},\n",
       " {'title': 'the sims expansion collection vol 1',\n",
       "  'manufacturer': '',\n",
       "  'price': '8.72'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.52083033,\n",
       " {'title': 'hoyle: classic collection 2006',\n",
       "  'manufacturer': 'encore',\n",
       "  'price': '19.99'},\n",
       " {'title': 'encore software 11050 - hoyle 4-pack 2006 - win 98 me 2000 xp',\n",
       "  'manufacturer': '',\n",
       "  'price': '18.97'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for (id_left, id_right) in false_positives[:3]:\n",
    "    display(\n",
    "        (\n",
    "            cos_similarity(test_left_vector_dict[id_left], test_right_vector_dict[id_right]),\n",
    "            utils.subdict(record_dict[id_left], field_list), utils.subdict(record_dict[id_right], field_list)\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.20618087,\n",
       " {'title': 'faxstf pro mac os 10.3.9 or above',\n",
       "  'manufacturer': 'aladdin systems',\n",
       "  'price': '49.99'},\n",
       " {'title': 'allume systems inc - stfmapbx2 - faxstf pro',\n",
       "  'manufacturer': '',\n",
       "  'price': '43.36'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.2653891,\n",
       " {'title': 'quickbooks premier manufacturer and wholesale edition 2007',\n",
       "  'manufacturer': 'intuit',\n",
       "  'price': '399.95'},\n",
       " {'title': 'intuit inc 299529 qb prem mfg & whlesle 07 (intuit inc 299529)',\n",
       "  'manufacturer': '',\n",
       "  'price': '335.99'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for (id_left, id_right) in false_negatives[:3]:\n",
    "    display(\n",
    "        (\n",
    "            cos_similarity(test_left_vector_dict[id_left], test_right_vector_dict[id_right]),\n",
    "            utils.subdict(record_dict[id_left], field_list), utils.subdict(record_dict[id_right], field_list)\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's still necessary to filter `found_pair_set` with a slower but more precise pairwise classifier.\n",
    "\n",
    "To do that, let's first save our model and data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tb_logs/amazon-google/version_8/checkpoints/epoch=13-step=1025.ckpt'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.trainer.checkpoint_callback.best_model_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir -p ../trained-models/notebooks/rl/\n",
    "!cp {model.trainer.checkpoint_callback.best_model_path} ../trained-models/notebooks/rl/rl-model.ckpt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('../trained-models/notebooks/rl/rl-train-records.json', 'w') as f:\n",
    "    json.dump(datamodule.train_record_dict, f, indent=4)\n",
    "\n",
    "with open('../trained-models/notebooks/rl/rl-valid-records.json', 'w') as f:\n",
    "    json.dump(datamodule.valid_record_dict, f, indent=4)\n",
    "\n",
    "with open('../trained-models/notebooks/rl/rl-test-records.json', 'w') as f:\n",
    "    json.dump(datamodule.test_record_dict, f, indent=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('../trained-models/notebooks/rl/rl-train-pos-pairs.json', 'w') as f:\n",
    "    json.dump([list(pair) for pair in datamodule.train_pos_pair_set], f, indent=4)\n",
    "\n",
    "with open('../trained-models/notebooks/rl/rl-valid-pos-pairs.json', 'w') as f:\n",
    "    json.dump([list(pair) for pair in datamodule.valid_pos_pair_set], f, indent=4)\n",
    "\n",
    "with open('../trained-models/notebooks/rl/rl-test-pos-pairs.json', 'w') as f:\n",
    "    json.dump([list(pair) for pair in datamodule.test_pos_pair_set], f, indent=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, let's proceed with matching on [End-to-End-Matching-Example.ipynb](./End-to-End-Matching-Example.ipynb)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}