From a2cf02b72bb4c382902a861d4366c5f075128f9c Mon Sep 17 00:00:00 2001
From: ashahzada <adnan@meetcleo.com>
Date: Mon, 24 Oct 2022 12:35:37 +0100
Subject: [PATCH 01/17] notebooks: added merchant deduplication notebook

---
 notebooks/Deduplication-merchants.ipynb | 2320 +++++++++++++++++++++++
 1 file changed, 2320 insertions(+)
 create mode 100755 notebooks/Deduplication-merchants.ipynb

diff --git a/notebooks/Deduplication-merchants.ipynb b/notebooks/Deduplication-merchants.ipynb
new file mode 100755
index 0000000..996a043
--- /dev/null
+++ b/notebooks/Deduplication-merchants.ipynb
@@ -0,0 +1,2320 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Deduplication 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": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from importlib import reload\n",
+    "import logging\n",
+    "import torch\n",
+    "import json\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",
+    "sys.path.insert(0, '..')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import entity_embed_local\n",
+    "from entity_embed_local import EntityEmbedLocal\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "torch.set_num_threads(1)\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "random_seed = 40\n",
+    "torch.manual_seed(random_seed)\n",
+    "np.random.seed(random_seed)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's download the CSV dataset to a temporary directory:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = pd.read_csv('data/alias_data.csv',names=['merchant_name','merchant_id','plaid_merchant','plaid_category','avg_tx_amount','count'])\n",
+    "dataset = data.groupby('merchant_id').head(200)\n",
+    "dataset.avg_tx_amount = dataset.avg_tx_amount.round()\n",
+    "dataset = dataset.astype(str)\n",
+    "# dataset = dataset[dataset.merchant_id.isin(dataset.merchant_id.unique()[:50000])]\n",
+    "dataset['cluster_id'] = pd.factorize(dataset['merchant_id'].tolist())[0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mapping = pd.Series(dataset.merchant_name.values,index=dataset.cluster_id).to_dict()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "record_dict = {}\n",
+    "cluster_field = 'cluster_id'\n",
+    "\n",
+    "for current_record_id, record in dataset[['cluster_id','merchant_name','plaid_merchant','plaid_category','avg_tx_amount']].iterrows():\n",
+    "    record['id'] = current_record_id\n",
+    "    record[cluster_field] = int(record[cluster_field])  # convert cluster_field to int\n",
+    "    record_dict[current_record_id] = record.to_dict()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "How many clusters this dataset has?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "35104"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cluster_total = len(set(record[cluster_field] for record in record_dict.values()))\n",
+    "cluster_total"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "From all clusters, we'll use only 50% for training, and other 15% for validation to test how well we can generalize:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "12:55:26 INFO:Singleton cluster sizes (train, valid, test):(18649, 4662, 7772)\n",
+      "12:55:26 INFO:Plural cluster sizes (train, valid, test):(2412, 603, 1006)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from 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.60,\n",
+    "    valid_proportion=0.15,\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": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(26719, 6591, 11098)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(train_record_dict), len(valid_record_dict), len(test_record_dict)"
+   ]
+  },
+  {
+   "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": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "field_list = ['merchant_name','plaid_merchant','plaid_category','avg_tx_amount']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'merchant_name': 'dutchbrosll',\n",
+       " 'plaid_merchant': 'dutch bros. coffee',\n",
+       " 'plaid_category': 'food and drink restaurants coffee shop',\n",
+       " 'avg_tx_amount': '-10.0'}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "utils.subdict(record_dict[2], field_list)"
+   ]
+  },
+  {
+   "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": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'0123456789abcdefghijklmnopqrstuvwxyz!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ '"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from 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": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "field_config_dict = {\n",
+    "    \n",
+    "    'merchant_name': {\n",
+    "        'field_type': \"MULTITOKEN\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'alphabet': alphabet,\n",
+    "        'max_str_len': None,  # compute\n",
+    "    },\n",
+    "\n",
+    "    'merchant_name_semantic': {\n",
+    "        'key': 'merchant_name',\n",
+    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'vocab': \"tx_embeddings_large.vec\",\n",
+    "        'max_str_len': None,  # compute\n",
+    "    },\n",
+    "     'avg_tx_amount': {\n",
+    "        'field_type': \"STRING\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'alphabet': alphabet,\n",
+    "        'max_str_len': None,  # compute\n",
+    "    },\n",
+    "    'avg_tx_amount_semantic': {\n",
+    "        'key':\"avg_tx_amount\",\n",
+    "        'field_type': \"SEMANTIC_STRING\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'vocab': \"tx_embeddings_large.vec\",\n",
+    "        'max_str_len': None,  # compute\n",
+    "    },\n",
+    "    'plaid_merchant': {\n",
+    "        'field_type': \"MULTITOKEN\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'alphabet': alphabet,\n",
+    "        'max_str_len': None,  # compute\n",
+    "    },\n",
+    "    'plaid_merchant_semantic': {\n",
+    "        'key': 'plaid_merchant',\n",
+    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'vocab': \"tx_embeddings_large.vec\",\n",
+    "    },\n",
+    "    'plaid_category': {\n",
+    "        'field_type': \"MULTITOKEN\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'alphabet': alphabet,\n",
+    "        'max_str_len': None,  # compute\n",
+    "    },\n",
+    "    'plaid_category_semantic': {\n",
+    "        'key': 'plaid_category',\n",
+    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
+    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
+    "        'vocab': \"tx_embeddings_large.vec\",\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": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "12:55:27 INFO:For field=merchant_name, computing actual max_str_len\n",
+      "12:55:27 INFO:actual_max_str_len=23 must be even to enable NN pooling. Updating to 24\n",
+      "12:55:27 INFO:For field=merchant_name, using actual_max_str_len=24\n",
+      "12:55:27 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n",
+      "12:55:29 INFO:For field=avg_tx_amount, computing actual max_str_len\n",
+      "12:55:29 INFO:For field=avg_tx_amount, using actual_max_str_len=8\n",
+      "12:55:29 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n",
+      "12:55:30 INFO:For field=plaid_merchant, computing actual max_str_len\n",
+      "12:55:30 INFO:actual_max_str_len=23 must be even to enable NN pooling. Updating to 24\n",
+      "12:55:30 INFO:For field=plaid_merchant, using actual_max_str_len=24\n",
+      "12:55:31 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n",
+      "12:55:32 INFO:For field=plaid_category, computing actual max_str_len\n",
+      "12:55:32 INFO:actual_max_str_len=17 must be even to enable NN pooling. Updating to 18\n",
+      "12:55:32 INFO:For field=plaid_category, using actual_max_str_len=18\n",
+      "12:55:32 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "from data_utils.field_config_parser 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": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from entity_embed import DeduplicationDataModule\n",
+    "\n",
+    "batch_size = 32\n",
+    "eval_batch_size = 64\n",
+    "datamodule = DeduplicationDataModule(\n",
+    "    train_record_dict=train_record_dict,\n",
+    "    valid_record_dict=valid_record_dict,\n",
+    "    test_record_dict=test_record_dict,\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",
+    "    train_loader_kwargs ={\"num_workers\":0,\"multiprocessing_context\":\"fork\"},\n",
+    "    eval_loader_kwargs ={\"num_workers\":0,\"multiprocessing_context\":\"fork\"},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We've used `DeduplicationDataModule` because we're doing Deduplication of a single dataset/table (a.k.a. Entity Clustering, Entity Resolution, etc.).\n",
+    "\n",
+    "We're NOT doing Record Linkage of two datasets here. Check the other notebook [Record-Linkage-Example](./Record-Linkage-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 `EntityEmbed` model object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "setting embedding size to 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "from entity_embed_local import EntityEmbedLocal\n",
+    "\n",
+    "ann_k = 15\n",
+    "model = EntityEmbedLocal(\n",
+    "    record_numericalizer,\n",
+    "    ann_k=ann_k,\n",
+    "    embedding_size=100,\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 `EntityEmbed.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": 30,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13:50:27 INFO:GPU available: False, used: False\n",
+      "13:50:27 INFO:TPU available: False, using: 0 TPU cores\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calling up trainer....\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13:51:20 INFO:\n",
+      "  | Name        | Type       | Params\n",
+      "-------------------------------------------\n",
+      "0 | blocker_net | BlockerNet | 6.6 M \n",
+      "1 | loss_fn     | SupConLoss | 0     \n",
+      "-------------------------------------------\n",
+      "2.3 M     Trainable params\n",
+      "4.3 M     Non-trainable params\n",
+      "6.6 M     Total params\n",
+      "26.554    Total estimated model params size (MB)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4: 100%|██████████| 1019/1019 [04:07<00:00,  4.12it/s, loss=0.818, v_num=27]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "14:10:50 INFO:Loading the best validation model from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/models/epoch=1-step=1832-v7.ckpt...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "setting embedding size to 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "trainer = model.fit(\n",
+    "    datamodule,\n",
+    "    min_epochs=2,\n",
+    "    max_epochs=5,\n",
+    "    check_val_every_n_epoch=1,\n",
+    "    early_stop_monitor=\"valid_recall_at_0.7\",\n",
+    "    model_save_dir='models',\n",
+    "    use_gpu=False,\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# !mkdir -p models/entityembed\n",
+    "!cp {model.trainer.checkpoint_callback.best_model_path} models/entityembed/ee-model.ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path = \"models/entityembed/\"\n",
+    "\n",
+    "with open(path+ 'ee-train-records.json', 'w') as f:\n",
+    "    json.dump(datamodule.train_record_dict, f, indent=4)\n",
+    "\n",
+    "with open(path+ 'ee-valid-records.json', 'w') as f:\n",
+    "    json.dump(datamodule.valid_record_dict, f, indent=4)\n",
+    "\n",
+    "with open(path+ 'ee-test-records.json', 'w') as f:\n",
+    "    json.dump(datamodule.test_record_dict, f, indent=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "setting embedding size to 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = EntityEmbedLocal.load_from_checkpoint('models/epoch=1-step=1832-v7.ckpt')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`EntityEmbed.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": 31,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'valid_f1_at_0.3': 0.0,\n",
+       " 'valid_f1_at_0.5': 0.0,\n",
+       " 'valid_f1_at_0.7': 0.0,\n",
+       " 'valid_pair_entity_ratio_at_0.3': 10.15106931594115,\n",
+       " 'valid_pair_entity_ratio_at_0.5': 4.946155012892461,\n",
+       " 'valid_pair_entity_ratio_at_0.7': 1.6895191870165327,\n",
+       " 'valid_precision_at_0.3': 0.0,\n",
+       " 'valid_precision_at_0.5': 0.0,\n",
+       " 'valid_precision_at_0.7': 0.0,\n",
+       " 'valid_recall_at_0.3': 0.0,\n",
+       " 'valid_recall_at_0.5': 0.0,\n",
+       " 'valid_recall_at_0.7': 0.0}"
+      ]
+     },
+     "execution_count": 31,
+     "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": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'merchant_name': 0.2551257014274597,\n",
+       " 'merchant_name_semantic': 0.22146005928516388,\n",
+       " 'avg_tx_amount': 0.03779561445116997,\n",
+       " 'avg_tx_amount_semantic': 0.24249973893165588,\n",
+       " 'plaid_merchant': 0.07616355270147324,\n",
+       " 'plaid_merchant_semantic': 0.060125213116407394,\n",
+       " 'plaid_category': 0.07688859850168228,\n",
+       " 'plaid_category_semantic': 0.02994149550795555}"
+      ]
+     },
+     "execution_count": 28,
+     "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": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "16:57:02 INFO:Test positive pair count: 30657\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'test_f1_at_0.3': 0.0,\n",
+       " 'test_f1_at_0.5': 0.0,\n",
+       " 'test_f1_at_0.7': 0.0,\n",
+       " 'test_pair_entity_ratio_at_0.3': 17.187250554323725,\n",
+       " 'test_pair_entity_ratio_at_0.5': 5.513303769401331,\n",
+       " 'test_pair_entity_ratio_at_0.7': 2.3838137472283814,\n",
+       " 'test_precision_at_0.3': 0.0,\n",
+       " 'test_precision_at_0.5': 0.0,\n",
+       " 'test_precision_at_0.7': 0.0,\n",
+       " 'test_recall_at_0.3': 0.0,\n",
+       " 'test_recall_at_0.5': 0.0,\n",
+       " 'test_recall_at_0.7': 0.0}"
+      ]
+     },
+     "execution_count": 30,
+     "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 the [Record-Linkage-Example](./Record-Linkage-Example.ipynb) for an example of matching."
+   ]
+  },
+  {
+   "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": 102,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "# batch embedding: 100%|██████████| 286/286 [00:57<00:00,  4.95it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_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": 103,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vis_sample_size = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n=20\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)[n:vis_sample_size+n])\n",
+    "\n",
+    "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": 105,
+   "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": 107,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "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",
+    "import random\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_]['alias'][:25]\n",
+    "    ax.text(x + 2 , y + 2+ (5*random.random()), 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": 20,
+   "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": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prod_test_record_dict = {}\n",
+    "\n",
+    "merchants_list = pd.read_csv('data/us_companies.csv', header=None,names=['merchant_name']).iloc[:,0].tolist()\n",
+    "merchants_list\n",
+    "\n",
+    "merchants = pd.read_csv('data/merchants_list.csv',names=[\"merchant_name\",\"merchant_id\",\"plaid_merchant\",\"plaid_category\",\"avg_tx_amount\",\"count\"])\n",
+    "merchants = merchants.sort_values('count', ascending=False).drop_duplicates(['merchant_name','merchant_id'])\n",
+    "merchants.avg_tx_amount = merchants.avg_tx_amount.round()\n",
+    "merchants = merchants.apply(lambda x: x.astype(str).str.lower()).reset_index()\n",
+    "for current_record_id, record in merchants.iterrows():\n",
+    "    prod_test_record_dict[current_record_id] = record.to_dict()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then call `predict_pairs` with some `ann_k` and `sim_threshold`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "# batch embedding:  69%|██████▉   | 410/592 [00:39<00:19,  9.19it/s]12:56:38 WARNING:Found out of alphabet char at val=döner, char=ö\n",
+      "# batch embedding:  84%|████████▍ | 497/592 [00:48<00:08, 11.22it/s]12:56:47 WARNING:Found out of alphabet char at val=côte, char=ô\n",
+      "# batch embedding: 100%|██████████| 592/592 [00:56<00:00, 10.52it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "72547"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sim_threshold = 0.85\n",
+    "ann_k=15\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": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "37865"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total_merchants = merchants.merchant_name.nunique()\n",
+    "total_merchants\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "idf_df = pd.read_csv('data/idf_weights.csv')\n",
+    "idf_weights = dict(zip(idf_df.token,idf_df.idf))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 291,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calculate_genericity(tokens_left,tokens_right):\n",
+    "    tokens = tokens_left + tokens_right\n",
+    "    return  (sum([1-idf_weights.get(t,1) for t in tokens])/len(tokens))\n",
+    "\n",
+    "def calculate_amount_similarity(l_amount, r_amount):\n",
+    "    if max(l_amount,r_amount) == 0 or l_amount * r_amount < 0:\n",
+    "        return False\n",
+    "    l_amount, r_amount = (abs(n) for n in (l_amount, r_amount))\n",
+    "    is_different_bracket = abs(l_amount - r_amount) > 10\n",
+    "    is_ratio_large = (min(l_amount , r_amount)/ max(l_amount , r_amount)) < 0.8\n",
+    "    return is_different_bracket or is_ratio_large\n",
+    "# calculate_genericity(prod_test_record_dict.get(3256)['merchant_name'].split(),prod_test_record_dict.get(12722)['merchant_name'].split())\n",
+    "# calculate_amount_similarity(82.0, -100.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 302,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "06ea0405b6e04d07801df03e080afd60",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/72547 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from scipy.sparse import csr_matrix\n",
+    "from scipy.sparse.csgraph import connected_components\n",
+    "from tqdm.notebook import tqdm\n",
+    "\n",
+    "graph = np.zeros((total_merchants,total_merchants))\n",
+    "\n",
+    "for (id_left, id_right, similarity) in tqdm(list(found_pair_set)):\n",
+    "    is_different_category = prod_test_record_dict.get(id_left)['plaid_category'].strip() != prod_test_record_dict.get(id_right)['plaid_category'].strip()\n",
+    "    genericity = calculate_genericity(prod_test_record_dict.get(id_left)['merchant_name'].split(),prod_test_record_dict.get(id_right)['merchant_name'].split())\n",
+    "    is_avg_amount_different= calculate_amount_similarity(float(prod_test_record_dict.get(id_left)['avg_tx_amount']),float(prod_test_record_dict.get(id_left)['avg_tx_amount']))\n",
+    "    score = similarity - (is_different_category * 0.1) - (0.5 * genericity) - (is_avg_amount_different * 0.05)\n",
+    "    \n",
+    "    if score >0.85 :\n",
+    "        # print(prod_test_record_dict.get(id_left))\n",
+    "        # print(prod_test_record_dict.get(id_right))\n",
+    "        # print(score)\n",
+    "        # print(\"------------------\")\n",
+    "        graph[id_left,id_right] = 1\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 304,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph = csr_matrix(graph)\n",
+    "# print(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 305,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(35960, array([    0,     1,     2, ..., 35957, 35958, 35959], dtype=int32))"
+      ]
+     },
+     "execution_count": 305,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n",
+    "(n_components,labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 306,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ad663eec48b6484ca04d314230c8836a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/37865 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dup_cluster = []\n",
+    "for i in tqdm(range(len(labels))):\n",
+    "    dupes = list(np.where(labels==i)[0])\n",
+    "    if len(dupes) > 1:\n",
+    "        dup_cluster.append([prod_test_record_dict.get(key) for key in dupes])\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'\\n'.join(pd.Series(dup_cluster).iloc[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 337,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pandas import option_context\n",
+    "\n",
+    "with option_context('display.max_colwidth', 400):\n",
+    "    (pd.DataFrame(dup_cluster).apply(lambda x: '\\n'.join(x.dropna().astype(str)), axis=1)).to_csv('data/dupes.csv')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.6537699722699062"
+      ]
+     },
+     "execution_count": 32,
+     "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": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's check now the metrics of the found duplicate pairs:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cos_similarity = lambda a, b: np.dot(a, b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fields = ['merchant_name',\n",
+    " 'plaid_merchant',\n",
+    " 'plaid_category',\n",
+    " 'avg_tx_amount','count']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9f613bd140204935badae4f6c7c1a079",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/72542 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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>matching_similarity</th>\n",
+       "      <th>merchant</th>\n",
+       "      <th>matched_merchant</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.915286</td>\n",
+       "      <td>{'merchant_name': 'carroll county', 'plaid_mer...</td>\n",
+       "      <td>(carroll emc, -24.0, 26)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.868136</td>\n",
+       "      <td>{'merchant_name': 'express fuels', 'plaid_merc...</td>\n",
+       "      <td>(express nails, -70.0, 14)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.905586</td>\n",
+       "      <td>{'merchant_name': 'white', 'plaid_merchant': '...</td>\n",
+       "      <td>(white hart inn, -8.0, 1)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.961777</td>\n",
+       "      <td>{'merchant_name': 'poke city', 'plaid_merchant...</td>\n",
+       "      <td>(poke poku, -24.0, 7)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.977440</td>\n",
+       "      <td>{'merchant_name': 'new china fun', 'plaid_merc...</td>\n",
+       "      <td>(new china restaurant, -22.0, 323)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>72537</th>\n",
+       "      <td>0.865486</td>\n",
+       "      <td>{'merchant_name': 'los', 'plaid_merchant': 'na...</td>\n",
+       "      <td>(los cabos, -60.0, 35)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>72538</th>\n",
+       "      <td>0.926597</td>\n",
+       "      <td>{'merchant_name': 'mega bev', 'plaid_merchant'...</td>\n",
+       "      <td>(mega liquor, -22.0, 121)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>72539</th>\n",
+       "      <td>0.902664</td>\n",
+       "      <td>{'merchant_name': 'village inn pizza', 'plaid_...</td>\n",
+       "      <td>(village restaurant, -20.0, 20)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>72540</th>\n",
+       "      <td>0.882056</td>\n",
+       "      <td>{'merchant_name': 'el amigo', 'plaid_merchant'...</td>\n",
+       "      <td>(el sol, -20.0, 19)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>72541</th>\n",
+       "      <td>0.859562</td>\n",
+       "      <td>{'merchant_name': 'campus bo', 'plaid_merchant...</td>\n",
+       "      <td>(campus bookstor building, -236.0, 5)</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>72542 rows × 3 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       matching_similarity                                           merchant  \\\n",
+       "0                 0.915286  {'merchant_name': 'carroll county', 'plaid_mer...   \n",
+       "1                 0.868136  {'merchant_name': 'express fuels', 'plaid_merc...   \n",
+       "2                 0.905586  {'merchant_name': 'white', 'plaid_merchant': '...   \n",
+       "3                 0.961777  {'merchant_name': 'poke city', 'plaid_merchant...   \n",
+       "4                 0.977440  {'merchant_name': 'new china fun', 'plaid_merc...   \n",
+       "...                    ...                                                ...   \n",
+       "72537             0.865486  {'merchant_name': 'los', 'plaid_merchant': 'na...   \n",
+       "72538             0.926597  {'merchant_name': 'mega bev', 'plaid_merchant'...   \n",
+       "72539             0.902664  {'merchant_name': 'village inn pizza', 'plaid_...   \n",
+       "72540             0.882056  {'merchant_name': 'el amigo', 'plaid_merchant'...   \n",
+       "72541             0.859562  {'merchant_name': 'campus bo', 'plaid_merchant...   \n",
+       "\n",
+       "                            matched_merchant  \n",
+       "0                   (carroll emc, -24.0, 26)  \n",
+       "1                 (express nails, -70.0, 14)  \n",
+       "2                  (white hart inn, -8.0, 1)  \n",
+       "3                      (poke poku, -24.0, 7)  \n",
+       "4         (new china restaurant, -22.0, 323)  \n",
+       "...                                      ...  \n",
+       "72537                 (los cabos, -60.0, 35)  \n",
+       "72538              (mega liquor, -22.0, 121)  \n",
+       "72539        (village restaurant, -20.0, 20)  \n",
+       "72540                    (el sol, -20.0, 19)  \n",
+       "72541  (campus bookstor building, -236.0, 5)  \n",
+       "\n",
+       "[72542 rows x 3 columns]"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from tqdm.notebook import tqdm\n",
+    "duplicates = pd.DataFrame(columns=['matching_similarity','merchant','matched_merchant'])\n",
+    "for (id_left, id_right, similarity) in tqdm(list(found_pair_set)):\n",
+    "    merchant_a = utils.subdict(prod_test_record_dict[id_left], fields)\n",
+    "    merchant_b = utils.subdict(prod_test_record_dict[id_right], fields)\n",
+    "    duplicates = duplicates.append({'matching_similarity':similarity,'merchant':merchant_a,'matched_merchant':(merchant_b['merchant_name'],merchant_b['avg_tx_amount'],merchant_b['count'])},ignore_index=True)\n",
+    "\n",
+    "duplicates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/adnanshahzada/opt/miniconda3/envs/entity-embed-env/lib/python3.8/site-packages/pandas/core/generic.py:5516: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  self[name] = value\n"
+     ]
+    },
+    {
+     "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>matching_similarity</th>\n",
+       "      <th>matched_merchant</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>merchant</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': \"america''s best\", 'plaid_merchant': \"america''s best\", 'plaid_category': 'food and drink restaurants ', 'avg_tx_amount': '-107.0', 'count': '1341'}</th>\n",
+       "      <td>[0.931]</td>\n",
+       "      <td>[(america''s best wings, -22.0, 281)]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': \"auntie anne''s\", 'plaid_merchant': \"auntie anne''s\", 'plaid_category': 'food and drink restaurants ', 'avg_tx_amount': '-10.0', 'count': '22971'}</th>\n",
+       "      <td>[0.981, 0.978]</td>\n",
+       "      <td>[(auntie annes, -11.0, 17), (auntie annies, -8...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': \"bahama buck''s\", 'plaid_merchant': \"bahama buck''s tx\", 'plaid_category': 'shops clothing and accessories ', 'avg_tx_amount': '-10.0', 'count': '39'}</th>\n",
+       "      <td>[0.952]</td>\n",
+       "      <td>[(bahama bucks, -11.0, 437)]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': \"baker''s dozen\", 'plaid_merchant': \"baker''s dozen\", 'plaid_category': 'shops food and beverage store ', 'avg_tx_amount': '-12.0', 'count': '4'}</th>\n",
+       "      <td>[0.901]</td>\n",
+       "      <td>[(baker''s iga, -24.0, 21)]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': \"bill''s liquor\", 'plaid_merchant': \"bill''s liquor\", 'plaid_category': 'shops food and beverage store ', 'avg_tx_amount': '-23.0', 'count': '19'}</th>\n",
+       "      <td>[0.921]</td>\n",
+       "      <td>[(bill''s superette, -15.0, 232)]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': 'zoom management', 'plaid_merchant': 'nan', 'plaid_category': 'service  ', 'avg_tx_amount': '-30.0', 'count': '22'}</th>\n",
+       "      <td>[0.903, 0.962, 0.935]</td>\n",
+       "      <td>[(zoom tan, -23.0, 208), (zoom mart, -19.0, 14...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': 'zoom mart', 'plaid_merchant': 'nan', 'plaid_category': 'service  ', 'avg_tx_amount': '-19.0', 'count': '14'}</th>\n",
+       "      <td>[0.95, 0.926]</td>\n",
+       "      <td>[(zoom.us, -16.0, 513), (zoom tan, -23.0, 208)]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': 'zoom tan', 'plaid_merchant': 'zoom tan', 'plaid_category': 'service personal care ', 'avg_tx_amount': '-23.0', 'count': '208'}</th>\n",
+       "      <td>[0.927]</td>\n",
+       "      <td>[(zoom.us, -16.0, 513)]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': 'zoom', 'plaid_merchant': 'nan', 'plaid_category': 'service  ', 'avg_tx_amount': '-19.0', 'count': '99'}</th>\n",
+       "      <td>[0.964, 0.985, 0.966, 0.933, 0.922, 0.969]</td>\n",
+       "      <td>[(zoom.us, -16.0, 513), (zoom mart, -19.0, 14)...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>{'merchant_name': 'zt', 'plaid_merchant': 'nan', 'plaid_category': 'transfer debit ', 'avg_tx_amount': '-11.0', 'count': '139'}</th>\n",
+       "      <td>[0.98]</td>\n",
+       "      <td>[(zt 645, -12.0, 14)]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>9918 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                                           matching_similarity  \\\n",
+       "merchant                                                                                         \n",
+       "{'merchant_name': \"america''s best\", 'plaid_mer...                                     [0.931]   \n",
+       "{'merchant_name': \"auntie anne''s\", 'plaid_merc...                              [0.981, 0.978]   \n",
+       "{'merchant_name': \"bahama buck''s\", 'plaid_merc...                                     [0.952]   \n",
+       "{'merchant_name': \"baker''s dozen\", 'plaid_merc...                                     [0.901]   \n",
+       "{'merchant_name': \"bill''s liquor\", 'plaid_merc...                                     [0.921]   \n",
+       "...                                                                                        ...   \n",
+       "{'merchant_name': 'zoom management', 'plaid_mer...                       [0.903, 0.962, 0.935]   \n",
+       "{'merchant_name': 'zoom mart', 'plaid_merchant'...                               [0.95, 0.926]   \n",
+       "{'merchant_name': 'zoom tan', 'plaid_merchant':...                                     [0.927]   \n",
+       "{'merchant_name': 'zoom', 'plaid_merchant': 'na...  [0.964, 0.985, 0.966, 0.933, 0.922, 0.969]   \n",
+       "{'merchant_name': 'zt', 'plaid_merchant': 'nan'...                                      [0.98]   \n",
+       "\n",
+       "                                                                                     matched_merchant  \n",
+       "merchant                                                                                               \n",
+       "{'merchant_name': \"america''s best\", 'plaid_mer...              [(america''s best wings, -22.0, 281)]  \n",
+       "{'merchant_name': \"auntie anne''s\", 'plaid_merc...  [(auntie annes, -11.0, 17), (auntie annies, -8...  \n",
+       "{'merchant_name': \"bahama buck''s\", 'plaid_merc...                       [(bahama bucks, -11.0, 437)]  \n",
+       "{'merchant_name': \"baker''s dozen\", 'plaid_merc...                        [(baker''s iga, -24.0, 21)]  \n",
+       "{'merchant_name': \"bill''s liquor\", 'plaid_merc...                  [(bill''s superette, -15.0, 232)]  \n",
+       "...                                                                                               ...  \n",
+       "{'merchant_name': 'zoom management', 'plaid_mer...  [(zoom tan, -23.0, 208), (zoom mart, -19.0, 14...  \n",
+       "{'merchant_name': 'zoom mart', 'plaid_merchant'...    [(zoom.us, -16.0, 513), (zoom tan, -23.0, 208)]  \n",
+       "{'merchant_name': 'zoom tan', 'plaid_merchant':...                            [(zoom.us, -16.0, 513)]  \n",
+       "{'merchant_name': 'zoom', 'plaid_merchant': 'na...  [(zoom.us, -16.0, 513), (zoom mart, -19.0, 14)...  \n",
+       "{'merchant_name': 'zt', 'plaid_merchant': 'nan'...                              [(zt 645, -12.0, 14)]  \n",
+       "\n",
+       "[9918 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "duplicates_strong = duplicates[duplicates.matching_similarity>0.9]\n",
+    "duplicates_strong.matching_similarity = duplicates_strong.matching_similarity.apply(lambda x: round(x,3))\n",
+    "duplicates_strong.merchant = duplicates_strong.merchant.astype(str)\n",
+    "result =duplicates_strong.groupby('merchant').agg(lambda x: list(x))\n",
+    "result.to_csv('data/duplicate_merchants_ct.csv')\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('Baho Convenience Store', False),\n",
+       " ('Hilton Payroll', False),\n",
+       " ('Fast Shop', False),\n",
+       " ('Imperial Mart', False),\n",
+       " ('Bitterroot Beanery', False),\n",
+       " ('Piedmont Natural Gas', False),\n",
+       " ('The Island Shoppe', False),\n",
+       " ('Americas Best Wings', False),\n",
+       " ('Rockland Nails', False),\n",
+       " ('Irobot Corporation', False),\n",
+       " ('Khalil`s Food & Liquor', False),\n",
+       " ('Quality Auto Repair', False),\n",
+       " ('Jackpot Mini Mart', False),\n",
+       " ('Westside Convenience', False),\n",
+       " ('H And M Mini Sto', False),\n",
+       " ('Patel Corner Pantry', False),\n",
+       " ('Guys Pizza Downtown', False),\n",
+       " ('Xingyu Restaurant Inc', False),\n",
+       " ('5801 Video Lounge & Caf', False),\n",
+       " ('Just Salad', True)]"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "idx_a += 20\n",
+    "idx_b += 20\n",
+    "[(r,r in merchants_list) for  r in dataset.iloc[idx_a:idx_b,:]['merchant_name'].tolist()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 144,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.7512554540215691, 0.12059282165133735)"
+      ]
+     },
+     "execution_count": 144,
+     "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": 145,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12086"
+      ]
+     },
+     "execution_count": 145,
+     "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": 146,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "266186"
+      ]
+     },
+     "execution_count": 146,
+     "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": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "true_positives = list(found_pair_set - datamodule.test_pos_pair_set)\n",
+    "len(false_positives)\n",
+    "for (id_left, id_right) in list(found_pair_set)[:10]:\n",
+    "    display(\n",
+    "        (\n",
+    "            record_dict[id_left],\n",
+    "            record_dict[id_right],\n",
+    "            cos_similarity(test_vector_dict[id_left], test_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": 147,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.87486815,\n",
+       " {'alias': 'r&b tea', 'plaid_merchant': 'r&b tea', 'avg_tx_amount': '-6.35'},\n",
+       " {'alias': 'r & gs food basket',\n",
+       "  'plaid_merchant': 'r & gs food basket',\n",
+       "  'avg_tx_amount': '-21.83'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.8825392,\n",
+       " {'alias': 'country wide insurance',\n",
+       "  'plaid_merchant': 'country wide insurance',\n",
+       "  'avg_tx_amount': '-284.13'},\n",
+       " {'alias': 'country convenie',\n",
+       "  'plaid_merchant': 'country convenie',\n",
+       "  'avg_tx_amount': '-14.1'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.905407,\n",
+       " {'alias': 'china town 1', 'plaid_merchant': 'nan', 'avg_tx_amount': '-25.0'},\n",
+       " {'alias': 'china delight chinese',\n",
+       "  'plaid_merchant': 'china delight chinese',\n",
+       "  'avg_tx_amount': '-21.56'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.70510805,\n",
+       " {'alias': 'blue bay',\n",
+       "  'plaid_merchant': 'blue bay',\n",
+       "  'avg_tx_amount': '-12.96'},\n",
+       " {'alias': 'blue moon tap house',\n",
+       "  'plaid_merchant': 'blue moon tap house',\n",
+       "  'avg_tx_amount': '-26.07'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9555845,\n",
+       " {'alias': 'lincoln highway',\n",
+       "  'plaid_merchant': 'lincoln highway',\n",
+       "  'avg_tx_amount': '-11.24'},\n",
+       " {'alias': 'lincoln c mart',\n",
+       "  'plaid_merchant': 'lincoln c mart',\n",
+       "  'avg_tx_amount': '-24.99'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.95284754,\n",
+       " {'alias': 'quick pick grocery ltd',\n",
+       "  'plaid_merchant': 'nan',\n",
+       "  'avg_tx_amount': '-8.98'},\n",
+       " {'alias': 'quick pick atlanta',\n",
+       "  'plaid_merchant': 'quick pick',\n",
+       "  'avg_tx_amount': '-5.26'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.8914383,\n",
+       " {'alias': 'china gourmet house',\n",
+       "  'plaid_merchant': 'china gourmet house',\n",
+       "  'avg_tx_amount': '-23.85'},\n",
+       " {'alias': 'china town 1', 'plaid_merchant': 'nan', 'avg_tx_amount': '-36.75'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9162289,\n",
+       " {'alias': 'taco heads fort worth',\n",
+       "  'plaid_merchant': 'taco heads fort worth',\n",
+       "  'avg_tx_amount': '-18.76'},\n",
+       " {'alias': 'taco monster',\n",
+       "  'plaid_merchant': 'taco monster',\n",
+       "  'avg_tx_amount': '-29.71'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.95120347,\n",
+       " {'alias': 'noodles pho u',\n",
+       "  'plaid_merchant': 'noodles pho u',\n",
+       "  'avg_tx_amount': '-33.58'},\n",
+       " {'alias': 'noodles & company',\n",
+       "  'plaid_merchant': 'noodles & company',\n",
+       "  'avg_tx_amount': '-30.15'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9241347,\n",
+       " {'alias': 'noodles and dumplings',\n",
+       "  'plaid_merchant': 'noodles and dumplings',\n",
+       "  'avg_tx_amount': '-48.14'},\n",
+       " {'alias': 'noodles & company',\n",
+       "  'plaid_merchant': 'noodles & company',\n",
+       "  'avg_tx_amount': '-8.7'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for (id_left, id_right) in false_positives[:10]:\n",
+    "    display(\n",
+    "        (\n",
+    "            cos_similarity(test_vector_dict[id_left], test_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": 149,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.99850756,\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-20.42'},\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-18.5'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99695677,\n",
+       " {'alias': 'rent-a-center',\n",
+       "  'plaid_merchant': 'rent-a-center',\n",
+       "  'avg_tx_amount': '-121.85'},\n",
+       " {'alias': 'rent-a-center',\n",
+       "  'plaid_merchant': 'rent-a-center',\n",
+       "  'avg_tx_amount': '-38.35'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9966733,\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-17.18'},\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-26.18'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.97021323,\n",
+       " {'alias': 'cardtronics', 'plaid_merchant': 'nan', 'avg_tx_amount': '-43.5'},\n",
+       " {'alias': 'cardtronics',\n",
+       "  'plaid_merchant': 'cardtronics',\n",
+       "  'avg_tx_amount': '-41.16'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9971533,\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-23.7'},\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-7.62'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99700713,\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-18.72'},\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-20.54'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9975728,\n",
+       " {'alias': \"dave & buster''s\",\n",
+       "  'plaid_merchant': 'dave & busters',\n",
+       "  'avg_tx_amount': '-35.75'},\n",
+       " {'alias': \"dave & buster''s\",\n",
+       "  'plaid_merchant': 'dave & busters',\n",
+       "  'avg_tx_amount': '-77.44'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9961077,\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-14.02'},\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-9.2'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99612856,\n",
+       " {'alias': \"dave & buster''s\",\n",
+       "  'plaid_merchant': 'dave & busters',\n",
+       "  'avg_tx_amount': '-46.28'},\n",
+       " {'alias': \"dave & buster''s\",\n",
+       "  'plaid_merchant': \"dave & buster''s\",\n",
+       "  'avg_tx_amount': '-33.63'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9968643,\n",
+       " {'alias': 'tractor supply',\n",
+       "  'plaid_merchant': 'tractor supply',\n",
+       "  'avg_tx_amount': '-28.6'},\n",
+       " {'alias': 'tractor supply',\n",
+       "  'plaid_merchant': 'tractor supply',\n",
+       "  'avg_tx_amount': '-54.1'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9972248,\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-32.71'},\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-10.57'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9969662,\n",
+       " {'alias': 'cardtronics',\n",
+       "  'plaid_merchant': 'cardtronics',\n",
+       "  'avg_tx_amount': '-184.65'},\n",
+       " {'alias': 'cardtronics',\n",
+       "  'plaid_merchant': 'cardtronics',\n",
+       "  'avg_tx_amount': '-52.5'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9916726,\n",
+       " {'alias': 'urban air killeen',\n",
+       "  'plaid_merchant': 'urban air killeen',\n",
+       "  'avg_tx_amount': '-36.15'},\n",
+       " {'alias': 'urban air',\n",
+       "  'plaid_merchant': 'urban air',\n",
+       "  'avg_tx_amount': '-19.75'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9962817,\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-98.06'},\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-10.69'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.997394,\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-5.0'},\n",
+       " {'alias': 'stop & shop',\n",
+       "  'plaid_merchant': 'stop & shop',\n",
+       "  'avg_tx_amount': '-7.48'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99658275,\n",
+       " {'alias': 'rent-a-center',\n",
+       "  'plaid_merchant': 'rent-a-center',\n",
+       "  'avg_tx_amount': '-152.17'},\n",
+       " {'alias': 'rent-a-center',\n",
+       "  'plaid_merchant': 'rent-a-center',\n",
+       "  'avg_tx_amount': '-344.69'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99650383,\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-24.02'},\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-6.12'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.997722,\n",
+       " {'alias': 'krispy kreme',\n",
+       "  'plaid_merchant': 'krispy kreme',\n",
+       "  'avg_tx_amount': '-12.15'},\n",
+       " {'alias': 'krispy kreme',\n",
+       "  'plaid_merchant': 'krispy kreme',\n",
+       "  'avg_tx_amount': '-11.94'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99689335,\n",
+       " {'alias': 'rent-a-center',\n",
+       "  'plaid_merchant': 'rent-a-center',\n",
+       "  'avg_tx_amount': '-8.94'},\n",
+       " {'alias': 'rent-a-center',\n",
+       "  'plaid_merchant': 'rent-a-center',\n",
+       "  'avg_tx_amount': '-58.77'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9976802,\n",
+       " {'alias': 'cardtronics',\n",
+       "  'plaid_merchant': 'cardtronics',\n",
+       "  'avg_tx_amount': '-40.0'},\n",
+       " {'alias': 'cardtronics',\n",
+       "  'plaid_merchant': 'cardtronics',\n",
+       "  'avg_tx_amount': '-52.72'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99777186,\n",
+       " {'alias': 'chipotle mexican grill',\n",
+       "  'plaid_merchant': 'chipotle mexican grill',\n",
+       "  'avg_tx_amount': '-14.17'},\n",
+       " {'alias': 'chipotle mexican grill',\n",
+       "  'plaid_merchant': 'chipotle mexican grill',\n",
+       "  'avg_tx_amount': '-12.07'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9955483,\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-12.93'},\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-23.91'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9961946,\n",
+       " {'alias': \"dave & buster''s\",\n",
+       "  'plaid_merchant': \"dave & buster''s\",\n",
+       "  'avg_tx_amount': '-38.62'},\n",
+       " {'alias': \"dave & buster''s\",\n",
+       "  'plaid_merchant': \"dave & buster''s\",\n",
+       "  'avg_tx_amount': '-70.86'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9975935,\n",
+       " {'alias': 'holiday inn',\n",
+       "  'plaid_merchant': 'holiday inn',\n",
+       "  'avg_tx_amount': '-296.98'},\n",
+       " {'alias': 'holiday inn',\n",
+       "  'plaid_merchant': 'holiday inn',\n",
+       "  'avg_tx_amount': '-39.1'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9973572,\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-48.81'},\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-8.24'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.99457943,\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-12.56'},\n",
+       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-36.24'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9984803,\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-25.21'},\n",
+       " {'alias': 'kwik trip',\n",
+       "  'plaid_merchant': 'kwik trip',\n",
+       "  'avg_tx_amount': '-28.34'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.97368807,\n",
+       " {'alias': 'cardtronics', 'plaid_merchant': 'nan', 'avg_tx_amount': '-51.75'},\n",
+       " {'alias': 'cardtronics',\n",
+       "  'plaid_merchant': 'cardtronics',\n",
+       "  'avg_tx_amount': '-89.69'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9977134,\n",
+       " {'alias': 'gulf oil',\n",
+       "  'plaid_merchant': 'gulf oil',\n",
+       "  'avg_tx_amount': '-19.08'},\n",
+       " {'alias': 'gulf oil',\n",
+       "  'plaid_merchant': 'gulf oil',\n",
+       "  'avg_tx_amount': '-34.91'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(0.9969918,\n",
+       " {'alias': 'marshalls',\n",
+       "  'plaid_merchant': 'marshalls',\n",
+       "  'avg_tx_amount': '-76.19'},\n",
+       " {'alias': 'marshalls',\n",
+       "  'plaid_merchant': 'marshalls',\n",
+       "  'avg_tx_amount': '-43.74'})"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for (id_left, id_right) in false_negatives[:30]:\n",
+    "    display(\n",
+    "        (\n",
+    "            cos_similarity(test_vector_dict[id_left], test_vector_dict[id_right]),\n",
+    "            utils.subdict(record_dict[id_left], field_list), utils.subdict(record_dict[id_right], field_list)\n",
+    "        )\n",
+    "    )"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.13",
+   "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.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "e3bb7d66ba21cc372144d4e6f3a54e31b034566124f778bc0ae068d657400bc6"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 7ee7f7cd973c8d22e6c692f0e8aeb659744106bb Mon Sep 17 00:00:00 2001
From: Benj Pettit <benjamin.p@meetcleo.com>
Date: Tue, 25 Oct 2022 15:24:09 +0100
Subject: [PATCH 02/17] feat(data_utils): enable custom transaction embedding

