Interactive labeling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 629,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import json\n",
    "import glob\n",
    "\n",
    "from modAL.models import ActiveLearner\n",
    "from modAL.uncertainty import uncertainty_sampling\n",
    "\n",
    "from sklearn.datasets import load_digits\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.metrics import f1_score, classification_report, confusion_matrix\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "import scipy\n",
    "from scipy.sparse import hstack\n",
    "\n",
    "from IPython import display\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 630,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Helper function\n",
    "def delete_row_csr(mat, i):\n",
    "    if not isinstance(mat, scipy.sparse.csr_matrix):\n",
    "        raise ValueError(\"works only for CSR format -- use .tocsr() first\")\n",
    "    n = mat.indptr[i+1] - mat.indptr[i]\n",
    "    if n > 0:\n",
    "        mat.data[mat.indptr[i]:-n] = mat.data[mat.indptr[i+1]:]\n",
    "        mat.data = mat.data[:-n]\n",
    "        mat.indices[mat.indptr[i]:-n] = mat.indices[mat.indptr[i+1]:]\n",
    "        mat.indices = mat.indices[:-n]\n",
    "    mat.indptr[i:-1] = mat.indptr[i+1:]\n",
    "    mat.indptr[i:] -= n\n",
    "    mat.indptr = mat.indptr[:-1]\n",
    "    mat._shape = (mat._shape[0]-1, mat._shape[1])\n",
    "    \n",
    "    return(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The dataset\n",
    "Now we set up the initial training set for our classifier. I need to pull out a bunch of passages to have a pool to select from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 631,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  \n",
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/ipykernel_launcher.py:7: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  import sys\n",
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3049: DtypeWarning: Columns (4,5,10) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n",
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/ipykernel_launcher.py:11: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    }
   ],
   "source": [
    "labeled_files = glob.glob('output/labeled_data/*.csv')\n",
    "df_labeled = pd.concat((pd.read_csv(f) for f in labeled_files))\n",
    "\n",
    "ds_files = glob.glob('output/labeled_data/active_learning_labels/data_sharing*.csv')\n",
    "od_files = glob.glob('output/labeled_data/active_learning_labels/open_data*.csv')\n",
    "df_data_sharing_al = pd.concat((pd.read_csv(f) for f in ds_files))\n",
    "df_open_data_al = pd.concat((pd.read_csv(f) for f in od_files))\n",
    "\n",
    "df_pmcids = pd.read_csv('data/PMC-ids.csv')\n",
    "\n",
    "df = pd.concat([df_labeled, df_data_sharing_al, df_open_data_al])\n",
    "df.reset_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 632,
   "metadata": {},
   "outputs": [],
   "source": [
    "#add some manuscript-level information\n",
    "df['pmcid'] = df.pmcid.astype('str')\n",
    "df['offset'] = df.paper_offset.astype('str')\n",
    "df_pmcids['pmcid'] = df_pmcids.PMCID.apply(lambda x: str(x)[3:])\n",
    "df = df.merge(df_pmcids, how='left', on='pmcid')\n",
    "df['pmcid-offset'] = df.apply(lambda x: x['pmcid']+'-'+x['offset'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 633,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3049: DtypeWarning: Columns (1) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    }
   ],
   "source": [
    "nimh_papers = pd.read_csv('output/nimh_papers.csv')\n",
    "#load file index\n",
    "file_ix = pd.read_csv('output/file_index.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3000,)"
      ]
     },
     "execution_count": 634,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#pull a sample of papers for the \"pool\" to learn from\n",
    "sampled_papers = pd.Series(nimh_papers.pmcid.unique()).sample(3000, replace=False)\n",
    "sampled_papers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 635,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2681, 3)"
      ]
     },
     "execution_count": 635,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#file_locs = file_ix[file_ix.pmcid.isin(nimh_papers.pmcid.unique())]\n",
    "file_locs = file_ix[file_ix.pmcid.isin(sampled_papers.unique().tolist())]\n",
    "file_locs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 636,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "file_locs['pmcid'] = file_locs.pmcid.astype('str')\n",
    "file_locs = file_locs.sort_values('file')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 637,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_dat = []\n",
    "last_file = ''\n",
    "for i, file_path in enumerate(file_locs.file):\n",
    "    if last_file == file_path:\n",
    "        paper = dat[file_locs.paper_number.iloc[i]]\n",
    "        for j in paper['documents'][0]['passages']:\n",
    "            if 'section_type' in list(j['infons'].keys()):\n",
    "                if j['infons']['section_type'] != 'REF':\n",
    "                    pmc_and_offset = file_locs.pmcid.iloc[i] + '-' + str(j['offset'])\n",
    "                    if pmc_and_offset not in df['pmcid-offset'].tolist():\n",
    "                        out_dat.append([j['text'], j['offset'], file_locs.pmcid.iloc[i], j['infons']['section_type']])\n",
    "        last_file = file_path\n",
    "        \n",
    "    else:    \n",
    "        with open(file_path[24:]) as infile:\n",
    "            dat = json.load(infile)\n",
    "            paper = dat[file_locs.paper_number.iloc[i]]\n",
    "            for j in paper['documents'][0]['passages']:\n",
    "                if 'section_type' in list(j['infons'].keys()):\n",
    "                    if j['infons']['section_type'] != 'REF':\n",
    "                        pmc_and_offset = file_locs.pmcid.iloc[i] + '-' + str(j['offset'])\n",
    "                        if pmc_and_offset not in df['pmcid-offset'].tolist():\n",
    "                            out_dat.append([j['text'], j['offset'], file_locs.pmcid.iloc[i], j['infons']['section_type']])\n",
    "            last_file = file_path\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 638,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(207831, 16)"
      ]
     },
     "execution_count": 638,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_pool = pd.DataFrame(out_dat, columns=['text', 'offset', 'pmcid', 'section'])\n",
    "df_pool['pmcid'] = df_pool.pmcid.astype('str')\n",
    "df_pool = df_pool.merge(df_pmcids, how='left', on='pmcid')\n",
    "df_pool.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 639,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['index', 'data_sharing', 'doi', 'open_data', 'paper_offset', 'pmcid',\n",
       "       'repo', 'section', 'text', 'offset', 'Journal Title', 'ISSN', 'eISSN',\n",
       "       'Year', 'Volume', 'Issue', 'Page', 'DOI', 'PMCID', 'PMID',\n",
       "       'Manuscript Id', 'Release Date', 'pmcid-offset'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 639,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split data into data sharing and open data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 640,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    1167\n",
       "1     184\n",
       "Name: open_data, dtype: int64"
      ]
     },
     "execution_count": 640,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_open_data = df[~pd.isnull(df.open_data)]\n",
    "df_open_data['open_data'] = df_open_data.open_data.astype('int')\n",
    "df_open_data.reset_index(inplace=True)\n",
    "df_open_data.open_data.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 641,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n",
      "/home/riddleta/ac_knowl/ac_knowl/lib/python3.7/site-packages/pandas/core/generic.py:6288: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self._update_inplace(new_data)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    1285\n",
       "1      66\n",
       "Name: data_sharing, dtype: int64"
      ]
     },
     "execution_count": 641,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_data_sharing = df[~pd.isnull(df.data_sharing)]\n",
    "df_data_sharing['data_sharing'] = df_data_sharing.data_sharing.astype('int')\n",
    "df_data_sharing.reset_index(inplace=True)\n",
    "df_data_sharing.text.fillna('', inplace=True)\n",
    "df_data_sharing.data_sharing.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Active learning for open data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 642,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df_open_data.text\n",
    "y = df_open_data.open_data\n",
    "#X, y = load_digits(return_X_y=True)\n",
    "\n",
    "train_x, test_x, y_train, y_test = train_test_split(X, y, stratify=y, test_size=.4)\n",
    "\n",
    "cv = CountVectorizer()\n",
    "enc = OneHotEncoder(handle_unknown='ignore')\n",
    "\n",
    "x_text_train = cv.fit_transform(train_x)\n",
    "one_hots_train = enc.fit_transform(df_open_data[['section', 'Journal Title', 'Year']].iloc[train_x.index])\n",
    "y_train = np.array(y_train)\n",
    "x_text_test = cv.transform(test_x)\n",
    "one_hots_test = enc.transform(df_open_data[['section', 'Journal Title', 'Year']].iloc[test_x.index])\n",
    "y_test = np.array(y_test)\n",
    "\n",
    "x_train = hstack([x_text_train, one_hots_train])\n",
    "x_test = hstack([x_text_test, one_hots_test])\n",
    "\n",
    "#X_initial, y_initial = X_train[initial_idx], y_train[initial_idx]\n",
    "x_text_pool = cv.transform(df_pool.text)\n",
    "x_pool_one_hots = enc.transform(df_pool[['section', 'Journal Title', 'Year']])\n",
    "x_pool = hstack([x_text_pool, x_pool_one_hots]).tocsr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 643,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<207831x10052 sparse matrix of type '<class 'numpy.float64'>'\n",
       "\twith 8612531 stored elements in Compressed Sparse Row format>"
      ]
     },
     "execution_count": 643,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_pool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing the learner\n",
    "Now we initialize the active learner. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 644,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = ActiveLearner(\n",
    "    estimator=AdaBoostClassifier(),\n",
    "    query_strategy=uncertainty_sampling,\n",
    "    X_training=x_train, y_training=y_train\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also set how many queries we want to make. The more the better! (Usually :) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 645,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666667"
      ]
     },
     "execution_count": 645,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(learner.predict(x_test), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 646,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.94      0.95       483\n",
      "           1       0.59      0.76      0.67        58\n",
      "\n",
      "    accuracy                           0.92       541\n",
      "   macro avg       0.78      0.85      0.81       541\n",
      "weighted avg       0.93      0.92      0.92       541\n",
      "\n",
      "[[453  30]\n",
      " [ 14  44]]\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(learner.predict(x_test), y_test))\n",
    "print(confusion_matrix(learner.predict(x_test), y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_queries = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The active learning loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 648,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Open Data?\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "accuracy_scores = [f1_score(learner.predict(x_test), y_test)]\n",
    "queried_data = pd.DataFrame()\n",
    "labels = []\n",
    "\n",
    "for i in range(n_queries):\n",
    "    display.clear_output(wait=True)\n",
    "    query_idx, query_inst = learner.query(x_pool)\n",
    "    with plt.style.context('seaborn-white'):\n",
    "        print(df_pool.text[query_idx].iloc[0])\n",
    "        plt.figure(figsize=(10, 5))\n",
    "        plt.title('Accuracy of your model')\n",
    "        plt.plot(range(i+1), accuracy_scores)\n",
    "        plt.scatter(range(i+1), accuracy_scores)\n",
    "        plt.xlabel('number of queries')\n",
    "        plt.ylabel('accuracy')\n",
    "        display.display(plt.gcf())\n",
    "        plt.close('all')\n",
    "\n",
    "    print(\"Open Data?\")\n",
    "    y_new = np.array([int(input())], dtype=int)\n",
    "    learner.teach(query_inst, y_new)\n",
    "    x_pool = delete_row_csr(x_pool, query_idx[0])\n",
    "    #X_pool, y_pool = np.delete(X_pool, query_idx, axis=0)#, np.delete(y_pool, query_idx, axis=0)\n",
    "    accuracy_scores.append(f1_score(learner.predict(x_test), y_test))\n",
    "    temp = df_pool[['text', 'offset', 'pmcid', 'section', 'DOI']].iloc[query_idx]\n",
    "    labels.append(y_new[0])\n",
    "    queried_data = pd.concat([queried_data, temp])\n",
    "\n",
    "queried_data['open_data'] = labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 649,
   "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>text</th>\n",
       "      <th>offset</th>\n",
       "      <th>pmcid</th>\n",
       "      <th>section</th>\n",
       "      <th>DOI</th>\n",
       "      <th>open_data</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>123574</th>\n",
       "      <td>Lessons derived from this study can be useful ...</td>\n",
       "      <td>28133</td>\n",
       "      <td>3213136</td>\n",
       "      <td>DISCUSS</td>\n",
       "      <td>10.1371/journal.pone.0027447</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>128386</th>\n",
       "      <td>Adropin overexpression does not reduce cholest...</td>\n",
       "      <td>38748</td>\n",
       "      <td>5985041</td>\n",
       "      <td>FIG</td>\n",
       "      <td>10.1016/j.molmet.2017.12.002</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34413</th>\n",
       "      <td>However, the amount of available data remains ...</td>\n",
       "      <td>6254</td>\n",
       "      <td>2789920</td>\n",
       "      <td>INTRO</td>\n",
       "      <td>10.1016/j.neuroimage.2009.09.056</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44595</th>\n",
       "      <td>Twenty four young women were selected from the...</td>\n",
       "      <td>10637</td>\n",
       "      <td>2976801</td>\n",
       "      <td>METHODS</td>\n",
       "      <td>10.1177/1087054710361586</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101130</th>\n",
       "      <td></td>\n",
       "      <td>37741</td>\n",
       "      <td>3994700</td>\n",
       "      <td>CONCL</td>\n",
       "      <td>10.1016/j.tig.2009.09.003</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                     text  offset    pmcid  \\\n",
       "123574  Lessons derived from this study can be useful ...   28133  3213136   \n",
       "128386  Adropin overexpression does not reduce cholest...   38748  5985041   \n",
       "34413   However, the amount of available data remains ...    6254  2789920   \n",
       "44595   Twenty four young women were selected from the...   10637  2976801   \n",
       "101130                                                      37741  3994700   \n",
       "\n",
       "        section                               DOI  open_data  \n",
       "123574  DISCUSS      10.1371/journal.pone.0027447          0  \n",
       "128386      FIG      10.1016/j.molmet.2017.12.002          0  \n",
       "34413     INTRO  10.1016/j.neuroimage.2009.09.056          0  \n",
       "44595   METHODS          10.1177/1087054710361586          0  \n",
       "101130    CONCL         10.1016/j.tig.2009.09.003          0  "
      ]
     },
     "execution_count": 649,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queried_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 650,
   "metadata": {},
   "outputs": [],
   "source": [
    "queried_data.columns = ['text', 'paper_offset', 'pmcid', 'section', 'doi', 'open_data']\n",
    "queried_data.to_csv('output/labeled_data/active_learning_labels/open_data07.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Active learning for data sharing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 651,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df_data_sharing.text\n",
    "y = df_data_sharing.data_sharing\n",
    "#X, y = load_digits(return_X_y=True)\n",
    "\n",
    "train_x, test_x, y_train, y_test = train_test_split(X, y, stratify=y, test_size=.4)\n",
    "\n",
    "cv = CountVectorizer(ngram_range=(1,2))\n",
    "enc = OneHotEncoder(handle_unknown='ignore')\n",
    "\n",
    "x_text_train = cv.fit_transform(train_x)\n",
    "one_hots_train = enc.fit_transform(df_data_sharing[['section', 'Journal Title', 'Year']].iloc[train_x.index])\n",
    "y_train = np.array(y_train)\n",
    "x_text_test = cv.transform(test_x)\n",
    "one_hots_test = enc.transform(df_data_sharing[['section', 'Journal Title', 'Year']].iloc[test_x.index])\n",
    "y_test = np.array(y_test)\n",
    "\n",
    "x_train = hstack([x_text_train, one_hots_train])\n",
    "x_test = hstack([x_text_test, one_hots_test])\n",
    "\n",
    "#X_initial, y_initial = X_train[initial_idx], y_train[initial_idx]\n",
    "x_text_pool = cv.transform(df_pool.text)\n",
    "x_pool_one_hots = enc.transform(df_pool[['section', 'Journal Title', 'Year']])\n",
    "x_pool = hstack([x_text_pool, x_pool_one_hots]).tocsr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 652,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<207831x57702 sparse matrix of type '<class 'numpy.float64'>'\n",
       "\twith 12940179 stored elements in Compressed Sparse Row format>"
      ]
     },
     "execution_count": 652,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_pool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing the learner\n",
    "Now we initialize the active learner. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 653,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = ActiveLearner(\n",
    "    estimator=AdaBoostClassifier(),\n",
    "    query_strategy=uncertainty_sampling,\n",
    "    X_training=x_train, y_training=y_train\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 654,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4761904761904762"
      ]
     },
     "execution_count": 654,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(learner.predict(x_test), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 655,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.97      0.98       525\n",
      "           1       0.38      0.62      0.48        16\n",
      "\n",
      "    accuracy                           0.96       541\n",
      "   macro avg       0.69      0.80      0.73       541\n",
      "weighted avg       0.97      0.96      0.96       541\n",
      "\n",
      "[[509  16]\n",
      " [  6  10]]\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(learner.predict(x_test), y_test))\n",
    "print(confusion_matrix(learner.predict(x_test), y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 656,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_queries = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The active learning loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 657,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "System-level effects\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Sharing?\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "accuracy_scores = [f1_score(learner.predict(x_test), y_test)]\n",
    "queried_data = pd.DataFrame()\n",
    "labels = []\n",
    "\n",
    "for i in range(n_queries):\n",
    "    display.clear_output(wait=True)\n",
    "    query_idx, query_inst = learner.query(x_pool)\n",
    "    with plt.style.context('seaborn-white'):\n",
    "        print(df_pool.text[query_idx].iloc[0])\n",
    "        plt.figure(figsize=(10, 5))\n",
    "        plt.title('Accuracy of your model')\n",
    "        plt.plot(range(i+1), accuracy_scores)\n",
    "        plt.scatter(range(i+1), accuracy_scores)\n",
    "        plt.xlabel('number of queries')\n",
    "        plt.ylabel('accuracy')\n",
    "        display.display(plt.gcf())\n",
    "        plt.close('all')\n",
    "\n",
    "    print(\"Data Sharing?\")\n",
    "    y_new = np.array([int(input())], dtype=int)\n",
    "    learner.teach(query_inst, y_new)\n",
    "    x_pool = delete_row_csr(x_pool, query_idx[0])\n",
    "    #X_pool, y_pool = np.delete(X_pool, query_idx, axis=0)#, np.delete(y_pool, query_idx, axis=0)\n",
    "    accuracy_scores.append(f1_score(learner.predict(x_test), y_test))\n",
    "    temp = df_pool[['text', 'offset', 'pmcid', 'section', 'DOI']].iloc[query_idx]\n",
    "    labels.append(y_new[0])\n",
    "    queried_data = pd.concat([queried_data, temp])\n",
    "\n",
    "queried_data['data_sharing'] = labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 658,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    98\n",
       "1     2\n",
       "Name: data_sharing, dtype: int64"
      ]
     },
     "execution_count": 658,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queried_data.data_sharing.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 659,
   "metadata": {},
   "outputs": [],
   "source": [
    "queried_data.columns = ['text', 'paper_offset', 'pmcid', 'section', 'doi', 'data_sharing']\n",
    "queried_data.to_csv('output/labeled_data/active_learning_labels/data_sharing07.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<598x8367 sparse matrix of type '<class 'numpy.float64'>'\n",
       "\twith 36832 stored elements in COOrdinate format>"
      ]
     },
     "execution_count": 552,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "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>text</th>\n",
       "      <th>offset</th>\n",
       "      <th>pmcid</th>\n",
       "      <th>section</th>\n",
       "      <th>Journal Title</th>\n",
       "      <th>ISSN</th>\n",
       "      <th>eISSN</th>\n",
       "      <th>Year</th>\n",
       "      <th>Volume</th>\n",
       "      <th>Issue</th>\n",
       "      <th>Page</th>\n",
       "      <th>DOI</th>\n",
       "      <th>PMCID</th>\n",
       "      <th>PMID</th>\n",
       "      <th>Manuscript Id</th>\n",
       "      <th>Release Date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>83499</th>\n",
       "      <td>\\n        \\n          \\n            Predictor\\...</td>\n",
       "      <td>37230</td>\n",
       "      <td>4035109</td>\n",
       "      <td>TABLE</td>\n",
       "      <td>J Clin Psychiatry</td>\n",
       "      <td>0160-6689</td>\n",
       "      <td>1555-2101</td>\n",
       "      <td>2011</td>\n",
       "      <td>72</td>\n",
       "      <td>8</td>\n",
       "      <td>1027</td>\n",
       "      <td>10.4088/JCP.10m06410</td>\n",
       "      <td>PMC4035109</td>\n",
       "      <td>21813075.0</td>\n",
       "      <td>NIHMS317910</td>\n",
       "      <td>live</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                    text  offset    pmcid  \\\n",
       "83499  \\n        \\n          \\n            Predictor\\...   37230  4035109   \n",
       "\n",
       "      section      Journal Title       ISSN      eISSN  Year Volume Issue  \\\n",
       "83499   TABLE  J Clin Psychiatry  0160-6689  1555-2101  2011     72     8   \n",
       "\n",
       "       Page                   DOI       PMCID        PMID Manuscript Id  \\\n",
       "83499  1027  10.4088/JCP.10m06410  PMC4035109  21813075.0   NIHMS317910   \n",
       "\n",
       "      Release Date  \n",
       "83499         live  "
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_pool.iloc[query_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ac_knowl",
   "language": "python",
   "name": "ac_knowl"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}