notebooks/MLCR_Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook to examine distribution of papers in a topic by their likehood of membership.\n",
    "\n",
    "Try to answer the questions:\n",
    "    'what is a good threshold/cutoff to exclude papers from a given topic, if any?'\n",
    "    'Are there a large number of seemingly random, low-probability papers in a topic?'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import h5py\n",
    "import os\n",
    "import json\n",
    "import math\n",
    "import sys\n",
    "import statistics as stat\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.stats import pearsonr, spearmanr, sem # standard error of mean\n",
    "sys.path.append(\"../src\")\n",
    "from process import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defs of data to use\n",
    "\n",
    "# Viz19, 10 Runs 125 topics, 'astro-only' high-impact journals, no SEDs\n",
    "versions = ['19_2_125_rec1', '19_2_125_rec2','19_2_125_rec3','19_2_125_rec4','19_2_125_rec5',\n",
    "            '19_2_125_rec6', '19_2_125_rec7','19_2_125_rec8','19_2_125_rec9','19_2_125_rec10'] \n",
    "\n",
    "citation_filename = '../data/astro_only_doc_citation_bibcode_cnts_2010.json'\n",
    "\n",
    "# Document content type\n",
    "contentType = 'decadal'\n",
    "#contentType = 'whitepaper'\n",
    "\n",
    "# Low cite threshold\n",
    "low_cite_threshold = 10 # dont use papers with fewer cites than this\n",
    "\n",
    "# min topic threshold to use\n",
    "# IMPORTANT NOTE: we HAVE to have some way of discrimination of which citations to keep because otherwise\n",
    "# we get the same average number of citations for every topic IF we have min_inference of 0 (e.g. ALL papers are relevant for \n",
    "# all topics, so its the same population, and hence values for avg citiations, for all topics).\n",
    "# Best value is ~0.2\n",
    "#\n",
    "min_inferences = [0.01, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7] # threshold of paper inference to be included in citation count for a topic\n",
    "\n",
    "# maximum inference threshold to use, discard everything above this\n",
    "max_inference = 1.0\n",
    "\n",
    "# use filtered? for 19_2_125 means no Grav Wave topic\n",
    "use_filtered = True\n",
    "\n",
    "# whether to use pearson or spearman coorelation\n",
    "use_spearman = True\n",
    "\n",
    "# minimum citations needed per topic\n",
    "min_citations_needed = 3 # IF lower than this, we dont have enough data to estimate reasonable avg\n",
    "\n",
    "# debug mode\n",
    "chatty = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set filtering\n",
    "filtered = \"_filtered\" if use_filtered else \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adj_cite_cnt(yr:int, cite_cnt:int)->int:\n",
    "    #return eic_func(yr, cite_cnt)\n",
    "    return sigmoid_func(yr, cite_cnt)\n",
    "\n",
    "# from mmodel fitting astro journals we're using\n",
    "cite_half_life = 10.7\n",
    "\n",
    "# [p[0] * (1. - (0.5) ** (dx/p[1])) \n",
    "def eic_func(yr:int, cite_cnt:int)->int:\n",
    "    ''' apply the 'exponential to constant' function with prior fitted values for this model '''\n",
    "    #max_cite_est = cite_cnt / (1 - (0.5 ** ((2021 - yr)/cite_half_life)))\n",
    "    max_cite_est = cite_cnt / (1 - (0.5 ** ((2011 - yr)/cite_half_life)))\n",
    "    return int(max_cite_est)\n",
    "\n",
    "# (p[0] / (1 + (p[1] * math.exp(p[2] * dx))))\n",
    "# array([59.4822963 , 10.19423547, -0.39783075]),\n",
    "def sigmoid_func1(yr:int, cite_cnt:int)->int:\n",
    "    ''' apply the 'sigmoid/logistic growth' function with prior fitted values for this model '''\n",
    "    max_cite_est = (cite_cnt + 72.5) * (1 + math.exp(-0.18 * (2010 - yr)))\n",
    "    return int(max_cite_est)\n",
    "\n",
    "# (p[0] / (1 + (p[1] * math.exp(p[2] * dx))))\n",
    "# array([59.4822963 , 10.19423547, -0.39783075]),\n",
    "def sigmoid_func(yr:int, cite_cnt:int)->int:\n",
    "    ''' apply the 'sigmoid/logistic growth' function with prior fitted values for this model '''\n",
    "    max_cite_est = cite_cnt * (10.194 * math.exp(-0.3978 * (2010 - yr)))\n",
    "    return int(max_cite_est)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_topic_bibcode_h5py(viz_data_loc: os.PathLike)->pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Load object parameters from an hdf database.\n",
    "    Args:\n",
    "        viz_data_loc: path to hdf file\n",
    "    \"\"\"\n",
    "\n",
    "    with h5py.File(viz_data_loc, \"r\") as f0:\n",
    "        embedding = f0[\"embedding\"][:]\n",
    "        topic_coherences = f0[\"topic_coherences\"][:]\n",
    "        paper_ids = f0[\"paper_ids\"][:]\n",
    "        bibcodes = f0[\"bibcodes\"][:]\n",
    "        nasa_affiliation = f0[\"nasa_affiliation\"][:]\n",
    "        years = f0[\"years\"][:]\n",
    "        keyword_ids = f0[\"keyword_ids\"][:]\n",
    "        keywords = f0[\"keywords\"][:]\n",
    "        kwd_ts_values = f0[\"keyword_ts_values\"][:]\n",
    "        kwd_ts_cols = f0[\"keyword_cols\"][:]\n",
    "\n",
    "    #embedding_df = pd.DataFrame({\"bibcodes\": bibcodes, \"embedding\": embedding})\n",
    "    embedding_df = pd.DataFrame(embedding)\n",
    "    embedding_df['bibcodes'] = bibcodes\n",
    "    embedding_df.index = paper_ids\n",
    "        \n",
    "    return embedding_df\n",
    "\n",
    "# assemble dataset of papers by topic and counts\n",
    "# We will use the inference value for each topics contribution to a paper as its fractional counts to contribute \n",
    "# to that topic (above min threshold value for inference). We co-add all paper fractional contributions to a topic\n",
    "# then find the average number of citations for that topic\n",
    "def get_citations(data:pd.DataFrame, bibcodes, min_inference:float, \n",
    "                  doc_topic_data:pd.DataFrame, version:str)->dict:\n",
    "    \n",
    "    topics = doc_topic_data['topic']\n",
    "    topic_citations = { t:[] for t in topics }\n",
    "    \n",
    "    # step thru our paper data (~77k papers)\n",
    "    for i, row in data.iterrows():\n",
    "        \n",
    "        # get paper properties we'll need\n",
    "        bibcode = bibcodes[i].decode('utf-8')\n",
    "        try:     \n",
    "            est_cites = est_doc_citations[bibcode]\n",
    "        except KeyError as kex:\n",
    "            # this may happen because we culled low cite count paper\n",
    "            # move to the next paper\n",
    "            #print(f\"failed to find cites for key:{kex}\")\n",
    "            continue\n",
    "\n",
    "        # now iterate over topics to add in paper contribution\n",
    "        for topic, inf_fraction in row.items():\n",
    "\n",
    "            if topic in topic_citations.keys():\n",
    "                if inf_fraction > min_inference and inf_fraction <= max_inference:\n",
    "                    topic_citations[topic].append(est_cites) # the right way\n",
    "                    #topic_citations[topic].append(est_cites*inf_fraction) # TEST!\n",
    "                    #topic_citations[topic].append(inf_fraction) # ONLY Test, to see if correlated.. Ans: it is with TCS/RI because of how they are calculated. SO DONT USE.\n",
    "\n",
    "    # safety check for too few citations\n",
    "    for t in topic_citations.keys():\n",
    "        if len(topic_citations[t]) < min_citations_needed:\n",
    "            #print (f\"Warning topic: {t} lacks enough citations for an average, ignoring\")\n",
    "            topic_citations[t] = []\n",
    "            \n",
    "    # get the mean\n",
    "    bad_topics = []\n",
    "    topic_avg_citations = {}\n",
    "    for t in topic_citations:\n",
    "        try:\n",
    "            topic_avg_citations[t] = stat.mean(topic_citations[t])\n",
    "        except Exception as ex:\n",
    "            #print(f\"Warning: cant calculate avg citations for topic {t}, setting to ignore\")\n",
    "            topic_avg_citations[t] = -1.\n",
    "            bad_topics.append(t)\n",
    "\n",
    "    #merge data for citation/topic with RI/topic\n",
    "    cites = []\n",
    "    for i,row in doc_topic_data.iterrows():\n",
    "        topic = row['topic']\n",
    "        cites.append(topic_avg_citations[topic])\n",
    "\n",
    "    if chatty and len(bad_topics) > 0:\n",
    "        print(f\" * {version} dropped %s topics because of citation issues\" % len(bad_topics))\n",
    "    #print (f\" LENGTH CITES: %s\" % len(cites))\n",
    "    return cites\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_doc_data (doc_topic_data:pd.DataFrame):\n",
    "    \n",
    "    orig_ri = list(doc_topic_data['ri'])\n",
    "    orig_tcs = list(doc_topic_data['tcs']) # this is literature TCS\n",
    "    orig_doc_tcs = list(doc_topic_data['doc_tcs']) # this is document TCS (decadal_report or whitepapers)\n",
    "    orig_cagr = list(doc_topic_data['cagr'])\n",
    "    orig_cites = list(doc_topic_data['avg_cites'])\n",
    "\n",
    "    # Drop bad data (because of cites problem)\n",
    "    tcs=[]\n",
    "    ri=[]\n",
    "    cagr=[]\n",
    "    cites=[]\n",
    "    doc_tcs=[]\n",
    "    for t in range(0, len(list(doc_topic_data['topic']))):\n",
    "        try:\n",
    "            if orig_cites[t] == -1.:\n",
    "                print (f\" Dropping topic {t} because no good citation estimate\")\n",
    "            else:\n",
    "                cites.append(orig_cites[t])\n",
    "                ri.append(orig_ri[t]) \n",
    "                cagr.append(orig_cagr[t])\n",
    "                tcs.append(orig_tcs[t])\n",
    "                doc_tcs.append(orig_doc_tcs[t])\n",
    "\n",
    "        except Exception as ex:\n",
    "            print (\"LEN of orig_x: %s\" % len(orig_x))\n",
    "            raise ex\n",
    "    return cagr, cites, doc_tcs, tcs, ri\n",
    "        \n",
    "\n",
    "def process (versions:list, min_inference:float, contentType:str, chatty:bool=False, filtered:str=\"\", spearman:bool=use_spearman):\n",
    "\n",
    "    cagr_coeffs = []\n",
    "    cagr_p_vals = []\n",
    "    \n",
    "    ri_coeffs = []\n",
    "    ri_p_vals = []\n",
    "    \n",
    "    tcs_coeffs = []\n",
    "    tcs_p_vals = []\n",
    "    \n",
    "    doc_tcs_coeffs = []\n",
    "    doc_tcs_p_vals = []\n",
    "    \n",
    "    for version in versions:\n",
    "        # load viz data with topic inferences\n",
    "        viz_filename = f\"../data/viz_data_{version}.hdf5\"\n",
    "        data = load_topic_bibcode_h5py(viz_filename)\n",
    "\n",
    "        # pull out bibcodes\n",
    "        bibcodes = data['bibcodes']\n",
    "        del data['bibcodes']\n",
    "\n",
    "        # load topic RI/CAGR/TCS data\n",
    "        doc_topic_data = pd.read_csv(f'../results/{contentType}_topic_data_{version}{filtered}.csv') \n",
    "\n",
    "        # merge / add in citation data\n",
    "        doc_topic_data['avg_cites'] = get_citations(data, bibcodes, min_inference, doc_topic_data, version)\n",
    "\n",
    "        # something may go wrong in cites calculation, so drop negative citations (represents a failed calc)\n",
    "        doc_topic_data = doc_topic_data[doc_topic_data['avg_cites'] >= 0.]\n",
    "\n",
    "        # clean and split out data for analysis\n",
    "        cagr, cites, doc_tcs, tcs, ri = clean_doc_data(doc_topic_data)\n",
    "        \n",
    "        # calculate correlations and plot - Cites vs TCS (literature)\n",
    "        if spearman:\n",
    "            coeff, p = spearmanr(cites, tcs)\n",
    "        else:\n",
    "            coeff, p = pearsonr(cites, tcs)\n",
    "            \n",
    "        if chatty:\n",
    "            print (f\"TCS:{version}{filtered} r:{coeff}, p:{p}\")\n",
    "        tcs_coeffs.append(coeff)\n",
    "        tcs_p_vals.append(p)\n",
    "        #plot_data (cites, tcs, ylabel=\"TCS\", xlabel=\"MLCR\", title=f\"{version}\\nr:%8.5f p:%12.10f\" % (coeff, p), ax=None)\n",
    "        \n",
    "        # calculate correlations and plot - Cites vs TCS (document)\n",
    "        if spearman:\n",
    "            coeff, p = spearmanr(cites, doc_tcs)\n",
    "        else:\n",
    "            coeff, p = pearsonr(cites, doc_tcs)\n",
    "            \n",
    "        if chatty:\n",
    "            print (f\"DOC TCS:{version}{filtered} r:{coeff}, p:{p}\")\n",
    "        doc_tcs_coeffs.append(coeff)\n",
    "        doc_tcs_p_vals.append(p)\n",
    "        #plot_data (cites, doc_tcs, ylabel=\"TCS\", xlabel=\"MLCR\", title=f\"{version}\\nr:%8.5f p:%12.10f\" % (coeff, p), ax=None)\n",
    "\n",
    "        # calculate correlations and plot - Cites vs RI\n",
    "        if spearman:\n",
    "            coeff, p = spearmanr(cites, ri)\n",
    "        else:\n",
    "            coeff, p = pearsonr(cites, ri)\n",
    "            \n",
    "        if chatty:\n",
    "            print (f\"RI:{version} r:{coeff}, p:{p}\")\n",
    "           \n",
    "        ri_coeffs.append(coeff)\n",
    "        ri_p_vals.append(p)\n",
    "        #plot_data (cites, ri, ylabel=\"RI\", xlabel=\"MLCR\", title=f\"{version}\\nr:%8.5f p:%12.10f\" % (coeff, p), ax=None)\n",
    "\n",
    "        if spearman:\n",
    "            coeff, p = spearmanr(cites, cagr)\n",
    "        else:\n",
    "            coeff, p = pearsonr(cites, cagr)\n",
    "            \n",
    "        if chatty:\n",
    "            print (f\"CAGR:{version} r:{coeff}, p:{p}\")\n",
    "        cagr_coeffs.append(coeff)\n",
    "        cagr_p_vals.append(p)\n",
    "        \n",
    "        if chatty:\n",
    "            plot_data (cites, cagr, ylabel=\"CAGR\", xlabel=\"MCLR\", title=f\"{version} ({min_inference} - {max_inference})\\nr:%8.5f p:%12.10f\" % (coeff, p), ax=None)\n",
    "\n",
    "        # write out dataset\n",
    "        doc_topic_data.to_csv(f'../results/ri_vs_citation_{contentType}_{version}_{min_inference}.csv')\n",
    "\n",
    "    return cagr_coeffs, ri_coeffs, tcs_coeffs, doc_tcs_coeffs, tcs_p_vals, cagr_p_vals, ri_p_vals, doc_tcs_p_vals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Do the work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load raw citation info\n",
    "doc_citations_raw = {}\n",
    "with open (citation_filename, 'r') as f:\n",
    "    doc_citations_raw = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# correct citation data based on 1 - exp-decay model (see notebook)\n",
    "# to get a normalized population (as if all were equally out for same amount of time to be cited)\n",
    "est_doc_citations = {}\n",
    "\n",
    "for yr, docs in doc_citations_raw.items():\n",
    "    cites = []\n",
    "    adj_cites = []\n",
    "    for bibcode, cite_cnt in docs.items():\n",
    "        # use only papers with reasonable number of cites (low cite cnts are highly uncertain for estimation)\n",
    "        if cite_cnt >= low_cite_threshold:\n",
    "            est_doc_citations[bibcode] = adj_cite_cnt(int(yr),cite_cnt)\n",
    "            cites.append(cite_cnt)\n",
    "            adj_cites.append(est_doc_citations[bibcode])\n",
    "        \n",
    "    #print (f\"Mean cites {yr}: flt:%s adj:%s\" % (stat.mean(cites), stat.mean(adj_cites)))\n",
    "\n",
    "#est_doc_citations[str(b'2000AJ....120.1579Y')]\n",
    "#est_doc_citations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19_2_125_filtered (decadal)\n",
      "\n",
      "Use spearman: False\n",
      "min_inf:0.01\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.1\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.15\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.2\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "DOC TCS:  0.45935,  0.01458\n",
      "TCS:  0.08279,  0.02240\n",
      "CAGR:  0.74672,  0.00905\n",
      "RI:  0.53913,  0.01514\n",
      "\n",
      "TCS Pval: 4.568703e-01, 1.174998e-01\n",
      "CAGR Pval: 6.595585e-21, 6.027525e-21\n",
      "RI Pval: 3.025652e-09, 2.303172e-09\n",
      "DOC TCS Pval: 2.982924e-06, 2.599348e-06\n",
      "\n",
      "min_inf:0.3\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.4\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.5\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.6\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n",
      "min_inf:0.7\n",
      "\n",
      "Mean Val ; StdDev; StdErr\n"
     ]
    }
   ],
   "source": [
    "# do the analysis\n",
    "print (f\"%s%s (%s)\\n\" % (versions[0][:-5], filtered, contentType))\n",
    "mean_cagrs = []\n",
    "mean_ris = []\n",
    "mean_doc_tcss = []\n",
    "stderr_cagrs = []\n",
    "stderr_ris = []\n",
    "stderr_doc_tcss = []\n",
    "use_spearman=False\n",
    "\n",
    "print (f\"Use spearman: {use_spearman}\")\n",
    "# loop over recs and get mean vals    \n",
    "for min_inference in min_inferences:\n",
    "    \n",
    "    print (f\"min_inf:{min_inference}\\n\")\n",
    "    #chatty = True if (min_inference == 0.2) else False\n",
    "    cagr_coeffs, ri_coeffs, tcs_coeffs, doc_tcs_coeffs, tcs_p_vals, cagr_p_vals, ri_p_vals, doc_tcs_p_vals = process(versions, min_inference, \n",
    "                                                                                                                     contentType, chatty=chatty, \n",
    "                                                                                                                     filtered=filtered, spearman=use_spearman)\n",
    "    print (\"Mean Val ; StdDev; StdErr\")\n",
    "    \n",
    "    mean_cagr = stat.mean(cagr_coeffs)\n",
    "    mean_cagr_p = stat.mean(cagr_p_vals)\n",
    "    mean_ri   = stat.mean(ri_coeffs)\n",
    "    mean_ri_p = stat.mean(ri_p_vals)\n",
    "    mean_tcs  = stat.mean(tcs_coeffs)\n",
    "    mean_tcs_p = stat.mean(tcs_p_vals)\n",
    "    mean_doc_tcs  = stat.mean(doc_tcs_coeffs)\n",
    "    mean_doc_tcs_p  = stat.mean(doc_tcs_p_vals)\n",
    "        \n",
    "    stderr_cagr = sem(cagr_coeffs)\n",
    "    stderr_cagr_p = sem(cagr_p_vals)\n",
    "    \n",
    "    stderr_ri   = sem(ri_coeffs)\n",
    "    stderr_ri_p  = sem(ri_p_vals)\n",
    "    \n",
    "    stderr_tcs  = sem(tcs_coeffs)\n",
    "    stderr_tcs_p  = sem(tcs_p_vals)\n",
    "    \n",
    "    stderr_doc_tcs  = sem(doc_tcs_coeffs)\n",
    "    stderr_doc_tcs_p  = sem(doc_tcs_p_vals)\n",
    "    \n",
    "\n",
    "    if min_inference == 0.2:\n",
    "        \n",
    "        print (f\"DOC TCS: %8.5f, %8.5f\" % (mean_doc_tcs, stderr_doc_tcs))\n",
    "        print (f\"TCS: %8.5f, %8.5f\" % (mean_tcs, stderr_tcs))\n",
    "        print (f\"CAGR: %8.5f, %8.5f\" % (mean_cagr, stderr_cagr))\n",
    "        print (f\"RI: %8.5f, %8.5f\\n\" % (mean_ri, stderr_ri))\n",
    "\n",
    "        print (f\"TCS Pval: %e, %e\" % (mean_tcs_p, stderr_tcs_p))\n",
    "        print (f\"CAGR Pval: %e, %e\" % (mean_cagr_p, stderr_cagr_p))\n",
    "        print (f\"RI Pval: %e, %e\" % (mean_ri_p, stderr_ri_p))\n",
    "        print (f\"DOC TCS Pval: %e, %e\\n\" % (mean_doc_tcs_p, stderr_doc_tcs_p))\n",
    "\n",
    "    mean_cagrs.append(mean_cagr)\n",
    "    mean_doc_tcss.append(mean_doc_tcs)\n",
    "    mean_ris.append(mean_ri)\n",
    "    \n",
    "    stderr_cagrs.append(stderr_cagr)\n",
    "    stderr_doc_tcss.append(stderr_doc_tcs)\n",
    "    stderr_ris.append(stderr_ri)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "19_2_125_filtered (decadal)\n",
    "\n",
    "Use spearman: False\n",
    "\n",
    "min_inf:0.2\n",
    "\n",
    "Mean Val ; StdDev; StdErr\n",
    "DOC TCS:  0.45935,  0.01458\n",
    "TCS:  0.08279,  0.02240\n",
    "CAGR:  0.74672,  0.00905\n",
    "RI:  0.53913,  0.01514\n",
    "\n",
    "TCS Pval: 4.568703e-01, 1.174998e-01\n",
    "CAGR Pval: 6.595585e-21, 6.027525e-21\n",
    "RI Pval: 3.025652e-09, 2.303172e-09\n",
    "DOC TCS Pval: 2.982924e-06, 2.599348e-06\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_data_errs (x, y, y_err, xlabel=\"\", ylabel=\"\", title=\"Title\", ax=None, color='red'):\n",
    "    if ax == None:\n",
    "        fig, ax = plt.subplots()\n",
    "\n",
    "    #plt.style.use('fivethirtyeight')\n",
    "\n",
    "    ax.plot(x, y, marker='o', markerfacecolor=color, linestyle=' ')\n",
    "    plt.errorbar(x, y, fmt='ko', yerr=y_err)\n",
    "\n",
    "    ax.set_title(title)\n",
    "    ax.set(xlabel=xlabel, ylabel=ylabel)\n",
    "    \n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.1, 0.6)"
      ]
     },
     "execution_count": 11,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "ax = plot_data_errs (min_inferences, mean_doc_tcss, stderr_doc_tcss, \n",
    "                     ylabel=f\"DOC TCS-MLCR Correlation ({contentType})\", xlabel=\"Min Topic Paper Inference\", \n",
    "                     title=f\"For {contentType} %s%s\" % (versions[0][:-5], filtered), ax=None)\n",
    "ax.set_ylim([0.1, 0.6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.35, 0.75)"
      ]
     },
     "execution_count": 12,
     "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": [
    "ax = plot_data_errs (min_inferences, mean_cagrs, stderr_cagrs, \n",
    "                     ylabel=\"TCS_CAGR$_{1998-2019}$ - MLCR R\", xlabel=\"I$_{paper}$ Min Threshold\", \n",
    "                     title=\"\", #f\"%s%s\" % (versions[0][:-5], filtered), \n",
    "                     ax=None)\n",
    "ax.set_ylim([0.35, 0.75])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote: ../results/mlcr_min_inferences_decadal_19_2_125_filtered.csv\n"
     ]
    }
   ],
   "source": [
    "mlcr_data = pd.DataFrame({'mean_cagr': mean_cagrs, 'mean_ri': mean_ris, 'mean_doc_tcss':mean_doc_tcss, \n",
    "                          'stderr_cagr': stderr_cagrs, 'stderr_ri': stderr_ris, 'stderr_doc_tcs': stderr_doc_tcs, \n",
    "                          'min_inference': min_inferences})\n",
    "\n",
    "vers = versions[0][:-5]\n",
    "filename = f'../results/mlcr_min_inferences_{contentType}_{vers}{filtered}.csv'\n",
    "print (f\"wrote: {filename}\")\n",
    "mlcr_data.to_csv(filename, index=False)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0.01, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7],\n",
       " [0.7170519546073346,\n",
       "  0.7298396272960639,\n",
       "  0.7486433445599382,\n",
       "  0.7467246758039161,\n",
       "  0.7159772704373568,\n",
       "  0.6256633034636256,\n",
       "  0.6205232677813719,\n",
       "  0.5375857673154457,\n",
       "  0.4276074210469612])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min_inferences, mean_cagrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}