---
 entity_embed/data_utils/field_config_parser.py | 8 ++++++--
 entity_embed/data_utils/numericalizer.py       | 1 +
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/entity_embed/data_utils/field_config_parser.py b/entity_embed/data_utils/field_config_parser.py
index e548235..84a8ccf 100644
--- a/entity_embed/data_utils/field_config_parser.py
+++ b/entity_embed/data_utils/field_config_parser.py
@@ -2,7 +2,7 @@
 import logging
 from importlib import import_module
 
-from torchtext.vocab import Vocab
+from torchtext.vocab import Vocab, Vectors
 
 from .numericalizer import (
     AVAILABLE_VOCABS,
@@ -93,7 +93,11 @@ def _parse_field_config(cls, field, field_config, record_list):
                     "an field name."
                 )
             vocab = Vocab(vocab_counter)
-            vocab.load_vectors(vocab_type)
+            if vocab_type in {'tx_embeddings_large.vec','tx_embeddings.vec'}:
+                vectors = Vectors(vocab_type, cache='.vector_cache')
+                vocab.load_vectors(vectors)
+            else:
+                vocab.load_vectors(vocab_type)
 
         # Compute max_str_len if necessary
         if field_type in (FieldType.STRING, FieldType.MULTITOKEN) and (max_str_len is None):
