missing_values.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import random\n",
    "from functools import partial\n",
    "import pandas as pd\n",
    "import anonlink\n",
    "from clkhash.field_formats import *\n",
    "from clkhash.comparators import NgramComparison\n",
    "from clkhash import Schema\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from clk_based_comparison import generate_clks, pr_curve_from_clks\n",
    "from token_based_utils import tokenize_entities, sim_fun\n",
    "from eval_utils import compute_accuracies, load_true_matches\n",
    "from analysis import get_aucs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_DIR = 'data'\n",
    "MAX_SPARSENESS = 80  # up to 80% missing data\n",
    "SPARSENESS_STEP = 5  # in 5% steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploration of how Anonlink handles missing data\n",
    "\n",
    "Anonlink uses CLKs for entity resolution.\n",
    "\n",
    "Although CLKs have been shown to work well for linkage on real world data, little work has been done to evaluate their resilience to missing data.\n",
    "\n",
    "A CLK is a composite Bloom filter, that is that for an entity record, all feature values are tokenized and then inserted into one Bloom filter in such a way that the similarity of two filters relates to the similarity of the corresponding entity records.\n",
    "\n",
    "The approach of combining all entity information into one representation can lead to problems when the entity information is incomplete. Consider the following scenario: \n",
    "\n",
    "```\n",
    "Dataset A: John | Doe | First Street | 24 |      |             | 0404123456 \n",
    "Dataset B: John | Doe |              | 24 | 1234 | Sunny Hills |\n",
    "```\n",
    "Those two records have three out of the seven features in common. This means that the corresponding composite Bloom filters each contain information from two features which is missing in the other filter. Thus, the comparison will procude a reduced similarity score.\n",
    "\n",
    "This raises an interesting question. Will the reduction in similarity scores have an impact on the linkage results? And if so, what is the relationship between data sparseness and linkage quality?\\\n",
    "We will try to answer those question with some experimentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### data creation\n",
    "We use the febrl tool to generate PII data. We create two pairs of base datasets, one where the entity records in the second dataset are identical to the first, if present, and in the second pair we introduce typical noise (like spelling mistakes).\n",
    "\n",
    "For both pairs of base datasets we then create a series of datasets where we control the sparseness. In 5% increments, we remove datapoints from both datasets, up to 80% missing data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sparsify_df(df, percentage, seed=None):\n",
    "    \"\"\"removes 'percentage' percent elements from dataframe 'df' \"\"\"\n",
    "    rows = df.shape[0]\n",
    "    cols = df.shape[1]\n",
    "    num_elements = rows * cols\n",
    "    num_to_remove = int(round(num_elements * percentage))\n",
    "    if seed is not None:\n",
    "        random.seed(seed)\n",
    "    rem = random.sample(range(num_elements), num_to_remove)\n",
    "    for i in rem:\n",
    "        row = i // cols\n",
    "        col = i % cols\n",
    "        df.iloc[row, col] = ''\n",
    "\n",
    "def load_datasets():\n",
    "    dfa = pd.read_csv(os.path.join(DATA_DIR, 'PII_A.csv'), index_col=0, skipinitialspace=True)\n",
    "    dfb_clean = pd.read_csv(os.path.join(DATA_DIR, 'PII_B_clean.csv'), index_col=0, skipinitialspace=True)\n",
    "    dfb_noisy = pd.read_csv(os.path.join(DATA_DIR, 'PII_B_noisy.csv'), index_col=0, skipinitialspace=True)\n",
    "    return dfa, dfb_clean, dfb_noisy\n",
    "\n",
    "def create_base_datasets():\n",
    "    dfa, dfb_clean, dfb_noisy = load_datasets()\n",
    "    noisy_path = os.path.join(DATA_DIR, 'noisy')\n",
    "    noisefree_path = os.path.join(DATA_DIR, 'noisefree')\n",
    "    os.makedirs(noisefree_path, exist_ok=True)\n",
    "    os.makedirs(noisy_path, exist_ok=True)\n",
    "    dfa.to_csv(os.path.join(noisy_path, '00_A.csv'))\n",
    "    dfb_noisy.to_csv(os.path.join(noisy_path, '00_B.csv'))\n",
    "    dfa.to_csv(os.path.join(noisefree_path, '00_A.csv'))\n",
    "    dfb_clean.to_csv(os.path.join(noisefree_path, '00_B.csv'))\n",
    "    \n",
    "    for sparsity in range(SPARSENESS_STEP, MAX_SPARSENESS+1, SPARSENESS_STEP):\n",
    "        print(f'creating datasets with {sparsity}% missing data...')\n",
    "        dfa, dfb_clean, dfb_noisy = load_datasets()\n",
    "        sparsify_df(dfa, sparsity/100)\n",
    "        dfa.to_csv(os.path.join(noisy_path, f'{sparsity:02}_A.csv'))\n",
    "        dfa.to_csv(os.path.join(noisefree_path, f'{sparsity:02}_A.csv'))\n",
    "        sparsify_df(dfb_noisy, sparsity / 100)\n",
    "        dfb_noisy.to_csv(os.path.join(noisy_path, f'{sparsity:02}_B.csv'))\n",
    "        sparsify_df(dfb_clean, sparsity/100)\n",
    "        dfb_clean.to_csv(os.path.join(noisefree_path, f'{sparsity:02}_B.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating datasets with 5% missing data...\n",
      "creating datasets with 10% missing data...\n",
      "creating datasets with 15% missing data...\n",
      "creating datasets with 20% missing data...\n",
      "creating datasets with 25% missing data...\n",
      "creating datasets with 30% missing data...\n",
      "creating datasets with 35% missing data...\n",
      "creating datasets with 40% missing data...\n",
      "creating datasets with 45% missing data...\n",
      "creating datasets with 50% missing data...\n",
      "creating datasets with 55% missing data...\n",
      "creating datasets with 60% missing data...\n",
      "creating datasets with 65% missing data...\n",
      "creating datasets with 70% missing data...\n",
      "creating datasets with 75% missing data...\n",
      "creating datasets with 80% missing data...\n"
     ]
    }
   ],
   "source": [
    "create_base_datasets()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linkage schema\n",
    "Clkhash support two different strategies to insert tokens into the Bloom filter:\n",
    "\n",
    "- BitsPerTokenStrategy: Insert every token *bitsPerToken* number of times.\n",
    "\n",
    "- BitsPerFeatureStrategy: Same number of insertions for each value of this feature, irrespective of the actual number of tokens. The number of filter insertions for a token is computed by dividing bitsPerFeature equally amongst the tokens.\n",
    "\n",
    "We will create CLKs for both strategies. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "clk_length = 1024\n",
    "\n",
    "fields = [\n",
    "    Ignore('id'),\n",
    "    StringSpec('given_name', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                    strategy=BitsPerTokenStrategy(8), \n",
    "                                                    missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('surname', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                 strategy=BitsPerTokenStrategy(8),\n",
    "                                                 missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('street_number', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                        strategy=BitsPerTokenStrategy(8), \n",
    "                                                        missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('address_1', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                   strategy=BitsPerTokenStrategy(8), \n",
    "                                                   missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('address_2', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                   strategy=BitsPerTokenStrategy(8), \n",
    "                                                   missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('suburb', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                strategy=BitsPerTokenStrategy(8), \n",
    "                                                missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('postcode', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                   strategy=BitsPerTokenStrategy(8), \n",
    "                                                   missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('state', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                               strategy=BitsPerTokenStrategy(8), \n",
    "                                               missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('date_of_birth', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                        strategy=BitsPerTokenStrategy(8), \n",
    "                                                        missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('phone_number', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                      strategy=BitsPerTokenStrategy(8), \n",
    "                                                      missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('soc_sec_id', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                     strategy=BitsPerTokenStrategy(8), \n",
    "                                                     missing_value=MissingValueSpec(sentinel='')))\n",
    "]\n",
    "\n",
    "fixed_k_schema = Schema(fields, clk_length)\n",
    "\n",
    "fields = [\n",
    "    Ignore('id'),\n",
    "    StringSpec('given_name', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                    strategy=BitsPerFeatureStrategy(60), \n",
    "                                                    missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('surname', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                 strategy=BitsPerFeatureStrategy(60), \n",
    "                                                 missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('street_number', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                        strategy=BitsPerFeatureStrategy(60),  \n",
    "                                                        missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('address_1', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                   strategy=BitsPerFeatureStrategy(60),  \n",
    "                                                   missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('address_2', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                   strategy=BitsPerFeatureStrategy(60), \n",
    "                                                   missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('suburb', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                                strategy=BitsPerFeatureStrategy(60), \n",
    "                                                missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('postcode', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                   strategy=BitsPerFeatureStrategy(60), \n",
    "                                                   missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('state', FieldHashingProperties(comparator=NgramComparison(2), \n",
    "                                               strategy=BitsPerFeatureStrategy(60), \n",
    "                                               missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('date_of_birth', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                        strategy=BitsPerFeatureStrategy(60), \n",
    "                                                        missing_value=MissingValueSpec(sentinel=''))),\n",
    "    StringSpec('phone_number', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                      strategy=BitsPerFeatureStrategy(60), \n",
    "                                                      missing_value=MissingValueSpec(sentinel=''))),\n",
    "    IntegerSpec('soc_sec_id', FieldHashingProperties(comparator=NgramComparison(1, positional=True), \n",
    "                                                     strategy=BitsPerFeatureStrategy(60), \n",
    "                                                     missing_value=MissingValueSpec(sentinel='')))\n",
    "]\n",
    "\n",
    "var_k_schema = Schema(fields, clk_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline\n",
    "We will compare clkhash against three different baselines:\n",
    "\n",
    "### per feature based comparison baselines\n",
    "We compare records on a per feature basis, that is, we compare two records by comparing the values for each feature \n",
    "separately and then combine those feature similarities in a meaningful way. \n",
    "This gives us a chance to treat the feature values that are missing differently to the present values.\n",
    "\n",
    "#### a) sum of similarities\n",
    "This is a simple way of combining the feature similarity. We just sum them up. The higher the sum, the more likely it is a match.\n",
    "\n",
    "#### b) averaged token comparison per feature\n",
    "We compute the similarity for each pair of feature values and set the similarity to zero if one of the values is missing. The similarity score is computed as the average of the non-zero similarity values. Finally, to favour scores with more non-zero similarity values, we introduce a penalty factor which increases with the number of features with missing data. (The choice of 0.95 is arbitrary, but experiments with different factors achieved very similar results.)\n",
    "\n",
    "![image.png](image.png)\n",
    "\n",
    "### comparisons of tokens of all features (composite)\n",
    "This is closer to CLKs. Here we produce all the tokens of a record combine them in a set. We then compute the similarity of the sets. So no detour to Bloom filters. \n",
    "This is interesting, as it is an upper bound of what composite Bloom filter based matching can achieve. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "currently working on noisefree with 0% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 5% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 10% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 15% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 20% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 25% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 30% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 35% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 40% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 45% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 50% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 55% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 60% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 65% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 70% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 75% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisefree with 80% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 0% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 5% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 10% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 15% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 20% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 25% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 30% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 35% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 40% missing values\n",
      "tokenize entities...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 45% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 50% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 55% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 60% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 65% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 70% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 75% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "currently working on noisy with 80% missing values\n",
      "tokenize entities...\n",
      "done\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=False ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=True and sum_of_sims=True ...\n",
      "solve...\n",
      "generate candidate pairs with per_feature=False and sum_of_sims=False ...\n",
      "solve...\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "def token_based_comparison(file_a, file_b, schema, true_matches):\n",
    "    print('tokenize entities...')\n",
    "    tok_a = tokenize_entities(file_a, schema)\n",
    "    tok_b = tokenize_entities(file_b, schema)\n",
    "    print('done')\n",
    "\n",
    "    folder, filename = os.path.split(file_a)\n",
    "    for per_feature, sum_of_sims in ((True, False), (True, True), (False, False)):\n",
    "        print(f'generate candidate pairs with per_feature={per_feature} and sum_of_sims={sum_of_sims} ...')\n",
    "        result = anonlink.candidate_generation.find_candidate_pairs(\n",
    "            (tok_a, tok_b),\n",
    "            partial(sim_fun, per_feature, sum_of_sims),\n",
    "            0.0)\n",
    "        print('solve...')\n",
    "        precisions, recalls = compute_accuracies(result, true_matches)\n",
    "        file_ex = \"per_feature\" if per_feature else \"composite\"\n",
    "        if sum_of_sims:\n",
    "            file_ex = file_ex + '_sum_of_sims'\n",
    "        with open(os.path.join(folder, f'{filename[0:2]}_pr_{file_ex}.pkl'), 'wb') as f:\n",
    "            pickle.dump((precisions, recalls), f)\n",
    "\n",
    "the_truth = load_true_matches(os.path.join(DATA_DIR, 'PII_A.csv'), os.path.join(DATA_DIR, 'PII_B_clean.csv'))\n",
    "for folder in ('noisefree', 'noisy'):\n",
    "    for percentage in range(0, MAX_SPARSENESS+1, SPARSENESS_STEP):\n",
    "        print(f'currently working on {folder} with {percentage}% missing values')\n",
    "        token_based_comparison(os.path.join(DATA_DIR, folder, f'{percentage:02}_A.csv'), \n",
    "                               os.path.join(DATA_DIR, folder, f'{percentage:02}_B.csv'), var_k_schema, the_truth)\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quality metric\n",
    "\n",
    "We measure the quality of the linkage as the area under the precision-recall curve. A precision-recall curve is very similar to ROC, the only difference is that it does not take the true negatives into account. This is very useful in our case, as we have an imbalanced problem (the number of non-matches outweighs the number of matches by orders of magnitude), and ROC would show skewed results. Precision-recall curves are not affected by the class imbalance.\n",
    "\n",
    "The area under the precision-recall curve has a value between 0 and 1, the higher, the better.\n",
    "\n",
    "Let's first look at the results for the baselines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def print_pr_curve(folder, strategies, title):\n",
    "    x = range(0, MAX_SPARSENESS+1, SPARSENESS_STEP)\n",
    "    aucs = get_aucs(folder, strategies)\n",
    "    for k, v in aucs.items():\n",
    "        plt.plot(x, v, label=k)\n",
    "    plt.title(title)\n",
    "    plt.legend()\n",
    "    plt.xlabel('% missing data')\n",
    "    plt.ylabel('area under PR curve')\n",
    "    plt.show()\n",
    "\n",
    "print_pr_curve(os.path.join(DATA_DIR, 'noisefree'), ('composite', 'per_feature', 'per_feature_sum_of_sims'), 'baseline - noisefree')\n",
    "print_pr_curve(os.path.join(DATA_DIR, 'noisy'), ('composite', 'per_feature', 'per_feature_sum_of_sims'), 'baseline - noisy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that it is advantegeous to compare the feature values separately, it produces better results for the same amount of missing data compared to the composite aproach. Surprisingly, the *composite* comparison is more resilient to noise in the data than the *per_feature* comparison as its performance is largly unaffected. The *per_feature* approach looses almost all of its advantage and the results are very similar.\n",
    "\n",
    "Let's produce the CLKs for both strategies and evaluate the linkage results over all the different datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "working on folder: data2/noisy\n",
      "current schema: bits_per_token\n",
      "working on 0% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.52kclk/s, mean=509, std=27.3]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.61kclk/s, mean=508, std=27.9]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 5% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.66kclk/s, mean=490, std=38.9]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.76kclk/s, mean=489, std=39.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 10% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.07kclk/s, mean=472, std=46.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.59kclk/s, mean=471, std=49.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 15% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.90kclk/s, mean=450, std=55.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.93kclk/s, mean=450, std=55.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 20% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.94kclk/s, mean=431, std=60.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.84kclk/s, mean=430, std=62.1]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 25% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.95kclk/s, mean=410, std=68.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.24kclk/s, mean=409, std=67.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 30% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.25kclk/s, mean=388, std=74.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.44kclk/s, mean=386, std=75]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 35% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.13kclk/s, mean=366, std=78.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.89kclk/s, mean=363, std=80.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 40% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.72kclk/s, mean=342, std=81.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.57kclk/s, mean=343, std=79.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 45% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.95kclk/s, mean=318, std=85]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.95kclk/s, mean=315, std=86.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 50% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.33kclk/s, mean=295, std=87.7]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.23kclk/s, mean=293, std=89.6]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 55% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.64kclk/s, mean=268, std=91.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.66kclk/s, mean=268, std=87.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 60% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.33kclk/s, mean=242, std=90.7]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.99kclk/s, mean=242, std=90.6]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 65% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.58kclk/s, mean=214, std=91.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.92kclk/s, mean=215, std=91.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 70% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.27kclk/s, mean=187, std=89.4]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.75kclk/s, mean=185, std=88.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 75% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.15kclk/s, mean=159, std=85.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.47kclk/s, mean=159, std=89.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 80% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 10.3kclk/s, mean=127, std=80.9]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 10.7kclk/s, mean=128, std=82.2]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "current schema: bits_per_feature\n",
      "working on 0% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.32kclk/s, mean=484, std=8.7] \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.25kclk/s, mean=484, std=8.79]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 5% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.43kclk/s, mean=466, std=25.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.26kclk/s, mean=466, std=26.1]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 10% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.58kclk/s, mean=447, std=34.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.47kclk/s, mean=447, std=36.1]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 15% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.73kclk/s, mean=428, std=42.5]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.38kclk/s, mean=428, std=42.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 20% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.96kclk/s, mean=409, std=47.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.82kclk/s, mean=408, std=49]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 25% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.29kclk/s, mean=388, std=53]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.11kclk/s, mean=388, std=54.2]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 30% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.48kclk/s, mean=367, std=60]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.33kclk/s, mean=367, std=60.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 35% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.78kclk/s, mean=345, std=63.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.64kclk/s, mean=345, std=65.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 40% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.87kclk/s, mean=323, std=66]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.28kclk/s, mean=323, std=66.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 45% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.35kclk/s, mean=301, std=70]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.08kclk/s, mean=300, std=72.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 50% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.74kclk/s, mean=277, std=71.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.37kclk/s, mean=277, std=73.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 55% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.11kclk/s, mean=253, std=74.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.99kclk/s, mean=253, std=70.9]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 60% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.72kclk/s, mean=228, std=75.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.44kclk/s, mean=228, std=73.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 65% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.48kclk/s, mean=202, std=75.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.16kclk/s, mean=202, std=75.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 70% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.19kclk/s, mean=175, std=74.9]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.02kclk/s, mean=175, std=75.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 75% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.86kclk/s, mean=148, std=71.5]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 9.19kclk/s, mean=148, std=75]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 80% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 10.4kclk/s, mean=120, std=66.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 10.7kclk/s, mean=120, std=69.1]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on folder: data2/noisefree\n",
      "current schema: bits_per_token\n",
      "working on 0% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.26kclk/s, mean=509, std=27.3]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.22kclk/s, mean=508, std=27.9]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 5% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.33kclk/s, mean=490, std=38.9]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.39kclk/s, mean=490, std=39]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 10% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.59kclk/s, mean=472, std=46.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.48kclk/s, mean=471, std=48.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 15% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.79kclk/s, mean=450, std=55.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.61kclk/s, mean=451, std=56.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 20% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.01kclk/s, mean=431, std=60.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.84kclk/s, mean=430, std=62.6]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 25% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.26kclk/s, mean=410, std=68.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.06kclk/s, mean=409, std=67.9]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 30% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.96kclk/s, mean=388, std=74.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.31kclk/s, mean=389, std=74.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 35% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.68kclk/s, mean=366, std=78.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.49kclk/s, mean=365, std=75.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 40% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.17kclk/s, mean=342, std=81.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.92kclk/s, mean=341, std=83.2]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 45% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.36kclk/s, mean=318, std=85]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.16kclk/s, mean=318, std=81.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 50% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.53kclk/s, mean=295, std=87.7]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.47kclk/s, mean=293, std=88.2]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 55% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.03kclk/s, mean=268, std=91.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.88kclk/s, mean=269, std=88.1]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 60% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.64kclk/s, mean=242, std=90.7]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.36kclk/s, mean=241, std=89.2]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 65% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.30kclk/s, mean=214, std=91.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.07kclk/s, mean=215, std=91.6]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 70% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.07kclk/s, mean=187, std=89.4]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.09kclk/s, mean=188, std=89.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 75% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.67kclk/s, mean=159, std=85.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 9.38kclk/s, mean=157, std=86.1]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 80% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 9.54kclk/s, mean=127, std=80.9]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 9.93kclk/s, mean=127, std=83.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "current schema: bits_per_feature\n",
      "working on 0% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.25kclk/s, mean=484, std=8.7] \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.21kclk/s, mean=483, std=8.63]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 5% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.37kclk/s, mean=466, std=25.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.37kclk/s, mean=466, std=25.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 10% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.57kclk/s, mean=447, std=34.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.51kclk/s, mean=447, std=35.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 15% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 2.62kclk/s, mean=428, std=42.5]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.64kclk/s, mean=428, std=43.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 20% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.98kclk/s, mean=409, std=47.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 3.84kclk/s, mean=408, std=49.7]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 25% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.16kclk/s, mean=388, std=53]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.07kclk/s, mean=388, std=54]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 30% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.34kclk/s, mean=367, std=60]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.37kclk/s, mean=367, std=60]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 35% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.54kclk/s, mean=345, std=63.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.51kclk/s, mean=346, std=62]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 40% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.00kclk/s, mean=323, std=66]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 4.81kclk/s, mean=323, std=67.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 45% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.32kclk/s, mean=301, std=70]  \n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.19kclk/s, mean=300, std=69]  \n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 50% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.68kclk/s, mean=277, std=71.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.48kclk/s, mean=277, std=71.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 55% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.92kclk/s, mean=253, std=74.6]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 5.91kclk/s, mean=253, std=73.8]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 60% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.47kclk/s, mean=228, std=75.2]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 6.27kclk/s, mean=228, std=74.2]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 65% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.31kclk/s, mean=202, std=75.1]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.01kclk/s, mean=202, std=75.4]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 70% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 7.87kclk/s, mean=175, std=74.9]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.13kclk/s, mean=175, std=75.5]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 75% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 8.77kclk/s, mean=148, std=71.5]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 9.15kclk/s, mean=148, std=72.3]\n",
      "generating CLKs:   0%|          | 0.00/2.00k [00:00<?, ?clk/s, mean=0, std=0]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n",
      "working on 80% missing values\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 10.1kclk/s, mean=120, std=66.8]\n",
      "generating CLKs: 100%|██████████| 2.00k/2.00k [00:00<00:00, 10.6kclk/s, mean=120, std=69.5]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "schema_dict = {'bits_per_token': fixed_k_schema,\n",
    "               'bits_per_feature': var_k_schema}\n",
    "\n",
    "def run_series(folder, schema_dict, true_matches):\n",
    "    for label, schema in schema_dict.items():\n",
    "        print(f'current schema: {label}')\n",
    "        for i in range(0, MAX_SPARSENESS+1, SPARSENESS_STEP):\n",
    "            print(f'working on {i}% missing values')\n",
    "            ds1 = os.path.join(folder, f'{i:02}_A.csv')\n",
    "            ds2 = os.path.join(folder, f'{i:02}_B.csv')\n",
    "            clks_a = generate_clks(ds1, schema)\n",
    "            clks_b = generate_clks(ds2, schema)\n",
    "            precisions, recalls = pr_curve_from_clks(clks_a, clks_b, 0, true_matches)\n",
    "            res_file = os.path.join(folder, f'{i:02}_pr_{label}.pkl')\n",
    "            with open(res_file, 'wb') as f:\n",
    "                pickle.dump((precisions, recalls), f)\n",
    "            print('done')\n",
    "\n",
    "true_matches = load_true_matches(os.path.join(DATA_DIR, 'PII_A.csv'), os.path.join(DATA_DIR,'PII_B_clean.csv'))\n",
    "for folder in (os.path.join(DATA_DIR, 'noisy'), os.path.join(DATA_DIR, 'noisefree')):\n",
    "    print(f'working on folder: {folder}')\n",
    "    run_series(folder, schema_dict, true_matches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "It's time to compare the linkage quality of the CLKs to the two baselines from before. For both, the noisefree and the noisy dataset we create a graph where we compare \n",
    "the two baselines:\n",
    "- 'per_feature' - averaged feature-wise token comparison\n",
    "- 'composite' - comparison of the combined tokens of all features\n",
    "\n",
    "to the two CLK encoding strategies:\n",
    "- 'bits_per_token' - Insert every token bitsPerToken number of times.\n",
    "- 'bits_per_feature'- Same number of insertions for each value of this feature.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3gUVRfA4d/Z9B5IgRACoYSeBDBSpUhRUMFPRUFRwEZXEUQRlCZipyldEEEEAaVjowlIKAHpRXovgRRCSN3c749ZMGCAgCSzkPs+zzw7u3N35uyKezK3ilIKTdM0reCymB2ApmmaZi6dCDRN0wo4nQg0TdMKOJ0INE3TCjidCDRN0wo4nQg0TdMKOJ0ItLuWiFwUkdL/8RzlRWSLiCSJyOt3KrZbuP5KEXklv6+radnpRKDdtZRSnkqpg//xNG8DK5RSXkqpUXcirrwiIodFpMm9ch3NfuhEoBV0JYGd1zsoIg75GIummUInAs1Utr8+3xKRbSKSKCI/iIhrtuOvish+EYkTkQUiUizbMSUiZW37j4jILlsVzwkReStbucds1T8JIrJWRCJsry8HHgS+slUzlRORKSIyVkSWiEgy8KCIuIjI5yJyVETOiMg4EXG72fmv83mbisge22f9CpBsx8qIyHIROS8i50Rkuoj42o5NA0oAC22xvm17fbaInLadb5WIVM52vtv5TnK8jnaPU0rpTW+mbcBhYANQDCgM7AY62441As4B1QEX4EtgVbb3KqCsbf8UUM+2XwiobtuvBpwFagIOQHvbNV1sx1cCr2Q75xQgEaiL8YeSKzAcWGCLzwtYCHyUm/Nf81n9gSSgFeAEvAlkXr4+UBZoavusAcAqYMQ131WTa875ki0mF2AEsCXbsdv9Tv51Hb3d25u+I9DswSil1EmlVBzGj2xV2+ttgclKqc1KqTTgXaC2iITmcI4MoJKIeCul4pVSm22vdwTGK6XWK6WsSqlvgTSg1g3ima+U+lMplWUr2xF4UykVp5RKAoYCbW7j/I8AO5VSc5RSGRg/3KcvH1RK7VdK/a6USlNKxQLDgAY3iBOl1GSlVJLt+xkIRIqITx58J9o9TCcCzR6czrZ/CfC07RcDjlw+oJS6CJwHgnM4x1MYP7RHROQPEalte70k0MtWBZIgIglAiO3c13Ms234A4A5syvb+X2yv3+r5i2U/t1JKZX8uIkVEZKatGucC8B3GXUSORMRBRD4WkQO28odthy6/505+J9o9TCcCzZ6dxPjRAkBEPAA/4MS1BZVSG5VSjwOBwDxglu3QMeBDpZRvts1dKTXjBtfNPiXvOSAFqJzt/T5KqcvJ6lbOfwrjB/fy55HszzHuNBQQrpTyBp4nWxvCNXEBPAc8DjQBfIDQy6f+j9+JnpK4gNGJQLNnM4AXRaSqiLhg/FCuV0odzl5IRJxFpK2I+NiqXC4AWbbDE4HOIlJTDB4i8qiIeOUmAFv10ERguIgE2q4XLCIP38b5FwOVReRJEXEEXgeKZjvuBVwEEkUkGOh9zfvPAKWvKZ+GcZfkbvt+7sR3cu11tHucTgSa3VJKLQXeB37E+Gu6DP/UzV/rBeCwrYqkM0b7AkqpGOBV4CsgHtgPdLjFUN6xvW+d7fxLgfK3en6l1DngaeBjjB/vMODPbEUGYTSMJ2IkjZ+uOcVHwHu26py3gKkYVWcngF3AumvK3+53cu11tHucGNWUmqZpWkGl7wg0TdMKOJ0INE3TCjidCDRN0wo4nQg0TdMKOEezA7hV/v7+KjQ01OwwNE3T7iqbNm06p5QKyOnYXZcIQkNDiYmJMTsMTdO0u4qIHLneMV01pGmaVsDpRKBpmlbA6USgaZpWwOlEoGmaVsDpRKBpmlbA5VkiEJHJInJWRHZc57iIyCgxliHcJiLV8yoWTdM07fry8o5gCtDsBsebY8y+GIaxYtLYPIxF0zRNu448G0eglFp1nSUFL3scmGpbpWmdiPiKSJBS6lRexPPLxPdJWLscuHqlD8n2LKfXb1TWcvkVESwIFlsZC4KIccxiOyaIbd94t4PIlbIWERQgIsaJbe81nl9+zWK7lu345WO2a2R/3eLoiMXRgjg5ILZHi6MDFicLcuXREQcnC5bLxyyCRWzxiiAWcBDB1dEBB0v2b+E/sDiCgyNYnMDByfbcKdtzh2z7Ttcp6wgOzuDsAc6exqPcofg0rYAyc0BZMFcvCXjc9tq/EoGIdMS4a6BEiRK3dbGEv/4kPDrutt57I/bcyKL4Z6kp603KikUZm4NCLLbnjgpH1ywc3aw4uuXw6GrF4nCDc/4rmrwg/yQFF1ticPbKtu8JLl7XlPH8J4m4eIGHP3gEgJNbHsWoafbtrhhZrJSaAEwAiIqKuq1flDZjlmc/Hwr1z2P2/es9Xt63Pc9SWViVlQxrBplZVjKzMsnIMvbTrelkWq1kZmUYjyqDDKtR1qoyycjKxGrNJMOaiVVZsVozUEqByoKsLGMZKWsWoFBW65VjKksBWSirQshCZWXZ1pzKgiyFUllYM9K5lHKBlJREUlIukJaSREbqRdLTLiIZmThZwckKjplk21e4Z7ngluWMS5YTrlkOuFgdcU0XvJKseMSn4XY0CYesf6eTRGd34lx9OO/qTZyr15X9BDcf0n0Lk1XYDwc/f3x93Akt7EqpQi6EFnaiVCEXAt0tSFYmZGWANROu7GcY+9aMbMcysj3PgPSLkJ4MaRdt+xdt+8nG/oWT/+ynXYSM5Jv/I3HOlhQ8Aq7e9wzI9noAuBXihllQ0+4iZiaCE1y9XmtxcliLNi+IrVqGAlajkJKZQmJaIvGp8SSkJfyzpRqPZ9PirxxPTEvkXMo50rPSAbAooYJDScJVMGWtfoSkeRCQ7EiRuFQKnYmlxNmzcP4wluNxSFbWv66d6ObNPp9gtvmGMKtQSf4uFILVw4uSfu6UDvAg1M+DUH8PStk2Pw9no/rrTsnKMpLBlWSRZDymXoBL5yA5FpIvP8ZC/GE4vtE4pv79eRALuPtdnTC8gqBsYwitZ1RjadpdIk9XKLO1ESxSSlXJ4dijQHfgEaAmMEopVeNm54yKilJ6rqH8Yc2ycizpGPsS9rEv3tj2J+znaNJRsmw/ji4OLpT2KU1YoTDCfMMI8y5DGQnA54KVzNhYMs+eJTM2loxjx0nZvp30gwfB9m8uyT+Io0VKsdM7hHUuRdnnHUSmxfjbxMvFkVD/7MnBnVA/Y9/X3Tn/voSsLEiJ/ydB/GvLljwunITMVHD1gfKPQMUWUKaRrnLS7IKIbFJKReV4LK8SgYjMABoC/hiLYQ8AnACUUuPE+HPvK4yeRZeAF21rqd6QTgTmS81M5UDigauSw774fcSmxF4p4+PiQ1nfskZyKBRGuULlqFC4Ak4pGaTu2EHKtu2kbNtGyratWGPPGW9yciK9VBjnQ8pyKCCUrZ7B/GX14ERCKlnZ/pn6ezpTq7Qf9cMCeCDMn2K+dvJDm5ECB1bA7oWwdwmkJoCTO4Q1hYotIewhcPU2O0qtgDIlEeQVnQjsV0JqAvsS9vF3/N9XksP+hP0k2+rnHcWRcoXLEe4fTkRABBH+EZTwKoH19OmrEkPqzl2olBQAHHx9cQ4PJ61sRc4Gl2F/4RJsvwh/7j/HmQtpAJQN9KRemD/1wwKoWbow7s520PRlzYDDa4yksGcRXDxj9HYq3dC4Uyj/iFGlpGn5RCcCzTRKKU4mn2RP3B52nNvBttht7Di3g0uZlwDwdvYm3D+c8IBwI0H4R+Dj6Ena/v2kbN1GyvZtpG7dRtr+/VeqlJxKlsD9vvu4EBbORp8S/B7vyPpDcaRlZuHsYCEqtBD1wgKoF+ZPpSBvLHeq++vtysoy2ht2LzASQ8IRo42hRB0jKVR8DHyKmxujds/TiUCzK9YsKwcTD7L93Ha2xW5j27ltHEg4cKXdoYRXiSuJITIgkvKFymNJSTeqlLZvI2XLVlJiYrAmJgLgWKQILtXv40ypiqzzDGFJogu7zxh3IX4ezjwQ5n8lMRTxdjXtcwNGMju93UgIuxdC7G7j9WLVbUmhJfiXNTdG7Z6kE4Fm9y5lXGLn+Z1GYojdxvZz26+0OThbnKngV4EI/wgjOQRGUsw9iPQDB7gUE8OljTFciokh8+xZwKhOskRW43hIef70CGF+kjtnLxldX8sX8aJ+OSMx1ChVGFcnk7uAntv3T1I4udl4LaAiVGoJ970I3kHmxqfdM3Qi0O46SinOXDpzVWLYdX4XqdZUAMr4lKFhSEMeLPEg4f7hCELG8eNXksKlmBgyjh4FwOLhgbVSOIeLlWOVWzALUgtxCQvOjhZql/bj9cZlua9kYTM/riHhGOxZbCSFo2uNUdRV20LdN6BwKbOj0+5yOhFo94SMrAz2x+9n05lNrDy2kpgzMViVFT9XPxqGNKRhSENqBdXC1dGo/sk4c5aUTTFX7hrS9u0zTuTsTHq5SuwvWpb5EsQq9xK0rBpMn+YV7KcHUtwhWDsK/vrOGFxXpRU88CYUqWR2ZNpdSicC7Z6UmJbImhNrWHlsJWtOrOFixkVcHVypXaw2D4Y8SP3i9fFz87tSPjM+npTNm427hk2bSN21C6xWzpWL4L1Sj3LGO4AuDcrSsX5p3JztZNTwhVOwbjRsnGwMiCv/KNTrBcXvMzsy7S6jE4F2z8uwZrDxzEZWHF3ByuMrOZ18GkGoGljVqEIKeZBSPldXr1gvJpO4YD6xw4aTlZ5OdJ3HGep9H0UKe9GneQUeiwi6s6Ob/4tLcbBhAqwba4xPKNXASAil6utJ97Rc0YlAK1CUUuyJ28PKYytZcWwFu+OMnjmh3qE8GPIgDUMaEhkQiYNtrqCMs2c5M/Qjkn75BWvJUoyu9jQ/E8j9oYUY0KIyVYJ9zPw4V0tLgk1TYO2XxtiE4CgjIZRrBhZ7ngJRM5tOBFqBdjr5NCuOrWDlsZVsOL2BzKxMCrkUon7x+jQt2ZT6xesjIiStXMmZwR+QcfIk5x58hL5+9TludaR1VAi9HipPgJeL2R/lHxmpsGU6/DkCEo5CYCV4oCdUfsKYvlvTrqETgabZJKUn8efJP1lxdAWrT6wmKT2JZ8o9Q9+afXGwOJB16RKxX35F3LffYilUiOjm7RmSXAxXZ0deb1yWDnVK4exoR395WzNhx4+wZhjE7oFCoVC3B1R9DhztKHFpptOJQNNykJGVwei/RjNpxySahTZj6ANDcbLNGpq6axen+g8gdccOpGZtxldrxdzTilL+HvR7pCKNKwbaT/sBGKOX9y6B1Z/Dyb+MmVBrd4f7OhhrMGgFnk4EmnYD3+78ls9jPqdOsToMbzgcdyd3AJTVSvz074kdMQKVlcWF1u3p5xjOvvOp1Avzp/9jlQgr4mVy9NdQCg6uhNVfwOHV4FYYanUxxiLoO4QCTScCTbuJufvmMjB6IFX8qzCm8Rh8XP5pIM44dYrTQz7k4rJlOJcrx6ZWXRhyUEhOt/JCrZL0aBKWv1Nj59axDbB6GPz9s9HLqM33+u6gANOJQNNyYdmRZfRe1ZuS3iUZ33Q8ge6BVx2/8PvvnBnyIZlnz+L2TGumVGzG1K3n8HZzolfTcjxbowSODnbUfnDZlhkwvxsUqwZtZ4O7HYyi1vKdTgSalksbTm3gteWvUci1EBOaTqCE99VrZFsvXiR2xEjip0/HMSCAzG49GZwQSPShOMoX8WLks1WpUNQO1xzYsxhmvwiFS8MLc/UcRgXQjRKBHf75omnmqRFUg8kPT+ZSxiXa/dyOvXF7rzru4OlJ0ff6EfrDTBwKF4YBffh06zQmNitO/KV0nhi9lkXbTpoU/Q1UeBSenwOJx2DywxB30OyINDuiE4GmXaOyf2WmNJ+Ck4MTL/7yIpvObPpXGbeICErNmU1g794kR68jpOdLzPY/QuUgT7p//xcfLdlNpjWHtY7NVKo+tF9gDEqb3AzO7DQ7Is1O6ESgaTko7VOaqc2m4ufmR6ffO7Hq+Kp/lRFHR/xefonSCxfiHnUfl4Z/zrBdP9ChelHGrzpI+282EJecbkL0NxB8H7z4s7EwzjePwLGNZkek2QGdCDTtOoI8g/i2+beU8S3DG8vfYNHBRTmWcy4eTMj48QT2eYfkZcto/8NHDGsczMbD8bT4cg07TiTmc+Q3EVgBXvoV3ArB1JZwYLnZEWkm04lA026gsGthJj00iepFqvPu6nf5fvf3OZYTEfw6dKD46K9IO3SI8A/fZE5Tf5RSPDV2LT9tPp7Pkd9EoZJGMihcGqY/A7vmmx2RZiKdCDTtJjydPRnTZAyNQhrx0YaPGLtlLNfrbefVqBGh078DpXB+szOzI61UK+FLz1lbGbhgJxn21G7gVQQ6LILg6jC7A2yeZnZEmkl0ItC0XHBxcOGLhl/wv7L/Y8zWMXy04aMrayxfy7ViRUJnzcKlVCku9OrBl457eLluKFPWHqbt1+uJTUrL5+hvwK2Q0Z209IOwoDus/crsiDQT6ESgabnkaHFkcJ3BtK/Unhl7ZvDu6nfJyMrIsaxTkUBKTpuKV5MmnPv0U16Jmc3IVlXYdjyBFl+u4a+j8fkc/Q04e8CzM6HS/+C3frDsA2OqCq3A0IlA026BiNArqhdvVH+DJYeW8MbyN0jJTMmxrMXdneCRI/B79RUSfviBamMG89MLETg5Cq3Hr2PmhqP5HP0NODpDq8lQvb0xcd2St4yJ7LQCQScCTbtFIsIr4a/Qv3Z/1pxYQ+ffO3Mh/ULOZS0WAnv1IujDD0nesAGXNzsx93+h1CxdmD4/befdn7aTlmnN509wHRYHaDHSmKBu49cwtyNYc77j0e4tOhFo2m16utzTfNbgM7ad28aLv7zIuZRz1y3r+9STlJg0icxz54hr/zxjIx3p2rAMMzYcpc2EdZxOTM3HyG9ABJoOhiYDYftsmNkW0i+ZHZWWx3Qi0LT/4OHQhxndaDTHko7R7ud2HEg4cN2yHjVrEDpzBg7e3hx/8UU6ZexjbNvq/H06ice+XMPGw3H5GPlNPPAmPDYC9v0G3z0FqXY2FkK7o3Qi0LT/qE5wHSY+NJHkjGSeXfws8/bPu25Zl1KlCP1hJm5Vq3Ky99tErZjN3K518HJ15NkJ65gaffi6XVPzXdSL0GoSHN8IUx6Di7FmR6TlEZ0INO0OiAyIZE6LOYT7h/P+n+/Tb00/LmXkXKXi4OtLiUlf4/Pkk5wbMxaPTwcx79UoGpYPoP/8nbw1exupGXbSblDlKaNH0bl98E0zSDhmdkRaHtCJQNPukAD3ACY0nUCXyC4sPLCQZxc/y/74/TmWFWdngj4cQkDPnlxYsoT4jq8wpnkoPZqE8ePm47Qat5azF+yk3SCsiTHW4GKsbebSQ2ZHpN1hOhFo2h3kYHGga9WuTHhoAolpiTesKhIR/Du+SvDIkaTu3cvRNm3oXAImtY/iUGwyz4yP5mRCzl1T813J2sYo5PRkmP40pNjROAjtP9OJQNPyQK2gWsxpOYfIgMibVhV5P/wQJadNIysjnSPPPkfNc38z9eWanL+YzjPjozkWZye9doIijOUu4w/DDy9App3NrKrdNp0INC2P+Lv5M77peLpGdr1SVbQvfl+OZd3Cq1Bq1iycQkI41qkzpdYs4ftXa5GUmskz46M5GHsxn6O/jtC68PhoOLwaFr6uRyDfI3Qi0LQ85GBxoEvVLkx8aCKJaYk8t/g55u6bm2PPIKegIEKnf4dn/fqc+WAIRed9x8yOtUjPzKL1hHXsO5NkwifIQWRraNgXts6AVZ+ZHY12B+RpIhCRZiKyV0T2i0ifHI6XEJEVIvKXiGwTkUfyMh5NM0vNoJpGVVFgJP3X9r9uVZHFw4Pio78yehR99RX+s6cws2NNBGg9YR07T9pJf/4Gb0Pks7DiQ9g2y+xotP8ozxKBiDgAo4HmQCXgWRGpdE2x94BZSqlqQBtgTF7Fo2lm83fzZ3yT8XSt2pVFBxfRZnEb/o7/+1/lxMGBoCEf4NPqKc6NGYvP95P5oWMtXB0tPDdxPVuPJZgQ/bVBCrQYBaH1YH43OPyn2RFp/0Fe3hHUAPYrpQ4qpdKBmcDj15RRgLdt3weww1W/Ne3OcbA40CWyC18/9DVJ6Uk8t/g5ftr307+qisRiIWjwYHyffprz48fjMXUCMzvWwtvNkee/Xk+MPYxCdnSGZ6aCb0n4oS2cy7mrrGb/8jIRBAPZR58ct72W3UDgeRE5DiwBXsvpRCLSUURiRCQmNlaPbtTufjWCajC7xWyqBVZjwNoB9F3T919VRWKxUHTQQHzbtOb8xIm4TB7DDx1rEeDlQrvJG4g+cN6k6LNxLwxtZxlrIE9vBcl2EJN2y8xuLH4WmKKUKg48AkwTkX/FpJSaoJSKUkpFBQQE5HuQmpYX/N38GddkHN2qdmPJoSW0XtT6X1VFYrFQdMAACj33LHGTJuMw7ktmdKxJsK8bHb7ZwB9/28EfRoVLG6OPL5yEmc9Chp0MhNNyLS8TwQkgJNvz4rbXsnsZmAWglIoGXAH/PIxJ0+yKg8WBzpGd+fqhr7mYcZHnFj/Hj3//eFVVkYhQ5P33KfT888RNmQKjRzDj1ZqUCfDk1W9jWLrrjHkf4LKQGvDkeDi2HuZ10WsZ3GXyMhFsBMJEpJSIOGM0Bi+4psxRoDGAiFTESAR28CeOpuWv+4vez+wWs6keWJ2B0QPps7rPVQveiAhF+vWlULsXiPt2KpmjhjH9lRpUDPKi83ebWLL9lInR21R+wpi+eudPsGKI2dFotyDPEoFSKhPoDvwK7MboHbRTRAaLSEtbsV7AqyKyFZgBdFB2M/WipuUvfzd/xjUdx2vVXuOXw7/Q8beOJKb9011URCjy7rsU7tCB+GnTSPviU6a+XIPIEF+6f7+ZeX9de8Ntgro9oHo7WP0FbJ5mdjRaLsnd9rsbFRWlYmJizA5D0/LU70d+551V71DSuyRjm4ylqEfRK8eUUpz9/HPiJk3Gt01rvN7py6vTNrPu0Hk+eTKCZ+4PucGZ84E1w5iP6PBqaDsHyjxobjwaACKySSkVldMxsxuLNU3LQdOSTRnXZBynkk/R7ud2HEr8Z8ZPESHwrbeMtZBn/kDSRx8yuf191AsL4O0ftzEt+rBpcQPg4ATPfAv+5WBWOzi729x4tJu6aSIQw/Mi0t/2vISI1Mj70DStYKsRVIPJD08mzZpG+5/bs+PcjivHRISAnj3x69SJhFmzSBgymAnPV6NJxUDen7+Tr1cfNDFywNUHnpsFTm4w/RlIsoMGbe26cnNHMAaojdHVEyAJY8Swpml5rJJfJaY1n4a7kzsv/foSa0+uvXJMRAjo8Qb+XbuQMHsOcQMHMrpNVR4JL8qQxbsZvcLkAV6+IUa30uRYmNFGr31sx3KTCGoqpboBqQBKqXjAOU+j0jTtihLeJZjWfBohXiF0W9aNXw79cuWYiBDw+uv4d+9O4k8/cX5Af0Y+HcH/qhbjs1/3Muy3veYufRlc3Vju8uRf8NOrkGUnK69pV8lNIsiwzRukAEQkANCdhDUtHwW4B/BNs2+I8I/g7VVvM2PPjKuPd++G/2vdSZw3j9j33+Pzp8JpHRXCqOX7+ejnPeYmgwqPwsNDYc8i+L2/eXFo1+WYizKjgLlAoIh8CLTCmCxO07R85O3szfim4+m9qjdD1w8lLjWOrpFdEREAArp1QxwciB0xEmXNYujQoTg7Wpiw6iDBvm60rxNqXvC1ukDcQYj+CgqXgvtfMS8W7V9umgiUUtNFZBPGwC8B/qeU0t0ANM0Ero6uDG84nMHRgxm3dRxxKXH0rdkXB4sDAP6dO4PFgdhhwyAri0GffMyx+EsMXbKbOmX8CCviZU7gItDsY0g4Ckt6g08JKPeQObFo/5KbXkOjgMJKqdFKqa90EtA0czlaHBlUZxAvV3mZWX/Poveq3qRb/1k20r/jqwS+1YsLS5Zw8u23+eR/FfFwceSNmVtIyzSxjt7BEVpNhiKVYc6LcHq7ebFoV8lNG8Em4D0ROSAin4tIjgMSNE3LPyJCj/t68FbUW/x+5He6Lu3KxfR/lrP0e+UVAt9+m6SffyFjwHt8+ngldp26wLDf/r3+Qb5y8TS6lbp4G91KL9jB1BjazROBUupbpdQjwP3AXuATEcl54VVN0/JV+8rtGfrAUDad2cRLv77E+ZR/poH2e+lFAvu8Q9JvvxGxYg7P1SzBhNUHWXvgnIkRA97FjKmrUxNh1guQmWZuPNotjSwuC1QASgJ78iYcTdNuVYsyLRjZaCSHEg/R7ud2HE86fuWYX4cO+Dz5JOfHT+CtYqmU8vOg16ytJF7KMDFioGg4PDEWjm+Exb3gLpvq5l6TmzaCT213AIOB7UCUUqpFnkemaVqu1S9en4kPTSQhLYF2P7djb9zeK8eK9O2LU3Awcf36MqJFGLFJafSdt93cLqUAlR6Her3gr2kQM8ncWAq4GyYCMfqlJQG1lVLNlFJTlFJ2sGCqpmnXqhpYlW+bfYuI8OIvL7LpzCYAHDw9KPbJJ2ScPIn/lNG82bQci7edYq49zFb6YD8o2xR+fgeOrL15eS1P3DAR2KaEfkYpZXKloqZpuVG2UFm+a/4dfm5+dPq9EyuPrQTAvXo1/Dp1JHHuXNqmHaBGaGH6z9/JsTiTp32wOMBTXxvrHs9qB4l2kJwKoNy0EWwWkfvzPBJN0+6IIM8gpjafSphvGD1W9GDuvrkABHTtimuVKpwdMIDPGxVDgDd/2EKm1eSJAtx8oc33kJECPzyvl7o0Qa7mGgKibd1Ht4nIdhHZlteBaZp2+wq5FmLSw5OoUbQG/df2Z+6+uYiTE8U++5Ss9HT4eDAftKxEzJF4xv1xwOxwIbACPDEOTm6GxT1143E+y00ieBgoAzQCWgCP2R41TbNj7k7ujG48mtpBtRkcPZi1J9fiUqoURd55h+S1a6m3cwUtIosxYuk+th6zg6a/ii2g/tuwZTpsmGh2NAVKbhKBus6maZqdc3JwYljDYZT2LU3PlT3ZG7cX39bP4NmwIbGff8GAcFcCvVzo8cMWktMyzQ4XGr4L5ZrBr+/C4TVmR1Ng5CYRLAYW2R6XAQeBn/MyKE3T7hxPZ09GNx6Nhw8Yv8wAACAASURBVJMHXZd15cylMwR9OASLlxcX3uvLsCcrcfh8MkMW28HsMRYLPDkBCpWCWe0h4ZjZERUIuRlZHK6UirA9hgE1gOi8D03TtDulqEdRxjQeQ3JGMl2XdSXFy5mgIR+QtmcPpRZ8R6f6ZZix4Si/7TxtdqjG6mZtvjdGHP/wvNGIrOWpW16zWCm1GaMBWdO0u0j5wuUZ1mAYhxIO0WtlL1wbPIBv69bETf6GLj4JVC7mTZ+ftnM2yQ567QSUM+4MTm2BRW/qxuM8lpuRxT2zbW+JyPfAyXyITdO0O6xOcB361+5P9KloBkcPJvDt3jiXKMHZfn0Z8WgZktMy6T17m/mjjgEqPAIN+8LWGbB+nNnR3NNyc0fglW1zwWgreDwvg9I0Le88EfYEXSK7MG//PCbsn0qxzz8j8+xZ3McO571HK/LH37FMjT5idpiG+r2hwmPwaz84tMrsaO5ZuVmYZlB+BKJpWv7pEtmFExdPMGbLGIrVLUbd7t2IHTmKFg3qs6JCUfMXsrnMYoH/jYWvG8PsDtBxJfiWMDeme1BuqoZ+FxHfbM8LiciveRuWpml5SUQYWHsgNYNqMnDtQPa3iMCtWjXODP6AoXUD8HRx5HWzF7K5zNUb2swAawbMbAvpJk+LcQ/KTdVQQPaJ5pRS8UBg3oWkaVp+cHJwYnjD4YT6hPLmqrdI69cZrFbSPhjAp09WYfepC3xh9kI2l/mXNeYkOr0dFr6hG4/vsNwkAquIXLkXE5GS6AFlmnZP8HL2YmyTsbg7utNt92Dcer/GpQ0bqLruZ9rWLMHE1QdZu99O5pws9zA06gfbZ0H0aLOjuafkJhH0A9aIyDQR+Q5YBbybt2FpmpZfinoUZXST0SSlJ9HTfSFujR/k7IgRvF3WQil/D3rNtoOFbC6r95YxFcXv78OBFWZHc8/IzYCyX4DqwA/ATOA+pZRuI9C0e0iFwhUY1nAY+xMPMKJJGg6+vpzv24eR/6toPwvZAIgYjcf+5WHOixB/2OyI7gm5GlCmlDqnlFpk2+zkPlHTtDupbnBd+tfuz7ILG1j2QkXS9u0n4IdJ9HzIWMjmp812slaAixe0mQ4qC2Y+rxuP74BbHlmsadq968mwJ+kY0ZExLms50bwq8VOn8bzDaWqUKsyABXawkM1lfmXgqclwZgcs6K4bj/8jnQg0TbtK96rdaVG6BW9X3k5aiSKc6duXLx4uiYidLGRzWVgTaNwfdvwIa0eZHc1d7ZYTgYj4iki/vAhG0zTziQiD6gyiWkhNBjaNJyM+Dhn2CUMer0zMkXiGL7WTLqUAD7wJlf4HSwfC0XVmR3PXum4iEJEQEZkgIotE5BUR8RCRL4C/yeU4AhFpJiJ7RWS/iPS5TplnRGSXiOy0zWOkaZrJnBycGP7gcKRcaeY0cCbpt99ocDiGNveHMHrFAZbuOmN2iAYReHw0eAUZ01DoKqLbcqM7gqkYk8t9CVQGYoBiQIRS6o2bnVhEHIDRQHOgEvCsiFS6pkwYRlfUukqpykCP2/kQmqbded7O3oxpPIY/6vmwL9SZUx8Mpl81b6oEe/PmrC0cPW8n7QUunvBgXzgRA7vmmx3NXelGiaCwUmqgUupXpdSbGJPOtVVK5XbC8hrAfqXUQaVUOkbX02snq3sVGG0brYxS6uwtxq9pWh4K8gziq6ZjGNPSiZSsNGL79WFM60gsInT+bhOpGXYwBQVA5LMQWAmWDTamotBuyQ3bCGzzChUWkcLAecAn2/ObCQayLy903PZaduWAciLyp4isE5Fm14mjo4jEiEhMbGxsLi6tadqdUtGvIv1aDufrhy2k/bUVp2/HMaJNVXafvsB783bYx/gCiwM0GQhxB2DTFJODufvcKBH4AJuBTbbNO9vzmDt0fUcgDGgIPAtMzD7B3WVKqQlKqSilVFRAQMAdurSmablVr3g9Gr08gF+rCQmTvqH6vo281iiMOZuOM3OjnSwnGfYQlHwA/vgE0pLMjuauct1EoJQKVUqVus5WOhfnPgGEZHte3PZadseBBUqpDKXUIYyG6LBb/RCapuW9VuVakfZaW3aFwPG+fehUNJ365QIYMH8n244n3PwEeU0Emg6C5FhY+5XZ0dxVbtRrKFBERth6DQ0VEe9bPPdGIExESomIM9AGWHBNmXkYdwOIiD9GVdHBW7yOpmn5pGett1nWsTpxrlaOduvMsCYhBHi50OW7zcQnp5sdHhSPgkqPw9ovIclOejbdBW7WaygZo9eQF3BLIzaUUplAd+BXYDcwSym1U0QGi0hLW7FfgfMisgtYAfRWSp2/xc+gaVo+cbI4MfixkXzd1p/0+DgS3u7BmGfCiU1Ko8cPW8jKsoP2gsYDwJpmVBFpuSLXa+gRka1KqchszzcrparnW2TXERUVpWJi7lQThaZpt2N77HbGDmvLa3Mz8Hm6FSsefZl+83bSo0kYPZqUMzs8WNwLYr6BbhuMtQw0RGSTUioqp2O30mvI4ZrnmqYVUOEB4TR5aSBzawuJs+fQ/GA0T1Uvzshl+1i51w56gTd4B5zcYPlgsyO5K9ys19Am8rbXkKZpd6knw54k85Vn2FRGOP3hEN4rnkL5Il70+GGL+ZPTeQZCndeMAWbH9c/Vzdys11Dp/9BrSNO0e1yfWn1Z/lIEp3zhdM83GNOkGNYsRdfpm80fbFa7O3gEwu/99dQTN6FnH9U07bY5OzjzcfNRTGhbmJTUi2S914vhLcuz/UQigxbuMjc4F09o+A4c+RP+1mtp3YhOBJqm/SeB7oG889RIRj7uQNrev6kwdSRdG5RmxoajzI4xebBZ9fbgV9aYnTTLTqbDsEM6EWia9p9VL1KdZs++y/SGFpJ++YUOR1ZRp4wf783bwc6TieYF5uBkrFkQuxu26MmNr+dmvYYcRGRPfgWjadrdq035Nlie+x+rKwnnRo7ks+ALFHJ3pst3m0m8ZOJEcBVbQnAUrBiql7W8jhsmAqWUFdgrIiXyKR5N0+5SIsL7dfrzxwuVOVLUwoX3+jCmXmFOJabQa7aJg81EoOlgSDoJ68eZE4Ody03VUCFgp4gsE5EFl7e8DkzTtLuPi4MLnzcdxbg2PiRZ0vEa0ocBDUNYuvssY/84YF5goXWhXDNYMwIuxZkXh53KTSJ4H3gMGAx8kW3TNE37lyDPIPq1HM4XT1hIO36Mej+M5PHwonzx217W7DtnXmBNBkJ6EqzWP1/XumkiUEr9ARwGnGz7GzEGlmmapuWoRlANHvlfL75+SLi05k/ePraMsoGevD7zL04mpJgTVGBFqPocbJgA8UfMicFO3TQRiMirwBxgvO2lYIxZQzVN066rXaV2OD/xKL9Wt3Bhyjd8FXiW9Mwsuk7fTHpmljlBNewLYoEVH5pzfTuVm6qhbkBd4AKAUmofuVy8XtO0gktEGFRnEH8+XZ69JR2xfjqEkdVc2HIsgSGLTRps5hMMtbrAtllwaps5Mdih3CSCNNuawwCIiCOgx2trmnZTbo5uDGsykrFPexLvrggZPpDukb5MjT7CvL+uXacqn9TtAW6+sHSAOde3Q7lJBH+ISF/ATUSaArOBhXkblqZp94oQrxD6N/+cj55QpMaf46n5X1E7xIt3f9rO/rMmLCnp5gv1e8OB5XBgRf5f3w7lJhH0AWKB7UAnYAnwXl4GpWnavaVucF0eb/4GXz6iSN2yhQ+P/oKzg9Bv7g6utyZKnrr/FfApYUxIl2VSe4UdyU2voSyl1ESl1NNKqVa2fV01pGnaLXm5yst4PvwQc+s4kDZ/Lp8772P9oTh+2mxCFZGjCzR6D05vgx0/5v/17cyN1izeLiLbrrflZ5Capt39RIQhDwxhw2Ol2VrOmeLTx/K403mGLtlNwiUT1jsOfxqKhhuL12Sm5f/17ciN7ggeA1oAv9i2trbtZ4zqIU3TtFvi4eTBiMajGP+EG4meDnTcNJsLyal8+uve/A/GYoEmgyDhKGyclP/XtyM3WpjmiFLqCNBUKfW2Umq7bXsHeCj/QtQ07V4S6hPKgCYfM7GxFcvB/QxWu5mx4Sh/HY3P/2DKNobSDWHVZ5Bq4iypJstNY7GISN1sT+rk8n2apmk5ahjSkOKPPsVfZSxE/j6T8g6p9Ju7g0yrCQ23TQZBShz8OTL/r20ncvOD/jIwRkQOi8gRYAzwUt6GpWnava5nVC9+fMwXa3oqg08uZdepC0yNNmHqh2JVjfaC6DFw4WT+X98O5KbX0CalVCQQCUQopaoqpfRcQ5qm/Sc+Lj680uw9fqoleK1dSTvnswz7/W/OXEjN/2AavQfKCis/yv9r24HczDXkIiLPYUw18YaI9BeR/nkfmqZp97pmoc0499QDnCkktF47HZWezuBFJkw/USjUGFvw13dwtuCtxZWbqqH5wONAJpCcbdM0TftPRIR36w1gWjNXLMdP8FHGVhZvO8Wqv2PzP5h6b4GzJywblP/XNlluEkFxpVRrpdSnSqkvLm95HpmmaQVCMc9iNGjVg+gKQpnffuB+lxT6z99BakY+Lzbv4QcP9IC9S+Dgyvy9tslykwjWikh4nkeiaVqB1bZiW6JbVSAdK+8eXMTh85cYu9KEFc1qdgG/svBTJ7h4Nv+vb5LcJIIHgE0istc2qni7Hlmsadqd5GBxoGfzD5nzgAW3jet53fUUY1ce4NC5fK6FdnaHp7+F1AT48RXIyue7EpPkJhE0B8IwBpG14J8Rx5qmaXdMRb+K+LfrwFF/aLp8Ct5k0H++CZPSFa0Cj3wGh/4wBpoVALlJBOo6m6Zp2h3VOaob858oguPZ8wy9tIHV+86xaNup/A+k2gsQ+Sys/LhAtBfkJhEsBhbZHpcBBzHmG9I0Tbuj3BzdeL7NUFaGC8G/zaWRWzIfLNpFUmpG/gYiAo9+AQHljSqipNP5e/18lpsBZeFKqQjbYxhQA4jO+9A0TSuI6gTX4WyHZqQ4ZdF9+w/EJqUy7Pe/8z8QZw+jvSA9Gea8DNbM/I8hn9zynEG2UcU18yAWTdM0AF5r/B5zG3vgtmMXfV2O8O3aw+w4YcKkcIEV4LHhcGQNrBya/9fPJ7kZWdwz2/aWiHwP5GpCDhFpZutttF9E+tyg3FMiokQk6hZi1zTtHlXYtTA1O73H/iCo8esUgp2svDdvB1lZJjRPRrYx2gxWfwH7fs//6+eD3NwReGXbXDDaCh6/2ZtExAEYjdHrqBLwrIhUyqGcF/AGsD73YWuadq9rEfY469tG4phwkcEJK9hyLIEZG4+aE8wjn0GRKvBTR0g8bk4MeSg3bQSDsm0fKqWmK6VyMytUDWC/UuqgUiodmEnOCeQD4BPAhJmmNE2zVyJCp2c+Y/l9jgT+/gtPeF7kk5/3cO6iCauJObkZ7QXWdJjzEljzufE6j+XlugLBwLFsz4/bXrtCRKoDIUqpxXkYh6Zpd6kQ7xC8unfmghs8t34yqekZDF2y25xg/MtCy1FwbD0sG2xODHnEtAVmRMQCDAN65aJsRxGJEZGY2FgTJqPSNM00bWt2ZGmLYDz3HWWA4x5+2nyCdQfPmxNMlacg6mVYOwr23ju96PMyEZwAQrI9L2577TIvoAqwUkQOA7WABTk1GCulJiilopRSUQEBAXkYsqZp9sbJ4sQT3YezK0SovHgaFdwyeW/eDtIzTVjNDODhoRAUCXM7Q7wJC+nkgdz0GnIVkW4iMkZEJl/ecnHujUCYiJQSEWegDbDg8kGlVKJSyl8pFaqUCgXWAS2VUjG3+Vk0TbtHVQkI50yXljikpNPnxHz2n73I12sOmhOMkys8PQVUFsx5ETLTzYnjDsrNHcE0oCjwMPAHxl/2STd7k1IqE+gO/ArsBmYppXaKyGARaXn7IWuaVhC1b/E+K+t4UmRVNO294hi1bB/H4i6ZE0zh0vD4aDixCX6/+9fpyk0iKKuUeh9IVkp9CzxKLgeUKaWWKKXKKaXKKKU+tL3WXym1IIeyDfXdgKZp1+Ph5EHkOx9yzgseWTkeR5XFoIU7zQuoUktj2ur1Y2HXfPPiuANykwgu95NKEJEqgA8QmHchaZqm5ax+2ENsea463sfOM0CtZ+nus/y208R5gJoOhuD7YH53iDOpquoOyE0imCAihYD3Mer4dwGf5mlUmqZp19Gm0wi2lXUkbNGP3O+ZwaCFu7iUbtI8QI7O0OobEAvM7gAZd+dwqNwMKPtaKRWvlPpDKVVaKRWolBqXH8FpmqZdK8A9ANferyGZWXT+eyonElIYuWyfeQEVKglPjINTW+HXvubF8R/kptdQERGZJCI/255XEpGX8z40TdO0nLWo/wrrmwZTbMNuuvkcY9LqQ+w5fcG8gMo3hzqvQ8wk2D7HvDhuk9xs9R9bAvgG6KeUihQRR+AvpZQp6xhHRUWpmJir25QzMjI4fvw4qal3522ZdjVXV1eKFy+Ok5OT2aFoduzA2T0cffxJXJ3c6dFoMIF+3sztWgdHB5PGyVozYMqjcGYndFwJ/mHmxHEdIrJJKZXjxJ6OuXi/v1Jqloi8C0a3UBGxq4U8jx8/jpeXF6GhoYiI2eFo/4FSivPnz3P8+HFKlSpldjiaHSsTWIGYzi2I+GgBfVN/4Y0TDzN+1UG6PVjWnIAcnIz2gnEPGO0Fryw15ii6C+QmdSaLiB+25SlFpBZgwsTg15eamoqfn59OAvcAEcHPz0/f3Wm58uTzQ9ge7knooqU8UzyTEUv/Zu/pmw5zyjs+wfDkRDizA35+27w4blFuEkFPjN5CZUTkT2Aq8FqeRnUbdBK4d+j/llpuOTk4ETbgI7JE0TD6S7xdnXhr9lYyrCZNPwEQ1gTqvQWbp8LWmebFcQtumAhsE8O5Ag2AOkAnoLJSals+xKZpmnZT1ao04USLKEptOsGrwZvZfiKR8X8cMDeohu9CyQdg0ZsQu9fcWHLhholAKZUFjFZKZSqldiqldiil7q2JuO9xCxYs4OOPPwZg3rx57Nq1y+SINO3Oe6jvaJK8nSg+fRqNqggjl+0zt4rIwRFaTTLaCOZ1sfv1jnNTNbTMtpSkvl+/C7Vs2ZI+fYxVQnUi0O5Vzp7eBL7RgzInrJQ8OBIvVzG/isirKDzyuTEfUfRX5sWRC7lJBJ2A2UCaiFwQkSQRMbHDrv2aOnUqERERREZG8sILL3D48GEaNWpEREQEjRs35uhRY5m9Dh060KVLF2rVqkXp0qVZuXIlL730EhUrVqRDhw5Xzufp6cmbb75J5cqVady4MZfXYtiyZQu1atUiIiKCJ554gvj4eABGjRpFpUqViIiIoE2bNgBMmTKF7t27s3btWhYsWEDv3r2pWrUqBw4c4MCBAzRr1oz77ruPevXqsWfPnvz9wjTtDirZpj0ZpYNpuPgoD0RG20cVUeUnoGJLWDHUrquIbtp9VCnllR+B3CmDFu5k18k7m6cqFfNmQIvKNyyzc+dOhgwZwtq1a/H39ycuLo727dtf2SZPnszrr7/OvHnzAIiPjyc6OpoFCxbQsmVL/vzzT77++mvuv/9+tmzZQtWqVUlOTiYqKorhw4czePBgBg0axFdffUW7du348ssvadCgAf3792fQoEGMGDGCjz/+mEOHDuHi4kJCQsJV8dWpU4eWLVvy2GOP0apVKwAaN27MuHHjCAsLY/369XTt2pXly5ff0e9O0/KLODhQ5v0POPriS3j9/CO165Zi5DKhSaUiVCjqbVJQAo9+AYfXwLyu8PJvYHEwJ5YbyNXICxEpJCI1RKT+5S2vA7vbLF++nKeffhp/f38AChcuTHR0NM899xwAL7zwAmvWrLlSvkWLFogI4eHhFClShPDwcCwWC5UrV+bw4cMAWCwWWrduDcDzzz/PmjVrSExMJCEhgQYNGgDQvn17Vq1aBUBERARt27blu+++w9Hxxjn+4sWLrF27lqeffpqqVavSqVMnTp06dUe/E03Lbx61a+PeoB6toiE+9Wu8PC6ZX0XkGQiPfAYnYiB6tHlx3MBN7whE5BXgDYx1CLZgrCQWDTTK29Buz83+crcXLi4ugPFjf3n/8vPMzJwblm7WTLN48WJWrVrFwoUL+fDDD9m+fft1y2ZlZeHr68uWLVtuI3pNs19F336HSy1b8ujKJJY9MY8tG1sz/o8DdG9k4kjfKk/BzrmwfAiUawYB5cyLJQe5uSN4A7gfOKKUehCoBiTc+C0FT6NGjZg9ezbnzxtrqcbFxVGnTh1mzjT6EU+fPp169erd0jmzsrKYM8eYt+T777/ngQcewMfHh0KFCrF69WoApk2bRoMGDcjKyuLYsWM8+OCDfPLJJyQmJnLx4sWrzufl5UVSktGTwtvbm1KlSjF79mzAGNG7devW2/8CNM1OuJQpg+8zz9B4s5WUI1sIr7yJkcv2mTsXkQg8Ogyc3WF+N8iyq8kZcpUIUpVSqQAi4qKU2gOUz9uw7j6VK1emX79+NGjQgMjISHr27MmXX37JN998Q0REBNOmTWPkyJG3dE4PDw82bNhAlSpVWL58Of37Gyshffvtt/Tu3ZuIiAi2bNlC//79sVqtPP/884SHh1OtWjVef/11fH19rzpfmzZt+Oyzz6hWrRoHDhxg+vTpTJo0icjISCpXrsz8+Xf34hqadllA9+44uLvTa50/x9Q8vHyOmV9F5FUEmn8GxzfAujHmxZGD3Ew6Nxd4EeiBUR0UDzgppR7J+/D+LadJ53bv3k3FihXNCCdPeXp6/uuv+oLiXv1vquWfcxMnEvvFMMa+XJS/goVjO7rQq3FVXmtsYhWRUjCzLRxYBp3X5OvEdDeadC436xE8oZRKUEoNxFicZhLwvzsboqZp2p1VuF07nIoVo/MqV5Iz4gitsIhRy/9m9ymTq4geGwaOrnZVRXRL87XaFqdZoJRKz6uAtH8U1LsBTbsTLC4uBPTsiew7zAcXmnBebcYzYAO955hdRVQUmn8Kx9bDevtY48ukibs1TdPynvejj+AaEUG52RtpFFAXVXghu87tYdxKkweaRTwD5ZrDssFw3uRY0IlA07R7mIhQpM87ZJ49S6+/y+LnWgj/0rMZtWKHHVQRDQdHF2OgmclVRDoRaJp2T3OvXh2vhx/m0rff80mld0jlNO7FFprfi8g7CJp9AsfWwYYJ5sWBTgSaphUAgb16ojIzKTbjDzpFdiLLYyN7L/7BWLOriCLbQNjDsHSQqVVEOhFomnbPcy5RgsJt25L401w6ODekemB1PIPn89XqaPOriFqMAAdnmN8dssy5Q9GJwI7FxsZSs2ZNqlWrdmUk8a2YMmUKJ0+ezIPINO3u49+lMw7e3pz//As+rvcxHs4uuAbPoNfsGJOriIpBs4/g6FrYONGUEHQisAPXm1to2bJlhIeH89dff93y9BRwe4ngerFo2t3OwccH/27dSF4bjdemvxlS9wOU83EOZM4yv4qo6nNQtiksHQhxB/P98jcdWWxvbjqy+Oc+cPr6k63dlqLh0PzjGxY5fPjwlbn9N2/eTOXKlZk6dSq7d++mZ8+eXLx4EX9/f6ZMmUJQUBANGzakatWqrFmzhmeffZZevXpddb4tW7bQsmVLUlJSCA4OJjo6mtWrVzNgwADS0tIoU6YM33zzDZ6engwePJiFCxeSkpJCnTp1GD9+PD/++CMdOnQgODgYNzc3oqOjqVixIjExMfj7+xMTE8Nbb73FypUrGThwIAcOHODgwYOUKFGC7777jj59+rBy5UrS0tLo1q0bnTp1urPf6U3okcVaXlDp6Rxs0RIcHSk9fx6fbP6c6bunk36iPfNe7EjFIJOmqwZIPAFjahm/N+0XgeXO/p3+n0YWa7m3d+9eunbtyu7du/H29mb06NG89tprzJkzh02bNvHSSy/Rr1+/K+XT09OJiYn5VxIAqFq1KoMHD6Z169Zs2bKF5ORkhgwZwtKlS9m8eTNRUVEMGzYMgO7du7Nx40Z27NhBSkoKixYtolWrVkRFRTF9+nS2bNmCm5vbDWPftWsXS5cuZcaMGUyaNAkfHx82btzIxo0bmThxIocOHbqzX5ammUCcnQns/RbpBw6QMHs2Pe/rSVnf8jgXnUOPOX+YW0XkEwwPD4Ujf8LGr/P10jedhvquc5O/3PNSSEgIdevWBYz1A4YOHcqOHTto2rQpAFarlaCgoCvlL681kBvr1q1j165dV86fnp5O7dq1AVixYgWffvoply5dIi4ujsqVK9OiRYtbir1ly5ZXksVvv/3Gtm3brsx8mpiYyL59+yhVqtQtnVPT7JFn48a4R0UR++VXeLdowbCGn9FqwTMcdZjIV8vDeLNpBfOCq/Y87JoHSwdAWFMonD//z917icBE164X4OXlReXKlYmOjs6xvIeHR67PrZSiadOmzJgx46rXU1NT6dq1KzExMYSEhDBw4EBSU1NzPIfj/9u79/iarrSB479HEoK4JygxDWZaIpK4Di290EoRKYO3VXXppy7Vq2rHZRhC0TG0BtW6VEuLiks7VdUa9dLXtW1C6hKqWqHucR+ERPK8f+yd05NIkMjJOUnW9/M5n5y99zprP84+zjp7rb2f5e1Nun1VQtYyzrGoKjNmzCAiIuK24zOMwkJEqDpsGIndu3Nm9hxqvzaEMff9nZGbRjJ75xwiGkQTXMONM5p1mgbvtoSVL0HvlfneRZQd0zWUjw4fPuz40l+8eDEtWrQgKSnJsS41NZU9e/bkqe4WLVqwefNmDhw4AMDly5fZv3+/4wvd39+fS5cuOX7FQ+b5BwCCgoKIi4sDYMWKFTnuKyIigvfee4/U1FQA9u/fz+XLl/MUt2F4otINQ6jweBRnFywg9ehRoupGEfGHjvhU+YYXP13u5i6iQIiYAIkbIXZegezSNAT56N5772XmzJnUr1+fc+fOOcYHhg0bRlhYGOHh4WzZsiVPdQcEBDB//nx69OhBaGgoLVu2ZN++fVSsWJH+/fsTEhJCREQEzZo1c7ymb9++YMCVHwAAF4ZJREFUPPfcc4SHh5OcnMyYMWN45ZVXaNq0KV5eOc+b2q9fP4KDg2ncuDEhISEMHDjQXE1kFDkBgweDCKfengrA2FZ/x9+3Bid959F59tfuncimUS+o2wbWjoFziS7fXdG7ashNEhMTiYyMZPfu3W6No6jwhGNqFH2n/vUvzsyaTdDSGEqHhrL3zF56ftmL1Os+XDvejQFNI3mxzR/x9XHDhPPnf7O6iGqE50sXkduuGhKRx0TkJxE5ICLDs9k+REQSRGSniKwTkbtdGY9hGIazKv364+Xvz8l/TEJVqV+lPks7LaFu5bsoFTifuQlv0X7aOr779UzBB1exFkSMt7qI4j506a5c1hCIiBcwE2gPBAM9RCQ4S7EdQFNVDQWWA/90VTyuFhQUlOezgQkTJhAeHp7pMWHChHyO0DCMrLz8yhLw8kskb9/Of/+zFoA/VvojSzstoXdwb0pW3srZSv+kx4JPGfHpLi4kpxZsgI37QJ2HYO1oOHfIZbtxWdeQiLQEolU1wl4eAaCqb+ZQvhHwjqref7N6PbVryMhf5pgaBUXT0jjYuQvp165Rd9UXSMmSjm1bjm1h5KaRnE0+T/LJCCqktuGNxxvyWMhdN6kxn50/bHUR1WwCvT+3rizKA3d1DdUEfnNaPmKvy8mzwFfZbRCRASISKyKxSUlJ+RiiYRjFnXh5UXXoUFIPH+bs4sWZtt1X4z4+jfqUB2u1plS1L9Fqcxm0ZAMDPorlxIXsL9POdxX/AO3egIPfQtx8l+zCI64aEpGngabA5Oy2q+ocVW2qqk0DAgIKNjjDMIo8v9atKNuqFafffY/r585l2lbJtxLTHp7GmJZjEN9Eqtw7g/87up5H3/6WhdsOkZ5eABfcNHkGWg2xriRyAVc2BEeBWk7Lgfa6TETkEWAkEKWq11wYj2EYRo6qDv0r6Zcucfq9927YJiJ0u6cbSzstpW6lWvjU+IhKd3/OqM/jeGLOVg6ccvH84iLwyBio5JrraVzZEPwA/ElEaotISeBJYKVzAXtcYDZWI3DKhbEYhmHclO8991CxWzfOLf6EK/aNl1nVrlCbhe0X8mzIs5z32sTdobP56VwCHaZtZPq6n0m57sYb0e6AyxoCVb0OvAisAfYCS1V1j4iME5Eou9hkwA9YJiLxIrIyh+o8XmJiIiEhITes79evHwkJCQBMnDixoMPKUXx8PKtXr75luejoaKZMmVIAERmG+wW8/BLeVQM49HQvTowbR5rTnfkZfLx8GNxkMPMi5uHjnUaJmu9Qr973vL12H5EzNhJ36Fw2NXs2l+YaUtXVwOos60Y7PX8kv/c56ftJ7Du7L1/rrFe5HsOaD8vTa99///csghMnTuRvf/tbfoV1W65fv463942HOT4+ntjYWDp06FCg8RiGJ/P296fOyi84PWM6Zz9eyMW1a6k+ciTlIiJuyCXWrHozVkStYNzWcfzn0HLCm+/n+IEudJu1hT4tg3g94l78ShWOdG4eMVhcVFy/fp2ePXtSv359unXrxpUrV3jooYeIjY1l+PDhJCcnEx4eTs+ePbl8+TIdO3YkLCyMkJAQYmJicqw3KCiIoUOH0rBhQ5o3b+7IN5SUlETXrl1p1qwZzZo1Y/PmzYD1K75Xr17cf//99OrV64b6UlJSGD16NDExMYSHhxMTE8PZs2fp3LkzoaGhtGjRgp07d97wurlz59K+fXuSk5P55ZdfHPMvtG7dmn37rMa3b9++vPzyy9x3333UqVMnU+4jwygMvPzKUm3ECIKWLsUnoCpHB7/KbwMHknLkyA1lK5SqwJQHpzD+/vEcTz5AicC3aNPkGAu2JtLu7W9Zt/dkwf8D8kJVC9WjSZMmmlVCQsIN6wrawYMHFdBNmzapquozzzyjkydP1gcffFB/+OEHVVUtW7aso/zy5cu1X79+juXz58/nWPfdd9+t48ePV1XVBQsWaMeOHVVVtUePHrpx40ZVVT106JDWq1dPVVXHjBmjjRs31itXruRY54cffqgvvPCCY/nFF1/U6OhoVVVdt26dhoWFOeqaPHmyzpgxQ6OiovTq1auqqtqmTRvdv3+/qqpu27ZNH374YVVV7dOnj3br1k3T0tJ0z549Wrdu3Zu/cTnwhGNqGOmpqXpmwQLd16ix7g0L19Nz52p6Skq2ZQ9fOKxPrXpKQ+aH6MCvX9O2b3+ldw9bpf/4aq+mp6cXcOQ3AmI1h+/VwnHeUkhknY9g+vTpOZZt2LAhr732GsOGDSMyMvKWU1H26NHD8ffVV18F4JtvvnGMPwBcvHiRS5esqxec5xe4HZs2bXJkJG3Tpg1nzpzh4kUr6dZHH31ErVq1+Pe//42Pjw+XLl1iy5YtdO/e3fH6a9d+v+Crc+fOlChRguDgYE6eLCS/iAwjG+LtTeXevSnXrh0nJ0zg1JS3uLDyC6qPjaZMo0aZytYqX4v57eczZ+cc5uycw11/2MNjgf14b8MvXLl2nTGdGlCiRN5uBnM10zWUj7L2IWZddnbPPfewfft2GjZsyKhRoxg3btxt153xPD09nW3bthEfH098fDxHjx7Fz88PyN1cB7fSsGFDEhMTOWKfGqenp1OxYkXHfuPj49m7d6+jfKlSpRzPtZAlNTSM7PhUr07gjBkEznyHtIsXOfRUT46PHUvaxcwZSn1K+PBC+AvMf2w+oGxLfoPWTfewYGsiQ1fs5Lo701vfhGkI8lHW+QhatWqVabuPj48jx/+xY8coU6YMTz/9NH/961/Zvn37TevOGEOIiYlxzEzWrl07ZsyY4SgTHx9/27FmnaugdevWLFq0CIANGzbg7+9P+fLW5ByNGjVi9uzZREVFcezYMcqXL0/t2rVZtmwZYH3Z//jjj7e9b8MorMq1bUudVauo3Ls352OW8kvHjlxcvfqGHzyNqjZiWadltPlDG+Ivf0yTJv9h+fZEXl6ywyMvMTUNQT7KOh/BoEGDMm0fMGAAoaGh9OzZk127dtG8eXPCw8MZO3Yso0aNumnd586dIzQ0lGnTpjF1qpU/ffr06cTGxhIaGkpwcDCzZs267VgffvhhEhISHIPF0dHRxMXFERoayvDhw1mwYEGm8q1atWLKlCl07NiR06dPs2jRIubNm0dYWBgNGjTg888/v+19G0ZhZg0mDydo2VJ8qlbj6JDX+G3AjYPJ5UqWY8qDUxgUNoj9V9ZzT/hCvkr4mQEfx3I1Nc1N0WfPzEdQCAQFBREbG4u/v7+7QykwRf2YGkWDpqVxbvEnJE2diqan4//C81Tp2xfx8clUbk3iGkZtGkVJKceJn5+k6V0Nmde3WYFeXuq2+QgMwzCKMvHyonKvp6mz+kv8Wrcm6a23OfiXrlzZsSNTuYigCBa0X0DpkiWoUHcOO858S8/3v+P8lRQ3RZ6ZaQg8SJcuXW6Yl2DNmjUkJibm+WxgzZo1N9TZpUuXfI7cMIo3azB5OoHvziTt0iUO9XiK42OiSbtwwVEmuEowSyKXEFylHqVqLmL/1RU8MWcLSf91f4o10zVkeCRzTI3CKv3yZZJmvMPZjz7Cq3Jlqo0YTvkOHRxX+6WkpTB261hW/rKS9EuhBCT3ZlG/B6hZ8fYv984L0zVkGIZRQEqULUu14cOsweTq1Tn22uv81n+AYzC5pFdJxt8/ntebvo6X3y7OlJ9Ktzlfknj6svtidtueDcMwirDSDRoQFLOEaiNHkrx9O79GduL03LloaioiQp8GfXin7TuULnOeS/5v0fXDxfx04sYkdwXBNASGYRguknkwuZU1mNy1m2Mw+YHAB1gSuZjq5SqQEjCT7oums/PI+QKP0zQEhmEYLnazO5PrVKzD8qgYwgIao/5LeGrFKLb9WrBT8pqGIJ8UtvkIwMpbFBoa6rhBLTc2bNjAli1bXBCVYRRdv9+Z3Ov3O5O//pryJcvzYfvZPF67O1LxW579ehBrEg4WWFxF7qqhExMncm1v/s5HUKp+ParfYh6BxMREIiMj2b17d45l/Pz8HEnhCkpO8xGcOHGCVq1aOVJa51Z0dDR+fn68/vrrdxxLdsxVQ0ZRl7x7DydGj+ZqQgJlH3yA6n8fTcnAmnywczFTt08iPcWf4Y0n0atpthf65Jq5aqiAFJb5CMDKU3T06FHCw8PZuHFjjvMLfPHFF/z5z3+mUaNGPPLII5w8eZLExERmzZrF1KlTHa/v27dvprkHMpLfbdiwgdatWxMVFUVwcDAACxcudKTXGDhwIGlpnnW7vWEUhNIhDQhaGkO1EcO58kMsv3bqxJl5H/BM8P8w/aFZeJe8zKSdzzPl/75wfTA55af21IeZjyB/5iM4ePCgNmjQwLGc0/wCZ8+edeRSnzt3rg4ZMsSxj8mTJzte36dPH122bJljOePfun79ei1Tpoz++uuvqmodq8jISE2xc7oPGjRIFyxYcEN8nnBMDaOgpBw9qoefG6QJ99bTXx7vrFd+/FF/On1Qm3zQTht8GKqvrn7njuc0wMxHUDAK63wEN5tf4MiRIzzxxBMcP36clJQUateufVt1OmvevLnjdevWrSMuLo5mzZoBkJycTNWqVXNdp2EUJT41ahD47kz++803nHxjPIlPPEmlp55i9cAP6bp6GGtPzaLHpwf5uMub+JTwuXWFuWQagnyUl/kIVq9ezahRo2jbti2jR4/OsfzN5iPw9fW9oXxu5iNwnl8gq5deeokhQ4YQFRXFhg0biI6OzrYOb29v0tPTHfWlpPyeQ8U5FlWlT58+vPnmm7cdn2EUByJC+UcfpWzLliT9axrnFi3Ce+1aPh8xgqeTarLn0pcM/qo6Mzve/rjc7TJjBPmoMM1H4Oxm8wtcuHCBmjVrAmRKTZ11PoOgoCDi4uIAWLlypePfmVXbtm1Zvnw5p06dAuDs2bMcOnQoT3EbRlHk5edH9VEjCYpZgleVKpx89VVmbb3I4/o8w+/r75J9moYgHxWm+Qiyyml+gejoaLp3706TJk0yJb7r1KkTn332mWOwuH///nz77beEhYWxdevWHM9IgoODGT9+PO3atSM0NJRHH32U48eP5zluwyiqSoeGUnvZUqoOHcqVbdt4evr7VNi62SX7KnKXjxZFZj4CwyjeUo8e5cSEiQS8+AK+9tV3uXWzy0fNGIFhGIaH86lZk1rvznRZ/aYh8CBdunTh4MHMdxNOmjSJxMTEPNe5Zs0ahg0blmld7dq1+eyzz/Jcp2EYRUuRaQhU9aZX6RQGrvhyjoiIICIiIt/rdaXC1l1pGIVdkRgs9vX15cyZM+YLpAhQVc6cOZPtJbGGYbhGkTgjCAwM5MiRIyQlFWzGPsM1fH19CQwMdHcYhlFsFImGwMfHJ093vBqGYRhFpGvIMAzDyDvTEBiGYRRzpiEwDMMo5grdncUikgTkNTmNP3A6H8PJLyau3DFx5Z6nxmbiyp07ietuVQ3IbkOhawjuhIjE5nSLtTuZuHLHxJV7nhqbiSt3XBWX6RoyDMMo5kxDYBiGUcwVt4ZgjrsDyIGJK3dMXLnnqbGZuHLHJXEVqzECwzAM40bF7YzAMAzDyMI0BIZhGMVcsWkIROQxEflJRA6IyHA3xvGBiJwSkd1O6yqLyFoR+dn+W8kNcdUSkfUikiAie0TkFU+ITUR8ReR7EfnRjmusvb62iHxnH88YESlZkHE5xeclIjtEZJWnxCUiiSKyS0TiRSTWXucJn7GKIrJcRPaJyF4RaenuuETkXvt9ynhcFJHB7o7Lju1V+zO/W0Q+sf8vuOTzVSwaAhHxAmYC7YFgoIeI5G2+tzs3H3gsy7rhwDpV/ROwzl4uaNeB11Q1GGgBvGC/R+6O7RrQRlXDgHDgMRFpAUwCpqrqH4FzwLMFHFeGV4C9TsueEtfDqhrudM25u48jwDTga1WtB4RhvW9ujUtVf7Lfp3CgCXAF+MzdcYlITeBloKmqhgBewJO46vOlqkX+AbQE1jgtjwBGuDGeIGC30/JPwF3287uAnzzgPfsceNSTYgPKANuBP2PdXemd3fEtwHgCsb4k2gCrAPGQuBIB/yzr3HocgQrAQewLVDwlriyxtAM2e0JcQE3gN6AyVpboVUCEqz5fxeKMgN/f1AxH7HWeopqqHrefnwCquTMYEQkCGgHf4QGx2d0v8cApYC3wC3BeVa/bRdx1PP8FDAXS7eUqHhKXAv8RkTgRGWCvc/dxrA0kAR/aXWnvi0hZD4jL2ZPAJ/Zzt8alqkeBKcBh4DhwAYjDRZ+v4tIQFBpqNfVuu6ZXRPyAFcBgVb3ovM1dsalqmlqn7oFAc6BeQceQlYhEAqdUNc7dsWSjlao2xuoKfUFEHnDe6Kbj6A00Bt5T1UbAZbJ0t7jzs2/3tUcBy7Juc0dc9pjE41gNaA2gLDd2Keeb4tIQHAVqOS0H2us8xUkRuQvA/nvKHUGIiA9WI7BIVT/1pNgAVPU8sB7rlLiiiGRMrOSO43k/ECUiicASrO6haR4QV8avSVT1FFZ/d3PcfxyPAEdU9Tt7eTlWw+DuuDK0B7ar6kl72d1xPQIcVNUkVU0FPsX6zLnk81VcGoIfgD/ZI+4lsU4BV7o5JmcrgT728z5Y/fMFSkQEmAfsVdW3PSU2EQkQkYr289JY4xZ7sRqEbu6KS1VHqGqgqgZhfZ7+V1V7ujsuESkrIuUynmP1e+/GzcdRVU8Av4nIvfaqtkCCu+Ny0oPfu4XA/XEdBlqISBn7/2bG++Waz5e7BmYK+gF0APZj9S+PdGMcn2D1+aVi/Up6FqtveR3wM/ANUNkNcbXCOv3dCcTbjw7ujg0IBXbYce0GRtvr6wDfAwewTudLufGYPgSs8oS47P3/aD/2ZHzW3X0c7RjCgVj7WP4bqOQhcZUFzgAVnNZ5QlxjgX325/5joJSrPl8mxYRhGEYxV1y6hgzDMIwcmIbAMAyjmDMNgWEYRjFnGgLDMIxizjQEhmEYxZxpCIxCx763YJOdlbGz0/rPRaTGHda9OuO+hVy85jkR6X0n+82h3ocysprepEy4iHTI730bxYtpCIzCqAcwC+uO2cEAItIJ2KGqx+6kYlXtoNYdzLl5zSxV/ehO9nsHwrHu9zCMPDMNgVEYpWJlIi0FpNm33A8G/pnTC0Rkvoi8JyLbRORX+9f2B3Ze/PlO5RJFxN++Q/dLseZB2C0iT9jb/yHWnA07RWSKvS5aRF63n28QkUlizaGwX0Ra2+vLiMhS+7Wf2Tnlm2YT52N2vv7twF+c1jcXka12wrYtdh79ksA44Ak7l/4T2ZW743fbKPK8b13EMDzOYvsxABgGPA98rKpXbvG6Slh5iqKwUgjcD/QDfhCRcFWNdyr7GHBMVTsCiEgFEakCdAHqqarepAvJW1Wb2102Y7DyxjwPnFPVYBEJwbpzOxMR8QXmYuUtOgDEOG3eB7RW1esi8ggwUVW7ishorJz1L9p1lM9aDuh6i/fFKObMGYFR6KjqBVXtqNakK9uBTsByEZkr1gxYLXN46Rdq3Uq/CzipqrtUNR0rFUNQlrK7gEftX/etVfUCVirgq8A8EfkL1iQm2clI2BfnVG8rrOR0qOpurDQLWdXDSjT2sx3nQqdtFYBlYs1sNxVokMO+b7ecYTiYhsAo7P4OTMAaN9iElYgrOoey1+y/6U7PM5YznR2r6n6s7Ji7gPEiMlqtPPDNsTJnRgJf32I/aVnrvQNvAOvVmq2qE+B7h+UMw8E0BEahJSJ/AgJVdQPWmEE6VuK80vlQdw3giqouBCYDje25Giqo6mrgVazpFm/XZuB/7LqDgYbZlNkHBIlIXXu5h9O2Cvyecriv0/r/AuVuo5xh5Mg0BEZhNgEYaT//BBiElXJ8Wj7U3RD4XqyZ0cYA47G+cFeJyE6ss48huajvXSBARBLsuvZgdTU5qOpVrHGPL+3BYucc+P8E3hSRHWQ+y1gPBGcMFt+knGHkyGQfNYwCICJegI+qXrV/8X8D3KuqKW4OzTDMLwbDKCBlgPX2LHACPG8aAcNTmDMCwzCMYs6MERiGYRRzpiEwDMMo5kxDYBiGUcyZhsAwDKOYMw2BYRhGMff/uX6VbXRNT3IAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_pr_curve(os.path.join(DATA_DIR, 'noisefree'), ('composite', 'per_feature', 'bits_per_token', 'bits_per_feature'), 'noisefree dataset')\n",
    "print_pr_curve(os.path.join(DATA_DIR, 'noisy'), ('composite', 'per_feature', 'bits_per_token', 'bits_per_feature'), 'noisy dataset')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusions\n",
    "The CLK-based linkage results are very close to the ones from the *composite* comparison technique (that's the comparison of the sets of tokens of the records).\n",
    "\n",
    "Interestingly, the *bits_per_feature* strategy performs slightly better than the *bits_per_token* strategy for data sparseness of up to 55%. This is somewhat surprising, as the *bits_per_token* strategy more closely resembles the *composite* comparison technique.\n",
    "\n",
    "The ability to compare feature values separately enables better comparison results for the same level of data sparseness. In the noisefree case, the *per_feature* comparison produces similar results to the composite techiques for data with up to 15% less data points. However, this advantage almost disappears once noise is added to the dataset.\n",
    "\n",
    "For this dataset, anonlink can handle up to 20% missing data without any degredation in linkage quality. The quality will decrease sharply for data sparseness over 30%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "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.7.4"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}