notebooks/Bootstrap_Estimation_Decadal2010-Whitepapers_TCS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook to examine error (standard deviation) of TCS using bootstrap method for whitepapers\n",
    "This is estimated for TCS 2010 Decadal Survey Whitepapers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os, sys\n",
    "sys.path.append(\"../src\")\n",
    "from process import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Config section\n",
    "version = '19_2_125_rec1'\n",
    "\n",
    "# viz 19 (125 topics)\n",
    "topics_to_estimate_errors = [29, 32, 45, 64, 70, 74, 91, 95, 97, 120]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>115</th>\n",
       "      <th>116</th>\n",
       "      <th>117</th>\n",
       "      <th>118</th>\n",
       "      <th>119</th>\n",
       "      <th>120</th>\n",
       "      <th>121</th>\n",
       "      <th>122</th>\n",
       "      <th>123</th>\n",
       "      <th>124</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.041421</td>\n",
       "      <td>0.000329</td>\n",
       "      <td>0.000339</td>\n",
       "      <td>0.000327</td>\n",
       "      <td>0.000304</td>\n",
       "      <td>0.000322</td>\n",
       "      <td>0.000319</td>\n",
       "      <td>0.00032</td>\n",
       "      <td>0.00034</td>\n",
       "      <td>0.044078</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000325</td>\n",
       "      <td>0.000313</td>\n",
       "      <td>0.000319</td>\n",
       "      <td>0.000332</td>\n",
       "      <td>0.000315</td>\n",
       "      <td>0.00032</td>\n",
       "      <td>0.000331</td>\n",
       "      <td>0.000327</td>\n",
       "      <td>0.000325</td>\n",
       "      <td>0.000322</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 125 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2         3         4         5         6  \\\n",
       "0  0.041421  0.000329  0.000339  0.000327  0.000304  0.000322  0.000319   \n",
       "\n",
       "         7        8         9  ...       115       116       117       118  \\\n",
       "0  0.00032  0.00034  0.044078  ...  0.000325  0.000313  0.000319  0.000332   \n",
       "\n",
       "        119      120       121       122       123       124  \n",
       "0  0.000315  0.00032  0.000331  0.000327  0.000325  0.000322  \n",
       "\n",
       "[1 rows x 125 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load data\n",
    "topic_distrib_data = open_topic_distrib(version, 'whitepapers')\n",
    "\n",
    "# process document inference data to get an idea of inferences by topic, for each paper in our data\n",
    "data_by_paper = topic_distrib_data.drop(['Unnamed: 0'], axis=1)\n",
    "data_by_paper[:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '1', '2']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = list(data_by_paper.keys())\n",
    "list(data_by_paper.keys())[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data_by_paper.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "274"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_seq = list(range(0, len(data_by_paper)))\n",
    "len(row_seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import statistics\n",
    "\n",
    "# sample data for bootstrap\n",
    "import random\n",
    "def sample_paragraphs(topic:str, data_by_paper:pd.DataFrame, samples_per_run:int=100):\n",
    "    ''' find TCS or summed total inference from paragraphs for topic '''\n",
    "    total_inference = 0\n",
    "    \n",
    "    keys = list(data_by_paper.keys())\n",
    "    t_size = len(keys)\n",
    "        \n",
    "    # random sample, no replacement\n",
    "    num_topics = len(data_by_paper.columns)\n",
    "    \n",
    "    # using random sampling of the rows, no replacement\n",
    "    data = data_by_paper\n",
    "    \n",
    "    row_seq = list(range(0, len(data)))\n",
    "    #print (row_seq)\n",
    "\n",
    "    random_rows = random.sample(row_seq, samples_per_run)\n",
    "    for random_row in random_rows:\n",
    "        row_data = data[data.index==random_row]\n",
    "        value = list(row_data[topic].values)[0]\n",
    "        total_inference += value\n",
    "\n",
    "    return total_inference\n",
    "\n",
    "# sample data for bootstrap\n",
    "def sample_paragraphs_repl(topic, data_by_paper:dict, samples_per_run:int=100):\n",
    "    \n",
    "    total_inference = 0\n",
    "    \n",
    "    t_size = len(data_by_paper.keys())\n",
    "    \n",
    "    # random sample with replacement.\n",
    "    num_topics = len(data_by_paper.columns)\n",
    "    \n",
    "     # using random sampling of the rows, no replacement\n",
    "    data = data_by_paper\n",
    "    \n",
    "    row_seq = list(range(0, len(data)))\n",
    "    #print (row_seq)\n",
    "\n",
    "    random_rows = []\n",
    "    for i in range(0,samples_per_run):\n",
    "        random_rows.append(random.choice(row_seq))\n",
    "   \n",
    "    for random_row in random_rows:\n",
    "        row_data = data[data.index==random_row]\n",
    "        value = list(row_data[topic].values)[0]\n",
    "        total_inference += value\n",
    "\n",
    "    return total_inference\n",
    "\n",
    "def bootstrap_estimate (topic:str, data_by_paper:dict, \\\n",
    "                       num_times_to_sample:int=10, num_data_samples:int=10000,\\\n",
    "                       replacement:bool=True):\n",
    "    \n",
    "    \"\"\" Returns the mean and standard deviation for selected topic inference values \"\"\"\n",
    "    \n",
    "    stats = []\n",
    "    for i in range(0, num_times_to_sample):\n",
    "        if replacement:\n",
    "            stats.append(sample_paragraphs_repl(topic, data_by_paper, num_data_samples))\n",
    "        else:\n",
    "            stats.append(sample_paragraphs(topic, data_by_paper, num_data_samples))\n",
    "    \n",
    "    #calculate mean, standard deviation\n",
    "    return statistics.mean(stats), np.std(stats)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "274"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# overall size (using smallest/first year)\n",
    "len(data_by_paper[k[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "191"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# choose to sample ~70% of the smallest year size\n",
    "sample_size = int(len(data_by_paper) * 0.7)\n",
    "sample_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " time to run:  0.47 sec\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.6102956209249002, 0.21320187236554608)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "start_time = time.time()\n",
    "\n",
    "# bootstrap w/replacement is same as w/o replacement according to:\n",
    "#  https://stats.stackexchange.com/questions/69744/why-at-all-consider-sampling-without-replacement-in-a-practical-application\n",
    "# when applied to first-order statistics like mean and variance. w/o replacement should\n",
    "# be used for higher order statistics (e.g. skewness, kurtosis)\n",
    "\n",
    "# takes about 560 sec per ~18000 data samples per topic \n",
    "result = bootstrap_estimate(\"64\", data_by_paper, 10, sample_size)\n",
    "print (f\" time to run: %5.2f sec\" % (time.time()-start_time))\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#start_time = time.time()\n",
    "#result = bootstrap_estimate(64, data_by_paper, 10, 18000, replacement=False)\n",
    "#print (f\" time to run: %5.2f sec\" % (time.time()-start_time))\n",
    "#result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing topic 29\n",
      "Doing topic 32\n",
      "Doing topic 45\n",
      "Doing topic 64\n",
      "Doing topic 70\n",
      "Doing topic 74\n",
      "Doing topic 91\n",
      "Doing topic 95\n",
      "Doing topic 97\n",
      "Doing topic 120\n"
     ]
    }
   ],
   "source": [
    "# Now defined above\n",
    "results = {}\n",
    "for topic in topics_to_estimate_errors:\n",
    "    print (f\"Doing topic {topic}\")\n",
    "    results[topic] = bootstrap_estimate(str(topic), data_by_paper, 10, sample_size, replacement=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{29: (0.46133424224029995, 0.13320717899668016),\n",
       " 32: (1.3627058157251004, 0.2905644079065685),\n",
       " 45: (0.8536000844518998, 0.1095721806858675),\n",
       " 64: (0.5279143936755, 0.32653006183092176),\n",
       " 70: (2.3912716355718997, 0.699412193136246),\n",
       " 74: (2.1499680205441005, 0.5094859106387135),\n",
       " 91: (0.5751401418779002, 0.23887497618672454),\n",
       " 95: (1.3555758259588, 0.3184365653275134),\n",
       " 97: (0.5082239376805, 0.18337072911617291),\n",
       " 120: (1.8132168016363002, 0.3522798527781437)}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#timeseries_filename=f'../data/time_series_characteristics_{version}.csv'\n",
    "# read in data with various info, each row is a topic number \n",
    "#timeseries_data = pd.read_csv(timeseries_filename, index_col=False)\n",
    "#timeseries_data['count'][64]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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>topic</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>29</td>\n",
       "      <td>0.461334</td>\n",
       "      <td>0.133207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>32</td>\n",
       "      <td>1.362706</td>\n",
       "      <td>0.290564</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>45</td>\n",
       "      <td>0.853600</td>\n",
       "      <td>0.109572</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>64</td>\n",
       "      <td>0.527914</td>\n",
       "      <td>0.326530</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>70</td>\n",
       "      <td>2.391272</td>\n",
       "      <td>0.699412</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>74</td>\n",
       "      <td>2.149968</td>\n",
       "      <td>0.509486</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>91</td>\n",
       "      <td>0.575140</td>\n",
       "      <td>0.238875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>95</td>\n",
       "      <td>1.355576</td>\n",
       "      <td>0.318437</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>97</td>\n",
       "      <td>0.508224</td>\n",
       "      <td>0.183371</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>120</td>\n",
       "      <td>1.813217</td>\n",
       "      <td>0.352280</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   topic      mean       std\n",
       "0     29  0.461334  0.133207\n",
       "1     32  1.362706  0.290564\n",
       "2     45  0.853600  0.109572\n",
       "3     64  0.527914  0.326530\n",
       "4     70  2.391272  0.699412\n",
       "5     74  2.149968  0.509486\n",
       "6     91  0.575140  0.238875\n",
       "7     95  1.355576  0.318437\n",
       "8     97  0.508224  0.183371\n",
       "9    120  1.813217  0.352280"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "topics = [t for t in results.keys()]\n",
    "mean  = [results[t][0] for t in topics]\n",
    "std    = [results[t][1] for t in topics]\n",
    "#counts = [timeseries_data['count'][t] for t in topics]\n",
    "r_data = pd.DataFrame({'topic':topics, 'mean':mean, 'std':std})\n",
    "\n",
    "# save a copy\n",
    "r_data.to_csv(f'../results/bootstrap_error_est_results_tcs_repl_DS2010_whitepapers_{version}.csv')\n",
    "r_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.19989508993623, 0.31617340566035523)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# overall population mean TCS and associated standard deviation\n",
    "r_data['mean'].mean(), r_data['std'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: title={'center': 'Bootstrap Error Estimation (TCS, DS2010)'}, xlabel='TCS', ylabel='std'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "r_data.plot(kind='scatter', x='mean', y='std', xlabel=\"TCS\", title=\"Bootstrap Error Estimation (TCS, DS2010)\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:strat-paper]",
   "language": "python",
   "name": "conda-env-strat-paper-py"
  },
  "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}