diff --git a/entity_embed/data_utils/numericalizer.py b/entity_embed/data_utils/numericalizer.py
index dbdbdc8..4bd90df 100644
--- a/entity_embed/data_utils/numericalizer.py
+++ b/entity_embed/data_utils/numericalizer.py
@@ -27,6 +27,7 @@
     "glove.6B.100d",
     "glove.6B.200d",
     "glove.6B.300d",
+    "tx_embeddings_large.vec",
 ]
 
 

From 8764297ffa6242e4d294f422d76ebc81bf7ee4ba Mon Sep 17 00:00:00 2001
From: Benj Pettit <benjamin.p@meetcleo.com>
Date: Tue, 25 Oct 2022 15:26:57 +0100
Subject: [PATCH 03/17] Revert "notebooks: added merchant deduplication
 notebook"

This reverts commit a2cf02b72bb4c382902a861d4366c5f075128f9c.
---
 notebooks/Deduplication-merchants.ipynb | 2320 -----------------------
 1 file changed, 2320 deletions(-)
 delete mode 100755 notebooks/Deduplication-merchants.ipynb

diff --git a/notebooks/Deduplication-merchants.ipynb b/notebooks/Deduplication-merchants.ipynb
deleted file mode 100755
index 996a043..0000000
--- a/notebooks/Deduplication-merchants.ipynb
+++ /dev/null
@@ -1,2320 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Deduplication 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": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from importlib import reload\n",
-    "import logging\n",
-    "import torch\n",
-    "import json\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",
-    "sys.path.insert(0, '..')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import entity_embed_local\n",
-    "from entity_embed_local import EntityEmbedLocal\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "torch.set_num_threads(1)\n",
-    "\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "\n",
-    "random_seed = 40\n",
-    "torch.manual_seed(random_seed)\n",
-    "np.random.seed(random_seed)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load Dataset"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's download the CSV dataset to a temporary directory:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = pd.read_csv('data/alias_data.csv',names=['merchant_name','merchant_id','plaid_merchant','plaid_category','avg_tx_amount','count'])\n",
-    "dataset = data.groupby('merchant_id').head(200)\n",
-    "dataset.avg_tx_amount = dataset.avg_tx_amount.round()\n",
-    "dataset = dataset.astype(str)\n",
-    "# dataset = dataset[dataset.merchant_id.isin(dataset.merchant_id.unique()[:50000])]\n",
-    "dataset['cluster_id'] = pd.factorize(dataset['merchant_id'].tolist())[0]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mapping = pd.Series(dataset.merchant_name.values,index=dataset.cluster_id).to_dict()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "record_dict = {}\n",
-    "cluster_field = 'cluster_id'\n",
-    "\n",
-    "for current_record_id, record in dataset[['cluster_id','merchant_name','plaid_merchant','plaid_category','avg_tx_amount']].iterrows():\n",
-    "    record['id'] = current_record_id\n",
-    "    record[cluster_field] = int(record[cluster_field])  # convert cluster_field to int\n",
-    "    record_dict[current_record_id] = record.to_dict()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "How many clusters this dataset has?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "35104"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "cluster_total = len(set(record[cluster_field] for record in record_dict.values()))\n",
-    "cluster_total"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "From all clusters, we'll use only 50% for training, and other 15% for validation to test how well we can generalize:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "12:55:26 INFO:Singleton cluster sizes (train, valid, test):(18649, 4662, 7772)\n",
-      "12:55:26 INFO:Plural cluster sizes (train, valid, test):(2412, 603, 1006)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from 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.60,\n",
-    "    valid_proportion=0.15,\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": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(26719, 6591, 11098)"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(train_record_dict), len(valid_record_dict), len(test_record_dict)"
-   ]
-  },
-  {
-   "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": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "field_list = ['merchant_name','plaid_merchant','plaid_category','avg_tx_amount']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "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": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'merchant_name': 'dutchbrosll',\n",
-       " 'plaid_merchant': 'dutch bros. coffee',\n",
-       " 'plaid_category': 'food and drink restaurants coffee shop',\n",
-       " 'avg_tx_amount': '-10.0'}"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "utils.subdict(record_dict[2], field_list)"
-   ]
-  },
-  {
-   "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": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'0123456789abcdefghijklmnopqrstuvwxyz!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ '"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from 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": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "field_config_dict = {\n",
-    "    \n",
-    "    'merchant_name': {\n",
-    "        'field_type': \"MULTITOKEN\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'alphabet': alphabet,\n",
-    "        'max_str_len': None,  # compute\n",
-    "    },\n",
-    "\n",
-    "    'merchant_name_semantic': {\n",
-    "        'key': 'merchant_name',\n",
-    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'vocab': \"tx_embeddings_large.vec\",\n",
-    "        'max_str_len': None,  # compute\n",
-    "    },\n",
-    "     'avg_tx_amount': {\n",
-    "        'field_type': \"STRING\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'alphabet': alphabet,\n",
-    "        'max_str_len': None,  # compute\n",
-    "    },\n",
-    "    'avg_tx_amount_semantic': {\n",
-    "        'key':\"avg_tx_amount\",\n",
-    "        'field_type': \"SEMANTIC_STRING\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'vocab': \"tx_embeddings_large.vec\",\n",
-    "        'max_str_len': None,  # compute\n",
-    "    },\n",
-    "    'plaid_merchant': {\n",
-    "        'field_type': \"MULTITOKEN\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'alphabet': alphabet,\n",
-    "        'max_str_len': None,  # compute\n",
-    "    },\n",
-    "    'plaid_merchant_semantic': {\n",
-    "        'key': 'plaid_merchant',\n",
-    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'vocab': \"tx_embeddings_large.vec\",\n",
-    "    },\n",
-    "    'plaid_category': {\n",
-    "        'field_type': \"MULTITOKEN\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'alphabet': alphabet,\n",
-    "        'max_str_len': None,  # compute\n",
-    "    },\n",
-    "    'plaid_category_semantic': {\n",
-    "        'key': 'plaid_category',\n",
-    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
-    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
-    "        'vocab': \"tx_embeddings_large.vec\",\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": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "12:55:27 INFO:For field=merchant_name, computing actual max_str_len\n",
-      "12:55:27 INFO:actual_max_str_len=23 must be even to enable NN pooling. Updating to 24\n",
-      "12:55:27 INFO:For field=merchant_name, using actual_max_str_len=24\n",
-      "12:55:27 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n",
-      "12:55:29 INFO:For field=avg_tx_amount, computing actual max_str_len\n",
-      "12:55:29 INFO:For field=avg_tx_amount, using actual_max_str_len=8\n",
-      "12:55:29 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n",
-      "12:55:30 INFO:For field=plaid_merchant, computing actual max_str_len\n",
-      "12:55:30 INFO:actual_max_str_len=23 must be even to enable NN pooling. Updating to 24\n",
-      "12:55:30 INFO:For field=plaid_merchant, using actual_max_str_len=24\n",
-      "12:55:31 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n",
-      "12:55:32 INFO:For field=plaid_category, computing actual max_str_len\n",
-      "12:55:32 INFO:actual_max_str_len=17 must be even to enable NN pooling. Updating to 18\n",
-      "12:55:32 INFO:For field=plaid_category, using actual_max_str_len=18\n",
-      "12:55:32 INFO:Loading vectors from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/.vector_cache/tx_embeddings_large.vec.pt\n"
-     ]
-    }
-   ],
-   "source": [
-    "from data_utils.field_config_parser 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": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from entity_embed import DeduplicationDataModule\n",
-    "\n",
-    "batch_size = 32\n",
-    "eval_batch_size = 64\n",
-    "datamodule = DeduplicationDataModule(\n",
-    "    train_record_dict=train_record_dict,\n",
-    "    valid_record_dict=valid_record_dict,\n",
-    "    test_record_dict=test_record_dict,\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",
-    "    train_loader_kwargs ={\"num_workers\":0,\"multiprocessing_context\":\"fork\"},\n",
-    "    eval_loader_kwargs ={\"num_workers\":0,\"multiprocessing_context\":\"fork\"},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We've used `DeduplicationDataModule` because we're doing Deduplication of a single dataset/table (a.k.a. Entity Clustering, Entity Resolution, etc.).\n",
-    "\n",
-    "We're NOT doing Record Linkage of two datasets here. Check the other notebook [Record-Linkage-Example](./Record-Linkage-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 `EntityEmbed` model object:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "setting embedding size to 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "from entity_embed_local import EntityEmbedLocal\n",
-    "\n",
-    "ann_k = 15\n",
-    "model = EntityEmbedLocal(\n",
-    "    record_numericalizer,\n",
-    "    ann_k=ann_k,\n",
-    "    embedding_size=100,\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 `EntityEmbed.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": 30,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "13:50:27 INFO:GPU available: False, used: False\n",
-      "13:50:27 INFO:TPU available: False, using: 0 TPU cores\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "calling up trainer....\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "13:51:20 INFO:\n",
-      "  | Name        | Type       | Params\n",
-      "-------------------------------------------\n",
-      "0 | blocker_net | BlockerNet | 6.6 M \n",
-      "1 | loss_fn     | SupConLoss | 0     \n",
-      "-------------------------------------------\n",
-      "2.3 M     Trainable params\n",
-      "4.3 M     Non-trainable params\n",
-      "6.6 M     Total params\n",
-      "26.554    Total estimated model params size (MB)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 4: 100%|██████████| 1019/1019 [04:07<00:00,  4.12it/s, loss=0.818, v_num=27]"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "14:10:50 INFO:Loading the best validation model from /Users/adnanshahzada/Cleo/Repos/deduplication/entity-embed/entity_embed/models/epoch=1-step=1832-v7.ckpt...\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "setting embedding size to 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "trainer = model.fit(\n",
-    "    datamodule,\n",
-    "    min_epochs=2,\n",
-    "    max_epochs=5,\n",
-    "    check_val_every_n_epoch=1,\n",
-    "    early_stop_monitor=\"valid_recall_at_0.7\",\n",
-    "    model_save_dir='models',\n",
-    "    use_gpu=False,\n",
-    ")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# !mkdir -p models/entityembed\n",
-    "!cp {model.trainer.checkpoint_callback.best_model_path} models/entityembed/ee-model.ckpt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "path = \"models/entityembed/\"\n",
-    "\n",
-    "with open(path+ 'ee-train-records.json', 'w') as f:\n",
-    "    json.dump(datamodule.train_record_dict, f, indent=4)\n",
-    "\n",
-    "with open(path+ 'ee-valid-records.json', 'w') as f:\n",
-    "    json.dump(datamodule.valid_record_dict, f, indent=4)\n",
-    "\n",
-    "with open(path+ 'ee-test-records.json', 'w') as f:\n",
-    "    json.dump(datamodule.test_record_dict, f, indent=4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "setting embedding size to 100\n"
-     ]
-    }
-   ],
-   "source": [
-    "model = EntityEmbedLocal.load_from_checkpoint('models/epoch=1-step=1832-v7.ckpt')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`EntityEmbed.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": 31,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'valid_f1_at_0.3': 0.0,\n",
-       " 'valid_f1_at_0.5': 0.0,\n",
-       " 'valid_f1_at_0.7': 0.0,\n",
-       " 'valid_pair_entity_ratio_at_0.3': 10.15106931594115,\n",
-       " 'valid_pair_entity_ratio_at_0.5': 4.946155012892461,\n",
-       " 'valid_pair_entity_ratio_at_0.7': 1.6895191870165327,\n",
-       " 'valid_precision_at_0.3': 0.0,\n",
-       " 'valid_precision_at_0.5': 0.0,\n",
-       " 'valid_precision_at_0.7': 0.0,\n",
-       " 'valid_recall_at_0.3': 0.0,\n",
-       " 'valid_recall_at_0.5': 0.0,\n",
-       " 'valid_recall_at_0.7': 0.0}"
-      ]
-     },
-     "execution_count": 31,
-     "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": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'merchant_name': 0.2551257014274597,\n",
-       " 'merchant_name_semantic': 0.22146005928516388,\n",
-       " 'avg_tx_amount': 0.03779561445116997,\n",
-       " 'avg_tx_amount_semantic': 0.24249973893165588,\n",
-       " 'plaid_merchant': 0.07616355270147324,\n",
-       " 'plaid_merchant_semantic': 0.060125213116407394,\n",
-       " 'plaid_category': 0.07688859850168228,\n",
-       " 'plaid_category_semantic': 0.02994149550795555}"
-      ]
-     },
-     "execution_count": 28,
-     "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": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "16:57:02 INFO:Test positive pair count: 30657\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'test_f1_at_0.3': 0.0,\n",
-       " 'test_f1_at_0.5': 0.0,\n",
-       " 'test_f1_at_0.7': 0.0,\n",
-       " 'test_pair_entity_ratio_at_0.3': 17.187250554323725,\n",
-       " 'test_pair_entity_ratio_at_0.5': 5.513303769401331,\n",
-       " 'test_pair_entity_ratio_at_0.7': 2.3838137472283814,\n",
-       " 'test_precision_at_0.3': 0.0,\n",
-       " 'test_precision_at_0.5': 0.0,\n",
-       " 'test_precision_at_0.7': 0.0,\n",
-       " 'test_recall_at_0.3': 0.0,\n",
-       " 'test_recall_at_0.5': 0.0,\n",
-       " 'test_recall_at_0.7': 0.0}"
-      ]
-     },
-     "execution_count": 30,
-     "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 the [Record-Linkage-Example](./Record-Linkage-Example.ipynb) for an example of matching."
-   ]
-  },
-  {
-   "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": 102,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "# batch embedding: 100%|██████████| 286/286 [00:57<00:00,  4.95it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "test_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": 103,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vis_sample_size = 10"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 104,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n=20\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)[n:vis_sample_size+n])\n",
-    "\n",
-    "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": 105,
-   "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": 107,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "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",
-    "import random\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_]['alias'][:25]\n",
-    "    ax.text(x + 2 , y + 2+ (5*random.random()), 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": 20,
-   "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": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prod_test_record_dict = {}\n",
-    "\n",
-    "merchants_list = pd.read_csv('data/us_companies.csv', header=None,names=['merchant_name']).iloc[:,0].tolist()\n",
-    "merchants_list\n",
-    "\n",
-    "merchants = pd.read_csv('data/merchants_list.csv',names=[\"merchant_name\",\"merchant_id\",\"plaid_merchant\",\"plaid_category\",\"avg_tx_amount\",\"count\"])\n",
-    "merchants = merchants.sort_values('count', ascending=False).drop_duplicates(['merchant_name','merchant_id'])\n",
-    "merchants.avg_tx_amount = merchants.avg_tx_amount.round()\n",
-    "merchants = merchants.apply(lambda x: x.astype(str).str.lower()).reset_index()\n",
-    "for current_record_id, record in merchants.iterrows():\n",
-    "    prod_test_record_dict[current_record_id] = record.to_dict()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then call `predict_pairs` with some `ann_k` and `sim_threshold`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "# batch embedding:  69%|██████▉   | 410/592 [00:39<00:19,  9.19it/s]12:56:38 WARNING:Found out of alphabet char at val=döner, char=ö\n",
-      "# batch embedding:  84%|████████▍ | 497/592 [00:48<00:08, 11.22it/s]12:56:47 WARNING:Found out of alphabet char at val=côte, char=ô\n",
-      "# batch embedding: 100%|██████████| 592/592 [00:56<00:00, 10.52it/s]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "72547"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sim_threshold = 0.85\n",
-    "ann_k=15\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": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "37865"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "total_merchants = merchants.merchant_name.nunique()\n",
-    "total_merchants\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "idf_df = pd.read_csv('data/idf_weights.csv')\n",
-    "idf_weights = dict(zip(idf_df.token,idf_df.idf))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 291,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def calculate_genericity(tokens_left,tokens_right):\n",
-    "    tokens = tokens_left + tokens_right\n",
-    "    return  (sum([1-idf_weights.get(t,1) for t in tokens])/len(tokens))\n",
-    "\n",
-    "def calculate_amount_similarity(l_amount, r_amount):\n",
-    "    if max(l_amount,r_amount) == 0 or l_amount * r_amount < 0:\n",
-    "        return False\n",
-    "    l_amount, r_amount = (abs(n) for n in (l_amount, r_amount))\n",
-    "    is_different_bracket = abs(l_amount - r_amount) > 10\n",
-    "    is_ratio_large = (min(l_amount , r_amount)/ max(l_amount , r_amount)) < 0.8\n",
-    "    return is_different_bracket or is_ratio_large\n",
-    "# calculate_genericity(prod_test_record_dict.get(3256)['merchant_name'].split(),prod_test_record_dict.get(12722)['merchant_name'].split())\n",
-    "# calculate_amount_similarity(82.0, -100.0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 302,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "06ea0405b6e04d07801df03e080afd60",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/72547 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "from scipy.sparse import csr_matrix\n",
-    "from scipy.sparse.csgraph import connected_components\n",
-    "from tqdm.notebook import tqdm\n",
-    "\n",
-    "graph = np.zeros((total_merchants,total_merchants))\n",
-    "\n",
-    "for (id_left, id_right, similarity) in tqdm(list(found_pair_set)):\n",
-    "    is_different_category = prod_test_record_dict.get(id_left)['plaid_category'].strip() != prod_test_record_dict.get(id_right)['plaid_category'].strip()\n",
-    "    genericity = calculate_genericity(prod_test_record_dict.get(id_left)['merchant_name'].split(),prod_test_record_dict.get(id_right)['merchant_name'].split())\n",
-    "    is_avg_amount_different= calculate_amount_similarity(float(prod_test_record_dict.get(id_left)['avg_tx_amount']),float(prod_test_record_dict.get(id_left)['avg_tx_amount']))\n",
-    "    score = similarity - (is_different_category * 0.1) - (0.5 * genericity) - (is_avg_amount_different * 0.05)\n",
-    "    \n",
-    "    if score >0.85 :\n",
-    "        # print(prod_test_record_dict.get(id_left))\n",
-    "        # print(prod_test_record_dict.get(id_right))\n",
-    "        # print(score)\n",
-    "        # print(\"------------------\")\n",
-    "        graph[id_left,id_right] = 1\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 304,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "graph = csr_matrix(graph)\n",
-    "# print(graph)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 305,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(35960, array([    0,     1,     2, ..., 35957, 35958, 35959], dtype=int32))"
-      ]
-     },
-     "execution_count": 305,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n",
-    "(n_components,labels)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 306,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ad663eec48b6484ca04d314230c8836a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/37865 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "dup_cluster = []\n",
-    "for i in tqdm(range(len(labels))):\n",
-    "    dupes = list(np.where(labels==i)[0])\n",
-    "    if len(dupes) > 1:\n",
-    "        dup_cluster.append([prod_test_record_dict.get(key) for key in dupes])\n",
-    "        "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "'\\n'.join(pd.Series(dup_cluster).iloc[0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 337,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pandas import option_context\n",
-    "\n",
-    "with option_context('display.max_colwidth', 400):\n",
-    "    (pd.DataFrame(dup_cluster).apply(lambda x: '\\n'.join(x.dropna().astype(str)), axis=1)).to_csv('data/dupes.csv')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1.6537699722699062"
-      ]
-     },
-     "execution_count": 32,
-     "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": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's check now the metrics of the found duplicate pairs:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cos_similarity = lambda a, b: np.dot(a, b)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fields = ['merchant_name',\n",
-    " 'plaid_merchant',\n",
-    " 'plaid_category',\n",
-    " 'avg_tx_amount','count']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9f613bd140204935badae4f6c7c1a079",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/72542 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "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>matching_similarity</th>\n",
-       "      <th>merchant</th>\n",
-       "      <th>matched_merchant</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>0.915286</td>\n",
-       "      <td>{'merchant_name': 'carroll county', 'plaid_mer...</td>\n",
-       "      <td>(carroll emc, -24.0, 26)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>0.868136</td>\n",
-       "      <td>{'merchant_name': 'express fuels', 'plaid_merc...</td>\n",
-       "      <td>(express nails, -70.0, 14)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>0.905586</td>\n",
-       "      <td>{'merchant_name': 'white', 'plaid_merchant': '...</td>\n",
-       "      <td>(white hart inn, -8.0, 1)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>0.961777</td>\n",
-       "      <td>{'merchant_name': 'poke city', 'plaid_merchant...</td>\n",
-       "      <td>(poke poku, -24.0, 7)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>0.977440</td>\n",
-       "      <td>{'merchant_name': 'new china fun', 'plaid_merc...</td>\n",
-       "      <td>(new china restaurant, -22.0, 323)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>72537</th>\n",
-       "      <td>0.865486</td>\n",
-       "      <td>{'merchant_name': 'los', 'plaid_merchant': 'na...</td>\n",
-       "      <td>(los cabos, -60.0, 35)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>72538</th>\n",
-       "      <td>0.926597</td>\n",
-       "      <td>{'merchant_name': 'mega bev', 'plaid_merchant'...</td>\n",
-       "      <td>(mega liquor, -22.0, 121)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>72539</th>\n",
-       "      <td>0.902664</td>\n",
-       "      <td>{'merchant_name': 'village inn pizza', 'plaid_...</td>\n",
-       "      <td>(village restaurant, -20.0, 20)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>72540</th>\n",
-       "      <td>0.882056</td>\n",
-       "      <td>{'merchant_name': 'el amigo', 'plaid_merchant'...</td>\n",
-       "      <td>(el sol, -20.0, 19)</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>72541</th>\n",
-       "      <td>0.859562</td>\n",
-       "      <td>{'merchant_name': 'campus bo', 'plaid_merchant...</td>\n",
-       "      <td>(campus bookstor building, -236.0, 5)</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>72542 rows × 3 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "       matching_similarity                                           merchant  \\\n",
-       "0                 0.915286  {'merchant_name': 'carroll county', 'plaid_mer...   \n",
-       "1                 0.868136  {'merchant_name': 'express fuels', 'plaid_merc...   \n",
-       "2                 0.905586  {'merchant_name': 'white', 'plaid_merchant': '...   \n",
-       "3                 0.961777  {'merchant_name': 'poke city', 'plaid_merchant...   \n",
-       "4                 0.977440  {'merchant_name': 'new china fun', 'plaid_merc...   \n",
-       "...                    ...                                                ...   \n",
-       "72537             0.865486  {'merchant_name': 'los', 'plaid_merchant': 'na...   \n",
-       "72538             0.926597  {'merchant_name': 'mega bev', 'plaid_merchant'...   \n",
-       "72539             0.902664  {'merchant_name': 'village inn pizza', 'plaid_...   \n",
-       "72540             0.882056  {'merchant_name': 'el amigo', 'plaid_merchant'...   \n",
-       "72541             0.859562  {'merchant_name': 'campus bo', 'plaid_merchant...   \n",
-       "\n",
-       "                            matched_merchant  \n",
-       "0                   (carroll emc, -24.0, 26)  \n",
-       "1                 (express nails, -70.0, 14)  \n",
-       "2                  (white hart inn, -8.0, 1)  \n",
-       "3                      (poke poku, -24.0, 7)  \n",
-       "4         (new china restaurant, -22.0, 323)  \n",
-       "...                                      ...  \n",
-       "72537                 (los cabos, -60.0, 35)  \n",
-       "72538              (mega liquor, -22.0, 121)  \n",
-       "72539        (village restaurant, -20.0, 20)  \n",
-       "72540                    (el sol, -20.0, 19)  \n",
-       "72541  (campus bookstor building, -236.0, 5)  \n",
-       "\n",
-       "[72542 rows x 3 columns]"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from tqdm.notebook import tqdm\n",
-    "duplicates = pd.DataFrame(columns=['matching_similarity','merchant','matched_merchant'])\n",
-    "for (id_left, id_right, similarity) in tqdm(list(found_pair_set)):\n",
-    "    merchant_a = utils.subdict(prod_test_record_dict[id_left], fields)\n",
-    "    merchant_b = utils.subdict(prod_test_record_dict[id_right], fields)\n",
-    "    duplicates = duplicates.append({'matching_similarity':similarity,'merchant':merchant_a,'matched_merchant':(merchant_b['merchant_name'],merchant_b['avg_tx_amount'],merchant_b['count'])},ignore_index=True)\n",
-    "\n",
-    "duplicates"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adnanshahzada/opt/miniconda3/envs/entity-embed-env/lib/python3.8/site-packages/pandas/core/generic.py:5516: SettingWithCopyWarning: \n",
-      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
-      "Try using .loc[row_indexer,col_indexer] = value instead\n",
-      "\n",
-      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
-      "  self[name] = value\n"
-     ]
-    },
-    {
-     "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>matching_similarity</th>\n",
-       "      <th>matched_merchant</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>merchant</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': \"america''s best\", 'plaid_merchant': \"america''s best\", 'plaid_category': 'food and drink restaurants ', 'avg_tx_amount': '-107.0', 'count': '1341'}</th>\n",
-       "      <td>[0.931]</td>\n",
-       "      <td>[(america''s best wings, -22.0, 281)]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': \"auntie anne''s\", 'plaid_merchant': \"auntie anne''s\", 'plaid_category': 'food and drink restaurants ', 'avg_tx_amount': '-10.0', 'count': '22971'}</th>\n",
-       "      <td>[0.981, 0.978]</td>\n",
-       "      <td>[(auntie annes, -11.0, 17), (auntie annies, -8...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': \"bahama buck''s\", 'plaid_merchant': \"bahama buck''s tx\", 'plaid_category': 'shops clothing and accessories ', 'avg_tx_amount': '-10.0', 'count': '39'}</th>\n",
-       "      <td>[0.952]</td>\n",
-       "      <td>[(bahama bucks, -11.0, 437)]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': \"baker''s dozen\", 'plaid_merchant': \"baker''s dozen\", 'plaid_category': 'shops food and beverage store ', 'avg_tx_amount': '-12.0', 'count': '4'}</th>\n",
-       "      <td>[0.901]</td>\n",
-       "      <td>[(baker''s iga, -24.0, 21)]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': \"bill''s liquor\", 'plaid_merchant': \"bill''s liquor\", 'plaid_category': 'shops food and beverage store ', 'avg_tx_amount': '-23.0', 'count': '19'}</th>\n",
-       "      <td>[0.921]</td>\n",
-       "      <td>[(bill''s superette, -15.0, 232)]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': 'zoom management', 'plaid_merchant': 'nan', 'plaid_category': 'service  ', 'avg_tx_amount': '-30.0', 'count': '22'}</th>\n",
-       "      <td>[0.903, 0.962, 0.935]</td>\n",
-       "      <td>[(zoom tan, -23.0, 208), (zoom mart, -19.0, 14...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': 'zoom mart', 'plaid_merchant': 'nan', 'plaid_category': 'service  ', 'avg_tx_amount': '-19.0', 'count': '14'}</th>\n",
-       "      <td>[0.95, 0.926]</td>\n",
-       "      <td>[(zoom.us, -16.0, 513), (zoom tan, -23.0, 208)]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': 'zoom tan', 'plaid_merchant': 'zoom tan', 'plaid_category': 'service personal care ', 'avg_tx_amount': '-23.0', 'count': '208'}</th>\n",
-       "      <td>[0.927]</td>\n",
-       "      <td>[(zoom.us, -16.0, 513)]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': 'zoom', 'plaid_merchant': 'nan', 'plaid_category': 'service  ', 'avg_tx_amount': '-19.0', 'count': '99'}</th>\n",
-       "      <td>[0.964, 0.985, 0.966, 0.933, 0.922, 0.969]</td>\n",
-       "      <td>[(zoom.us, -16.0, 513), (zoom mart, -19.0, 14)...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>{'merchant_name': 'zt', 'plaid_merchant': 'nan', 'plaid_category': 'transfer debit ', 'avg_tx_amount': '-11.0', 'count': '139'}</th>\n",
-       "      <td>[0.98]</td>\n",
-       "      <td>[(zt 645, -12.0, 14)]</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>9918 rows × 2 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                                                                           matching_similarity  \\\n",
-       "merchant                                                                                         \n",
-       "{'merchant_name': \"america''s best\", 'plaid_mer...                                     [0.931]   \n",
-       "{'merchant_name': \"auntie anne''s\", 'plaid_merc...                              [0.981, 0.978]   \n",
-       "{'merchant_name': \"bahama buck''s\", 'plaid_merc...                                     [0.952]   \n",
-       "{'merchant_name': \"baker''s dozen\", 'plaid_merc...                                     [0.901]   \n",
-       "{'merchant_name': \"bill''s liquor\", 'plaid_merc...                                     [0.921]   \n",
-       "...                                                                                        ...   \n",
-       "{'merchant_name': 'zoom management', 'plaid_mer...                       [0.903, 0.962, 0.935]   \n",
-       "{'merchant_name': 'zoom mart', 'plaid_merchant'...                               [0.95, 0.926]   \n",
-       "{'merchant_name': 'zoom tan', 'plaid_merchant':...                                     [0.927]   \n",
-       "{'merchant_name': 'zoom', 'plaid_merchant': 'na...  [0.964, 0.985, 0.966, 0.933, 0.922, 0.969]   \n",
-       "{'merchant_name': 'zt', 'plaid_merchant': 'nan'...                                      [0.98]   \n",
-       "\n",
-       "                                                                                     matched_merchant  \n",
-       "merchant                                                                                               \n",
-       "{'merchant_name': \"america''s best\", 'plaid_mer...              [(america''s best wings, -22.0, 281)]  \n",
-       "{'merchant_name': \"auntie anne''s\", 'plaid_merc...  [(auntie annes, -11.0, 17), (auntie annies, -8...  \n",
-       "{'merchant_name': \"bahama buck''s\", 'plaid_merc...                       [(bahama bucks, -11.0, 437)]  \n",
-       "{'merchant_name': \"baker''s dozen\", 'plaid_merc...                        [(baker''s iga, -24.0, 21)]  \n",
-       "{'merchant_name': \"bill''s liquor\", 'plaid_merc...                  [(bill''s superette, -15.0, 232)]  \n",
-       "...                                                                                               ...  \n",
-       "{'merchant_name': 'zoom management', 'plaid_mer...  [(zoom tan, -23.0, 208), (zoom mart, -19.0, 14...  \n",
-       "{'merchant_name': 'zoom mart', 'plaid_merchant'...    [(zoom.us, -16.0, 513), (zoom tan, -23.0, 208)]  \n",
-       "{'merchant_name': 'zoom tan', 'plaid_merchant':...                            [(zoom.us, -16.0, 513)]  \n",
-       "{'merchant_name': 'zoom', 'plaid_merchant': 'na...  [(zoom.us, -16.0, 513), (zoom mart, -19.0, 14)...  \n",
-       "{'merchant_name': 'zt', 'plaid_merchant': 'nan'...                              [(zt 645, -12.0, 14)]  \n",
-       "\n",
-       "[9918 rows x 2 columns]"
-      ]
-     },
-     "execution_count": 45,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "duplicates_strong = duplicates[duplicates.matching_similarity>0.9]\n",
-    "duplicates_strong.matching_similarity = duplicates_strong.matching_similarity.apply(lambda x: round(x,3))\n",
-    "duplicates_strong.merchant = duplicates_strong.merchant.astype(str)\n",
-    "result =duplicates_strong.groupby('merchant').agg(lambda x: list(x))\n",
-    "result.to_csv('data/duplicate_merchants_ct.csv')\n",
-    "result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[('Baho Convenience Store', False),\n",
-       " ('Hilton Payroll', False),\n",
-       " ('Fast Shop', False),\n",
-       " ('Imperial Mart', False),\n",
-       " ('Bitterroot Beanery', False),\n",
-       " ('Piedmont Natural Gas', False),\n",
-       " ('The Island Shoppe', False),\n",
-       " ('Americas Best Wings', False),\n",
-       " ('Rockland Nails', False),\n",
-       " ('Irobot Corporation', False),\n",
-       " ('Khalil`s Food & Liquor', False),\n",
-       " ('Quality Auto Repair', False),\n",
-       " ('Jackpot Mini Mart', False),\n",
-       " ('Westside Convenience', False),\n",
-       " ('H And M Mini Sto', False),\n",
-       " ('Patel Corner Pantry', False),\n",
-       " ('Guys Pizza Downtown', False),\n",
-       " ('Xingyu Restaurant Inc', False),\n",
-       " ('5801 Video Lounge & Caf', False),\n",
-       " ('Just Salad', True)]"
-      ]
-     },
-     "execution_count": 55,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "idx_a += 20\n",
-    "idx_b += 20\n",
-    "[(r,r in merchants_list) for  r in dataset.iloc[idx_a:idx_b,:]['merchant_name'].tolist()]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 144,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.7512554540215691, 0.12059282165133735)"
-      ]
-     },
-     "execution_count": 144,
-     "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": 145,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "12086"
-      ]
-     },
-     "execution_count": 145,
-     "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": 146,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "266186"
-      ]
-     },
-     "execution_count": 146,
-     "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": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "true_positives = list(found_pair_set - datamodule.test_pos_pair_set)\n",
-    "len(false_positives)\n",
-    "for (id_left, id_right) in list(found_pair_set)[:10]:\n",
-    "    display(\n",
-    "        (\n",
-    "            record_dict[id_left],\n",
-    "            record_dict[id_right],\n",
-    "            cos_similarity(test_vector_dict[id_left], test_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": 147,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.87486815,\n",
-       " {'alias': 'r&b tea', 'plaid_merchant': 'r&b tea', 'avg_tx_amount': '-6.35'},\n",
-       " {'alias': 'r & gs food basket',\n",
-       "  'plaid_merchant': 'r & gs food basket',\n",
-       "  'avg_tx_amount': '-21.83'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.8825392,\n",
-       " {'alias': 'country wide insurance',\n",
-       "  'plaid_merchant': 'country wide insurance',\n",
-       "  'avg_tx_amount': '-284.13'},\n",
-       " {'alias': 'country convenie',\n",
-       "  'plaid_merchant': 'country convenie',\n",
-       "  'avg_tx_amount': '-14.1'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.905407,\n",
-       " {'alias': 'china town 1', 'plaid_merchant': 'nan', 'avg_tx_amount': '-25.0'},\n",
-       " {'alias': 'china delight chinese',\n",
-       "  'plaid_merchant': 'china delight chinese',\n",
-       "  'avg_tx_amount': '-21.56'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.70510805,\n",
-       " {'alias': 'blue bay',\n",
-       "  'plaid_merchant': 'blue bay',\n",
-       "  'avg_tx_amount': '-12.96'},\n",
-       " {'alias': 'blue moon tap house',\n",
-       "  'plaid_merchant': 'blue moon tap house',\n",
-       "  'avg_tx_amount': '-26.07'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9555845,\n",
-       " {'alias': 'lincoln highway',\n",
-       "  'plaid_merchant': 'lincoln highway',\n",
-       "  'avg_tx_amount': '-11.24'},\n",
-       " {'alias': 'lincoln c mart',\n",
-       "  'plaid_merchant': 'lincoln c mart',\n",
-       "  'avg_tx_amount': '-24.99'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.95284754,\n",
-       " {'alias': 'quick pick grocery ltd',\n",
-       "  'plaid_merchant': 'nan',\n",
-       "  'avg_tx_amount': '-8.98'},\n",
-       " {'alias': 'quick pick atlanta',\n",
-       "  'plaid_merchant': 'quick pick',\n",
-       "  'avg_tx_amount': '-5.26'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.8914383,\n",
-       " {'alias': 'china gourmet house',\n",
-       "  'plaid_merchant': 'china gourmet house',\n",
-       "  'avg_tx_amount': '-23.85'},\n",
-       " {'alias': 'china town 1', 'plaid_merchant': 'nan', 'avg_tx_amount': '-36.75'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9162289,\n",
-       " {'alias': 'taco heads fort worth',\n",
-       "  'plaid_merchant': 'taco heads fort worth',\n",
-       "  'avg_tx_amount': '-18.76'},\n",
-       " {'alias': 'taco monster',\n",
-       "  'plaid_merchant': 'taco monster',\n",
-       "  'avg_tx_amount': '-29.71'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.95120347,\n",
-       " {'alias': 'noodles pho u',\n",
-       "  'plaid_merchant': 'noodles pho u',\n",
-       "  'avg_tx_amount': '-33.58'},\n",
-       " {'alias': 'noodles & company',\n",
-       "  'plaid_merchant': 'noodles & company',\n",
-       "  'avg_tx_amount': '-30.15'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9241347,\n",
-       " {'alias': 'noodles and dumplings',\n",
-       "  'plaid_merchant': 'noodles and dumplings',\n",
-       "  'avg_tx_amount': '-48.14'},\n",
-       " {'alias': 'noodles & company',\n",
-       "  'plaid_merchant': 'noodles & company',\n",
-       "  'avg_tx_amount': '-8.7'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for (id_left, id_right) in false_positives[:10]:\n",
-    "    display(\n",
-    "        (\n",
-    "            cos_similarity(test_vector_dict[id_left], test_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": 149,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.99850756,\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-20.42'},\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-18.5'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99695677,\n",
-       " {'alias': 'rent-a-center',\n",
-       "  'plaid_merchant': 'rent-a-center',\n",
-       "  'avg_tx_amount': '-121.85'},\n",
-       " {'alias': 'rent-a-center',\n",
-       "  'plaid_merchant': 'rent-a-center',\n",
-       "  'avg_tx_amount': '-38.35'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9966733,\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-17.18'},\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-26.18'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.97021323,\n",
-       " {'alias': 'cardtronics', 'plaid_merchant': 'nan', 'avg_tx_amount': '-43.5'},\n",
-       " {'alias': 'cardtronics',\n",
-       "  'plaid_merchant': 'cardtronics',\n",
-       "  'avg_tx_amount': '-41.16'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9971533,\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-23.7'},\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-7.62'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99700713,\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-18.72'},\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-20.54'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9975728,\n",
-       " {'alias': \"dave & buster''s\",\n",
-       "  'plaid_merchant': 'dave & busters',\n",
-       "  'avg_tx_amount': '-35.75'},\n",
-       " {'alias': \"dave & buster''s\",\n",
-       "  'plaid_merchant': 'dave & busters',\n",
-       "  'avg_tx_amount': '-77.44'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9961077,\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-14.02'},\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-9.2'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99612856,\n",
-       " {'alias': \"dave & buster''s\",\n",
-       "  'plaid_merchant': 'dave & busters',\n",
-       "  'avg_tx_amount': '-46.28'},\n",
-       " {'alias': \"dave & buster''s\",\n",
-       "  'plaid_merchant': \"dave & buster''s\",\n",
-       "  'avg_tx_amount': '-33.63'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9968643,\n",
-       " {'alias': 'tractor supply',\n",
-       "  'plaid_merchant': 'tractor supply',\n",
-       "  'avg_tx_amount': '-28.6'},\n",
-       " {'alias': 'tractor supply',\n",
-       "  'plaid_merchant': 'tractor supply',\n",
-       "  'avg_tx_amount': '-54.1'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9972248,\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-32.71'},\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-10.57'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9969662,\n",
-       " {'alias': 'cardtronics',\n",
-       "  'plaid_merchant': 'cardtronics',\n",
-       "  'avg_tx_amount': '-184.65'},\n",
-       " {'alias': 'cardtronics',\n",
-       "  'plaid_merchant': 'cardtronics',\n",
-       "  'avg_tx_amount': '-52.5'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9916726,\n",
-       " {'alias': 'urban air killeen',\n",
-       "  'plaid_merchant': 'urban air killeen',\n",
-       "  'avg_tx_amount': '-36.15'},\n",
-       " {'alias': 'urban air',\n",
-       "  'plaid_merchant': 'urban air',\n",
-       "  'avg_tx_amount': '-19.75'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9962817,\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-98.06'},\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-10.69'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.997394,\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-5.0'},\n",
-       " {'alias': 'stop & shop',\n",
-       "  'plaid_merchant': 'stop & shop',\n",
-       "  'avg_tx_amount': '-7.48'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99658275,\n",
-       " {'alias': 'rent-a-center',\n",
-       "  'plaid_merchant': 'rent-a-center',\n",
-       "  'avg_tx_amount': '-152.17'},\n",
-       " {'alias': 'rent-a-center',\n",
-       "  'plaid_merchant': 'rent-a-center',\n",
-       "  'avg_tx_amount': '-344.69'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99650383,\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-24.02'},\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-6.12'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.997722,\n",
-       " {'alias': 'krispy kreme',\n",
-       "  'plaid_merchant': 'krispy kreme',\n",
-       "  'avg_tx_amount': '-12.15'},\n",
-       " {'alias': 'krispy kreme',\n",
-       "  'plaid_merchant': 'krispy kreme',\n",
-       "  'avg_tx_amount': '-11.94'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99689335,\n",
-       " {'alias': 'rent-a-center',\n",
-       "  'plaid_merchant': 'rent-a-center',\n",
-       "  'avg_tx_amount': '-8.94'},\n",
-       " {'alias': 'rent-a-center',\n",
-       "  'plaid_merchant': 'rent-a-center',\n",
-       "  'avg_tx_amount': '-58.77'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9976802,\n",
-       " {'alias': 'cardtronics',\n",
-       "  'plaid_merchant': 'cardtronics',\n",
-       "  'avg_tx_amount': '-40.0'},\n",
-       " {'alias': 'cardtronics',\n",
-       "  'plaid_merchant': 'cardtronics',\n",
-       "  'avg_tx_amount': '-52.72'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99777186,\n",
-       " {'alias': 'chipotle mexican grill',\n",
-       "  'plaid_merchant': 'chipotle mexican grill',\n",
-       "  'avg_tx_amount': '-14.17'},\n",
-       " {'alias': 'chipotle mexican grill',\n",
-       "  'plaid_merchant': 'chipotle mexican grill',\n",
-       "  'avg_tx_amount': '-12.07'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9955483,\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-12.93'},\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-23.91'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9961946,\n",
-       " {'alias': \"dave & buster''s\",\n",
-       "  'plaid_merchant': \"dave & buster''s\",\n",
-       "  'avg_tx_amount': '-38.62'},\n",
-       " {'alias': \"dave & buster''s\",\n",
-       "  'plaid_merchant': \"dave & buster''s\",\n",
-       "  'avg_tx_amount': '-70.86'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9975935,\n",
-       " {'alias': 'holiday inn',\n",
-       "  'plaid_merchant': 'holiday inn',\n",
-       "  'avg_tx_amount': '-296.98'},\n",
-       " {'alias': 'holiday inn',\n",
-       "  'plaid_merchant': 'holiday inn',\n",
-       "  'avg_tx_amount': '-39.1'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9973572,\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-48.81'},\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-8.24'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.99457943,\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-12.56'},\n",
-       " {'alias': 'wawa', 'plaid_merchant': 'wawa', 'avg_tx_amount': '-36.24'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9984803,\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-25.21'},\n",
-       " {'alias': 'kwik trip',\n",
-       "  'plaid_merchant': 'kwik trip',\n",
-       "  'avg_tx_amount': '-28.34'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.97368807,\n",
-       " {'alias': 'cardtronics', 'plaid_merchant': 'nan', 'avg_tx_amount': '-51.75'},\n",
-       " {'alias': 'cardtronics',\n",
-       "  'plaid_merchant': 'cardtronics',\n",
-       "  'avg_tx_amount': '-89.69'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9977134,\n",
-       " {'alias': 'gulf oil',\n",
-       "  'plaid_merchant': 'gulf oil',\n",
-       "  'avg_tx_amount': '-19.08'},\n",
-       " {'alias': 'gulf oil',\n",
-       "  'plaid_merchant': 'gulf oil',\n",
-       "  'avg_tx_amount': '-34.91'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(0.9969918,\n",
-       " {'alias': 'marshalls',\n",
-       "  'plaid_merchant': 'marshalls',\n",
-       "  'avg_tx_amount': '-76.19'},\n",
-       " {'alias': 'marshalls',\n",
-       "  'plaid_merchant': 'marshalls',\n",
-       "  'avg_tx_amount': '-43.74'})"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for (id_left, id_right) in false_negatives[:30]:\n",
-    "    display(\n",
-    "        (\n",
-    "            cos_similarity(test_vector_dict[id_left], test_vector_dict[id_right]),\n",
-    "            utils.subdict(record_dict[id_left], field_list), utils.subdict(record_dict[id_right], field_list)\n",
-    "        )\n",
-    "    )"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.8.13",
-   "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.13"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "e3bb7d66ba21cc372144d4e6f3a54e31b034566124f778bc0ae068d657400bc6"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

