notebooks/Deduplication-Example.ipynb

{
 "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": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from importlib import reload\n",
    "import logging\n",
    "reload(logging)\n",
    "logging.basicConfig(format='%(asctime)s %(levelname)s:%(message)s', level=logging.INFO, datefmt='%H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "sys.path.insert(0, '..')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import entity_embed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "random_seed = 42\n",
    "torch.manual_seed(random_seed)\n",
    "np.random.seed(random_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use the [Music Brainz 20K from Database Group Leipzig](https://dbs.uni-leipzig.de/research/projects/object_matching/benchmark_datasets_for_entity_resolution). From the site: \"The Music Brainz dataset is based on real records about songs from the MusicBrainz database but uses the DAPO data generator to create duplicates with modified attribute values. The generated dataset consists of five sources and contains duplicates for 50% of the original records in two to five sources. All duplicates are generated with a high degree of corruption to stress-test the ER and clustering approaches.\"\n",
    "\n",
    "Here is it's [README](https://www.informatik.uni-leipzig.de/~saeedi/musicBrainz_readme.txt):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "5 sources\n",
    "---------- \n",
    "TID: a unique record's id (in the complete dataset).\n",
    "CID: cluster id (records having the same CID are duplicate)\n",
    "CTID: a unique id within a cluster (if two records belong to the same cluster they will have the same CID but different CTIDs). These ids (CTID) start with 1 and grow until cluster size.\n",
    "SourceID: identifies to which source a record belongs (there are five sources). The sources are deduplicated.\n",
    "Id: the original id from the source. Each source has its own Id-Format. Uniqueness is not guaranteed!! (can be ignored).\n",
    "number: track or song number in the album.\n",
    "length: the length of the track.\n",
    "artist: the interpreter (artist or band) of the track.\n",
    "year: date of publication.\n",
    "language: language of the track.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's download the CSV dataset to a temporary directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib\n",
    "import tempfile\n",
    "\n",
    "dataset_url = 'https://www.informatik.uni-leipzig.de/~saeedi/musicbrainz-20-A01.csv.dapo'\n",
    "tf = tempfile.NamedTemporaryFile(mode='r', delete=False)\n",
    "tf.close()\n",
    "\n",
    "urllib.request.urlretrieve(dataset_url, tf.name);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we must read the CSV dataset into a `dict` called `record_dict`.\n",
    "\n",
    "`record_dict` will contain all records from the dataset, and each record will have the indication of the true cluster it belongs to in the field `CID`.\n",
    "\n",
    "So `CID` is our `cluster_field`. Entity Embed needs that to train, validate, and test.\n",
    "\n",
    "We'll dynamically attribute an `id` to each record using `enumerate`. Entity Embed needs that too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "record_dict = {}\n",
    "cluster_field = 'CID'\n",
    "\n",
    "with open(tf.name, newline='') as f:\n",
    "    for current_record_id, record in enumerate(csv.DictReader(f)):\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example of a record:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'TID': '84',\n",
       " 'CID': 9369,\n",
       " 'CTID': '4',\n",
       " 'SourceID': '4',\n",
       " 'id': 83,\n",
       " 'number': '1',\n",
       " 'title': '001-Berimbou',\n",
       " 'length': '2m 23sec',\n",
       " 'artist': 'Astrud Gilberto',\n",
       " 'album': 'Look to the Rainbow (2008)',\n",
       " 'year': 'null',\n",
       " 'language': ' Eng.'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "record_dict[83]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a great song, but it's actually called \"Berimbau\", not \"Berimbou\"! And it's a Brazilian song, in Portuguese. This a small example on how noisy is this dataset..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many clusters this dataset has?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 9,
     "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 20% for training, and other 20% for validation to test how well we can generalize:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "21:28:05 INFO:Singleton cluster sizes (train, valid, test):(1000, 1000, 3000)\n",
      "21:28:05 INFO:Plural cluster sizes (train, valid, test):(1000, 1000, 3000)\n"
     ]
    }
   ],
   "source": [
    "from entity_embed.data_utils import utils\n",
    "\n",
    "train_record_dict, valid_record_dict, test_record_dict = utils.split_record_dict_on_clusters(\n",
    "    record_dict=record_dict,\n",
    "    cluster_field=cluster_field,\n",
    "    train_proportion=0.2,\n",
    "    valid_proportion=0.2,\n",
    "    random_seed=random_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note we're splitting the data on **clusters**, not records, so the record counts vary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3845, 3876, 11654)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_record_dict), len(valid_record_dict), len(test_record_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clean up the temporary files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.remove(tf.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll perform a very minimal preprocessing of the dataset. We want to simply force ASCII chars, lowercase all chars, and strip leading and trailing whitespace.\n",
    "\n",
    "The fields we'll clean are the ones we'll use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "field_list = ['number', 'title', 'artist', 'album', 'year', 'language']"
   ]
  },
  {
   "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": [
       "{'number': '1',\n",
       " 'title': '001-berimbou',\n",
       " 'artist': 'astrud gilberto',\n",
       " 'album': 'look to the rainbow (2008)',\n",
       " 'year': 'null',\n",
       " 'language': 'eng.'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "utils.subdict(record_dict[83], 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 entity_embed.data_utils.field_config_parser import DEFAULT_ALPHABET\n",
    "\n",
    "alphabet = DEFAULT_ALPHABET\n",
    "''.join(alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth noting you can use any alphabet you need, so the accent removal we performed is optional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we set an `field_config_dict`. It defines `field_type`s that determine how fields are processed in the neural network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "field_config_dict = {\n",
    "    'number': {\n",
    "        'field_type': \"STRING\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'title': {\n",
    "        'field_type': \"MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'title_semantic': {\n",
    "        'key': 'title',\n",
    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'vocab': \"fasttext.en.300d\",\n",
    "    },\n",
    "    'artist': {\n",
    "        'field_type': \"MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'album': {\n",
    "        'field_type': \"MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'album_semantic': {\n",
    "        'key': 'album',\n",
    "        'field_type': \"SEMANTIC_MULTITOKEN\",\n",
    "        'tokenizer': \"entity_embed.default_tokenizer\",\n",
    "        'vocab': \"fasttext.en.300d\",\n",
    "    },\n",
    "    'year': {\n",
    "        'field_type': \"STRING\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "    'language': {\n",
    "        'field_type': \"STRING\",\n",
    "        'alphabet': alphabet,\n",
    "        'max_str_len': None,  # compute\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we use our `field_config_dict` to get a `record_numericalizer`. This object will convert the strings from our records into tensors for the neural network.\n",
    "\n",
    "The same `record_numericalizer` must be used on ALL data: train, valid, test. This ensures numericalization will be consistent. Therefore, we pass `record_list=record_dict.values()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "21:28:05 INFO:For field=number, computing actual max_str_len\n",
      "21:28:05 INFO:For field=number, using actual_max_str_len=56\n",
      "21:28:05 INFO:For field=title, computing actual max_str_len\n",
      "21:28:05 INFO:For field=title, using actual_max_str_len=38\n",
      "21:28:05 INFO:Loading vectors from .vector_cache/wiki.en.vec.pt\n",
      "21:28:09 INFO:For field=artist, computing actual max_str_len\n",
      "21:28:09 INFO:actual_max_str_len=31 must be even to enable NN pooling. Updating to 32\n",
      "21:28:09 INFO:For field=artist, using actual_max_str_len=32\n",
      "21:28:09 INFO:For field=album, computing actual max_str_len\n",
      "21:28:09 INFO:For field=album, using actual_max_str_len=40\n",
      "21:28:09 INFO:Loading vectors from .vector_cache/wiki.en.vec.pt\n",
      "21:28:13 INFO:For field=year, computing actual max_str_len\n",
      "21:28:13 INFO:For field=year, using actual_max_str_len=68\n",
      "21:28:13 INFO:For field=language, computing actual max_str_len\n",
      "21:28:13 INFO:For field=language, using actual_max_str_len=72\n"
     ]
    }
   ],
   "source": [
    "from entity_embed import FieldConfigDictParser\n",
    "\n",
    "record_numericalizer = FieldConfigDictParser.from_dict(field_config_dict, record_list=record_dict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Data Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "under the hood, Entity Embed uses [pytorch-lightning](https://pytorch-lightning.readthedocs.io/en/latest/), so we need to create a datamodule object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 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",
    ")"
   ]
  },
  {
   "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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from entity_embed import EntityEmbed\n",
    "\n",
    "ann_k = 100\n",
    "model = EntityEmbed(\n",
    "    record_numericalizer,\n",
    "    ann_k=ann_k,\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": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "21:28:14 INFO:GPU available: True, used: True\n",
      "21:28:14 INFO:TPU available: False, using: 0 TPU cores\n",
      "21:28:14 INFO:Train positive pair count: 3193\n",
      "21:28:14 INFO:Valid positive pair count: 3256\n",
      "21:28:14 INFO:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "21:29:40 INFO:\n",
      "  | Name        | Type       | Params\n",
      "-------------------------------------------\n",
      "0 | blocker_net | BlockerNet | 37.1 M\n",
      "1 | loss_fn     | SupConLoss | 0     \n",
      "-------------------------------------------\n",
      "27.4 M    Trainable params\n",
      "9.8 M     Non-trainable params\n",
      "37.1 M    Total params\n",
      "148.528   Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation sanity check: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8edce859f54c4c71ae15463e337a8697",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "21:36:39 INFO:Loading the best validation model from tb_logs/music/version_2/checkpoints/epoch=7-step=993.ckpt...\n"
     ]
    }
   ],
   "source": [
    "trainer = model.fit(\n",
    "    datamodule,\n",
    "    min_epochs=5,\n",
    "    max_epochs=100,\n",
    "    check_val_every_n_epoch=1,\n",
    "    early_stop_monitor=\"valid_recall_at_0.3\",\n",
    "    tb_save_dir='tb_logs',\n",
    "    tb_name='music',\n",
    ")"
   ]
  },
  {
   "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": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'valid_f1_at_0.3': 0.0884584253632036,\n",
       " 'valid_f1_at_0.5': 0.6781917749382583,\n",
       " 'valid_f1_at_0.7': 0.9420405556442599,\n",
       " 'valid_pair_entity_ratio_at_0.3': 17.96620227038184,\n",
       " 'valid_pair_entity_ratio_at_0.5': 1.5626934984520124,\n",
       " 'valid_pair_entity_ratio_at_0.7': 0.7757997936016512,\n",
       " 'valid_precision_at_0.3': 0.04629722704883898,\n",
       " 'valid_precision_at_0.5': 0.5213802212316329,\n",
       " 'valid_precision_at_0.7': 0.9810442301296973,\n",
       " 'valid_recall_at_0.3': 0.9901719901719902,\n",
       " 'valid_recall_at_0.5': 0.9699017199017199,\n",
       " 'valid_recall_at_0.7': 0.9060196560196561}"
      ]
     },
     "execution_count": 22,
     "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": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'number': 0.10696423798799515,\n",
       " 'title': 0.1652841418981552,\n",
       " 'title_semantic': 0.18542489409446716,\n",
       " 'artist': 0.10326992720365524,\n",
       " 'album': 0.14224572479724884,\n",
       " 'album_semantic': 0.17302878201007843,\n",
       " 'year': 0.06483650952577591,\n",
       " 'language': 0.058945849537849426}"
      ]
     },
     "execution_count": 23,
     "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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "21:36:57 INFO:Test positive pair count: 9801\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'test_f1_at_0.3': 0.039520721725206466,\n",
       " 'test_f1_at_0.5': 0.39654243190580823,\n",
       " 'test_f1_at_0.7': 0.9129705837524767,\n",
       " 'test_pair_entity_ratio_at_0.3': 41.332418053887075,\n",
       " 'test_pair_entity_ratio_at_0.5': 3.2985241118929123,\n",
       " 'test_pair_entity_ratio_at_0.7': 0.8479492019907328,\n",
       " 'test_precision_at_0.3': 0.02016242879208118,\n",
       " 'test_precision_at_0.5': 0.24882287141333473,\n",
       " 'test_precision_at_0.7': 0.9092289010321797,\n",
       " 'test_recall_at_0.3': 0.990919293949597,\n",
       " 'test_recall_at_0.5': 0.9759208244056728,\n",
       " 'test_recall_at_0.7': 0.9167431894704622}"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "603ca0e083404c3faa487c207e6c1d59",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "# batch embedding:   0%|          | 0/183 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "vis_sample_size = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cluster_dict = utils.record_dict_to_cluster_dict(test_record_dict, cluster_field)\n",
    "vis_cluster_dict = dict(sorted(test_cluster_dict.items(), key=lambda x: len(x[1]), reverse=True)[:vis_sample_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "vis_x = np.stack([test_vector_dict[id_] for cluster in vis_cluster_dict.values() for id_ in cluster])\n",
    "vis_y = np.array([cluster_id for cluster_id, cluster in vis_cluster_dict.items() for __ in cluster])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 30,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import itertools\n",
    "\n",
    "plt.figure(figsize=(16,10))\n",
    "ax = sns.scatterplot(\n",
    "    x=tsne_results[:,0],\n",
    "    y=tsne_results[:,1],\n",
    "    hue=vis_y,\n",
    "    palette=sns.color_palette(\"hls\", len(vis_cluster_dict.keys())),\n",
    "    legend=\"full\",\n",
    "    alpha=0.8\n",
    ")\n",
    "for id_, (x, y) in zip(itertools.chain.from_iterable(vis_cluster_dict.values()), tsne_results):\n",
    "    # text = id_\n",
    "    text = test_record_dict[id_]['title'][:30]\n",
    "    ax.text(x + 2, y + 2, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing manually (like a production run)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When running in production, you only have access to the trained `model` object and the production `record_dict` (without the `cluster_field` filled, of course).\n",
    "\n",
    "So let's simulate that by removing `cluster_field` from the `test_record_dict`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "prod_test_record_dict = copy.deepcopy(test_record_dict)\n",
    "\n",
    "for record in prod_test_record_dict.values():\n",
    "    del record[cluster_field]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then call `predict_pairs` with some `ann_k` and `sim_threshold`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9cee5777a6664895b4a2822a812f720e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "# batch embedding:   0%|          | 0/183 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "481673"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim_threshold = 0.3\n",
    "\n",
    "found_pair_set = model.predict_pairs(\n",
    "    record_dict=prod_test_record_dict,\n",
    "    batch_size=eval_batch_size,\n",
    "    ann_k=ann_k,\n",
    "    sim_threshold=sim_threshold\n",
    ")\n",
    "len(found_pair_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check now the metrics of the found duplicate pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41.33113094216578"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from entity_embed.evaluation import pair_entity_ratio\n",
    "\n",
    "pair_entity_ratio(len(found_pair_set), len(prod_test_record_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.020163056679531548, 0.990919293949597)"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "471961"
      ]
     },
     "execution_count": 35,
     "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": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "89"
      ]
     },
     "execution_count": 36,
     "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": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "cos_similarity = lambda a, b: np.dot(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.37550455,\n",
       " {'number': '3',\n",
       "  'title': 'tia carrere - why you wanna break my heart',\n",
       "  'artist': '',\n",
       "  'album': 'ballroom blitz (from the motion picture \"wayne\\'s world\")',\n",
       "  'year': '92',\n",
       "  'language': 'english'},\n",
       " {'number': '1',\n",
       "  'title': 'bring it back',\n",
       "  'artist': 'arthur dobrucki',\n",
       "  'album': 'all you need',\n",
       "  'year': '',\n",
       "  'language': 'english'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.42070764,\n",
       " {'number': '016',\n",
       "  'title': 'red-naped sapsucker / red-breasted sapsucker (the stokes field guide to bird songs: western region)',\n",
       "  'artist': 'donald & lillian stokes with kevin colver',\n",
       "  'album': 'the the stokes field guide to bird songs: western region',\n",
       "  'year': '',\n",
       "  'language': ''},\n",
       " {'number': '006',\n",
       "  'title': 'not a bad night, just the usual, really (river sand)',\n",
       "  'artist': 'wooden ambulance',\n",
       "  'album': 'river sand',\n",
       "  'year': '2013',\n",
       "  'language': ''})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.33568144,\n",
       " {'number': '13',\n",
       "  'title': \"isham jones & his orchestra - life begins when you're in love\",\n",
       "  'artist': '',\n",
       "  'album': 'jazz in the charts 024 (1936)',\n",
       "  'year': '',\n",
       "  'language': 'english'},\n",
       " {'number': '003',\n",
       "  'title': 'birks works (the chronological classics: dizzy gillespie and his orchestra 1951-1952)',\n",
       "  'artist': 'dizzy gillespie and his orchestra',\n",
       "  'album': 'the chronological classics: dizzy gillespie and his orchestra 1951-1952',\n",
       "  'year': '2003',\n",
       "  'language': ''})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for (id_left, id_right) in false_positives[:3]:\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": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.20283234,\n",
       " {'number': '9',\n",
       "  'title': 'one ton (volunteered slavery)',\n",
       "  'artist': 'rahsaan roland kirk',\n",
       "  'album': 'volunteered slavery',\n",
       "  'year': '2005',\n",
       "  'language': ''},\n",
       " {'number': '7',\n",
       "  'title': 'rahsaan roland kirk - one ton',\n",
       "  'artist': '',\n",
       "  'album': 'unknown',\n",
       "  'year': '05',\n",
       "  'language': 'english'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.20968628,\n",
       " {'number': '2',\n",
       "  'title': '002-make my day',\n",
       "  'artist': 'flamingo star',\n",
       "  'album': 'eng.',\n",
       "  'year': 'null',\n",
       "  'language': 'east volume lotus - mixed by ping (2009)'},\n",
       " {'number': '2',\n",
       "  'title': 'null',\n",
       "  'artist': '',\n",
       "  'album': 'east volume lotus - mixed by ping',\n",
       "  'year': '09',\n",
       "  'language': 'english'})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(-0.08710163,\n",
       " {'number': 'mbox3093886-hh',\n",
       "  'title': '4',\n",
       "  'artist': '275',\n",
       "  'album': '',\n",
       "  'year': 'billboard latin music awards 2000',\n",
       "  'language': ''},\n",
       " {'number': '004',\n",
       "  'title': 'llegar a ti (billboard latin music awards 2000)',\n",
       "  'artist': 'jaci velasquez',\n",
       "  'album': 'billboard latin music awards 2000',\n",
       "  'year': '',\n",
       "  'language': ''})"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for (id_left, id_right) in false_negatives[:3]:\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",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}