{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Apply Algorithm to Chen's Data" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import pandas as pd \n", "import numpy as np \n", "import seaborn as sns\n", "import matplotlib.pyplot as plt \n", "from scipy.stats import norm\n", "from scipy.stats import mode\n", "from sklearn.cluster import KMeans\n", "\n", "iterations = 20\n", "burn_in = 10\n", "thining = 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Preprocess data" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
participant_categoryparticipanttimestampdiseasedbiomarkermeasurement
0CN06/2/2011FalseFCI(HIP)-2.544567
1CN19/2/2011FalseFCI(HIP)-1.603212
2CN210/11/2011FalseFCI(HIP)-4.716009
3CN38/8/2011FalseFCI(HIP)-4.232625
4CN411/28/2011FalseFCI(HIP)3.628361
\n", "
" ], "text/plain": [ " participant_category participant timestamp diseased biomarker \\\n", "0 CN 0 6/2/2011 False FCI(HIP) \n", "1 CN 1 9/2/2011 False FCI(HIP) \n", "2 CN 2 10/11/2011 False FCI(HIP) \n", "3 CN 3 8/8/2011 False FCI(HIP) \n", "4 CN 4 11/28/2011 False FCI(HIP) \n", "\n", " measurement \n", "0 -2.544567 \n", "1 -1.603212 \n", "2 -4.716009 \n", "3 -4.232625 \n", "4 3.628361 " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = pd.read_excel(\"data/Chen2016Data.xlsx\")\n", "df.rename(columns={df.columns[0]: 'participant_category', df.columns[1]: 'participant'}, inplace=True)\n", "df['diseased'] = df.apply(lambda row: row.participant_category != 'CN', axis = 1)\n", "df = pd.melt(df, id_vars=['participant_category', \"participant\", \"timestamp\", 'diseased'], \n", " value_vars=[\"FCI(HIP)\", \"GMI(HIP)\", \"FCI(Fusi)\", \"FCI(PCC)\", \"GMI(FUS)\"], \n", " var_name='biomarker', value_name='measurement')\n", "# convert participant id\n", "num_participant = len(df.participant.unique())\n", "participant_string_id_dic = dict(zip(df.participant.unique(), [_ for _ in range(num_participant)]))\n", "df['participant'] = df.apply(lambda row: participant_string_id_dic[row.participant], axis = 1 )\n", "data_we_have = df \n", "data_we_have.head()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(45, 144)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "## These are the healthy participants (Participant ID)\n", "non_diseased_participants = list(set(data_we_have.loc[data_we_have.diseased == False].participant))\n", "len(non_diseased_participants), len(set(data_we_have.participant))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['GMI(FUS)', 'FCI(HIP)', 'FCI(PCC)', 'FCI(Fusi)', 'GMI(HIP)']" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "biomarkers = list(set(data_we_have.biomarker))\n", "biomarkers" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num_biomarkers = len(biomarkers)\n", "num_biomarkers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Get Theta and Phi Estimates Using k-means" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def get_theta_phi(data, biomarker, kmeans_setup):\n", " \"\"\"To get theta and phi parametesr\n", " Input:\n", " - data: data we have right now, without access to S_n and kj\n", " - biomarker: a string of biomarker name\n", " Output:\n", " mean and std of theta and phi\n", " \"\"\"\n", " # two empty clusters to strore measurements\n", " clusters = [[] for _ in range(2)]\n", " # dataframe for this biomarker\n", " biomarker_df = data[data['biomarker'] == biomarker].reset_index(drop=True)\n", " measurements = np.array(biomarker_df['measurement'])\n", " # reshape to satisfy sklearn requirements\n", " measurements = measurements.reshape(-1, 1)\n", " # dataframe for non-diseased participants\n", " healthy_df = biomarker_df[biomarker_df['diseased'] == False]\n", " kmeans = kmeans_setup.fit(measurements)\n", " predictions = kmeans.predict(measurements)\n", " # to store measurements into their cluster\n", " for i, prediction in enumerate(predictions):\n", " clusters[prediction].append(measurements[i][0])\n", " # which cluster are healthy participants in\n", " healthy_predictions = kmeans.predict(measurements[healthy_df.index])\n", " # the mode of the above predictions will be the phi cluster index\n", " phi_cluster_idx = mode(healthy_predictions, keepdims=False).mode\n", " theta_cluster_idx = 1 - phi_cluster_idx\n", " theta_mean, theta_std = np.mean(clusters[theta_cluster_idx]), np.std(clusters[theta_cluster_idx])\n", " phi_mean, phi_std = np.mean(clusters[phi_cluster_idx]), np.std(clusters[phi_cluster_idx])\n", " return theta_mean, theta_std, phi_mean, phi_std" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "kmeans_setup = KMeans(n_clusters=2, random_state=0, n_init=\"auto\")\n", "# empty list of dictionaries to store the estimates \n", "means_stds_estimate_dict_list = []\n", "for biomarker in biomarkers:\n", " dic = {'biomarker': biomarker}\n", " theta_mean, theta_std, phi_mean, phi_std = get_theta_phi(data_we_have, biomarker, kmeans_setup)\n", " dic['theta_mean'] = theta_mean\n", " dic['theta_std'] = theta_std\n", " dic['phi_mean'] = phi_mean\n", " dic['phi_std'] = phi_std\n", " means_stds_estimate_dict_list.append(dic)\n", "theta_phi_kmeans = pd.DataFrame(means_stds_estimate_dict_list)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
biomarkertheta_meantheta_stdphi_meanphi_std
0GMI(FUS)0.4571070.0446670.5691500.035734
1FCI(HIP)2.7949182.983066-5.5467342.887983
2FCI(PCC)11.5831343.3589871.7819983.292063
3FCI(Fusi)-19.7670184.183856-10.2169223.021294
4GMI(HIP)0.3417780.0545710.4822450.037704
\n", "
" ], "text/plain": [ " biomarker theta_mean theta_std phi_mean phi_std\n", "0 GMI(FUS) 0.457107 0.044667 0.569150 0.035734\n", "1 FCI(HIP) 2.794918 2.983066 -5.546734 2.887983\n", "2 FCI(PCC) 11.583134 3.358987 1.781998 3.292063\n", "3 FCI(Fusi) -19.767018 4.183856 -10.216922 3.021294\n", "4 GMI(HIP) 0.341778 0.054571 0.482245 0.037704" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "theta_phi_kmeans" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Metropolis-Hastings Algorithm Implementation Soly Dependent on Theta_Phi_Kmeans" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def fill_up_pdata(pdata, k_j):\n", " '''Fill up a single participant's data using k_j; basically add two columns: \n", " k_j and affected\n", " Note that this function assumes that pdata already has the S_n column\n", " \n", " Input:\n", " - pdata: a dataframe of ten biomarker values for a specific participant \n", " - k_j: a scalar\n", " '''\n", " data = pdata.copy()\n", " data['k_j'] = k_j\n", " data['affected'] = data.apply(lambda row: row.k_j >= row.S_n, axis = 1)\n", " return data " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def compute_single_measurement_likelihood(theta_phi, biomarker, affected, measurement):\n", " '''Computes the likelihood of the measurement value of a single biomarker\n", " We know the normal distribution defined by either theta or phi\n", " and we know the measurement. This will give us the probability\n", " of this given measurement value. \n", "\n", " input:\n", " - theta_phi: the dataframe containing theta and phi values for each biomarker\n", " - biomarker: an integer between 0 and 9 \n", " - affected: boolean \n", " - measurement: the observed value for a biomarker in a specific participant\n", "\n", " output: a scalar\n", " '''\n", " biomarker_params = theta_phi[theta_phi.biomarker == biomarker].reset_index()\n", " mu = biomarker_params['theta_mean'][0] if affected else biomarker_params['phi_mean'][0]\n", " std = biomarker_params['theta_std'][0] if affected else biomarker_params['phi_std'][0]\n", " var = std**2\n", " likelihood = np.exp(-(measurement - mu)**2/(2*var))/np.sqrt(2*np.pi*var)\n", " return likelihood" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def compute_likelihood(pdata, k_j, theta_phi):\n", " '''This implementes the formula of https://ebm-book2.vercel.app/distributions.html#known-k-j\n", " This function computes the likelihood of seeing this sequence of biomarker values for a specific participant\n", " '''\n", " data = fill_up_pdata(pdata, k_j)\n", " likelihood = 1\n", " for i, row in data.iterrows():\n", " biomarker = row['biomarker']\n", " measurement = row['measurement']\n", " affected = row['affected']\n", " likelihood *= compute_single_measurement_likelihood(\n", " theta_phi, biomarker, affected, measurement)\n", " return likelihood" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def metropolis_hastings_with_theta_phi_kmeans(\n", " data_we_have, iterations, theta_phi, non_diseased_participants,\n", " burn_in, thining, \n", " ):\n", " '''Implement the metropolis-hastings algorithm\n", " Inputs: \n", " - data: data_we_have\n", " - iterations: number of iterations\n", "\n", " Outputs:\n", " - best_order: a numpy array\n", " - best_likelihood: a scalar \n", " '''\n", " num_participants = len(data_we_have.participant.unique())\n", " num_biomarkers = len(data_we_have.biomarker.unique())\n", " num_stages = num_biomarkers + 1\n", "\n", " all_dicts = []\n", "\n", " # initialize an ordering and likelihood\n", " # note that it should be a random permutation of numbers 1-10\n", " best_order = np.random.permutation(np.arange(1, num_stages))\n", " biomarker_names = np.array(list(data_we_have.biomarker.unique()))\n", " biomarker_best_order_dic = dict(zip(biomarker_names, best_order))\n", "\n", " best_likelihood = -np.inf\n", "\n", " # initialize participant_stages \n", " # note that high should be num_stages; otherwise, no participants will be in the stage of 10\n", " participant_stages = np.random.randint(low = 0, high = num_stages, size = num_participants)\n", " participant_stages[non_diseased_participants] = 0\n", "\n", " for _ in range(iterations):\n", " new_order = best_order.copy()\n", " # randomly select two indices\n", " a, b = np.random.choice(num_biomarkers, 2, replace=False)\n", " # swapping the order\n", " new_order[a], new_order[b] = new_order[b], new_order[a]\n", " # biomarker - order dict\n", " ordering_dic = dict(zip(biomarker_names, new_order))\n", " # fill up S_n column using the ordering dict\n", " # copy first in order not to change data_we_have\n", " data = data_we_have.copy()\n", " # now data_we_have has S_n column\n", " data['S_n'] = data.apply(lambda row: ordering_dic[row['biomarker']], axis = 1)\n", "\n", " all_participant_ln_likelihood = 0 \n", " for p in range(num_participants):\n", " # copy participant_stages \n", " participant_stages_copy = participant_stages.copy()\n", " # this participant data\n", " pdata = data[data.participant == p].reset_index(drop=True)\n", "\n", " \"\"\"If this participant is not diseased (i.e., if we know k_j is equal to 0)\n", " We still need to compute the likelihood of this participant seeing this sequence of biomarker data\n", " but we do not need to estimate k_j like below\n", "\n", " We still need to compute the likelihood because we need to add it to all_participant_ln_likelihood\n", " \"\"\"\n", " if p in non_diseased_participants:\n", " # the following will update pdata's kj and affect columns\n", " this_participant_likelihood = compute_likelihood(\n", " pdata, k_j = 0, theta_phi = theta_phi)\n", " this_participant_ln_likelihood = np.log(this_participant_likelihood)\n", " else:\n", " # initiaze stage_likelihood\n", " stage_likelihood = np.zeros(num_stages)\n", " for k_j in range(num_stages):\n", " # even though data above has everything, it is filled up by random stages\n", " # we don't like it and want to know the true k_j. All the following is to update participant_stages\n", "\n", " # likelihood for this participant to have this specific sequence of biomarker values\n", " participant_likelihood = compute_likelihood(pdata, k_j, theta_phi)\n", "\n", " # update each stage likelihood for this participant\n", " stage_likelihood[k_j] = participant_likelihood\n", " likelihood_sum = np.sum(stage_likelihood)\n", " normalized_stage_likelihood = [l/likelihood_sum for l in stage_likelihood]\n", " sampled_stage = np.random.choice(np.arange(num_stages), p = normalized_stage_likelihood)\n", " participant_stages_copy[p] = sampled_stage \n", "\n", " # if participant is at sample_stage, \n", " # what is the likelihood of this participant having this sequence of biomarker data:\n", " this_participant_likelihood = stage_likelihood[sampled_stage]\n", "\n", " # then, update all_participant_likelihood\n", " if this_participant_likelihood == 0:\n", " this_participant_ln_likelihood = np.log(this_participant_likelihood + 1e20)\n", " else:\n", " this_participant_ln_likelihood = np.log(this_participant_likelihood)\n", " \"\"\"\n", " All the codes in between are calculating this_participant_ln_likelihood. If we already know kj=0, then\n", " it's very simple. If kj is unknown, we need to calculate the likelihood of seeing this sequence of biomarker\n", " data at different stages, and get the relative likelihood before we get a sampled stage. Then we calculate\n", " this_participant_ln_likelihood again. \n", " \"\"\"\n", " all_participant_ln_likelihood += this_participant_ln_likelihood\n", " \n", " \"\"\"\n", " The key to both `metropolis_hastings_with_theta_phi_kmeans` and `metropolis_hastings` is to \n", " compare best_likelihood and the likelihood of all participants having specific sequences of measurements\n", " based on the assumed S_n. \n", "\n", " The difference lies in how to calculate all_participant_ln_likelihood. \n", "\n", " `metropolis_hastings_with_theta_phi_kmeans` tries to obtain k_j and calculate each likelihood exactly \n", " whereas `metropolis_hastings` did not obtain exact k_j and calculate the average likelihood instead\n", " \"\"\"\n", " acceptance_ratio = np.exp(all_participant_ln_likelihood - best_likelihood)\n", " random_number = np.random.rand()\n", " if random_number < acceptance_ratio:\n", " best_likelihood = all_participant_ln_likelihood\n", " biomarker_best_order_dic = ordering_dic\n", " participant_stages = participant_stages_copy\n", " \n", " if _ >= burn_in and _ % thining == 0:\n", " all_dicts.append(ordering_dic)\n", "\n", " if (_+1) % 10 == 0:\n", " print(f\"iteration {_ + 1} done\")\n", " return biomarker_best_order_dic, participant_stages, all_dicts" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iteration 10 done\n", "iteration 20 done\n", "iteration 30 done\n", "iteration 40 done\n", "iteration 50 done\n", "iteration 60 done\n", "iteration 70 done\n", "iteration 80 done\n", "iteration 90 done\n", "iteration 100 done\n", "iteration 110 done\n", "iteration 120 done\n", "iteration 130 done\n", "iteration 140 done\n", "iteration 150 done\n", "iteration 160 done\n", "iteration 170 done\n", "iteration 180 done\n", "iteration 190 done\n", "iteration 200 done\n" ] } ], "source": [ "biomarker_best_order_dic, participant_stages, all_dicts = metropolis_hastings_with_theta_phi_kmeans(\n", " data_we_have, iterations, theta_phi = theta_phi_kmeans, \n", " non_diseased_participants = non_diseased_participants,\n", " burn_in = burn_in, thining = thining, )" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def get_biomarker_stage_probability(df, num_biomarkers):\n", " # Create an empty list to hold dictionaries\n", " dict_list = []\n", "\n", " # for each biomarker\n", " for col in df.columns:\n", " dic = {\"biomarker\": col}\n", " # get the frequency of biomarkers\n", " stage_counts = df[col].value_counts()\n", " # for each stage\n", " for i in range(1, num_biomarkers + 1):\n", " # get stage:prabability\n", " dic[i] = stage_counts.get(i, 0)/len(df)\n", " dict_list.append(dic)\n", "\n", " dff = pd.DataFrame(dict_list)\n", " dff.set_index(dff.columns[0], inplace=True)\n", " return dff " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df = pd.DataFrame(all_dicts)\n", "biomarker_stage_probability_df = get_biomarker_stage_probability(df, num_biomarkers)\n", "sns.heatmap(biomarker_stage_probability_df, annot=True, cmap=\"Greys\", linewidths=.5, cbar_kws={'label': 'Probability'})\n", "plt.xlabel('Stage')\n", "plt.ylabel('Biomarker')\n", "plt.title('Heatmap of Biomarkers Involvement in Stages')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Estimate Theta and Phi Based on Conjugate Priors" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "def estimate_params_exact(m0, n0, s0_sq, v0, data):\n", " '''This is to estimate means and vars based on conjugate priors\n", " Inputs:\n", " - data: a vector of measurements \n", " - m0: prior estimate of $\\mu$.\n", " - n0: how strongly is the prior belief in $m_0$ is held.\n", " - s0_sq: prior estimate of $\\sigma^2$.\n", " - v0: prior degress of freedome, influencing the certainty of $s_0^2$.\n", " \n", " Outputs:\n", " - mu estiate, std estimate\n", " '''\n", " # Data summary\n", " sample_mean = np.mean(data)\n", " sample_size = len(data)\n", " sample_var = np.var(data, ddof=1) # ddof=1 for unbiased estimator\n", "\n", " # Update hyperparameters for the Normal-Inverse Gamma posterior\n", " updated_m0 = (n0 * m0 + sample_size * sample_mean) / (n0 + sample_size)\n", " updated_n0 = n0 + sample_size\n", " updated_v0 = v0 + sample_size \n", " updated_s0_sq = (1 / updated_v0) * ((sample_size - 1) * sample_var + v0 * s0_sq + \n", " (n0 * sample_size / updated_n0) * (sample_mean - m0)**2)\n", " updated_alpha = updated_v0/2\n", " updated_beta = updated_v0*updated_s0_sq/2\n", "\n", " # Posterior estimates\n", " mu_posterior_mean = updated_m0\n", " sigma_squared_posterior_mean = updated_beta/updated_alpha\n", "\n", " mu_estimation = mu_posterior_mean\n", " std_estimation = np.sqrt(sigma_squared_posterior_mean)\n", "\n", " return mu_estimation, std_estimation" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def get_estimated_means_stds_df(biomarkers, data_we_have, theta_phi_kmeans):\n", " '''To get estimated parameters, returns a Pandas DataFrame\n", " Input:\n", " - biomarkers: biomarkers \n", " - data_we_have: participants data filled with initial or updated participant_stages\n", "\n", " Output: \n", " - estimate_means_std_df, just like means_stds_df, containing the estimated mean and std_dev for \n", " distribution of biomarker values when the biomarker is affected and not affected\n", "\n", " Note that, there is one bug we need to fix: Sometimes, data_full might have only one observation or no ob\n", " '''\n", " # empty list of dictionaries to store the estimates \n", " means_stds_estimate_dict_list = []\n", " \n", " for biomarker in biomarkers: \n", " dic = {'biomarker': biomarker} # Initialize dictionary outside the inner loop\n", " for affected in [True, False]:\n", " data_full = data_we_have[(data_we_have.biomarker == biomarker) & (\n", " data_we_have.affected == affected)]\n", " if len(data_full) > 1:\n", " measurements = data_full.measurement\n", " mu_estimate, std_estimate = estimate_params_exact(\n", " m0 = 0, n0 = 1, s0_sq = 1, v0 = 1, data=measurements)\n", " if affected:\n", " dic['theta_mean'] = mu_estimate\n", " dic['theta_std'] = std_estimate\n", " else:\n", " dic['phi_mean'] = mu_estimate\n", " dic['phi_std'] = std_estimate\n", " # If there is only one observation or not observation at all, resort to theta_phi_kmeans\n", " # YES, IT IS POSSIBLE THAT DATA_FULL HERE IS NULL\n", " # For example, if a biomarker indicates stage of (num_biomarkers), but all participants' stages\n", " # are smaller than that stage; so that for all participants, this biomarker is not affected\n", " else:\n", " # DONT FORGTE RESET_INDEX; this because you are acessing [0]\n", " theta_phi_kmeans_biomarker_row = theta_phi_kmeans[\n", " theta_phi_kmeans.biomarker == biomarker].reset_index(drop=True)\n", " if affected:\n", " dic['theta_mean'] = theta_phi_kmeans_biomarker_row['theta_mean'][0]\n", " dic['theta_std'] = theta_phi_kmeans_biomarker_row['theta_std'][0]\n", " else:\n", " dic['phi_mean'] = theta_phi_kmeans_biomarker_row['phi_mean'][0]\n", " dic['phi_std'] = theta_phi_kmeans_biomarker_row['phi_std'][0]\n", " # print(f\"biomarker {biomarker} done!\")\n", " means_stds_estimate_dict_list.append(dic)\n", " estimate_means_stds_df = pd.DataFrame(means_stds_estimate_dict_list)\n", " return estimate_means_stds_df " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def add_kj_and_affected(data_we_have, participant_stages, num_participants):\n", " '''This is to fill up data_we_have. \n", " Basically, add two columns: k_j, and affected, based on the initial or updated participant_stages\n", " Note that we assume here we've already got S_n\n", "\n", " Inputs:\n", " - data_we_have\n", " - participant_stages: np array \n", " - participants: 0-99\n", " '''\n", " participant_stage_dic = dict(zip(np.arange(0, num_participants), participant_stages))\n", " data_we_have['k_j'] = data_we_have.apply(lambda row: participant_stage_dic[row.participant], axis = 1)\n", " data_we_have['affected'] = data_we_have.apply(lambda row: row.k_j >= row.S_n, axis = 1)\n", " return data_we_have " ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "def metropolis_hastings_unknown_theta_phi(\n", " data_we_have, iterations, non_diseased_participants, burn_in, thining, theta_phi_kmeans):\n", " num_participants = len(data_we_have.participant.unique())\n", " num_biomarkers = len(data_we_have.biomarker.unique())\n", " biomarker_names = np.array(list(data_we_have.biomarker.unique()))\n", "\n", " all_dicts = []\n", "\n", " # initialize an ordering and likelihood\n", " # note that it should be a random permutation of numbers 1-10\n", " best_order = np.random.permutation(np.arange(1, num_biomarkers+1))\n", " biomarker_best_order_dic = dict(zip(biomarker_names, best_order))\n", " best_likelihood = -np.inf \n", "\n", " # initialize participant_stages \n", " # note that high should be num_biomarkers + 1; otherwise, no participants will be in the stage of 10\n", " participant_stages = np.random.randint(low = 0, high = num_biomarkers + 1, size = num_participants)\n", " participant_stages[non_diseased_participants] = 0\n", "\n", " for _ in range(iterations):\n", " participant_stages_copy = participant_stages.copy()\n", " # when we update best_order below,\n", " # in each iteration, new_order will also update\n", " new_order = best_order.copy()\n", " # randomly select two indices\n", " a, b = np.random.choice(num_biomarkers, 2, replace=False)\n", " # swaping the order\n", " new_order[a], new_order[b] = new_order[b], new_order[a]\n", "\n", " # likelihood of seeing all participants' data \n", " # biomarker - order dict\n", " ordering_dic = dict(zip(biomarker_names, new_order))\n", " # fill up S_n column using the ordering dict\n", " # copy first in order not to change data_we_have\n", " data = data_we_have.copy()\n", " # now data_we_have has S_n column\n", " data['S_n'] = data.apply(lambda row: ordering_dic[row['biomarker']], axis = 1)\n", "\n", " # add kj and affected based on the initial randomized participant_stages\n", " data = add_kj_and_affected(data, participant_stages_copy, num_participants)\n", " # print(data.head())\n", "\n", " # get estimated_theta_phi\n", " estimated_theta_phi = get_estimated_means_stds_df(biomarker_names, data_we_have=data, theta_phi_kmeans=theta_phi_kmeans)\n", "\n", " all_participant_ln_likelihood = 0 \n", " for p in range(num_participants):\n", " # this participant data\n", " pdata = data[data.participant == p].reset_index(drop=True)\n", "\n", " \"\"\"If this participant is not diseased (i.e., if we know k_j is equal to 0)\n", " We still need to compute the likelihood of this participant seeing this sequence of biomarker data\n", " but we do not need to estimate k_j like below\n", "\n", " We still need to compute the likelihood because we need to add it to all_participant_ln_likelihood\n", " \"\"\"\n", " if p in non_diseased_participants:\n", " this_participant_likelihood = compute_likelihood(\n", " pdata, k_j = 0, theta_phi = estimated_theta_phi)\n", " this_participant_ln_likelihood = np.log(this_participant_likelihood)\n", " else:\n", " # initiaze stage_likelihood\n", " stage_likelihood = np.zeros(num_biomarkers + 1)\n", " for k_j in range(num_biomarkers +1):\n", " # even though data above has everything, it is filled up by random stages\n", " # we don't like it and want to know the true k_j. All the following is to update participant_stages\n", "\n", " # likelihood for this participant to have this specific sequence of biomarker values\n", " participant_likelihood = compute_likelihood(pdata, k_j, estimated_theta_phi)\n", "\n", " # update each stage likelihood for this participant\n", " stage_likelihood[k_j] = participant_likelihood\n", " likelihood_sum = np.sum(stage_likelihood)\n", " normalized_stage_likelihood = [l/likelihood_sum for l in stage_likelihood]\n", " sampled_stage = np.random.choice(np.arange(num_biomarkers + 1), p = normalized_stage_likelihood)\n", " participant_stages_copy[p] = sampled_stage \n", "\n", " # if participant is in sampled_stage, what is the likelihood of seeing this sequence of biomarker data:\n", " this_participant_likelihood = stage_likelihood[sampled_stage]\n", "\n", " # then, update all_participant_likelihood\n", " if this_participant_likelihood == 0:\n", " this_participant_ln_likelihood = np.log(this_participant_likelihood + 1e20)\n", " else:\n", " this_participant_ln_likelihood = np.log(this_participant_likelihood)\n", " all_participant_ln_likelihood += this_participant_ln_likelihood\n", " \n", " acceptance_ratio = np.exp(all_participant_ln_likelihood - best_likelihood)\n", " random_number = np.random.rand()\n", " if random_number < acceptance_ratio:\n", " best_likelihood = all_participant_ln_likelihood\n", " biomarker_best_order_dic = ordering_dic\n", " participant_stages = participant_stages_copy\n", " \n", " if _ >= burn_in and _ % thining == 0:\n", " all_dicts.append(ordering_dic)\n", "\n", " if (_+1) % 10 == 0:\n", " print(f\"iteration {_ + 1} done\")\n", " return biomarker_best_order_dic, participant_stages, all_dicts" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
participant_categoryparticipanttimestampdiseasedbiomarkermeasurement
0CN06/2/2011FalseFCI(HIP)-2.544567
1CN19/2/2011FalseFCI(HIP)-1.603212
2CN210/11/2011FalseFCI(HIP)-4.716009
3CN38/8/2011FalseFCI(HIP)-4.232625
4CN411/28/2011FalseFCI(HIP)3.628361
\n", "
" ], "text/plain": [ " participant_category participant timestamp diseased biomarker \\\n", "0 CN 0 6/2/2011 False FCI(HIP) \n", "1 CN 1 9/2/2011 False FCI(HIP) \n", "2 CN 2 10/11/2011 False FCI(HIP) \n", "3 CN 3 8/8/2011 False FCI(HIP) \n", "4 CN 4 11/28/2011 False FCI(HIP) \n", "\n", " measurement \n", "0 -2.544567 \n", "1 -1.603212 \n", "2 -4.716009 \n", "3 -4.232625 \n", "4 3.628361 " ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data_we_have.head()" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iteration 10 done\n", "iteration 20 done\n", "iteration 30 done\n", "iteration 40 done\n", "iteration 50 done\n", "iteration 60 done\n", "iteration 70 done\n", "iteration 80 done\n", "iteration 90 done\n", "iteration 100 done\n", "iteration 110 done\n", "iteration 120 done\n", "iteration 130 done\n", "iteration 140 done\n", "iteration 150 done\n", "iteration 160 done\n", "iteration 170 done\n", "iteration 180 done\n", "iteration 190 done\n", "iteration 200 done\n" ] } ], "source": [ "biomarker_best_order_dic, participant_stages, all_dicts = metropolis_hastings_unknown_theta_phi(\n", " data_we_have, iterations, non_diseased_participants, \n", " burn_in, thining, theta_phi_kmeans)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df = pd.DataFrame(all_dicts)\n", "biomarker_stage_probability_df = get_biomarker_stage_probability(df, num_biomarkers)\n", "sns.heatmap(biomarker_stage_probability_df, annot=True, cmap=\"Greys\", linewidths=.5, cbar_kws={'label': 'Probability'})\n", "plt.xlabel('Stage')\n", "plt.ylabel('Biomarker')\n", "plt.title('Heatmap of Biomarkers Involvement in Stages')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Use Average Likelihood and Without Having to Estimate Each Participange Stage" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "def average_all_likelihood(pdata, num_biomarkers, theta_phi):\n", " '''This is to compute https://ebm-book2.vercel.app/distributions.html#unknown-k-j\n", " '''\n", " return np.mean([compute_likelihood(pdata=pdata, k_j=x, theta_phi=theta_phi) for x in range(num_biomarkers+1)])" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def compute_ln_likelihood_assuming_ordering(ordering_dic, data, num_participants, num_biomarkers, theta_phi):\n", " \"\"\"Compute the (ln version of) the likelihood of seeing all participants' data,\n", " assuming that we already know the ordering\n", " Inputs:\n", " - ordering: an array of ordering for biomarker 0-9\n", " - data: data_we_have\n", " - num_participants\n", " - num_biomarkers \n", " Outputs:\n", " - ln(likelihood)\n", " \"\"\"\n", " # fill up S_n column using the ordering dict\n", " # copy first in order not to change data_we_have\n", " filled_data = data.copy()\n", " filled_data['S_n'] = filled_data.apply(lambda row: ordering_dic[row['biomarker']], axis = 1)\n", " ln_likelihood = 0 \n", " for p in range(num_participants):\n", " pdata = filled_data[filled_data.participant == p].reset_index(drop=True)\n", " average_likelihood = average_all_likelihood(pdata, num_biomarkers, theta_phi)\n", " p_ln_likelihood = (\n", " # natural logarithm\n", " np.log(average_likelihood) \n", " if average_likelihood > 0\n", " # this is to avoid np.log(0)\n", " else np.log(average_likelihood + 1e-20)\n", " )\n", " ln_likelihood += p_ln_likelihood\n", " return ln_likelihood" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A brush up on log:\n", "\n", "$L = P1 \\cdot P2 \\cdot P3$\n", "\n", "$\\ln(L) = \\ln (P1 \\cdot P2 \\cdot P3) = \\ln(P1) + \\ln(P2) + \\ln(P3)$" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "def metropolis_hastings_average_likelihood(data, iterations, burn_in, thining, theta_phi):\n", " '''Implement the metropolis-hastings algorithm\n", " Inputs: \n", " - data: data_we_have\n", " - iterations: number of iterations\n", "\n", " Outputs:\n", " - best_order: a numpy array\n", " - best_likelihood: a scalar \n", " '''\n", " num_participants = len(data.participant.unique())\n", " num_biomarkers = len(data.biomarker.unique())\n", "\n", " all_dicts = []\n", "\n", " # initialize an ordering and likelihood\n", " # note that it should be a random permutation of numbers 1-10\n", " best_order = np.random.permutation(np.arange(1, num_biomarkers+1))\n", " biomarker_names = np.array(list(data.biomarker.unique()))\n", " biomarker_best_order_dic = dict(zip(biomarker_names, best_order))\n", "\n", " best_likelihood = -np.inf \n", " # best_order = np.array(list(real_ordering_dic.values()))\n", " # best_likelihood = compute_likelihood_based_on_ordering(\n", " # best_order, data, num_participants, num_biomarkers, theta_phi\n", " # )\n", " for _ in range(iterations):\n", " new_order = best_order.copy()\n", " # randomly select two indices\n", " a, b = np.random.choice(num_biomarkers, 2, replace=False)\n", " # swapping the order\n", " new_order[a], new_order[b] = new_order[b], new_order[a]\n", " biomarker_new_order_dic = dict(zip(biomarker_names, new_order))\n", " ln_likelihood = compute_ln_likelihood_assuming_ordering(\n", " biomarker_new_order_dic, data, num_participants, num_biomarkers, theta_phi)\n", " # if swapping results in higher likelihood, \n", " # update the likelihood and accept the new ordering \n", " if ln_likelihood > best_likelihood:\n", " best_likelihood = ln_likelihood \n", " biomarker_best_order_dic = biomarker_new_order_dic\n", " else: \n", " # ratio = likelihood/best_likelihood\n", " # np.exp(a - b) = np.exp(a)/np.exp(b)\n", " acceptance_ratio = np.exp(ln_likelihood - best_likelihood)\n", " random_number = np.random.rand()\n", " if random_number < acceptance_ratio:\n", " best_likelihood = ln_likelihood\n", " biomarker_best_order_dic = biomarker_new_order_dic\n", "\n", " if _ >= burn_in and _ % thining == 0:\n", " all_dicts.append(biomarker_new_order_dic)\n", " \n", " if (_+1) % 10 == 0:\n", " print(f\"iteration {_ + 1} done\")\n", "\n", " return biomarker_best_order_dic, best_likelihood, all_dicts" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iteration 10 done\n", "iteration 20 done\n", "iteration 30 done\n", "iteration 40 done\n", "iteration 50 done\n", "iteration 60 done\n", "iteration 70 done\n", "iteration 80 done\n", "iteration 90 done\n", "iteration 100 done\n", "iteration 110 done\n", "iteration 120 done\n", "iteration 130 done\n", "iteration 140 done\n", "iteration 150 done\n", "iteration 160 done\n", "iteration 170 done\n", "iteration 180 done\n", "iteration 190 done\n", "iteration 200 done\n" ] } ], "source": [ "biomarker_best_order_dic, best_likelihood, all_dicts = metropolis_hastings_average_likelihood(\n", " data_we_have, iterations, burn_in, thining, theta_phi = theta_phi_kmeans)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df = pd.DataFrame(all_dicts)\n", "biomarker_stage_probability_df = get_biomarker_stage_probability(df, num_biomarkers)\n", "sns.heatmap(biomarker_stage_probability_df, annot=True, cmap=\"Greys\", linewidths=.5, cbar_kws={'label': 'Probability'})\n", "plt.xlabel('Stage')\n", "plt.ylabel('Biomarker')\n", "plt.title('Heatmap of Biomarkers Involvement in Stages')\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "bayes", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.19" } }, "nbformat": 4, "nbformat_minor": 2 }