{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# BSSD - Blind Source Separation Denoising" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**main function: denoise(** *ROIs_means_corrected, time, inactive_msk, t_sig_onset, method='ICA', n_comp=2, wavelet='Haar', autoselect='auto', whiten=True* **)**\n", "\n", "Return ROIs means filtered by Blind Source Separations (BSS) methods, estimated sources (components) of the observations, index of the selected source and estimated Signal-to-Noise Ratio in each ROI.\n", "\n", "Estimates noise power from inactive interval defined by *inactive_mask*. Then, applies a BSS method defined by *method* (with the wavelet filtering defined by *wavelet* if 'wPCA' or 'wICA' are chosen) and selects one or more components as representing the sources of the signal(s). Source selection can be manual or automatic. If auto, components are plotted and user must type source(s) number(s). If manual, source selection is done based on portions of the components that are higher than 2 times the noise standard deviation (only 1 source is selected when using *autoselect*='auto'). After that, inverse transformation is executed to rebuild the observations using just the selected source(s). Finally, signal power is calculated, as well as Signal-to-Noise Ratio (SNR) in each observation.\n", "\n", "**Parameters:** \n", "- **ROIs_means_corrected: array**\n", " - (F x R) array, where F are frames and R are ROI numbers. Also called observations.\n", "- **time: array**\n", " - (F,) array, where F are time points.\n", "- **inactive_msk: boolean array**\n", " - (F) boolean array, where F are frames.\n", "- **t_sig_onset: float**\n", " - time instant (in seconds) when signal is supposed to start.\n", "- **method: string, optional**\n", " - *PCA*, *ICA*, *wPCA* or *wICA*.\n", "- **n_comp: int, optional**\n", " - Number of components to allocate estimated sources (same as *n_components* input in [FastICA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.fastica.html#sklearn.decomposition.fastica) and [PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA)) except when n_comp=1, which means to separate into 2 components (minimum allowed by ICA or PCA) for later source selection (only 1 source is selected if autoselect='auto').\n", "- **wavelet: string, optional**\n", " - string representing the wavelet to be used (same as in [Pywavelets](https://pywavelets.readthedocs.io/en/latest/ref/wavelets.html#wavelet-families)). Tested wavelets are 'dmey' and 'Haar'.\n", "- **autoselect: string, optional**\n", " - string that determines whether source selection will be done manually (autoselect='manual') or automatically (autoselect='auto'). If 'auto', n_comp will always be 1, which means only one source is returned.\n", "- **whiten: bool, optional**\n", " - defines if PCA should whiten data.\n", " \n", "**Returns:** \n", "- **ROIs_means_filtered: array**\n", " - (F x R) array, where F are frames and R are ROI numbers.\n", "- **components: array**\n", " - (F x n_comp) array, where F are frames and n_comp is the number of components.\n", "- **selected_source_idx: int**\n", " - index of the selected source.\n", "- **SNR_dB: array**\n", " - (R,) array, where R are ROI numbers." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "testing = (__name__ == \"__main__\")\n", "if testing:\n", "# %matplotlib inline\n", " import matplotlib.pyplot as plt\n", " import matplotlib.image as mpimg\n", " import numpy as np\n", " import sys,os\n", " bssdpath = os.path.abspath('')\n", " if bssdpath not in sys.path:\n", " sys.path.append(bssdpath)\n", " items = os.listdir(bssdpath)\n", " if 'MESS.py' not in items:\n", " ! jupyter nbconvert --to 'python' MESS.ipynb\n", " if 'Remove_Photobleaching.py' not in items:\n", " ! jupyter nbconvert --to 'python' Remove_Photobleaching.ipynb\n", " import MESS as mes\n", " import Remove_Photobleaching as rpb" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Mandatory Parameters:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "if testing:\n", " from skimage import io\n", " fpath = os.path.join('Data','Cell1','videos_AP')\n", " fr = 55.78\n", " \n", " fname = 'vid1.tif'\n", " fullpath = os.path.join(fpath,fname)\n", " video = io.imread(fullpath)\n", " \n", " mname = 'cellmask.tif'\n", " fullpath = os.path.join(fpath,mname)\n", " mask = io.imread(fullpath)\n", " \n", " transitory=True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optional Parameters:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "if testing:\n", " t_sig_onset=0.5\n", " t_sig_end=1\n", " autoselect='manual'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Apply MESS and Remove_Photobleaching:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "if testing:\n", " ROIs_masks, label_ROIs, ROIs_means, time = mes.segment(mask,video, fr)\n", " ROIs_means_corrected, inactive_msk,t_sig_onset,t_sig_end = rpb.photob_remove(video,time, mask,ROIs_means,transitory,t_sig_onset,t_sig_end)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# BSSD functions:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def get_noise_power(ROIs_means_corrected,time,inactive_msk=None):\n", " import numpy as np\n", " nregions = ROIs_means_corrected.shape[1]\n", " if np.any(inactive_msk)==None:\n", " inactive_msk = np.ones_like(time,dtype=bool)\n", " noise = np.zeros((nregions,))\n", " for j in range(nregions):\n", " #Get NOISE POWER\n", " noise[j] = np.sum(np.square(abs(ROIs_means_corrected[inactive_msk,j])),axis=0)/(ROIs_means_corrected[inactive_msk,:].shape[0])\n", " return(noise)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def guess_t_sig_active_time(sources, t_sig_onset_idx):\n", " '''Returns indices of time vector later then t_sig_onset and when they are bigger than channel background noise'''\n", " import numpy as np\n", " noise_threshold = np.mean(sources[:t_sig_onset_idx,:],axis=0) + 2*np.std(sources[:t_sig_onset_idx,:],axis=0)\n", " t_sig_active = np.empty_like(sources,dtype=bool)\n", " for i in range(len(noise_threshold)):\n", " t_sig_active[:,i] = np.where(sources[:,i]>noise_threshold[i],True,False)\n", " t_sig_active[:t_sig_onset_idx,i] = False\n", " return(noise_threshold, t_sig_active)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def get_signal_power(ROIs_means_corrected,time,inactive_msk=None):\n", " import numpy as np\n", " nregions = ROIs_means_corrected.shape[1]\n", " if np.any(inactive_msk)==None:\n", " inactive_msk = np.ones_like(time,dtype=bool)\n", " active_mask = np.invert(inactive_msk)\n", " #Get SIGNAL POWER\n", " signal_power = np.sum(np.square(abs(ROIs_means_corrected[active_mask])),axis=0)/(len(active_mask))\n", " return(signal_power)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def manual_select():\n", " import numpy as np\n", " nb = input('Enter one or more sources number (separate numbers by \",\" if number of sources > 1): ')\n", " selected_source_idx = []\n", " if nb.find(',')==-1: #Single source selected\n", " try:\n", " number = int(nb)\n", " selected_source_idx.append(number)\n", " except ValueError:\n", " print(\"Invalid number\")\n", " else:\n", " nb = nb.replace(\" \",\"\")\n", " commas_idx = []\n", " import re\n", " for m in re.finditer(',', nb):\n", " commas_idx.append(m.start())\n", " try:\n", " number = int(nb[:commas_idx[0]])\n", " selected_source_idx.append(number)\n", " for i in range(len(commas_idx)):\n", " if i==len(commas_idx)-1:\n", " number = int(nb[commas_idx[i]+1:])\n", " else:\n", " number = int(nb[commas_idx[i]+1:commas_idx[i+1]])\n", " selected_source_idx.append(number)\n", " except ValueError:\n", " print(\"Invalid number list\")\n", " return(np.array(selected_source_idx))\n", " " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def wavelet_denoise(S, time, wave='dmey'):\n", " import numpy as np\n", " import pywt\n", " from statsmodels.robust.scale import mad\n", " w = pywt.Wavelet(wave)\n", " shape = S.shape\n", " n = shape[0]\n", " #Denoise just one component\n", " if len(shape)==1:\n", " if (n%2!=0):\n", " Y = np.zeros((n+1,))\n", " else:\n", " Y = np.zeros_like(S)\n", " max_level = pywt.dwt_max_level(n, w)\n", " coeff = pywt.wavedec(S, w, mode='periodization',level=max_level)\n", "\n", " sigma = mad(coeff[-1])\n", " K = np.sqrt(2*np.log(time.shape[0]))*sigma\n", "\n", " coeff_T = []\n", " for j in range(len(coeff)):\n", " c = pywt.threshold(coeff[j], K, 'hard')\n", " coeff_T.append(c)\n", " Y = pywt.waverec(coeff_T, w ,mode='periodization')\n", " if (n%2!=0):\n", " Y = Y[:len(Y)-1]\n", " return(Y)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def auto_select_signal(sources, time, t_sig_onset_idx):\n", " import numpy as np\n", " noise_threshold = 2*np.std(sources[:t_sig_onset_idx,:],axis=0)\n", " t_sig_active = np.where(abs(sources-np.mean(sources[:t_sig_onset_idx,:],axis=0))>noise_threshold,True,False)\n", " t_sig_active[:t_sig_onset_idx] = False\n", " sources_abovenoise_power = np.empty((sources.shape[1],))\n", " for i in range(sources.shape[1]):\n", " active_idxs = get_longest_ones_seq_idx(t_sig_active[:,i])\n", " if np.any(active_idxs)==None:\n", " sources_abovenoise_power[i] = 0 \n", " else:\n", " sources_abovenoise_power[i] = np.sum(np.square(sources[active_idxs,i]))\n", " sources_idx_sorted = np.argsort(sources_abovenoise_power)\n", " sources_idx_sorted_inverse = sources_idx_sorted[::-1] #sorts from max to min\n", " return(sources_idx_sorted_inverse)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def get_longest_ones_seq_idx(t_sig_active):\n", " import numpy as np\n", " ones_pos = np.nonzero(t_sig_active)[0]\n", " if ones_pos.size==0:\n", " return(None)\n", " else:\n", " d_ones_pos = np.diff(ones_pos)\n", " d_ones_pos = np.insert(d_ones_pos,len(d_ones_pos),0)\n", " seq=0\n", " maxseq=0\n", " for i in range(len(ones_pos)):\n", " if d_ones_pos[i]==1:\n", " seq+=1\n", " else:\n", " if ((seq+1)>maxseq):\n", " maxseq = seq+1\n", " pos = ones_pos[i] - seq\n", " pos_end = ones_pos[i]+1\n", " seq = 0\n", " longest_idxs = np.arange(pos,pos_end)\n", " return(longest_idxs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Main Function:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def denoise(ROIs_means_corrected,time,inactive_msk,t_sig_onset,method='ICA',n_comp=2,wavelet='Haar',autoselect='auto',whiten=True):\n", " import numpy as np\n", " import matplotlib.pyplot as plt\n", " if n_comp==1:\n", " n_comp=2\n", " autoselect='auto'\n", " \n", " noise_power = get_noise_power(ROIs_means_corrected,time,inactive_msk=inactive_msk)\n", " \n", " if (method=='ICA') | (method=='wICA'):\n", " from sklearn.decomposition import FastICA\n", " bss = FastICA(n_components=n_comp,max_iter=2000,tol=0.01)\n", " if (method=='PCA') | (method=='wPCA'):\n", " from sklearn.decomposition import PCA\n", " bss = PCA(n_components=n_comp,whiten=whiten)\n", " t_sig_onset_idx = np.argmin(abs(time-t_sig_onset))\n", " \n", " components = bss.fit_transform(ROIs_means_corrected) # Estimate sources\n", " components_filt = np.zeros_like(components)\n", " if autoselect=='auto':\n", " sources_idx_sorted_inverse = auto_select_signal(components, time, t_sig_onset_idx)\n", " selected_source_idx = sources_idx_sorted_inverse[0]\n", " else:\n", " plt.figure(figsize=[15,n_comp*2])\n", " plt.title('Type source numbers that countain signal')\n", " for i in range(n_comp):\n", " plt.subplot(n_comp,1,i+1)\n", " plt.plot(time,components[:,i])\n", " plt.axvline(t_sig_onset,color='k',linestyle='--',alpha=0.3)\n", " ymax = np.mean(components[inactive_msk,i]) + 2*np.std(components[inactive_msk,i])\n", " ymin = np.mean(components[inactive_msk,i]) - 2*np.std(components[inactive_msk,i])\n", " span = plt.axhspan(ymin=ymin,ymax=ymax,alpha=0.1,label='Noise CI95')\n", " s = 'Source #'+str(i)\n", " plt.ylabel(s,fontsize='large')\n", " ymin = 1.8*np.amin(components[:,i])\n", " ymax = 1.8*np.amax(components[:,i])\n", " plt.ylim(ymin, ymax)\n", " plt.legend(handles=[span],loc='upper right')\n", " plt.show()\n", " selected_source_idx = manual_select()\n", " plt.close()\n", " components_filt[:,selected_source_idx] = components[:,selected_source_idx]\n", " selected_source_idx = np.atleast_1d(selected_source_idx)\n", "\n", " if (method=='wPCA') | (method=='wICA'):\n", " for i in range(np.size(selected_source_idx)):\n", " components_filt[:,selected_source_idx[i]] = wavelet_denoise(components_filt[:,selected_source_idx[i]],time,wave=wavelet)\n", " ROIs_means_filtered = bss.inverse_transform(components_filt)\n", " ROIs_means_filtered = ROIs_means_filtered - np.median(ROIs_means_filtered[inactive_msk,:],axis=0)\n", " \n", " signal_power = get_signal_power(ROIs_means_filtered,time,inactive_msk)\n", " \n", " SNR = signal_power/noise_power\n", " SNR_dB = np.zeros_like(SNR)\n", " SNR_dB[SNR>0] = 10*np.log10(SNR[SNR>0])\n", " \n", " return(ROIs_means_filtered,components,selected_source_idx,SNR_dB)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Test" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Enter one or more sources number (separate numbers by \",\" if number of sources > 1): 1\n" ] } ], "source": [ "if testing:\n", " ROIs_means_filtered,components,selected_source_idx,SNR_dB = denoise(ROIs_means_corrected,time,inactive_msk,t_sig_onset,method='ICA',n_comp=2,wavelet='dmey',autoselect=autoselect)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Time of main function execution:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.63 ms ± 11.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" ] } ], "source": [ "if testing:\n", " %timeit ROIs_means_filtered,components,selected_source_idx,SNR_dB = denoise(ROIs_means_corrected,time,inactive_msk,t_sig_onset,method='ICA',n_comp=2,wavelet='dmey',autoselect='auto')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot results" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "if testing:\n", " nregions = np.amax(label_ROIs).astype(int)\n", " ncolors = nregions\n", " from matplotlib import cm\n", " from matplotlib.colors import ListedColormap\n", " brg = cm.get_cmap('brg', nregions)\n", " newcolors = np.tile((np.arange(0,ncolors))/(ncolors-1),nregions//(ncolors-1))\n", " newcolors = newcolors[:nregions]\n", " newcolors = brg(newcolors)\n", " black = np.array([0, 0, 0, 1])\n", " newcolors = np.insert(newcolors,0,black,axis=0)\n", " newcmp = ListedColormap(newcolors)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "if testing:\n", " fig, ax1 = plt.subplots(figsize=[15,5])\n", " for i in range(nregions):\n", " ax1.plot(time,ROIs_means_filtered[:,i],color=newcolors[i+1])" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Signal-to-Noise Ratio:\n", " [ -1.55009306 -8.06523569 -6.88669401 -9.68787618 -4.49952316\n", " -8.17990176 -18.01889425 -7.74672209 -5.433354 -11.63620034\n", " -8.79557891 -3.20098389 -7.08196221 -1.70275287 -6.31412562\n", " -9.4665097 -5.45778064 -1.22610373 -2.79484159 -0.06441938\n", " -0.11272562 -2.58543811 -1.69179894 -5.35694605 -6.81985697\n", " -8.42287603 -3.98122444 -1.61339279 -0.1584773 -2.47919827\n", " -0.43351041 -4.56366818] dB\n" ] } ], "source": [ "if testing:\n", " print('Signal-to-Noise Ratio:\\n',SNR_dB,'dB')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.6.8" } }, "nbformat": 4, "nbformat_minor": 2 }