From 78ff0c218233c966fe7d8e0429a2ea2aa1b490d7 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Thu, 27 Oct 2022 10:47:03 +0100
Subject: [PATCH 04/17] Update to use faiss

---
 entity_embed/__init__.py                      |   2 +-
 .../data_utils/field_config_parser.py         |  36 ++-
 entity_embed/data_utils/numericalizer.py      |   5 +-
 entity_embed/early_stopping.py                |   4 +-
 entity_embed/entity_embed.py                  |  17 +-
 entity_embed/indexes.py                       | 269 ++++++++++++------
 entity_embed/models.py                        |   2 +-
 requirements.txt                              |  12 +-
 tests/test_data_utils_helpers.py              |   3 +-
 9 files changed, 243 insertions(+), 107 deletions(-)

diff --git a/entity_embed/__init__.py b/entity_embed/__init__.py
index 0ebd1b7..9ce1ae6 100644
--- a/entity_embed/__init__.py
+++ b/entity_embed/__init__.py
@@ -2,7 +2,7 @@
 import logging
 
 # libgomp issue, must import n2 before torch. See: https://github.com/kakao/n2/issues/42
-import n2  # noqa: F401
+# import n2  # noqa: F401
 
 from .data_modules import *  # noqa: F401, F403
 from .data_utils.field_config_parser import FieldConfigDictParser  # noqa: F401
