segment_convergence_outlier_detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a1fbbcb5-b920-4c42-a0fe-bbfae9863188",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.5.1'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "import pickle,sys,os\n",
    "from numpy import *\n",
    "import ruptures as rpt\n",
    "from scipy.stats import norm, pearsonr, zscore, rankdata\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.covariance import EllipticEnvelope\n",
    "import math\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import sklearn\n",
    "sklearn.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "86eee08f-7b28-4409-ac11-23e33d13c900",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.inspection import DecisionBoundaryDisplay\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dc27512a-b707-4303-a2df-93098867cf0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('../../Human_hg38_chrom_ends.pkl','rb') as a:\n",
    "    ENDS = pickle.load(a)\n",
    "\n",
    "with open('../../Human_hg38_auto_10kb_windows.pkl','rb') as b:\n",
    "    W = pickle.load(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "83da0f94-9ae8-4244-be1a-1d50c8c3e81e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_numpy_arr(infile,columns=None):\n",
    "    arr_file = load(infile)\n",
    "    if columns is None:\n",
    "        arr = arr_file['arr']\n",
    "    else:\n",
    "        arr = arr_file['arr'][:,columns]\n",
    "    for cols in range(arr.shape[1]):\n",
    "        csum = sum(arr[:,cols])\n",
    "        arr[:,cols] /= csum\n",
    "    return arr\n",
    "\n",
    "def get_full_table(arr,win=10000):\n",
    "    rows = 0\n",
    "    full_table = []\n",
    "    for ch in range(22):\n",
    "        chrom = 'chr'+str(ch+1)\n",
    "        bound = ENDS[chrom]\n",
    "        windows = bound // win\n",
    "        full_table.append(arr[rows:rows+windows,:])\n",
    "        rows += windows\n",
    "    if rows!=arr.shape[0]:\n",
    "        print('error')\n",
    "    return full_table\n",
    "\n",
    "def get_full_table_array_k_chr(full_table,win=10000,k=1):\n",
    "    ends = []\n",
    "    if k == 1:\n",
    "        for ch in range(22):\n",
    "            if ch == 0:\n",
    "                arr = full_table[ch]\n",
    "            else:\n",
    "                arr = concatenate((arr,full_table[ch]),axis=0)\n",
    "            ends.append(arr.shape[0])\n",
    "    else:\n",
    "        ft = []\n",
    "        for ch in range(22):\n",
    "            chrom = 'chr'+str(ch+1)\n",
    "            bound = ENDS[chrom]\n",
    "            win2 = win*k\n",
    "            windows2 = bound // win2\n",
    "            arr_i = full_table[ch]\n",
    "            arr_k = zeros((windows2,arr_i.shape[1]))\n",
    "            for j in range(windows2-1):\n",
    "                arr_k[j] = arr_i[j*k:(j+1)*k,:].sum(axis=0)\n",
    "            arr_k[-1] = arr_i[(windows2-1)*k:,:].sum(axis=0)\n",
    "            if ch==0:\n",
    "                arr = arr_k\n",
    "            else:\n",
    "                arr = concatenate((arr,arr_k),axis=0)\n",
    "            ends.append(arr.shape[0])\n",
    "    return arr, ends\n",
    "\n",
    "def get_arr(infile,columns=None,k=1,print_ends=False):\n",
    "    df_arr = get_numpy_arr(infile,columns)\n",
    "    table = get_full_table(df_arr)\n",
    "    ftk, ends = get_full_table_array_k_chr(table,k=k)\n",
    "    if print_ends:\n",
    "        print(ends)\n",
    "    return ftk #arrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ac160fcc-3adc-4c20-a71a-a023a92fbef9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(287487, 3202)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = 1\n",
    "thgs = get_arr('merged_table_no_correction_1000g_10kb.npz',k=k)\n",
    "thgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9c95e9fe-2aab-4c8b-8caf-ac10944c1de8",
   "metadata": {},
   "outputs": [],
   "source": [
    "ctrl38s = get_arr('../../merged_table_no_correction_ctrl38_10kb.npz',k=k)\n",
    "ctdna36s = get_arr('../../merged_table_no_correction_ctdna36luad_10kb.npz',k=k)\n",
    "brcas = get_arr('../../merged_table_no_correction_brca_10kb.npz',k=k)\n",
    "crcs = get_arr('../../merged_table_no_correction_crc_10kb.npz',k=k)\n",
    "ctrl29s = get_arr('../../merged_table_no_correction_ctrl29_10kb.npz',k=k)\n",
    "ega8460 = get_arr('../../merged_table_no_correction_EGA8460_10kb.npz',k=k)\n",
    "ega5343_ctrl = get_arr('../../merged_table_no_correction_EGA5343_ctrl_10kb.npz',k=k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1cceb408-069f-4396-bf3f-32ac97886bb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "ega5343_prostate = get_arr('../../merged_table_no_correction_EGA5343_prostate_10kb.npz',k=k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1f498441-8715-44ad-addd-38b9e237b588",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24895, 49114, 68943, 87964, 106117, 123197, 139131, 153644, 167483, 180862, 194370, 207697, 219133, 229837, 240036, 249069, 257394, 265431, 271292, 277736, 282406, 287487]\n"
     ]
    }
   ],
   "source": [
    "arr_file = load('../../merged_table_no_correction_EGA7080_10kb.npz')\n",
    "samples = arr_file['samples']\n",
    "\n",
    "ctrl = [i for i in range(len(samples)) if samples[i].startswith('Ctrl')]\n",
    "ctdna = [i for i in range(len(samples)) if i not in ctrl] # and samples[i].endswith('_1')\n",
    "ega7080_ctrl = get_arr('../../merged_table_no_correction_EGA7080_10kb.npz',columns=ctrl,k=k)\n",
    "ega7080_ctdna = get_arr('../../merged_table_no_correction_EGA7080_10kb.npz',columns=ctdna,k=k,print_ends=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4c31ceb3-0d68-4ac9-afe8-63491fe69f0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "51248\n",
      "[0, 21838, 43007, 61151, 77732, 93356, 108799, 122508, 135682, 146854, 158478, 170121, 181337, 190291, 197701, 205137, 211316, 216730, 222093, 226049, 231029, 233445, 236239]\n"
     ]
    }
   ],
   "source": [
    "ends = [24895, 49114, 68943, 87964, 106117, 123197,139131, 153644, 167483, 180862, \n",
    "        194370, 207697, 219133, 229837, 240036, 249069, 257394, 265431, 271292, 277736, 282406, 287487]\n",
    "feats = [i for i in range(thgs.shape[0]) if sum(thgs[i,:])>0]\n",
    "print(ends[-1]-len(feats))\n",
    "#zf = [i for i in range(thgs.shape[0]) if i not in feats]\n",
    "#print(len(zf))\n",
    "chr_splits = [0]\n",
    "j = 0\n",
    "for e in ends:\n",
    "    for i in range(j,len(feats)):\n",
    "        if feats[i] > e:\n",
    "            chr_splits.append(i)\n",
    "            j = i\n",
    "            break\n",
    "chr_splits.append(len(feats))\n",
    "print(chr_splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "092d1455-ae19-4365-a8f9-735cc6704521",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rank(arr):\n",
    "    ranked_arr = []\n",
    "    for i in range(arr.shape[1]):\n",
    "        ranked = rankdata(arr[:,i],'min')\n",
    "        ranked_arr.append(ranked)\n",
    "    return array(ranked_arr).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1a95c7d2-3931-482f-b11e-8b73a5596795",
   "metadata": {},
   "outputs": [],
   "source": [
    "rctrl38s = get_rank(ctrl38s[feats,:])\n",
    "rctdna36s = get_rank(ctdna36s[feats,:])\n",
    "rbrcas = get_rank(brcas[feats,:])\n",
    "rcrcs = get_rank(crcs[feats,:])\n",
    "rctrl29s = get_rank(ctrl29s[feats,:])\n",
    "rega5343_ctrl = get_rank(ega5343_ctrl[feats,:])\n",
    "rega7080_ctrl = get_rank(ega7080_ctrl[feats,:])\n",
    "rega8460 = get_rank(ega8460[feats,:])\n",
    "rega7080_ctdna = get_rank(ega7080_ctdna[feats,:])\n",
    "rthgs = get_rank(thgs[feats,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f1511658-ba06-49fa-8622-9c91e2233b98",
   "metadata": {},
   "outputs": [],
   "source": [
    "rega5343_prostate = get_rank(ega5343_prostate[feats,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cd2a48e4-3335-4677-b8e7-04b64632adf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "rctrls = hstack((rega5343_ctrl,rega7080_ctrl,rctrl38s,rctrl29s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "691efc58-65dc-4954-a994-05bf7fa42cd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "rctdnas = hstack((rega7080_ctdna,rctdna36s,rbrcas,rcrcs,rega8460))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a95b2e91-ad72-457c-912f-7611c6ae17f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# segmentation\n",
    "def get_breakpoints(arr=rthgs,splits=chr_splits):\n",
    "    bkps = {}\n",
    "    breaks = [0]\n",
    "    offset = 0\n",
    "    for ch in range(22):\n",
    "        ctrl_signals = mean(arr[splits[ch]:splits[ch+1],:],axis=1)\n",
    "        sigma = std(ctrl_signals)\n",
    "        n = len(ctrl_signals)\n",
    "        if n < 100:\n",
    "            offset+=n\n",
    "            continue\n",
    "        algo = rpt.Binseg(model=\"l1\",min_size=100).fit(ctrl_signals) # min size is 1Mbp # \"l1\", \"rbf\", \"linear\", \"normal\", \"ar\",...\n",
    "        my_bkps = algo.predict(pen=log(n)*sigma)\n",
    "        bkps['chr'+str(ch+1)] = [offset]+[x+offset for x in my_bkps]\n",
    "        breaks += [x+offset for x in my_bkps]\n",
    "        offset+= n\n",
    "    return bkps, breaks\n",
    "bkps, breaks = get_breakpoints()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "618b905c-e2b9-4c3e-aafc-8c03c891b3da",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_segment_mean(arr,breaks=breaks):\n",
    "    n = len(breaks)-1\n",
    "    arr_seg = []\n",
    "    for i in range(n):\n",
    "        arr_seg.append(mean(arr[breaks[i]:breaks[i+1],:],axis=0))\n",
    "    return array(arr_seg)\n",
    "\n",
    "def get_rank_hist(arr, nbins=8):\n",
    "    hist = []\n",
    "    for s in range(arr.shape[1]):\n",
    "        h,_ = histogram(arr[:,s], bins=linspace(0,240000,nbins+1))\n",
    "        hist.append(h/sum(h))\n",
    "    return array(hist).T   # 8 x n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f4747093-49df-49f5-8119-f7062f42fb5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14766.613891687324 9091.224919564898 8910.747007094713 5086.423075596531\n"
     ]
    }
   ],
   "source": [
    "sctrl38s = get_segment_mean(rctrl38s)\n",
    "sctrl29s = get_segment_mean(rctrl29s) \n",
    "sega7080_ctrl = get_segment_mean(rega7080_ctrl)\n",
    "sega5343_ctrl = get_segment_mean(rega5343_ctrl)\n",
    "print(median(std(sctrl38s,axis=1)),median(std(sctrl29s,axis=1)),median(std(sega7080_ctrl,axis=1)),median(std(sega5343_ctrl,axis=1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "380cbcc8-472c-4fa6-a606-caaedecb807a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('chr1', 98), ('chr2', 100), ('chr3', 78), ('chr4', 81), ('chr5', 75), ('chr6', 71), ('chr7', 67), ('chr8', 67), ('chr9', 48), ('chr10', 56), ('chr11', 56), ('chr12', 41), ('chr13', 32), ('chr14', 35), ('chr15', 36), ('chr16', 28), ('chr17', 20), ('chr18', 30), ('chr19', 21), ('chr20', 21), ('chr21', 12), ('chr22', 17)]\n"
     ]
    }
   ],
   "source": [
    "nsegments = []\n",
    "for j in range(1,23):\n",
    "    chrom = 'chr'+str(j)\n",
    "    nsegments.append((chrom,len(bkps[chrom])-1))\n",
    "print(nsegments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc21e20c-fb36-4050-b7b8-c4d6d5c6b004",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "564a1b63-abd5-4cb5-b166-d7d7593998d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def EllipticEnv_predict(arr,ctrl,error=0.05,support_fraction=None,return_clf=True): # feats x n  \n",
    "    estimator = EllipticEnvelope(random_state=12345,contamination=error,support_fraction=support_fraction).fit(ctrl.T) \n",
    "    if return_clf:\n",
    "        return estimator.predict(arr.T), estimator\n",
    "    else:\n",
    "        return estimator.predict(arr.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "06d1ef01-1dfa-47da-b96a-7cd681c87b0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Calculate_alpha(rctrl,spe=0.9,error=0.05,support_fraction=0.9):\n",
    "    arr_labels = ensemble_clf(rctrl,rctrl,alpha=None,support_fraction=support_fraction)\n",
    "    sorted_vals = sorted(arr_labels)[::-1]; alphas = [1-x for x in sorted_vals]; #print(mean(alphas[:-1]),std(alphas[:-1]))\n",
    "    n = math.ceil(len(arr_labels)*spe); \n",
    "    alpha = round(1-sorted_vals[n-1],2); print('alpha:',alpha,'specificity:',n/len(arr_labels))\n",
    "    return alpha\n",
    "\n",
    "# 8 dimensions sum to 1; 7 dims encodes all info\n",
    "def ensemble_clf(rarr,rctrl,alpha,dims=[1,2,3,4,5,6,7],incl=['chr1','chr2','chr3','chr4','chr5','chr6','chr7','chr8','chr9','chr10','chr11',\n",
    "                'chr12','chr13','chr14','chr15','chr16','chr17','chr18','chr20'], error=0.05, support_fraction = 0.7, return_raw=True):\n",
    "    arr_labels = zeros(rarr.shape[1]); count = 0\n",
    "    for chrom in incl:\n",
    "        nseg = len(bkps[chrom])-1; #print(chrom,nseg)\n",
    "        arr = get_rank_hist(get_segment_mean(rarr,breaks=bkps[chrom]))[dims,:]\n",
    "        ctrl = get_rank_hist(get_segment_mean(rctrl,breaks=bkps[chrom]))[dims,:]\n",
    "        labels = array([max([x,0]) for x in EllipticEnv_predict(arr,ctrl,error=error,support_fraction=support_fraction,return_clf=False)]) # -1 for outlier, +1 inlier\n",
    "        labels *= nseg\n",
    "        arr_labels += labels\n",
    "        count += nseg\n",
    "    arr_labels/=count\n",
    "    if return_raw:\n",
    "        return arr_labels\n",
    "    #print(\"total number of segments:\",count)\n",
    "    preds = []\n",
    "    for x in arr_labels:\n",
    "        if 1-x > alpha:\n",
    "            preds.append(1) # 1 outlier\n",
    "        else:\n",
    "            preds.append(0) # 0 inlier\n",
    "    return preds\n",
    "\n",
    "def evaluate_performance(pred,truth):\n",
    "    tn, fp, fn, tp = confusion_matrix(truth, pred, labels=[0, 1]).ravel()\n",
    "    specificity = None; sensitivity = None\n",
    "    if tn+fp > 0:\n",
    "        specificity = tn / (tn+fp) #print('specificity:',specificity)\n",
    "    if tp+fn > 0:\n",
    "        sensitivity = tp/(tp+fn) #print('sensitivity:',sensitivity)\n",
    "    return sensitivity, specificity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "33598448-47f1-49b0-a527-97f459dc489a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.15 specificity: 0.9090909090909091\n",
      "sensitivity: 0.8340248962655602\n"
     ]
    }
   ],
   "source": [
    "# matched task, use at least 90% control samples for covariance estimate, i.e., support_fraction=0.9\n",
    "alpha = Calculate_alpha(rega7080_ctrl,spe=0.9,support_fraction=0.9)\n",
    "predY = ensemble_clf(rega7080_ctdna,rega7080_ctrl,alpha=alpha,support_fraction=0.9,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*241)\n",
    "print('sensitivity:',sens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5ab1e0d5-30d0-4b99-923f-f1e3643390d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee93451390>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rctrl38s,rctrl29s,rega5343_ctrl,rega7080_ctdna,rega7080_ctrl)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*91+[1]*263)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3e9c7ddf-2674-498e-b20a-e605c0bb91d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.19 specificity: 0.9010989010989011\n",
      "sensitivity: 0.5601659751037344\n",
      "specificity: 0.9090909090909091\n"
     ]
    }
   ],
   "source": [
    "# unmatched task, multiple control sets are used, making differences within control larger, use 70% samples for covaraince estimate\n",
    "# PCA plot shows substantial overlap between ctrl set and the query set\n",
    "alpha = Calculate_alpha(hstack((rctrl38s,rctrl29s,rega5343_ctrl)),spe=0.9,support_fraction=0.7)\n",
    "predY = ensemble_clf(hstack((rega7080_ctdna,rega7080_ctrl)),hstack((rctrl38s,rctrl29s,rega5343_ctrl)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*241+[0]*22)\n",
    "print('sensitivity:',sens)\n",
    "print('specificity:',spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59be0c7f-2ca3-4b39-9b37-8ce3c19dd367",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "33f83c84-51eb-41a9-b51e-879d7936464d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.09 specificity: 0.9210526315789473\n",
      "sensitivity: 0.2777777777777778\n"
     ]
    }
   ],
   "source": [
    "# matched task\n",
    "alpha = Calculate_alpha(rctrl38s,spe=0.9,support_fraction=0.9)\n",
    "predY = ensemble_clf(rctdna36s,rctrl38s,alpha=alpha,support_fraction=0.9,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*36)\n",
    "print('sensitivity:',sens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "165fe654-975e-474f-b7b3-728651bc9e1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee8f861bd0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rega7080_ctrl,rctrl29s,rega5343_ctrl,rctdna36s,rctrl38s)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*75+[1]*74)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a5ea7367-899b-4342-b1db-7325275fe178",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.43 specificity: 0.96\n",
      "sensitivity: 0.16666666666666666\n",
      "specificity: 0.868421052631579\n"
     ]
    }
   ],
   "source": [
    "# unmatched task\n",
    "# PCA plot shows fewer overlap between ctrl set and the query set, use a larger specificity constraint (0.95)\n",
    "alpha = Calculate_alpha(hstack((rega7080_ctrl,rctrl29s,rega5343_ctrl)),spe=0.95,support_fraction=0.7)\n",
    "predY = ensemble_clf(hstack((rctdna36s,rctrl38s)),hstack((rega7080_ctrl,rctrl29s,rega5343_ctrl)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*36+[0]*38)\n",
    "print('sensitivity:',sens)\n",
    "print('specificity:',spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b2b9000-a65b-4827-812b-c745a8783e32",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "220912cd-002a-4f01-a1ff-e7e8b51de9a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.2 specificity: 0.9166666666666666\n",
      "sensitivity: 1.0\n"
     ]
    }
   ],
   "source": [
    "# matched task\n",
    "alpha = Calculate_alpha(rega5343_ctrl,spe=0.9,support_fraction=0.9)\n",
    "#alpha = 0.17\n",
    "predY = ensemble_clf(rega5343_prostate,rega5343_ctrl,alpha=alpha,support_fraction=0.9,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*4)\n",
    "print('sensitivity:',sens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4021787d-3e7c-4424-8961-9348b558930c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee8f71b430>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rega7080_ctrl,rctrl29s,rctrl38s,rega5343_prostate,rega5343_ctrl)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*89+[1]*28)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "669ff12b-3132-424b-9667-abd35f2e711b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.27 specificity: 0.9550561797752809\n",
      "sensitivity: 1.0\n",
      "specificity: 1.0\n"
     ]
    }
   ],
   "source": [
    "# unmatched task\n",
    "# PCA plot shows few overlap between ctrl set and the query set, use a large specificity constraint (0.95)\n",
    "alpha = Calculate_alpha(hstack((rega7080_ctrl,rctrl29s,rctrl38s)),spe=0.95,support_fraction=0.7)\n",
    "predY = ensemble_clf(hstack((rega5343_prostate,rega5343_ctrl)),hstack((rega7080_ctrl,rctrl29s,rctrl38s)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*4+[0]*24)\n",
    "print('sensitivity:',sens)\n",
    "print('specificity:',spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c483fc86-ff1d-4051-816b-bdf4d1aa7bde",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a38a189e-9dc4-4bb6-8174-c53788c96c1e",
   "metadata": {},
   "source": [
    "#### When PCA shows no overlap, use a very strict specificity contraint (>0.95) on training and interpret results carefully"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "8e71770e-521f-470e-9963-2b52992c285b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee8f6caa70>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rega7080_ctrl,rctrl38s,rega5343_ctrl,rctrl29s)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*84+[1]*29)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9353229c-ca59-4b9f-a142-f45682f1e712",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.7 specificity: 0.9761904761904762\n",
      "specificity: 0.896551724137931\n"
     ]
    }
   ],
   "source": [
    "# unmatched task\n",
    "# PCA plot shows very few overlap between ctrl set and the query set, use a very large specificity constraint (0.97)\n",
    "alpha = Calculate_alpha(hstack((rega7080_ctrl,rctrl38s,rega5343_ctrl)),spe=0.97,support_fraction=0.7)\n",
    "predY = ensemble_clf(rctrl29s,hstack((rega7080_ctrl,rega5343_ctrl,rctrl38s)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[0]*29)\n",
    "#print('sensitivity:',sens)\n",
    "print('specificity:',spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab923f97-85e2-4536-ae64-6ee716dd5f41",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "08cf2308-6d00-4e4e-a659-5ef5e7a1285f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee8f5b29e0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rega7080_ctrl,rctrl38s,rega5343_ctrl,rctrl29s,rcrcs)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*113+[1]*12)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "fb3d81c9-f55a-4a1f-98c6-bc2ebf994489",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.42 specificity: 0.9734513274336283\n",
      "sensitivity: 1.0\n"
     ]
    }
   ],
   "source": [
    "# unmatched task\n",
    "# PCA plot shows no overlap between ctrl set and the query set, use a very large specificity constraint (0.97)\n",
    "alpha = Calculate_alpha(hstack((rctrl29s,rega7080_ctrl,rega5343_ctrl,rctrl38s)),spe=0.97,support_fraction=0.7)\n",
    "predY = ensemble_clf(rcrcs,hstack((rctrl29s,rega7080_ctrl,rega5343_ctrl,rctrl38s)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*rcrcs.shape[1])\n",
    "print('sensitivity:',sens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87c5061a-2fd2-4546-a379-342c49764f00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e7a2d332-87fd-4694-a687-8f5e1531eb93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee8f5b2e30>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rega7080_ctrl,rctrl38s,rega5343_ctrl,rctrl29s,rbrcas)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*113+[1]*9)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "562adab5-0938-46df-8fb7-17663574b463",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.42 specificity: 0.9734513274336283\n",
      "sensitivity: 1.0\n"
     ]
    }
   ],
   "source": [
    "# unmatched task\n",
    "# PCA plot shows no overlap between ctrl set and the query set, use a very large specificity constraint (0.97)\n",
    "alpha = Calculate_alpha(hstack((rctrl29s,rega7080_ctrl,rega5343_ctrl,rctrl38s)),spe=0.97,support_fraction=0.7)\n",
    "predY = ensemble_clf(rbrcas,hstack((rctrl29s,rega7080_ctrl,rega5343_ctrl,rctrl38s)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*rbrcas.shape[1])\n",
    "print('sensitivity:',sens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c83bc82-6d37-4d55-a6c7-1fd2c2ee3b12",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f7595b24-f8d1-4dae-82b5-21cb56609800",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fee8f372680>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(ncols=1, figsize=(5, 4))\n",
    "pca = PCA(n_components=2)\n",
    "X = hstack((rega7080_ctrl,rctrl38s,rega5343_ctrl,rctrl29s,rega8460)).T\n",
    "X_r = pca.fit_transform(X)\n",
    "y = array([0]*113+[1]*60)\n",
    "target_names = ['ctrl','query']\n",
    "colors = sns.color_palette(\"Set1\", 2)[::-1]\n",
    "for color, i, target_name in zip(colors, [0, 1], target_names):\n",
    "    axs.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.5, s=5, label=target_name)\n",
    "axs.set_xlabel('PC1');axs.set_ylabel('PC2');axs.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "acf75be9-b275-4b7d-ba8d-a03a5662a990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha: 0.42 specificity: 0.9734513274336283\n",
      "sensitivity: 0.95\n"
     ]
    }
   ],
   "source": [
    "# unmatched task\n",
    "# PCA plot shows no overlap between ctrl set and the query set, use a very large specificity constraint (0.97)\n",
    "alpha = Calculate_alpha(hstack((rctrl29s,rega7080_ctrl,rega5343_ctrl,rctrl38s)),spe=0.97,support_fraction=0.7)\n",
    "predY = ensemble_clf(rega8460,hstack((rctrl29s,rega7080_ctrl,rega5343_ctrl,rctrl38s)),alpha=alpha,support_fraction=0.7,return_raw=False)\n",
    "sens,spec = evaluate_performance(predY,[1]*rega8460.shape[1])\n",
    "print('sensitivity:',sens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd3907aa-9d7a-47cc-bcd4-61d90fca9806",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}