3.officer_nodes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 524,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import pandas, numpy, time\n",
    "from multiprocessing import Pool, cpu_count\n",
    "\n",
    "%matplotlib inline\n",
    "%pylab inline\n",
    "pylab.rcParams['figure.figsize'] = (15, 9)   # Change the size of plots\n",
    "\n",
    "N_ROWS = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# III. Grouping and Normalizing Officers:\n",
    "## Abstract \n",
    "\n",
    "\n",
    "\n",
    "## 0. Import and cleansing:\n",
    "Importing the dataset all lowercase, adding a parent_id column. Removing details from some names; ex: { boshen ltd./137-93, boshen ltd./136-83, boshen ltd./134-61 }. An upgrade could move these details to the notes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 525,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>countries</th>\n",
       "      <th>parent_id</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>node_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12000001</th>\n",
       "      <td>kim soo in</td>\n",
       "      <td>south korea</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12000002</th>\n",
       "      <td>tian yuan</td>\n",
       "      <td>china</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12000003</th>\n",
       "      <td>gregory john solomon</td>\n",
       "      <td>australia</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          name    countries  parent_id\n",
       "node_id                                               \n",
       "12000001            kim soo in  south korea          0\n",
       "12000002             tian yuan        china          0\n",
       "12000003  gregory john solomon    australia          0"
      ]
     },
     "execution_count": 525,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "officer_nodes = pandas.read_csv('data/raw/nodes.officer.csv', usecols=['node_id', 'name', 'countries'], index_col='node_id')\n",
    "officer_nodes['parent_id'] = 0\n",
    "\n",
    "officer_nodes = officer_nodes.applymap( lambda _str: _str.lower() if isinstance( _str,str ) else _str )\n",
    "\n",
    "def remove_punctuation(_str):\n",
    "    # TODO: replace with string.puctuation \n",
    "    for punc in [ ';', '#', ',', '|', '\\t', '\"', '/', '.', '(', ')', '-', '^', '_' ]:\n",
    "        _str = _str.replace( punc, ' ' )\n",
    "    return ' '.join(_str.split())\n",
    "    \n",
    "officer_nodes.name = officer_nodes.name.map( lambda _str: remove_punctuation(_str) if isinstance( _str,str) else _str )\n",
    "\n",
    "officer_nodes.head( N_ROWS )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This database is relatively large, thankfully over 50% of the entries seemed to be duplicates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 526,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Total entries: 238402 \n",
      "* Duplicates: 124109 or 52%\n"
     ]
    }
   ],
   "source": [
    "def count_duplicates( df, col ):\n",
    "    duplicates = df[ df.duplicated([ col ]) ]\n",
    "\n",
    "    total = df.shape[0]\n",
    "    unique = len( df[ col ].unique() )\n",
    "\n",
    "    duplicate_count = total - unique\n",
    "    duplicate_percent = int( (duplicate_count * 100) / total )\n",
    "\n",
    "    print( f'* Total entries: {total} \\n* Duplicates: {duplicate_count} or {duplicate_percent}%' )\n",
    "\n",
    "count_duplicates( officer_nodes, 'name' )\n",
    "\n",
    "# for record\n",
    "total = officer_nodes.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Normalizing \"bearer\" nodes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 527,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name\n",
       "the bearer     71543\n",
       "el portador     9351\n",
       "bearer           673\n",
       "dtype: int64"
      ]
     },
     "execution_count": 527,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "officer_nodes.groupby('name').size().sort_values(ascending=False).head( N_ROWS )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bearers cannot be grouped into a single ID as they could represent different officers, thus only typos and translations are normalized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 528,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name\n",
       "the bearer                         81696\n",
       "formia limited                       109\n",
       "north atlantic services limited      105\n",
       "dtype: int64"
      ]
     },
     "execution_count": 528,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bearer_nodes = officer_nodes.name.isin(\n",
    "    ['the  bearer', 'el portador', 'bearer', 'baerer',\n",
    "    'the baerer', 'the bearer', 'the beare', 'the ebarer',\n",
    "    'the beearer', 'the beared', 'el portaror', 'el portdor',\n",
    "    'the berear', 'el protador', 'the barer', 'bearr', 'the bear', \n",
    "    'elportador', 'al protador', 'al portador', 'to bearer'] \n",
    "    ) \n",
    "officer_nodes.loc[ bearer_nodes, 'name' ] = 'the bearer'\n",
    "\n",
    "# to quantify results\n",
    "bearer_nodes = officer_nodes[officer_nodes.name == 'the bearer']\n",
    "\n",
    "officer_nodes.groupby('name').size().sort_values(ascending=False).head( N_ROWS )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Removing direct duplicates:\n",
    "27% of the rest of the nodes (non bearer nodes) are exact duplicates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 529,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OTHER NODES\n",
      "* Total entries: 156706 \n",
      "* Duplicates: 42432 or 27%\n"
     ]
    }
   ],
   "source": [
    "officer_nodes = officer_nodes[ officer_nodes.name != 'the bearer']\n",
    "\n",
    "print('OTHER NODES')\n",
    "count_duplicates( officer_nodes, 'name' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maping the parent's ids to their exact duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 530,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Total in: 20.307018041610718\n"
     ]
    }
   ],
   "source": [
    "duplicates = officer_nodes.name.duplicated(keep=False)\n",
    "\n",
    "def map_parent_id(df):\n",
    "    # parent_id is the first row's node_id\n",
    "    parent_id = df.index[0]\n",
    "    # children are the rest of the rows\n",
    "    df.iloc[ 1:, df.columns.get_indexer(['parent_id']) ] = parent_id\n",
    "    return df\n",
    "\n",
    "def gapply_parallel(df_group, func):\n",
    "    t1 = time.time()\n",
    "\n",
    "    df_list = [ group for name, group in df_group ]\n",
    "\n",
    "    with Pool( cpu_count() ) as pool:\n",
    "        results = pool.map(func, df_list)\n",
    "\n",
    "    result_df = pandas.concat( results )\n",
    "\n",
    "    print( f'* Total in:', time.time()-t1 )\n",
    "    return result_df\n",
    "\n",
    "group_duplicates = officer_nodes.loc[ duplicates ].groupby('name')\n",
    "\n",
    "matches = gapply_parallel( group_duplicates, map_parent_id )\n",
    "\n",
    "officer_nodes.update(matches)\n",
    "officer_nodes.parent_id = officer_nodes.parent_id.astype('Int64')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 531,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Duplicates mapped: 42430\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>countries</th>\n",
       "      <th>parent_id</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>node_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12000044</th>\n",
       "      <td>noble nominees limited</td>\n",
       "      <td>belize</td>\n",
       "      <td>12000042</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12002698</th>\n",
       "      <td>tan sun hua</td>\n",
       "      <td>philippines</td>\n",
       "      <td>12000007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12002706</th>\n",
       "      <td>pilman holdings ltd</td>\n",
       "      <td>antigua and barbuda</td>\n",
       "      <td>12002705</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                            name            countries  parent_id\n",
       "node_id                                                         \n",
       "12000044  noble nominees limited               belize   12000042\n",
       "12002698             tan sun hua          philippines   12000007\n",
       "12002706     pilman holdings ltd  antigua and barbuda   12002705"
      ]
     },
     "execution_count": 531,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "duplicates_mapped = officer_nodes[ officer_nodes.parent_id > 0]\n",
    "print('Duplicates mapped:', duplicates_mapped.shape[0])\n",
    "\n",
    "duplicates_mapped.head(N_ROWS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saving the results in the clean 'data/output/edges.csv':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 532,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges = pandas.read_csv('data/processing/edges.csv')\n",
    "duplicate_nodes = duplicates_mapped.index\n",
    "\n",
    "def duplicate_to_parent(_id):\n",
    "    if _id in duplicate_nodes:\n",
    "        return duplicates_mapped.loc[_id, 'parent_id']\n",
    "    return _id\n",
    "    \n",
    "edges['start_id'] = edges['start_id'].apply(duplicate_to_parent)\n",
    "edges['end_id'] = edges['end_id'].apply(duplicate_to_parent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Splitting companies and people:\n",
    "The dataset is a mix of companies and people's name, we ought to separate these types of entities for further analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "metadata": {},
   "outputs": [],
   "source": [
    "officer_nodes = officer_nodes.loc[(officer_nodes.parent_id == 0) & officer_nodes.name.notna()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To extract companies, a corpus of tokens was compiled by selecting relevant words from a frequency analysis on all strings. Laborious process but very accurate as it eliminates errors from typos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "metadata": {},
   "outputs": [],
   "source": [
    "company_tokens = set(open(\"data/company_markers.txt\", \"r\").read().split())\n",
    "\n",
    "def is_company(_str):\n",
    "    # s.a. stands for sociedad anonima (anonymous company)\n",
    "    if ' s a' in _str:\n",
    "        return True\n",
    "    \n",
    "    _list = _str.split()\n",
    "    for w in _list:\n",
    "        if w in company_tokens:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "companies = officer_nodes.loc[officer_nodes.name.apply(is_company)] # boolean indexing returns a copy\n",
    "companies = officer_nodes.loc[companies.index]  # as a view\n",
    "\n",
    "names = officer_nodes.drop(companies.index)\n",
    "names = names.loc[ names.name.notna() ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Companies:\n",
    "More duplicates are found by simply removing all digits from the strings and sorting them. The digits are assumed to be details, typos or other unecessary markers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Total entries: 31973 \n",
      "* Duplicates: 387 or 1%\n"
     ]
    }
   ],
   "source": [
    "def remove_digits(_str):\n",
    "    return ''.join(list(filter(lambda x: not x.isdigit(), _str)))\n",
    "\n",
    "def sort_string(_str):\n",
    "    _str = _str.split()\n",
    "    _str.sort() \n",
    "    return ' '.join(_str)\n",
    "\n",
    "companies['name'] = companies['name'].apply(remove_digits)\n",
    "companies['name'] = companies['name'].apply(sort_string)\n",
    "\n",
    "count_duplicates(companies, 'name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Removing duplicates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Total in: 0.5842056274414062\n"
     ]
    }
   ],
   "source": [
    "def remove_duplicates(df, edges):\n",
    "    duplicates = df.name.duplicated(keep=False)\n",
    "    group_duplicates = df.loc[ duplicates ].groupby('name')\n",
    "\n",
    "    matches = gapply_parallel( group_duplicates, map_parent_id )\n",
    "\n",
    "    df.update(matches)\n",
    "    df.parent_id = companies.parent_id.astype('Int64')\n",
    "\n",
    "    edges['start_id'] = edges['start_id'].apply(duplicate_to_parent)\n",
    "    edges['end_id'] = edges['end_id'].apply(duplicate_to_parent)\n",
    "    \n",
    "    return df, edges\n",
    "\n",
    "companies, edges = remove_duplicates(companies, edges)\n",
    "\n",
    "duplicate_companies = companies[companies.parent_id > 0]\n",
    "companies = companies.drop(duplicate_companies.index)\n",
    "\n",
    "duplicate_companies.head(N_ROWS)\n",
    "edges.to_csv('data/processing/edges.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. People:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 537,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Total entries: 82270 \n",
      "* Duplicates: 2020 or 2%\n"
     ]
    }
   ],
   "source": [
    "to_remove = ['the', 'mr', 'm', 'miss', 'bearer', 'share', \n",
    "             'shares', 'beaer', 'warrant']\n",
    "\n",
    "# TODO : \n",
    "#remove_digit\n",
    "#remove_tokens\n",
    "#sort_string\n",
    "\n",
    "def sanitize_names(_str):\n",
    "    _str = remove_digits(_str)\n",
    "    \n",
    "    as_list = _str.split()\n",
    "    as_list = [ w for w in as_list if w not in to_remove ]\n",
    "    \n",
    "    as_list.sort()\n",
    "    \n",
    "    if len(as_list) > 0:\n",
    "        return ' '.join(as_list)\n",
    "    else:\n",
    "        return numpy.NaN\n",
    "\n",
    "names.name = names.name.map( lambda _str: sanitize_names(_str) if isinstance( _str,str) else _str )\n",
    "names = names.loc[ names.name.notna() ]\n",
    "\n",
    "count_duplicates(names, 'name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As important details have been removed, like the number of shares the person owns, we create new edges of type 'is'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Total in: 2.357980966567993\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parent_id</th>\n",
       "      <th>type</th>\n",
       "      <th>text</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>node_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12003111</th>\n",
       "      <td>12003108</td>\n",
       "      <td>is</td>\n",
       "      <td>same person</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12004112</th>\n",
       "      <td>12004109</td>\n",
       "      <td>is</td>\n",
       "      <td>same person</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12006882</th>\n",
       "      <td>12006702</td>\n",
       "      <td>is</td>\n",
       "      <td>same person</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         parent_id type         text\n",
       "node_id                             \n",
       "12003111  12003108   is  same person\n",
       "12004112  12004109   is  same person\n",
       "12006882  12006702   is  same person"
      ]
     },
     "execution_count": 538,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "duplicate_names = names[names.name.duplicated(keep=False)]\n",
    "group_duplicates = duplicate_names.groupby('name')\n",
    "\n",
    "matches = gapply_parallel( group_duplicates, map_parent_id )\n",
    "\n",
    "names.update(matches)\n",
    "\n",
    "new_edges = names[names.parent_id > 0].drop(['name', 'countries'], axis=1)\n",
    "new_edges['type'] = 'is'\n",
    "new_edges['text'] = 'same person'\n",
    "\n",
    "names = names[names.parent_id == 0]\n",
    "new_edges.head(N_ROWS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 539,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_edges.to_csv('data/processing/is.edges.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 540,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f91ddaa5750>"
      ]
     },
     "execution_count": 540,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "total_duplicates = ( duplicates_mapped.shape[0] \n",
    "                    + duplicate_companies.shape[0]\n",
    "                    + duplicate_names.shape[0] )\n",
    "\n",
    "data = numpy.array([ bearer_nodes.shape[0],\n",
    "                   companies.shape[0],\n",
    "                   names.shape[0],\n",
    "                   duplicates_mapped.shape[0] ])\n",
    "\n",
    "na = total - data.sum()\n",
    "data = numpy.append(data, na)\n",
    "\n",
    "s = pandas.Series(data, index=['the bearer', 'Companies', 'People', 'Duplicates', 'NaN'],\n",
    "                 name=' ')\n",
    "\n",
    "#as percentage of the total\n",
    "s.apply(lambda x: (x*100)/total)\n",
    "\n",
    "s.plot.pie(y=s.index, autopct='%1.1f%%', startangle=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TODO: save type people and company in original df"
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "kernelspec": {
   "display_name": "Python 3.7.5 64-bit",
   "language": "python",
   "name": "python37564bit72ba89a531ef4df18e1af0f065f1e4d6"
  },
  "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.5"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 2
}