diff --git a/entity_embed/data_utils/field_config_parser.py b/entity_embed/data_utils/field_config_parser.py
index e548235..ffecfa5 100644
--- a/entity_embed/data_utils/field_config_parser.py
+++ b/entity_embed/data_utils/field_config_parser.py
@@ -2,7 +2,9 @@
 import logging
 from importlib import import_module
 
-from torchtext.vocab import Vocab
+from torch import Tensor, nn
+from torchtext.vocab import Vocab, Vectors, build_vocab_from_iterator
+from torchtext.vocab import vocab as tt_vocab
 
 from .numericalizer import (
     AVAILABLE_VOCABS,
@@ -66,6 +68,7 @@ def _parse_field_config(cls, field, field_config, record_list):
         alphabet = field_config.get("alphabet", DEFAULT_ALPHABET)
         max_str_len = field_config.get("max_str_len")
         vocab = None
+        vector_tensor = None
 
         # Check if there's a key defined on the field_config,
         # useful when we want to have multiple FieldConfig for the same field
@@ -92,8 +95,33 @@ def _parse_field_config(cls, field, field_config, record_list):
                     "field_config if you wish to use a override "
                     "an field name."
                 )
-            vocab = Vocab(vocab_counter)
-            vocab.load_vectors(vocab_type)
+
+            vectors = Vectors(vocab_type, cache=".vector_cache")
+
+            vocab = tt_vocab(vocab_counter)
+
+            vectors = [vectors]
+            tot_dim = sum(v.dim for v in vectors)  # 100
+            vector_tensor = Tensor(len(vocab), tot_dim)
+
+            for i, token in enumerate(vocab.get_itos()):
+                start_dim = 0
+                for v in vectors:
+                    end_dim = start_dim + v.dim
+                    vector_tensor[i][start_dim:end_dim] = v[token.strip()]
+                    start_dim = end_dim
+                assert start_dim == tot_dim
+
+            print(f"Vector tensor shape: {vector_tensor.shape}")
+
+            print(len(vector_tensor))
+            print(len(vocab))
+
+            print(nn.Embedding.from_pretrained(vector_tensor))
+
+            # pretrained_vectors = vectors  # torchtext.vocab.FastText("en")
+
+            # vocab.load_vectors(vectors)
 
         # Compute max_str_len if necessary
         if field_type in (FieldType.STRING, FieldType.MULTITOKEN) and (max_str_len is None):
@@ -128,6 +156,7 @@ def _parse_field_config(cls, field, field_config, record_list):
             alphabet=alphabet,
             max_str_len=max_str_len,
             vocab=vocab,
+            vector_tensor=vector_tensor,
             n_channels=n_channels,
             embed_dropout_p=embed_dropout_p,
             use_attention=use_attention,
@@ -143,6 +172,7 @@ def _build_field_numericalizer(cls, field, field_config: FieldConfig):
             FieldType.SEMANTIC_STRING: SemanticStringNumericalizer,
             FieldType.SEMANTIC_MULTITOKEN: SemanticMultitokenNumericalizer,
         }
+        print(field_type_to_numericalizer_cls)
         numericalizer_cls = field_type_to_numericalizer_cls.get(field_type)
         if numericalizer_cls is None:
             raise ValueError(f"Unexpected field_type={field_type}")  # pragma: no cover
diff --git a/entity_embed/data_utils/numericalizer.py b/entity_embed/data_utils/numericalizer.py
index dbdbdc8..2960e70 100644
--- a/entity_embed/data_utils/numericalizer.py
+++ b/entity_embed/data_utils/numericalizer.py
@@ -7,7 +7,7 @@
 import numpy as np
 import regex
 import torch
-from torchtext.vocab import Vocab
+from torchtext.vocab import Vocab, Vectors
 
 logger = logging.getLogger(__name__)
 
@@ -45,6 +45,7 @@ class FieldConfig:
     alphabet: List[str]
     max_str_len: int
     vocab: Vocab
+    vector_tensor: torch.Tensor
     n_channels: int
     embed_dropout_p: float
     use_attention: bool
@@ -60,7 +61,7 @@ def __repr__(self):
         repr_dict = {}
         for k, v in self.__dict__.items():
             if isinstance(v, Callable):
-                repr_dict[k] = f"{inspect.getmodule(v).__name__}.{v.__name__}"
+                repr_dict[k] = f"{inspect.getmodule(v).__name__}.{getattr(v, '.__name__', repr(v))}"
             else:
                 repr_dict[k] = v
         return "{cls}({attrs})".format(
diff --git a/entity_embed/early_stopping.py b/entity_embed/early_stopping.py
index cf80e49..5e99b98 100644
--- a/entity_embed/early_stopping.py
+++ b/entity_embed/early_stopping.py
@@ -53,8 +53,8 @@ def __init__(
             save_top_k=save_top_k,
             save_weights_only=save_weights_only,
             mode=mode,
-            period=period,
-            prefix=prefix,
+            # period=period,
+            # prefix=prefix,
         )
         self.min_epochs = min_epochs
 
diff --git a/entity_embed/entity_embed.py b/entity_embed/entity_embed.py
index c4b8d95..adcbf44 100644
--- a/entity_embed/entity_embed.py
+++ b/entity_embed/entity_embed.py
@@ -12,12 +12,17 @@
 from .data_utils.datasets import RecordDataset
 from .early_stopping import EarlyStoppingMinEpochs, ModelCheckpointMinEpochs
 from .evaluation import f1_score, pair_entity_ratio, precision_and_recall
-from .indexes import ANNEntityIndex, ANNLinkageIndex
+
+from .indexes import ANNEntityIndex  # , ANNLinkageIndex
 from .models import BlockerNet
 
 logger = logging.getLogger(__name__)
 
 
+def hannah_test(n):
+    return n * 2
+
+
 class _BaseEmbed(pl.LightningModule):
     def __init__(
         self,
@@ -42,11 +47,12 @@ def __init__(
         self.record_numericalizer = record_numericalizer
         for field_config in self.record_numericalizer.field_config_dict.values():
             vocab = field_config.vocab
+            vector_tensor = field_config.vector_tensor
             if vocab:
                 # We can assume that there's only one vocab type across the
                 # whole field_config_dict, so we can stop the loop once we've
                 # found a field_config with a vocab
-                valid_embedding_size = vocab.vectors.size(1)
+                valid_embedding_size = vector_tensor.size(1)
                 if valid_embedding_size != embedding_size:
                     raise ValueError(
                         f"Invalid embedding_size={embedding_size}. "
@@ -99,7 +105,7 @@ def training_step(self, batch, batch_idx):
         self.log("train_loss", loss)
         return loss
 
-    def on_train_batch_end(self, outputs, batch, batch_idx, dataloader_idx):
+    def on_train_batch_end(self, outputs, batch, batch_idx, dataloader_idx=None):
         self.blocker_net.fix_pool_weights()
         self.log_dict(
             {
@@ -189,7 +195,7 @@ def fit(
             "max_epochs": max_epochs,
             "check_val_every_n_epoch": check_val_every_n_epoch,
             "callbacks": [early_stop_callback, checkpoint_callback],
-            "reload_dataloaders_every_epoch": True,  # for shuffling ClusterDataset every epoch
+            "reload_dataloaders_every_n_epochs": 10,  # for shuffling ClusterDataset every epoch
         }
         if use_gpu:
             trainer_args["gpus"] = 1
@@ -205,8 +211,9 @@ def fit(
                 "TensorBoardLogger or omit both to disable it"
             )
         trainer = pl.Trainer(**trainer_args)
+        print("Trainer done")
         trainer.fit(self, datamodule)
-
+        print("Model fit")
         logger.info(
             "Loading the best validation model from "
             f"{trainer.checkpoint_callback.best_model_path}..."
diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index c59151a..7045372 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -1,6 +1,7 @@
 import logging
+import faiss
 
-from n2 import HnswIndex
+# from n2 import HnswIndex
 
 from .helpers import build_index_build_kwargs, build_index_search_kwargs
 
@@ -9,13 +10,24 @@
 
 class ANNEntityIndex:
     def __init__(self, embedding_size):
-        self.approx_knn_index = HnswIndex(dimension=embedding_size, metric="angular")
+        self.approx_knn_index = faiss.index_factory(
+            embedding_size, "Flat", faiss.METRIC_INNER_PRODUCT
+        )
+        # self.approx_knn_index = HnswIndex(dimension=embedding_size, metric="angular")
         self.vector_idx_to_id = None
         self.is_built = False
+        print(self.approx_knn_index.is_trained)
 
     def insert_vector_dict(self, vector_dict):
         for vector in vector_dict.values():
-            self.approx_knn_index.add_data(vector)
+            # self.approx_knn_index.add_data(vector)
+
+            # print(vector.dtype)
+            # print(vector.shape)
+            # print(repr(vector))
+            vector = vector.reshape(1, 100)
+            # vector = faiss.normalize_L2(vector)
+            self.approx_knn_index.add(vector)
         self.vector_idx_to_id = dict(enumerate(vector_dict.keys()))
 
     def build(
@@ -25,9 +37,11 @@ def build(
         if self.vector_idx_to_id is None:
             raise ValueError("Please call insert_vector_dict first")
 
-        actual_index_build_kwargs = build_index_build_kwargs(index_build_kwargs)
-        self.approx_knn_index.build(**actual_index_build_kwargs)
+        # actual_index_build_kwargs = build_index_build_kwargs(index_build_kwargs)
+        # self.approx_knn_index.build(**actual_index_build_kwargs)
+        print(self.approx_knn_index.ntotal)
         self.is_built = True
+        # faiss.write_index(self.approx_knn_index, "vector.index")
 
     def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
         if not self.is_built:
@@ -36,105 +50,188 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
             raise ValueError(f"sim_threshold={sim_threshold} must be <= 1 and >= 0")
 
         logger.debug("Searching on approx_knn_index...")
-
+        print(sim_threshold)
         distance_threshold = 1 - sim_threshold
+        print(distance_threshold)
 
         index_search_kwargs = build_index_search_kwargs(index_search_kwargs)
-        neighbor_and_distance_list_of_list = self.approx_knn_index.batch_search_by_ids(
-            item_ids=self.vector_idx_to_id.keys(),
-            k=k,
-            include_distances=True,
-            **index_search_kwargs,
-        )
-
-        logger.debug("Search on approx_knn_index done, building found_pair_set now...")
 
         found_pair_set = set()
-        for i, neighbor_distance_list in enumerate(neighbor_and_distance_list_of_list):
+        item_ids = self.vector_idx_to_id  # .keys()
+        # print(item_ids)
+        for i in item_ids:
+            vector = self.approx_knn_index.reconstruct(i).reshape(1, 100)
+            # print(vector.shape)
+            # print(i)
+            similarities, neighbours = self.approx_knn_index.search(vector, k=k)
             left_id = self.vector_idx_to_id[i]
-            for j, distance in neighbor_distance_list:
-                if i != j and distance <= distance_threshold:
+            # print(similarities[0])
+            for similarity, j in zip(similarities[0], neighbours[0]):
+                # print(j)
+                if i != j and similarity >= sim_threshold:
                     right_id = self.vector_idx_to_id[j]
                     # must use sorted to always have smaller id on left of pair tuple
                     pair = tuple(sorted([left_id, right_id]))
                     found_pair_set.add(pair)
 
-        logger.debug(
-            f"Building found_pair_set done. Found len(found_pair_set)={len(found_pair_set)} pairs."
-        )
-
-        return found_pair_set
-
-
-class ANNLinkageIndex:
-    def __init__(self, embedding_size):
-        self.left_index = ANNEntityIndex(embedding_size)
-        self.right_index = ANNEntityIndex(embedding_size)
-
-    def insert_vector_dict(self, left_vector_dict, right_vector_dict):
-        self.left_index.insert_vector_dict(vector_dict=left_vector_dict)
-        self.right_index.insert_vector_dict(vector_dict=right_vector_dict)
-
-    def build(
-        self,
-        index_build_kwargs=None,
-    ):
-        self.left_index.build(index_build_kwargs=index_build_kwargs)
-        self.right_index.build(index_build_kwargs=index_build_kwargs)
-
-    def search_pairs(
-        self,
-        k,
-        sim_threshold,
-        left_vector_dict,
-        right_vector_dict,
-        left_source,
-        index_search_kwargs=None,
-    ):
-        if not self.left_index.is_built or not self.right_index.is_built:
-            raise ValueError("Please call build first")
-        if sim_threshold > 1 or sim_threshold < 0:
-            raise ValueError(f"sim_threshold={sim_threshold} must be <= 1 and >= 0")
-
-        index_search_kwargs = build_index_search_kwargs(index_search_kwargs)
-        distance_threshold = 1 - sim_threshold
-        all_pair_set = set()
-
-        for dataset_name, index, vector_dict, other_index in [
-            (left_source, self.left_index, right_vector_dict, self.right_index),
-            (None, self.right_index, left_vector_dict, self.left_index),
-        ]:
-            logger.debug(f"Searching on approx_knn_index of dataset_name={dataset_name}...")
+        print(f"found_pair_set: {len(found_pair_set)}")
+        logger.debug("Search on approx_knn_index done, building found_pair_set now...")
 
-            neighbor_and_distance_list_of_list = index.approx_knn_index.batch_search_by_vectors(
-                vs=vector_dict.values(), k=k, include_distances=True, **index_search_kwargs
+        if False:
+            neighbor_and_distance_list_of_list = self.approx_knn_index.batch_search_by_ids(
+                item_ids=self.vector_idx_to_id.keys(),
+                k=k,
+                include_distances=True,
+                **index_search_kwargs,
             )
 
-            logger.debug(
-                f"Search on approx_knn_index of dataset_name={dataset_name}... done, "
-                "filling all_pair_set now..."
-            )
+            logger.debug("Search on approx_knn_index done, building found_pair_set now...")
 
+            found_pair_set = set()
             for i, neighbor_distance_list in enumerate(neighbor_and_distance_list_of_list):
-                other_id = other_index.vector_idx_to_id[i]
+                left_id = self.vector_idx_to_id[i]
                 for j, distance in neighbor_distance_list:
-                    if distance <= distance_threshold:  # do NOT check for i != j here
-                        id_ = index.vector_idx_to_id[j]
-                        if dataset_name and dataset_name == left_source:
-                            left_id, right_id = (id_, other_id)
-                        else:
-                            left_id, right_id = (other_id, id_)
-                        pair = (
-                            left_id,
-                            right_id,
-                        )  # do NOT use sorted here, figure out from datasets
-                        all_pair_set.add(pair)
-
-            logger.debug(f"Filling all_pair_set with dataset_name={dataset_name} done.")
+                    if i != j and distance <= distance_threshold:
+                        right_id = self.vector_idx_to_id[j]
+                        # must use sorted to always have smaller id on left of pair tuple
+                        pair = tuple(sorted([left_id, right_id]))
+                        found_pair_set.add(pair)
 
         logger.debug(
-            "All searches done, all_pair_set filled. "
-            f"Found len(all_pair_set)={len(all_pair_set)} pairs."
+            f"Building found_pair_set done. Found len(found_pair_set)={len(found_pair_set)} pairs."
         )
 
-        return all_pair_set
+        return found_pair_set
+
+
+# class ANNEntityIndex:
+#     def __init__(self, embedding_size):
+#         self.approx_knn_index = HnswIndex(dimension=embedding_size, metric="angular")
+#         self.vector_idx_to_id = None
+#         self.is_built = False
+
+#     def insert_vector_dict(self, vector_dict):
+#         for vector in vector_dict.values():
+#             self.approx_knn_index.add_data(vector)
+#         self.vector_idx_to_id = dict(enumerate(vector_dict.keys()))
+
+#     def build(
+#         self,
+#         index_build_kwargs=None,
+#     ):
+#         if self.vector_idx_to_id is None:
+#             raise ValueError("Please call insert_vector_dict first")
+
+#         actual_index_build_kwargs = build_index_build_kwargs(index_build_kwargs)
+#         self.approx_knn_index.build(**actual_index_build_kwargs)
+#         self.is_built = True
+
+#     def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
+#         if not self.is_built:
+#             raise ValueError("Please call build first")
+#         if sim_threshold > 1 or sim_threshold < 0:
+#             raise ValueError(f"sim_threshold={sim_threshold} must be <= 1 and >= 0")
+
+#         logger.debug("Searching on approx_knn_index...")
+
+#         distance_threshold = 1 - sim_threshold
+
+#         index_search_kwargs = build_index_search_kwargs(index_search_kwargs)
+#         neighbor_and_distance_list_of_list = self.approx_knn_index.batch_search_by_ids(
+#             item_ids=self.vector_idx_to_id.keys(),
+#             k=k,
+#             include_distances=True,
+#             **index_search_kwargs,
+#         )
+
+#         logger.debug("Search on approx_knn_index done, building found_pair_set now...")
+
+#         found_pair_set = set()
+#         for i, neighbor_distance_list in enumerate(neighbor_and_distance_list_of_list):
+#             left_id = self.vector_idx_to_id[i]
+#             for j, distance in neighbor_distance_list:
+#                 if i != j and distance <= distance_threshold:
+#                     right_id = self.vector_idx_to_id[j]
+#                     # must use sorted to always have smaller id on left of pair tuple
+#                     pair = tuple(sorted([left_id, right_id]))
+#                     found_pair_set.add(pair)
+
+#         logger.debug(
+#             f"Building found_pair_set done. Found len(found_pair_set)={len(found_pair_set)} pairs."
+#         )
+
+#         return found_pair_set
+
+
+# class ANNLinkageIndex:
+#     def __init__(self, embedding_size):
+#         self.left_index = ANNEntityIndex(embedding_size)
+#         self.right_index = ANNEntityIndex(embedding_size)
+
+#     def insert_vector_dict(self, left_vector_dict, right_vector_dict):
+#         self.left_index.insert_vector_dict(vector_dict=left_vector_dict)
+#         self.right_index.insert_vector_dict(vector_dict=right_vector_dict)
+
+#     def build(
+#         self,
+#         index_build_kwargs=None,
+#     ):
+#         self.left_index.build(index_build_kwargs=index_build_kwargs)
+#         self.right_index.build(index_build_kwargs=index_build_kwargs)
+
+#     def search_pairs(
+#         self,
+#         k,
+#         sim_threshold,
+#         left_vector_dict,
+#         right_vector_dict,
+#         left_source,
+#         index_search_kwargs=None,
+#     ):
+#         if not self.left_index.is_built or not self.right_index.is_built:
+#             raise ValueError("Please call build first")
+#         if sim_threshold > 1 or sim_threshold < 0:
+#             raise ValueError(f"sim_threshold={sim_threshold} must be <= 1 and >= 0")
+
+#         index_search_kwargs = build_index_search_kwargs(index_search_kwargs)
+#         distance_threshold = 1 - sim_threshold
+#         all_pair_set = set()
+
+#         for dataset_name, index, vector_dict, other_index in [
+#             (left_source, self.left_index, right_vector_dict, self.right_index),
+#             (None, self.right_index, left_vector_dict, self.left_index),
+#         ]:
+#             logger.debug(f"Searching on approx_knn_index of dataset_name={dataset_name}...")
+
+#             neighbor_and_distance_list_of_list = index.approx_knn_index.batch_search_by_vectors(
+#                 vs=vector_dict.values(), k=k, include_distances=True, **index_search_kwargs
+#             )
+
+#             logger.debug(
+#                 f"Search on approx_knn_index of dataset_name={dataset_name}... done, "
+#                 "filling all_pair_set now..."
+#             )
+
+#             for i, neighbor_distance_list in enumerate(neighbor_and_distance_list_of_list):
+#                 other_id = other_index.vector_idx_to_id[i]
+#                 for j, distance in neighbor_distance_list:
+#                     if distance <= distance_threshold:  # do NOT check for i != j here
+#                         id_ = index.vector_idx_to_id[j]
+#                         if dataset_name and dataset_name == left_source:
+#                             left_id, right_id = (id_, other_id)
+#                         else:
+#                             left_id, right_id = (other_id, id_)
+#                         pair = (
+#                             left_id,
+#                             right_id,
+#                         )  # do NOT use sorted here, figure out from datasets
+#                         all_pair_set.add(pair)
+
+#             logger.debug(f"Filling all_pair_set with dataset_name={dataset_name} done.")
+
+#         logger.debug(
+#             "All searches done, all_pair_set filled. "
+#             f"Found len(all_pair_set)={len(all_pair_set)} pairs."
+#         )
+
+#         return all_pair_set
diff --git a/entity_embed/models.py b/entity_embed/models.py
index 68f8159..e78e735 100644
--- a/entity_embed/models.py
+++ b/entity_embed/models.py
@@ -58,7 +58,7 @@ def __init__(self, field_config, embedding_size):
 
         self.embedding_size = embedding_size
         self.dense_net = nn.Sequential(
-            nn.Embedding.from_pretrained(field_config.vocab.vectors),
+            nn.Embedding.from_pretrained(field_config.vector_tensor),
             nn.Dropout(p=field_config.embed_dropout_p),
         )
 
diff --git a/requirements.txt b/requirements.txt
index 199a67b..e25e7b2 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,12 +1,12 @@
 click==7.1.2,<8.0
 more-itertools>=8.6.0,<9.0
-n2>=0.1.7,<1.2
+# n2>=0.1.7,<1.2
 numpy>=1.19.0
 ordered-set>=4.0.2
-pytorch_lightning>=1.1.6,<1.3
-pytorch-metric-learning>=0.9.98,<1.0
+pytorch_lightning>=1.1.6
+pytorch-metric-learning>=0.9.98
 regex>=2020.11.13
-torch>=1.7.1,<1.9
-torchtext>=0.8,<0.10
-torchvision>=0.8.2<0.10
+torch>=1.7.1
+torchtext>=0.8
+torchvision>=0.8.2
 tqdm>=4.53.0
diff --git a/tests/test_data_utils_helpers.py b/tests/test_data_utils_helpers.py
index 830717f..92ffe85 100644
--- a/tests/test_data_utils_helpers.py
+++ b/tests/test_data_utils_helpers.py
@@ -3,7 +3,8 @@
 import tempfile
 
 import mock
-import n2  # noqa: F401
+
+# import n2  # noqa: F401
 import pytest
 from entity_embed.data_utils.field_config_parser import FieldConfigDictParser
 from entity_embed.data_utils.numericalizer import FieldConfig, FieldType, RecordNumericalizer

From 698d85ab013a54ab69b6fef08570c674ba087bb8 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Thu, 27 Oct 2022 11:08:48 +0100
Subject: [PATCH 05/17] Remove some print statements

---
 .../data_utils/field_config_parser.py         | 28 ++++++++-----------
 entity_embed/data_utils/numericalizer.py      |  2 +-
 2 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/entity_embed/data_utils/field_config_parser.py b/entity_embed/data_utils/field_config_parser.py
index 7e247f8..9aa7284 100644
--- a/entity_embed/data_utils/field_config_parser.py
+++ b/entity_embed/data_utils/field_config_parser.py
@@ -3,7 +3,8 @@
 from importlib import import_module
 
 from torch import Tensor, nn
-from torchtext.vocab import Vocab, Vectors
+from torchtext.vocab import Vocab, Vectors, FastText
+from torchtext.vocab import vocab as factory_vocab
 
 from .numericalizer import (
     AVAILABLE_VOCABS,
@@ -95,10 +96,16 @@ def _parse_field_config(cls, field, field_config, record_list):
                     "an field name."
                 )
 
-            vectors = Vectors(vocab_type, cache=".vector_cache")
+            if vocab_type in {"tx_embeddings_large.vec", "tx_embeddings.vec"}:
+                vectors = Vectors(vocab_type, cache=".vector_cache")
+            elif vocab_type == "fasttext":
+                vectors = FastText("en")  # might need to add standard fasttext
+            else:
+                vocab.load_vectors(vocab_type)  # won't work
 
-            vocab = torchtext.vocab.vocab(vocab_counter)
+            vocab = factory_vocab(vocab_counter)
 
+            # create vector tensor using tokens in vocab, order important
             vectors = [vectors]
             tot_dim = sum(v.dim for v in vectors)  # 100
             vector_tensor = Tensor(len(vocab), tot_dim)
@@ -112,19 +119,9 @@ def _parse_field_config(cls, field, field_config, record_list):
                 assert start_dim == tot_dim
 
             print(f"Vector tensor shape: {vector_tensor.shape}")
+            assert len(vector_tensor) == len(vocab)
 
-            print(len(vector_tensor))
-            print(len(vocab))
-
-            print(nn.Embedding.from_pretrained(vector_tensor))
-
-            # pretrained_vectors = vectors  # torchtext.vocab.FastText("en")
-
-            #if vocab_type in {'tx_embeddings_large.vec', 'tx_embeddings.vec'}:
-                #vectors = Vectors(vocab_type, cache='.vector_cache')
-                #vocab.load_vectors(vectors)
-            #else:
-                #vocab.load_vectors(vocab_type)
+            print(nn.Embedding.from_pretrained(vector_tensor))  # check embedding works
 
         # Compute max_str_len if necessary
         if field_type in (FieldType.STRING, FieldType.MULTITOKEN) and (max_str_len is None):
@@ -175,7 +172,6 @@ def _build_field_numericalizer(cls, field, field_config: FieldConfig):
             FieldType.SEMANTIC_STRING: SemanticStringNumericalizer,
             FieldType.SEMANTIC_MULTITOKEN: SemanticMultitokenNumericalizer,
         }
-        print(field_type_to_numericalizer_cls)
         numericalizer_cls = field_type_to_numericalizer_cls.get(field_type)
         if numericalizer_cls is None:
             raise ValueError(f"Unexpected field_type={field_type}")  # pragma: no cover
diff --git a/entity_embed/data_utils/numericalizer.py b/entity_embed/data_utils/numericalizer.py
index 2bb6947..13f48f4 100644
--- a/entity_embed/data_utils/numericalizer.py
+++ b/entity_embed/data_utils/numericalizer.py
@@ -7,7 +7,7 @@
 import numpy as np
 import regex
 import torch
-from torchtext.vocab import Vocab, Vectors
+from torchtext.vocab import Vocab
 
 logger = logging.getLogger(__name__)
 

From d0020cea1dd0523c989a90d033dc7fea24639c5f Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Thu, 27 Oct 2022 14:10:17 +0100
Subject: [PATCH 06/17] Add GPU param

---
 entity_embed/entity_embed.py |  8 ++++---
 entity_embed/indexes.py      | 43 ++++--------------------------------
 2 files changed, 9 insertions(+), 42 deletions(-)

diff --git a/entity_embed/entity_embed.py b/entity_embed/entity_embed.py
index adcbf44..af1daf4 100644
--- a/entity_embed/entity_embed.py
+++ b/entity_embed/entity_embed.py
@@ -167,6 +167,7 @@ def fit(
         tb_save_dir=None,
         tb_name=None,
         use_gpu=True,
+        accelerator=None,
     ):
         if early_stop_mode is None:
             if "pair_entity_ratio_at" in early_stop_monitor:
@@ -199,7 +200,8 @@ def fit(
         }
         if use_gpu:
             trainer_args["gpus"] = 1
-
+        if accelerator:
+            trainer_args["accelerator"] = accelerator
         if tb_name and tb_save_dir:
             trainer_args["logger"] = TensorBoardLogger(
                 tb_save_dir,
@@ -211,9 +213,9 @@ def fit(
                 "TensorBoardLogger or omit both to disable it"
             )
         trainer = pl.Trainer(**trainer_args)
-        print("Trainer done")
+
         trainer.fit(self, datamodule)
-        print("Model fit")
+
         logger.info(
             "Loading the best validation model from "
             f"{trainer.checkpoint_callback.best_model_path}..."
diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index 7045372..32a0f81 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -20,14 +20,10 @@ def __init__(self, embedding_size):
 
     def insert_vector_dict(self, vector_dict):
         for vector in vector_dict.values():
-            # self.approx_knn_index.add_data(vector)
-
-            # print(vector.dtype)
-            # print(vector.shape)
-            # print(repr(vector))
-            vector = vector.reshape(1, 100)
+            vector = vector.reshape(1, len(vector))
             # vector = faiss.normalize_L2(vector)
             self.approx_knn_index.add(vector)
+            # self.approx_knn_index.add_data(vector)
         self.vector_idx_to_id = dict(enumerate(vector_dict.keys()))
 
     def build(
@@ -39,7 +35,6 @@ def build(
 
         # actual_index_build_kwargs = build_index_build_kwargs(index_build_kwargs)
         # self.approx_knn_index.build(**actual_index_build_kwargs)
-        print(self.approx_knn_index.ntotal)
         self.is_built = True
         # faiss.write_index(self.approx_knn_index, "vector.index")
 
@@ -50,55 +45,25 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
             raise ValueError(f"sim_threshold={sim_threshold} must be <= 1 and >= 0")
 
         logger.debug("Searching on approx_knn_index...")
-        print(sim_threshold)
         distance_threshold = 1 - sim_threshold
-        print(distance_threshold)
 
         index_search_kwargs = build_index_search_kwargs(index_search_kwargs)
 
         found_pair_set = set()
-        item_ids = self.vector_idx_to_id  # .keys()
-        # print(item_ids)
+        item_ids = self.vector_idx_to_id
         for i in item_ids:
             vector = self.approx_knn_index.reconstruct(i).reshape(1, 100)
-            # print(vector.shape)
-            # print(i)
             similarities, neighbours = self.approx_knn_index.search(vector, k=k)
             left_id = self.vector_idx_to_id[i]
-            # print(similarities[0])
             for similarity, j in zip(similarities[0], neighbours[0]):
-                # print(j)
                 if i != j and similarity >= sim_threshold:
                     right_id = self.vector_idx_to_id[j]
                     # must use sorted to always have smaller id on left of pair tuple
                     pair = tuple(sorted([left_id, right_id]))
                     found_pair_set.add(pair)
 
-        print(f"found_pair_set: {len(found_pair_set)}")
-        logger.debug("Search on approx_knn_index done, building found_pair_set now...")
-
-        if False:
-            neighbor_and_distance_list_of_list = self.approx_knn_index.batch_search_by_ids(
-                item_ids=self.vector_idx_to_id.keys(),
-                k=k,
-                include_distances=True,
-                **index_search_kwargs,
-            )
-
-            logger.debug("Search on approx_knn_index done, building found_pair_set now...")
-
-            found_pair_set = set()
-            for i, neighbor_distance_list in enumerate(neighbor_and_distance_list_of_list):
-                left_id = self.vector_idx_to_id[i]
-                for j, distance in neighbor_distance_list:
-                    if i != j and distance <= distance_threshold:
-                        right_id = self.vector_idx_to_id[j]
-                        # must use sorted to always have smaller id on left of pair tuple
-                        pair = tuple(sorted([left_id, right_id]))
-                        found_pair_set.add(pair)
-
         logger.debug(
-            f"Building found_pair_set done. Found len(found_pair_set)={len(found_pair_set)} pairs."
+            f"Search on approx_knn_index and building found_pair_set done. Found len(found_pair_set)={len(found_pair_set)} pairs."
         )
 
         return found_pair_set

From 2bc4801c28593cea014079f92954a9d6942ec5a1 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Thu, 27 Oct 2022 17:00:24 +0100
Subject: [PATCH 07/17] Add l2 norm

---
 entity_embed/entity_embed.py | 4 ----
 entity_embed/indexes.py      | 2 +-
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/entity_embed/entity_embed.py b/entity_embed/entity_embed.py
index af1daf4..0d95e0e 100644
--- a/entity_embed/entity_embed.py
+++ b/entity_embed/entity_embed.py
@@ -19,10 +19,6 @@
 logger = logging.getLogger(__name__)
 
 
-def hannah_test(n):
-    return n * 2
-
-
 class _BaseEmbed(pl.LightningModule):
     def __init__(
         self,
diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index 32a0f81..63b1b4f 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -21,7 +21,7 @@ def __init__(self, embedding_size):
     def insert_vector_dict(self, vector_dict):
         for vector in vector_dict.values():
             vector = vector.reshape(1, len(vector))
-            # vector = faiss.normalize_L2(vector)
+            faiss.normalize_L2(vector)
             self.approx_knn_index.add(vector)
             # self.approx_knn_index.add_data(vector)
         self.vector_idx_to_id = dict(enumerate(vector_dict.keys()))

From c70237eb9352d757a5af7a055ef7b567adb248a2 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Tue, 1 Nov 2022 11:36:14 +0000
Subject: [PATCH 08/17] Add requirements

---
 hannah_requirements.txt | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 hannah_requirements.txt

diff --git a/hannah_requirements.txt b/hannah_requirements.txt
new file mode 100644
index 0000000..8437c66
--- /dev/null
+++ b/hannah_requirements.txt
@@ -0,0 +1,15 @@
+click==8.0.4
+faiss==1.5.3
+mock==4.0.3
+more_itertools==9.0.0
+numpy==1.21.5
+ordered_set==4.1.0
+pytest==7.1.1
+pytorch_lightning==1.7.7
+pytorch_metric_learning==1.6.2
+regex==2022.3.15
+setuptools==61.2.0
+sphinx_rtd_theme==1.0.0
+torch==1.13.0
+torchtext==0.14.0
+tqdm==4.64.0

From 23b869c2290c8ff7efad84d6c5967279c495bd7e Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Tue, 1 Nov 2022 12:04:09 +0000
Subject: [PATCH 09/17] Add print statements throughout for device debugging

---
 entity_embed/cli.py                            |  3 ++-
 entity_embed/data_utils/field_config_parser.py | 10 ++++++++--
 entity_embed/entity_embed.py                   |  7 ++++++-
 entity_embed/models.py                         |  1 +
 requirements.txt                               |  4 +++-
 5 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/entity_embed/cli.py b/entity_embed/cli.py
index 2aebb02..b2bff4e 100644
--- a/entity_embed/cli.py
+++ b/entity_embed/cli.py
@@ -369,7 +369,8 @@ def _load_model(kwargs):
 
     model = model_cls.load_from_checkpoint(kwargs["model_save_filepath"], datamodule=None)
     if kwargs["use_gpu"]:
-        model = model.to(torch.device("cuda"))
+        # model = model.to(torch.device("cuda"))
+        model = model.to(torch.device("mps"))
     else:
         model = model.to(torch.device("cpu"))
     return model
diff --git a/entity_embed/data_utils/field_config_parser.py b/entity_embed/data_utils/field_config_parser.py
index 9aa7284..2ca3b35 100644
--- a/entity_embed/data_utils/field_config_parser.py
+++ b/entity_embed/data_utils/field_config_parser.py
@@ -2,6 +2,7 @@
 import logging
 from importlib import import_module
 
+import torch
 from torch import Tensor, nn
 from torchtext.vocab import Vocab, Vectors, FastText
 from torchtext.vocab import vocab as factory_vocab
@@ -107,8 +108,10 @@ def _parse_field_config(cls, field, field_config, record_list):
 
             # create vector tensor using tokens in vocab, order important
             vectors = [vectors]
-            tot_dim = sum(v.dim for v in vectors)  # 100
-            vector_tensor = Tensor(len(vocab), tot_dim)
+            # device = torch.device("mps")
+            tot_dim = sum(v.dim for v in vectors)
+            # vector_tensor = torch.zeros(len(vocab), tot_dim)
+            vector_tensor = torch.Tensor(len(vocab), tot_dim)
 
             for i, token in enumerate(vocab.get_itos()):
                 start_dim = 0
@@ -119,6 +122,9 @@ def _parse_field_config(cls, field, field_config, record_list):
                 assert start_dim == tot_dim
 
             print(f"Vector tensor shape: {vector_tensor.shape}")
+            print(f"Vector tensor type: {vector_tensor.shape}")
+            print(f"Vector tensor type: {vector_tensor.device}")
+            print(f"Vector tensor type: {vector_tensor.dtype}")
             assert len(vector_tensor) == len(vocab)
 
             print(nn.Embedding.from_pretrained(vector_tensor))  # check embedding works
diff --git a/entity_embed/entity_embed.py b/entity_embed/entity_embed.py
index 0d95e0e..1c9cabd 100644
--- a/entity_embed/entity_embed.py
+++ b/entity_embed/entity_embed.py
@@ -73,11 +73,13 @@ def __init__(
         self.sim_threshold_list = sim_threshold_list
         self.index_build_kwargs = index_build_kwargs
         self.index_search_kwargs = index_search_kwargs
+        self._dev = "mps"
+        print(self.device)
+        print(self._dev)
 
     def forward(self, tensor_dict, sequence_length_dict, return_field_embeddings=False):
         tensor_dict = utils.tensor_dict_to_device(tensor_dict, device=self.device)
         sequence_length_dict = utils.tensor_dict_to_device(sequence_length_dict, device=self.device)
-
         return self.blocker_net(tensor_dict, sequence_length_dict, return_field_embeddings)
 
     def _warn_if_empty_indices_tuple(self, indices_tuple, batch_idx):
@@ -194,6 +196,7 @@ def fit(
             "callbacks": [early_stop_callback, checkpoint_callback],
             "reload_dataloaders_every_n_epochs": 10,  # for shuffling ClusterDataset every epoch
         }
+        print(self.device)
         if use_gpu:
             trainer_args["gpus"] = 1
         if accelerator:
@@ -217,6 +220,8 @@ def fit(
             f"{trainer.checkpoint_callback.best_model_path}..."
         )
         self.blocker_net = None
+        print(self.device)
+        print(self._dev)
         best_model = self.load_from_checkpoint(trainer.checkpoint_callback.best_model_path)
         best_model = best_model.to(self.device)
         self.blocker_net = best_model.blocker_net
diff --git a/entity_embed/models.py b/entity_embed/models.py
index e78e735..e69b5cb 100644
--- a/entity_embed/models.py
+++ b/entity_embed/models.py
@@ -151,6 +151,7 @@ def forward(self, x, sequence_lengths, **kwargs):
         x_list = x.unbind(dim=1)
         x_list = [self.embed_net(x) for x in x_list]
         x = torch.stack(x_list, dim=1)
+        print(x.device)
 
         # Compute a mask for the attention on the padded sequences
         # See e.g. https://discuss.pytorch.org/t/self-attention-on-words-and-masking/5671/5
diff --git a/requirements.txt b/requirements.txt
index e25e7b2..d17f5b0 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,5 @@
 click==7.1.2,<8.0
 more-itertools>=8.6.0,<9.0
-# n2>=0.1.7,<1.2
 numpy>=1.19.0
 ordered-set>=4.0.2
 pytorch_lightning>=1.1.6
@@ -10,3 +9,6 @@ torch>=1.7.1
 torchtext>=0.8
 torchvision>=0.8.2
 tqdm>=4.53.0
+
+# conda install grpcio
+# pip install faiss-cpu
\ No newline at end of file

From 6b967b6938fe0d71f46c21f90201bc7f85a2b3d9 Mon Sep 17 00:00:00 2001
From: Benj Pettit <benjamin.p@meetcleo.com>
Date: Tue, 1 Nov 2022 13:52:15 +0000
Subject: [PATCH 10/17] feat: L2 normalization of vectors to produce
 cosine-similarity ANN search. torch package upgrades. added FAISS dependency.

---
 entity_embed/indexes.py | 11 +++++------
 requirements.txt        | 13 ++++++++-----
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index 32a0f81..bbdcc62 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -1,5 +1,6 @@
 import logging
 import faiss
+import numpy as np
 
 # from n2 import HnswIndex
 
@@ -19,11 +20,10 @@ def __init__(self, embedding_size):
         print(self.approx_knn_index.is_trained)
 
     def insert_vector_dict(self, vector_dict):
-        for vector in vector_dict.values():
-            vector = vector.reshape(1, len(vector))
-            # vector = faiss.normalize_L2(vector)
-            self.approx_knn_index.add(vector)
-            # self.approx_knn_index.add_data(vector)
+        vector_array = np.array(list(vector_dict.values()))
+        l2_norm = np.linalg.norm(vector_array, ord=2, axis=1).reshape(vector_array.shape[0], 1)
+        vector_array_normalized = vector_array / l2_norm
+        self.approx_knn_index.add(vector_array_normalized)
         self.vector_idx_to_id = dict(enumerate(vector_dict.keys()))
 
     def build(
@@ -68,7 +68,6 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
 
         return found_pair_set
 
-
 # class ANNEntityIndex:
 #     def __init__(self, embedding_size):
 #         self.approx_knn_index = HnswIndex(dimension=embedding_size, metric="angular")
diff --git a/requirements.txt b/requirements.txt
index e25e7b2..2193f53 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,10 +3,13 @@ more-itertools>=8.6.0,<9.0
 # n2>=0.1.7,<1.2
 numpy>=1.19.0
 ordered-set>=4.0.2
-pytorch_lightning>=1.1.6
-pytorch-metric-learning>=0.9.98
 regex>=2020.11.13
-torch>=1.7.1
-torchtext>=0.8
-torchvision>=0.8.2
+pytorch-lightning==1.7.7
+pytorch-metric-learning>=0.9.99
+torch==1.12.1
+torchmetrics>=0.10.1
+torchtext==0.13.1
+torchvision>=0.13.1
 tqdm>=4.53.0
+faiss_cpu==1.7.2
+

From 18c7aae0906f8eecc0c17f83dfae0b3f7b4c235d Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Tue, 1 Nov 2022 18:32:14 +0000
Subject: [PATCH 11/17] Add default token to vocab:

---
 entity_embed/data_utils/field_config_parser.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/entity_embed/data_utils/field_config_parser.py b/entity_embed/data_utils/field_config_parser.py
index 2ca3b35..fdc204f 100644
--- a/entity_embed/data_utils/field_config_parser.py
+++ b/entity_embed/data_utils/field_config_parser.py
@@ -104,7 +104,13 @@ def _parse_field_config(cls, field, field_config, record_list):
             else:
                 vocab.load_vectors(vocab_type)  # won't work
 
-            vocab = factory_vocab(vocab_counter)
+            # adding <unk> token
+            unk_token = "<unk>"
+            vocab = factory_vocab(vocab_counter, specials=[unk_token])
+            # print(vocab["<unk>"])  # prints 0
+            # make default index same as index of unk_token
+            vocab.set_default_index(vocab[unk_token])
+            # print(vocab["probably out of vocab"])  # prints 0
 
             # create vector tensor using tokens in vocab, order important
             vectors = [vectors]

From 83715a1ba0319eaad8e4ae08837c1cc0b8010974 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Wed, 2 Nov 2022 13:05:42 +0000
Subject: [PATCH 12/17] Add truncation

---
 entity_embed/data_utils/numericalizer.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/entity_embed/data_utils/numericalizer.py b/entity_embed/data_utils/numericalizer.py
index 13f48f4..a4e3018 100644
--- a/entity_embed/data_utils/numericalizer.py
+++ b/entity_embed/data_utils/numericalizer.py
@@ -103,9 +103,11 @@ def build_tensor(self, val):
         # with characters as rows and positions as columns.
         # This is the shape expected by StringEmbedCNN.
         ord_encoded_val = self._ord_encode(val)
+        ord_encoded_val = ord_encoded_val[: self.max_str_len]  # truncate to max_str_len
         encoded_arr = np.zeros((len(self.alphabet), self.max_str_len), dtype=np.float32)
         if len(ord_encoded_val) > 0:
             encoded_arr[ord_encoded_val, range(len(ord_encoded_val))] = 1.0
+
         t = torch.from_numpy(encoded_arr)
         return t, len(val)
 

From 103c8070862b4c01115fd44bdbbf09bfbf200621 Mon Sep 17 00:00:00 2001
From: Benjamin Pettit <benjamin.p@Benjamin-Pettits-MacBook-Pro.local>
Date: Thu, 3 Nov 2022 09:45:14 +0000
Subject: [PATCH 13/17] feat(evaluation): model-agnostic embedding evaluator

---
 entity_embed/evaluation.py | 23 +++++++++++++++++++++++
 entity_embed/indexes.py    | 13 ++++++-------
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/entity_embed/evaluation.py b/entity_embed/evaluation.py
index 87ed12d..34a0f4c 100755
--- a/entity_embed/evaluation.py
+++ b/entity_embed/evaluation.py
@@ -1,5 +1,8 @@
 import csv
 import json
+from .indexes import ANNEntityIndex
+from .data_utils import utils
+import pandas as pd
 
 
 def pair_entity_ratio(found_pair_set_len, entity_count):
@@ -53,3 +56,23 @@ def evaluate_output_json(
         f1_score(precision, recall),
         pair_entity_ratio(len(found_pair_set), record_count),
     )
+
+
+class EmbeddingEvaluator:
+    def __init__(self, record_dict, vector_dict, cluster_field='cluster_id'):
+        self.record_dict = record_dict
+        self.cluster_field = cluster_field
+        embedding_size = len(next(iter(vector_dict.values())))
+        self.ann_index = ANNEntityIndex(embedding_size)
+        self.ann_index.insert_vector_dict(vector_dict)
+        self.ann_index.build()
+
+    def evaluate(self, k, sim_thresholds):
+        cluster_dict = utils.record_dict_to_cluster_dict(self.record_dict, self.cluster_field)
+        pos_pair_set = utils.cluster_dict_to_id_pairs(cluster_dict)
+        results = []
+        for sim_threshold in sim_thresholds:
+            found_pair_set = self.ann_index.search_pairs(k, sim_threshold)
+            precision, recall = precision_and_recall(found_pair_set, pos_pair_set)
+            results.append((sim_threshold, precision, recall, f1_score(precision, recall)))
+        return pd.DataFrame(results, columns=['threshold', 'precision', 'recall', 'f1_score'])
diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index bbdcc62..86b9752 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -16,14 +16,15 @@ def __init__(self, embedding_size):
         )
         # self.approx_knn_index = HnswIndex(dimension=embedding_size, metric="angular")
         self.vector_idx_to_id = None
+        self.normalized_vector_array = None
         self.is_built = False
-        print(self.approx_knn_index.is_trained)
+        self.embedding_size = embedding_size
 
     def insert_vector_dict(self, vector_dict):
         vector_array = np.array(list(vector_dict.values()))
         l2_norm = np.linalg.norm(vector_array, ord=2, axis=1).reshape(vector_array.shape[0], 1)
-        vector_array_normalized = vector_array / l2_norm
-        self.approx_knn_index.add(vector_array_normalized)
+        self.normalized_vector_array = vector_array / l2_norm
+        self.approx_knn_index.add(self.normalized_vector_array)
         self.vector_idx_to_id = dict(enumerate(vector_dict.keys()))
 
     def build(
@@ -50,11 +51,9 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
         index_search_kwargs = build_index_search_kwargs(index_search_kwargs)
 
         found_pair_set = set()
-        item_ids = self.vector_idx_to_id
-        for i in item_ids:
-            vector = self.approx_knn_index.reconstruct(i).reshape(1, 100)
+        for i, left_id in self.vector_idx_to_id.items():
+            vector = self.normalized_vector_array[[i], :]
             similarities, neighbours = self.approx_knn_index.search(vector, k=k)
-            left_id = self.vector_idx_to_id[i]
             for similarity, j in zip(similarities[0], neighbours[0]):
                 if i != j and similarity >= sim_threshold:
                     right_id = self.vector_idx_to_id[j]

From 5621e974ca7ab75ec5bd7c0dec0de8bc9158138e Mon Sep 17 00:00:00 2001
From: Benjamin Pettit <benjamin.p@Benjamin-Pettits-MacBook-Pro.local>
Date: Fri, 4 Nov 2022 13:27:55 +0000
Subject: [PATCH 14/17] feat(evaluation): evaluator takes an optional list of
 query_ids

---
 entity_embed/evaluation.py | 29 ++++++++++++++++++++++++-----
 entity_embed/indexes.py    | 19 ++++++++++---------
 2 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/entity_embed/evaluation.py b/entity_embed/evaluation.py
index 34a0f4c..4f89457 100755
--- a/entity_embed/evaluation.py
+++ b/entity_embed/evaluation.py
@@ -1,5 +1,6 @@
 import csv
 import json
+import random
 from .indexes import ANNEntityIndex
 from .data_utils import utils
 import pandas as pd
@@ -66,13 +67,31 @@ def __init__(self, record_dict, vector_dict, cluster_field='cluster_id'):
         self.ann_index = ANNEntityIndex(embedding_size)
         self.ann_index.insert_vector_dict(vector_dict)
         self.ann_index.build()
+        self.cluster_dict = utils.record_dict_to_cluster_dict(self.record_dict, self.cluster_field)
+        self.pos_pair_set = utils.cluster_dict_to_id_pairs(self.cluster_dict)
+
+    def evaluate(self, k, sim_thresholds, query_ids=None):
+        """
+        params:
+        k: int: number of nearest neighbours to retrieve
+        sim_thresholds: list of floats in the range [0,1]:
+        query_ids: list or set of ids that must be keys in self.vector_dict and self.record_dict. Indicates
+            which ids to find pairs for. If None, use all record ids as query ids
+
+        returns: pandas DataFrame of results, with one row for each threshold
+        """
+        if query_ids is None:
+            print(f"Using all {len(self.record_dict)} records to query for neighbours")
+            pos_pair_subset = self.pos_pair_set
+        else:
+            query_ids = set(query_ids)
+            print(f"Using subset of {len(query_ids)} query IDs")
+            pos_pair_subset = {pair for pair in self.pos_pair_set
+                               if pair[0] in query_ids or pair[1] in query_ids}
 
-    def evaluate(self, k, sim_thresholds):
-        cluster_dict = utils.record_dict_to_cluster_dict(self.record_dict, self.cluster_field)
-        pos_pair_set = utils.cluster_dict_to_id_pairs(cluster_dict)
         results = []
         for sim_threshold in sim_thresholds:
-            found_pair_set = self.ann_index.search_pairs(k, sim_threshold)
-            precision, recall = precision_and_recall(found_pair_set, pos_pair_set)
+            found_pair_set = self.ann_index.search_pairs(k, sim_threshold, query_id_subset=query_ids)
+            precision, recall = precision_and_recall(found_pair_set, pos_pair_subset)
             results.append((sim_threshold, precision, recall, f1_score(precision, recall)))
         return pd.DataFrame(results, columns=['threshold', 'precision', 'recall', 'f1_score'])
diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index 86b9752..11d5ef0 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -39,7 +39,7 @@ def build(
         self.is_built = True
         # faiss.write_index(self.approx_knn_index, "vector.index")
 
-    def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
+    def search_pairs(self, k, sim_threshold, index_search_kwargs=None, query_id_subset=None):
         if not self.is_built:
             raise ValueError("Please call build first")
         if sim_threshold > 1 or sim_threshold < 0:
@@ -52,14 +52,15 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None):
 
         found_pair_set = set()
         for i, left_id in self.vector_idx_to_id.items():
-            vector = self.normalized_vector_array[[i], :]
-            similarities, neighbours = self.approx_knn_index.search(vector, k=k)
-            for similarity, j in zip(similarities[0], neighbours[0]):
-                if i != j and similarity >= sim_threshold:
-                    right_id = self.vector_idx_to_id[j]
-                    # must use sorted to always have smaller id on left of pair tuple
-                    pair = tuple(sorted([left_id, right_id]))
-                    found_pair_set.add(pair)
+            if query_id_subset is None or left_id in query_id_subset:
+                vector = self.normalized_vector_array[[i], :]
+                similarities, neighbours = self.approx_knn_index.search(vector, k=k)
+                for similarity, j in zip(similarities[0], neighbours[0]):
+                    if i != j and similarity >= sim_threshold:
+                        right_id = self.vector_idx_to_id[j]
+                        # must use sorted to always have smaller id on left of pair tuple
+                        pair = tuple(sorted([left_id, right_id]))
+                        found_pair_set.add(pair)
 
         logger.debug(
             f"Search on approx_knn_index and building found_pair_set done. Found len(found_pair_set)={len(found_pair_set)} pairs."

From 6ab22dee9e669489e142e56e92f53a337851e509 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Fri, 4 Nov 2022 15:35:42 +0000
Subject: [PATCH 15/17] feat(evaluation): add missing pair sets

---
 entity_embed/evaluation.py | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/entity_embed/evaluation.py b/entity_embed/evaluation.py
index 4f89457..a6a60cb 100755
--- a/entity_embed/evaluation.py
+++ b/entity_embed/evaluation.py
@@ -60,7 +60,7 @@ def evaluate_output_json(
 
 
 class EmbeddingEvaluator:
-    def __init__(self, record_dict, vector_dict, cluster_field='cluster_id'):
+    def __init__(self, record_dict, vector_dict, cluster_field="cluster_id"):
         self.record_dict = record_dict
         self.cluster_field = cluster_field
         embedding_size = len(next(iter(vector_dict.values())))
@@ -70,7 +70,7 @@ def __init__(self, record_dict, vector_dict, cluster_field='cluster_id'):
         self.cluster_dict = utils.record_dict_to_cluster_dict(self.record_dict, self.cluster_field)
         self.pos_pair_set = utils.cluster_dict_to_id_pairs(self.cluster_dict)
 
-    def evaluate(self, k, sim_thresholds, query_ids=None):
+    def evaluate(self, k, sim_thresholds, query_ids=None, get_missing_pair_set=False):
         """
         params:
         k: int: number of nearest neighbours to retrieve
@@ -86,12 +86,24 @@ def evaluate(self, k, sim_thresholds, query_ids=None):
         else:
             query_ids = set(query_ids)
             print(f"Using subset of {len(query_ids)} query IDs")
-            pos_pair_subset = {pair for pair in self.pos_pair_set
-                               if pair[0] in query_ids or pair[1] in query_ids}
-
+            pos_pair_subset = {
+                pair for pair in self.pos_pair_set if pair[0] in query_ids or pair[1] in query_ids
+            }
         results = []
         for sim_threshold in sim_thresholds:
-            found_pair_set = self.ann_index.search_pairs(k, sim_threshold, query_id_subset=query_ids)
+            found_pair_set = self.ann_index.search_pairs(
+                k, sim_threshold, query_id_subset=query_ids
+            )
             precision, recall = precision_and_recall(found_pair_set, pos_pair_subset)
             results.append((sim_threshold, precision, recall, f1_score(precision, recall)))
-        return pd.DataFrame(results, columns=['threshold', 'precision', 'recall', 'f1_score'])
+            if get_missing_pair_set & (sim_threshold == min(sim_thresholds)):
+                self.missing_pair_set = pos_pair_subset - found_pair_set
+                id_to_name_map = {k: v["merchant_name"] for k, v in self.record_dict.items()}
+                self.missing_pair_name_set = set(
+                    map(
+                        lambda x: (id_to_name_map[x[0]], id_to_name_map[x[1]]),
+                        self.missing_pair_set,
+                    )
+                )
+
+        return pd.DataFrame(results, columns=["threshold", "precision", "recall", "f1_score"])

From 35e386f31485abe845a8effa376b47b5bdac519d Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Mon, 7 Nov 2022 17:19:49 +0000
Subject: [PATCH 16/17] feat: add logging

---
 entity_embed/evaluation.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/entity_embed/evaluation.py b/entity_embed/evaluation.py
index a6a60cb..ae5c189 100755
--- a/entity_embed/evaluation.py
+++ b/entity_embed/evaluation.py
@@ -4,7 +4,9 @@
 from .indexes import ANNEntityIndex
 from .data_utils import utils
 import pandas as pd
+import logging
 
+logger = logging.getLogger(__name__)
 
 def pair_entity_ratio(found_pair_set_len, entity_count):
     return found_pair_set_len / entity_count
@@ -64,10 +66,13 @@ def __init__(self, record_dict, vector_dict, cluster_field="cluster_id"):
         self.record_dict = record_dict
         self.cluster_field = cluster_field
         embedding_size = len(next(iter(vector_dict.values())))
+        logging.info("Building index...")
         self.ann_index = ANNEntityIndex(embedding_size)
         self.ann_index.insert_vector_dict(vector_dict)
         self.ann_index.build()
+        logging.info("Index built! Getting cluster dict...")
         self.cluster_dict = utils.record_dict_to_cluster_dict(self.record_dict, self.cluster_field)
+        logging.info("Getting positive pairs...")
         self.pos_pair_set = utils.cluster_dict_to_id_pairs(self.cluster_dict)
 
     def evaluate(self, k, sim_thresholds, query_ids=None, get_missing_pair_set=False):
@@ -81,11 +86,11 @@ def evaluate(self, k, sim_thresholds, query_ids=None, get_missing_pair_set=False
         returns: pandas DataFrame of results, with one row for each threshold
         """
         if query_ids is None:
-            print(f"Using all {len(self.record_dict)} records to query for neighbours")
+            logging.info(f"Using all {len(self.record_dict)} records to query for neighbours")
             pos_pair_subset = self.pos_pair_set
         else:
             query_ids = set(query_ids)
-            print(f"Using subset of {len(query_ids)} query IDs")
+            logging.info(f"Using subset of {len(query_ids)} query IDs")
             pos_pair_subset = {
                 pair for pair in self.pos_pair_set if pair[0] in query_ids or pair[1] in query_ids
             }

From 3e8e0252fd1ba23994102b2f23c02d3ba55525d4 Mon Sep 17 00:00:00 2001
From: Hannah <hannah.s@meetcleo.com>
Date: Fri, 18 Nov 2022 11:35:39 +0000
Subject: [PATCH 17/17] feat(preprocessor): add preprocessor feature

---
 entity_embed/__init__.py                      |  7 +++-
 .../data_utils/field_config_parser.py         | 15 ++++---
 entity_embed/data_utils/numericalizer.py      | 41 +++++++++++++++++++
 entity_embed/early_stopping.py                |  2 +-
 entity_embed/entity_embed.py                  | 26 +++++++-----
 entity_embed/evaluation.py                    | 12 ++++--
 entity_embed/indexes.py                       |  5 +++
 requirements.txt                              |  1 -
 8 files changed, 86 insertions(+), 23 deletions(-)

diff --git a/entity_embed/__init__.py b/entity_embed/__init__.py
index 9ce1ae6..4a5f21d 100644
--- a/entity_embed/__init__.py
+++ b/entity_embed/__init__.py
@@ -6,7 +6,12 @@
 
 from .data_modules import *  # noqa: F401, F403
 from .data_utils.field_config_parser import FieldConfigDictParser  # noqa: F401
-from .data_utils.numericalizer import default_tokenizer  # noqa: F401
+from .data_utils.numericalizer import (
+    default_tokenizer,
+    remove_space_digit_punc,
+    remove_places,
+    default_pre_processor,
+)  # noqa: F401
 from .entity_embed import *  # noqa: F401, F403
 from .indexes import *  # noqa: F401, F403
 
diff --git a/entity_embed/data_utils/field_config_parser.py b/entity_embed/data_utils/field_config_parser.py
index fdc204f..b7a6b54 100644
--- a/entity_embed/data_utils/field_config_parser.py
+++ b/entity_embed/data_utils/field_config_parser.py
@@ -66,6 +66,12 @@ def _parse_field_config(cls, field, field_config, record_list):
         tokenizer = _import_function(
             field_config.get("tokenizer", "entity_embed.default_tokenizer")
         )
+        pre_processor = _import_function(
+            field_config.get("pre_processor", "entity_embed.default_pre_processor")
+        )
+        multi_pre_processor = _import_function(
+            field_config.get("multi_pre_processor", "entity_embed.default_pre_processor")
+        )
         alphabet = field_config.get("alphabet", DEFAULT_ALPHABET)
         max_str_len = field_config.get("max_str_len")
         vocab = None
@@ -127,14 +133,9 @@ def _parse_field_config(cls, field, field_config, record_list):
                     start_dim = end_dim
                 assert start_dim == tot_dim
 
-            print(f"Vector tensor shape: {vector_tensor.shape}")
-            print(f"Vector tensor type: {vector_tensor.shape}")
-            print(f"Vector tensor type: {vector_tensor.device}")
-            print(f"Vector tensor type: {vector_tensor.dtype}")
+            logger.info(f"Vector tensor shape: {vector_tensor.shape}")
             assert len(vector_tensor) == len(vocab)
 
-            print(nn.Embedding.from_pretrained(vector_tensor))  # check embedding works
-
         # Compute max_str_len if necessary
         if field_type in (FieldType.STRING, FieldType.MULTITOKEN) and (max_str_len is None):
             logger.info(f"For field={field}, computing actual max_str_len")
@@ -165,6 +166,8 @@ def _parse_field_config(cls, field, field_config, record_list):
             key=key,
             field_type=field_type,
             tokenizer=tokenizer,
+            pre_processor=pre_processor,
+            multi_pre_processor=multi_pre_processor,
             alphabet=alphabet,
             max_str_len=max_str_len,
             vocab=vocab,
diff --git a/entity_embed/data_utils/numericalizer.py b/entity_embed/data_utils/numericalizer.py
index a4e3018..14246d8 100644
--- a/entity_embed/data_utils/numericalizer.py
+++ b/entity_embed/data_utils/numericalizer.py
@@ -4,10 +4,12 @@
 from enum import Enum
 from typing import Callable, List
 
+from string import punctuation
 import numpy as np
 import regex
 import torch
 from torchtext.vocab import Vocab
+from flashgeotext.geotext import GeoText, GeoTextConfiguration
 
 logger = logging.getLogger(__name__)
 
@@ -42,6 +44,8 @@ class FieldType(Enum):
 class FieldConfig:
     key: str
     field_type: FieldType
+    pre_processor: Callable[[str], List[str]]
+    multi_pre_processor: Callable[[str], List[str]]
     tokenizer: Callable[[str], List[str]]
     alphabet: List[str]
     max_str_len: int
@@ -79,6 +83,31 @@ def default_tokenizer(val):
     return tokenizer_re.findall(val)
 
 
+def remove_space_digit_punc(val):
+    val = "".join(c for c in val if (not c.isdigit()) and (c not in punctuation))
+    return val.replace(" ", "")
+
+
+config = GeoTextConfiguration(**{"case_sensitive": False})
+geotext = GeoText(config)
+
+
+def default_pre_processor(text):
+    return text
+
+
+def remove_places(text):
+    places = geotext.extract(text)
+    found_places = []
+    for i, v in places.items():
+        for w, x in v.items():
+            word = x["found_as"][0]
+            if word not in ["at", "com", "us", "usa"]:
+                found_places.append(word)
+                text = text.replace(word, "")
+    return text
+
+
 class StringNumericalizer:
     is_multitoken = False
 
@@ -87,6 +116,8 @@ def __init__(self, field, field_config):
         self.alphabet = field_config.alphabet
         self.max_str_len = field_config.max_str_len
         self.char_to_ord = {c: i for i, c in enumerate(self.alphabet)}
+        self.pre_processor = field_config.pre_processor
+        print(f"Found pre_processor {self.pre_processor} for field {self.field}")
 
     def _ord_encode(self, val):
         ord_encoded = []
@@ -102,6 +133,9 @@ def build_tensor(self, val):
         # encoded_arr is a one hot encoded bidimensional tensor
         # with characters as rows and positions as columns.
         # This is the shape expected by StringEmbedCNN.
+        # if val != self.pre_processor(val):
+        #     print(f"{val} -> {self.pre_processor(val)} -> {self.pre_processor} -> {self.field}")
+        val = self.pre_processor(val)
         ord_encoded_val = self._ord_encode(val)
         ord_encoded_val = ord_encoded_val[: self.max_str_len]  # truncate to max_str_len
         encoded_arr = np.zeros((len(self.alphabet), self.max_str_len), dtype=np.float32)
@@ -131,10 +165,16 @@ class MultitokenNumericalizer:
 
     def __init__(self, field, field_config):
         self.field = field
+        self.field_type = field_config.field_type
+        self.multi_pre_processor = field_config.multi_pre_processor
         self.tokenizer = field_config.tokenizer
         self.string_numericalizer = StringNumericalizer(field=field, field_config=field_config)
+        print(f"Found multi_pre_processor {self.multi_pre_processor} for field {self.field}")
 
     def build_tensor(self, val):
+        # if val != self.multi_pre_processor(val):
+        #     print(f"{val} -> {self.multi_pre_processor(val)} -> {self.multi_pre_processor} -> {self.field}")
+        val = self.multi_pre_processor(val)
         val_tokens = self.tokenizer(val)
         t_list = []
         for v in val_tokens:
@@ -153,6 +193,7 @@ class SemanticMultitokenNumericalizer(MultitokenNumericalizer):
     def __init__(self, field, field_config):
         self.field = field
         self.tokenizer = field_config.tokenizer
+        self.multi_pre_processor = field_config.multi_pre_processor
         self.string_numericalizer = SemanticStringNumericalizer(
             field=field, field_config=field_config
         )
diff --git a/entity_embed/early_stopping.py b/entity_embed/early_stopping.py
index 5e99b98..5edd788 100644
--- a/entity_embed/early_stopping.py
+++ b/entity_embed/early_stopping.py
@@ -38,7 +38,7 @@ def __init__(
         dirpath=None,
         filename=None,
         verbose=False,
-        save_last=None,
+        save_last=True,
         save_top_k=None,
         save_weights_only=False,
         period=1,
diff --git a/entity_embed/entity_embed.py b/entity_embed/entity_embed.py
index 1c9cabd..c613103 100644
--- a/entity_embed/entity_embed.py
+++ b/entity_embed/entity_embed.py
@@ -74,8 +74,6 @@ def __init__(
         self.index_build_kwargs = index_build_kwargs
         self.index_search_kwargs = index_search_kwargs
         self._dev = "mps"
-        print(self.device)
-        print(self._dev)
 
     def forward(self, tensor_dict, sequence_length_dict, return_field_embeddings=False):
         tensor_dict = utils.tensor_dict_to_device(tensor_dict, device=self.device)
@@ -154,6 +152,7 @@ def fit(
         min_epochs=5,
         max_epochs=100,
         check_val_every_n_epoch=1,
+        use_early_stop=False,
         early_stop_monitor="valid_recall_at_0.3",
         early_stop_min_delta=0.0,
         early_stop_patience=20,
@@ -161,18 +160,19 @@ def fit(
         early_stop_verbose=True,
         model_save_top_k=1,
         model_save_dir=None,
+        model_save_filename=None,
         model_save_verbose=False,
         tb_save_dir=None,
         tb_name=None,
-        use_gpu=True,
-        accelerator=None,
+        use_gpu=False,
+        accelerator="cpu",
+        ckpt_path=None,
     ):
         if early_stop_mode is None:
             if "pair_entity_ratio_at" in early_stop_monitor:
                 early_stop_mode = "min"
             else:
                 early_stop_mode = "max"
-
         early_stop_callback = EarlyStoppingMinEpochs(
             min_epochs=min_epochs,
             monitor=early_stop_monitor,
@@ -181,22 +181,27 @@ def fit(
             mode=early_stop_mode,
             verbose=early_stop_verbose,
         )
+        callbacks = []
+        if use_early_stop:
+            callbacks.append(early_stop_callback)
+            print("Using early stopping callback...")
         checkpoint_callback = ModelCheckpointMinEpochs(
             min_epochs=min_epochs,
             monitor=early_stop_monitor,
             save_top_k=model_save_top_k,
             mode=early_stop_mode,
             dirpath=model_save_dir,
+            filename=model_save_filename,
             verbose=model_save_verbose,
         )
+        callbacks.append(checkpoint_callback)
         trainer_args = {
             "min_epochs": min_epochs,
             "max_epochs": max_epochs,
             "check_val_every_n_epoch": check_val_every_n_epoch,
-            "callbacks": [early_stop_callback, checkpoint_callback],
+            "callbacks": callbacks,
             "reload_dataloaders_every_n_epochs": 10,  # for shuffling ClusterDataset every epoch
         }
-        print(self.device)
         if use_gpu:
             trainer_args["gpus"] = 1
         if accelerator:
@@ -211,17 +216,18 @@ def fit(
                 'Please provide both "tb_name" and "tb_save_dir" to enable '
                 "TensorBoardLogger or omit both to disable it"
             )
+        fit_args = {}
+        if ckpt_path:
+            fit_args["ckpt_path"] = ckpt_path
         trainer = pl.Trainer(**trainer_args)
 
-        trainer.fit(self, datamodule)
+        trainer.fit(self, datamodule, **fit_args)
 
         logger.info(
             "Loading the best validation model from "
             f"{trainer.checkpoint_callback.best_model_path}..."
         )
         self.blocker_net = None
-        print(self.device)
-        print(self._dev)
         best_model = self.load_from_checkpoint(trainer.checkpoint_callback.best_model_path)
         best_model = best_model.to(self.device)
         self.blocker_net = best_model.blocker_net
diff --git a/entity_embed/evaluation.py b/entity_embed/evaluation.py
index ae5c189..4cf767d 100755
--- a/entity_embed/evaluation.py
+++ b/entity_embed/evaluation.py
@@ -8,6 +8,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 def pair_entity_ratio(found_pair_set_len, entity_count):
     return found_pair_set_len / entity_count
 
@@ -70,9 +71,8 @@ def __init__(self, record_dict, vector_dict, cluster_field="cluster_id"):
         self.ann_index = ANNEntityIndex(embedding_size)
         self.ann_index.insert_vector_dict(vector_dict)
         self.ann_index.build()
-        logging.info("Index built! Getting cluster dict...")
+        logging.info("Index built!")
         self.cluster_dict = utils.record_dict_to_cluster_dict(self.record_dict, self.cluster_field)
-        logging.info("Getting positive pairs...")
         self.pos_pair_set = utils.cluster_dict_to_id_pairs(self.cluster_dict)
 
     def evaluate(self, k, sim_thresholds, query_ids=None, get_missing_pair_set=False):
@@ -100,7 +100,9 @@ def evaluate(self, k, sim_thresholds, query_ids=None, get_missing_pair_set=False
                 k, sim_threshold, query_id_subset=query_ids
             )
             precision, recall = precision_and_recall(found_pair_set, pos_pair_subset)
-            results.append((sim_threshold, precision, recall, f1_score(precision, recall)))
+            results.append(
+                (sim_threshold, precision, recall, f1_score(precision, recall), len(found_pair_set))
+            )
             if get_missing_pair_set & (sim_threshold == min(sim_thresholds)):
                 self.missing_pair_set = pos_pair_subset - found_pair_set
                 id_to_name_map = {k: v["merchant_name"] for k, v in self.record_dict.items()}
@@ -111,4 +113,6 @@ def evaluate(self, k, sim_thresholds, query_ids=None, get_missing_pair_set=False
                     )
                 )
 
-        return pd.DataFrame(results, columns=["threshold", "precision", "recall", "f1_score"])
+        return pd.DataFrame(
+            results, columns=["threshold", "precision", "recall", "f1_score", "n_pairs_found"]
+        )
diff --git a/entity_embed/indexes.py b/entity_embed/indexes.py
index 11d5ef0..9363152 100644
--- a/entity_embed/indexes.py
+++ b/entity_embed/indexes.py
@@ -55,6 +55,10 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None, query_id_subs
             if query_id_subset is None or left_id in query_id_subset:
                 vector = self.normalized_vector_array[[i], :]
                 similarities, neighbours = self.approx_knn_index.search(vector, k=k)
+                if all(similarities[0] >= sim_threshold) & (sim_threshold > 0.4):
+                    print(
+                        f"Found pair similarities for k = {k} are all higher than threshold {sim_threshold}"
+                    )
                 for similarity, j in zip(similarities[0], neighbours[0]):
                     if i != j and similarity >= sim_threshold:
                         right_id = self.vector_idx_to_id[j]
@@ -68,6 +72,7 @@ def search_pairs(self, k, sim_threshold, index_search_kwargs=None, query_id_subs
 
         return found_pair_set
 
+
 # class ANNEntityIndex:
 #     def __init__(self, embedding_size):
 #         self.approx_knn_index = HnswIndex(dimension=embedding_size, metric="angular")
diff --git a/requirements.txt b/requirements.txt
index a25190d..4384bba 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,7 +8,6 @@ pytorch-metric-learning>=0.9.99
 torch==1.12.1
 torchmetrics>=0.10.1
 torchtext==0.13.1
-torchvision>=0.13.1
 tqdm>=4.53.0
 
 # conda install grpcio