├── README.md ├── SCTransform.py ├── SCTransform_Example.ipynb └── setup.py /README.md: -------------------------------------------------------------------------------- 1 | # SCTransformPy 2 | 3 | 4 | This is a python port of the R package [SCTransform](https://github.com/ChristophH/sctransform). 5 | 6 | Currently, I only use log UMI counts as a single latent variable (the default in the R package). I'm planning on allowing the user to define custom regression models as is done in the R implementation. 7 | 8 | Implementation notes: 9 | - Poisson regression is done using the `statsmodels` package and parallelized with `multiprocessing`. 10 | - Improved Sheather & Jones bandwidth calculation is implemented by the `KDEpy` package. 11 | - Estimating `theta` using MLE was translated from the `theta.ml` function in R. 12 | - Pearson residuals are automatically clipped to be in the range `[0, sqrt(N/30)]` where `N` is the number of cells. This ensures that sparsity structure is preserved in the data. Practically, the results do not change much when allowing for dense, negative values. 13 | 14 | ## TODO 15 | - Provide comparison between the python and R implementations here to show that results are highly similar. 16 | - Clean up code and prepare for integration with `scanpy`. 17 | -------------------------------------------------------------------------------- /SCTransform.py: -------------------------------------------------------------------------------- 1 | import statsmodels.nonparametric.kernel_regression 2 | from KDEpy import FFTKDE 3 | from multiprocessing import Pool, Manager 4 | from scipy import stats 5 | import numpy as np 6 | import os 7 | import pandas as pd 8 | import statsmodels.discrete.discrete_model 9 | from anndata import AnnData 10 | import scipy as sp 11 | 12 | _EPS = np.finfo(float).eps 13 | 14 | def robust_scale_binned(y, x, breaks): 15 | bins = np.digitize(x,breaks) 16 | binsu = np.unique(bins) 17 | res = np.zeros(bins.size) 18 | for i in range(binsu.size): 19 | yb = y[bins==binsu[i]] 20 | res[bins==binsu[i]] = (yb - np.median(yb)) / (1.4826 * np.median(np.abs(yb - np.median(yb)))+ _EPS) 21 | 22 | return res 23 | 24 | 25 | def is_outlier(y, x, th = 10): 26 | z = FFTKDE(kernel='gaussian', bw='ISJ').fit(x) 27 | z.evaluate(); 28 | bin_width = (max(x) - min(x)) * z.bw / 2 29 | eps = _EPS * 10 30 | 31 | breaks1 = np.arange(min(x),max(x)+ bin_width,bin_width) 32 | breaks2 = np.arange(min(x) - eps - bin_width/2,max(x)+bin_width,bin_width) 33 | score1 = robust_scale_binned(y, x, breaks1) 34 | score2 = robust_scale_binned(y, x, breaks2) 35 | return np.abs(np.vstack((score1,score2))).min(0)>th 36 | 37 | 38 | def _parallel_init(igenes_bin_regress,iumi_bin,ign,imm,ips): 39 | global genes_bin_regress 40 | global umi_bin 41 | global gn 42 | global mm 43 | global ps 44 | genes_bin_regress = igenes_bin_regress 45 | umi_bin = iumi_bin 46 | gn = ign 47 | mm = imm 48 | ps = ips 49 | 50 | def _parallel_wrapper(j): 51 | name = gn[genes_bin_regress[j]] 52 | y = umi_bin[:,j].A.flatten() 53 | pr = statsmodels.discrete.discrete_model.Poisson(y,mm) 54 | res = pr.fit(disp=False) 55 | mu = res.predict() 56 | theta = theta_ml(y,mu) 57 | ps[name] = np.append(res.params,theta) 58 | 59 | 60 | def gmean(X,axis=0,eps=1): 61 | X=X.copy() 62 | X.data[:] = np.log(X.data+eps) 63 | return np.exp(X.mean(axis).A.flatten())-eps 64 | 65 | def theta_ml(y,mu): 66 | n = y.size 67 | weights = np.ones(n) 68 | limit = 10 69 | eps = (_EPS)**0.25 70 | 71 | from scipy.special import psi, polygamma 72 | def score(n,th,mu,y,w): 73 | return sum(w*(psi(th + y) - psi(th) + np.log(th) + 1 - np.log(th + mu) - (y + th)/(mu + th))) 74 | 75 | def info(n,th,mu,y,w): 76 | return sum(w*( - polygamma(1,th + y) + polygamma(1,th) - 1/th + 2/(mu + th) - (y + th)/(mu + th)**2)) 77 | 78 | t0 = n/sum(weights*(y/mu - 1)**2) 79 | it = 0 80 | de = 1 81 | 82 | while(it + 1 < limit and abs(de) > eps): 83 | it+=1 84 | t0 = abs(t0) 85 | i = info(n, t0, mu, y, weights) 86 | de = score(n, t0, mu, y, weights)/i 87 | t0 += de 88 | t0 = max(t0,0) 89 | 90 | return t0 91 | 92 | def SCTransform(adata,min_cells=5,gmean_eps=1,n_genes=2000,n_cells=None,bin_size=500,bw_adjust=3,inplace=True): 93 | """ 94 | This is a port of SCTransform from the Satija lab. See the R package for original documentation. 95 | 96 | Currently, only regression against the log UMI counts are supported. 97 | 98 | The only significant modification is that negative Pearson residuals are zero'd out to preserve 99 | the sparsity structure of the data. 100 | """ 101 | X=adata.X.copy() 102 | X=sp.sparse.csr_matrix(X) 103 | X.eliminate_zeros(); 104 | gn = np.array(list(adata.var_names)) 105 | cn = np.array(list(adata.obs_names)) 106 | genes_cell_count = X.sum(0).A.flatten() 107 | genes = np.where(genes_cell_count >= min_cells)[0] 108 | genes_ix=genes.copy() 109 | 110 | X = X[:,genes] 111 | Xraw=X.copy() 112 | gn = gn[genes] 113 | genes = np.arange(X.shape[1]) 114 | genes_cell_count = X.sum(0).A.flatten() 115 | 116 | 117 | genes_log_gmean = np.log10(gmean(X,axis=0,eps=gmean_eps)) 118 | 119 | if n_cells is not None and n_cells < X.shape[0]: 120 | cells_step1 = np.sort(np.random.choice(X.shape[0],replace=False,size=n_cells)) 121 | genes_cell_count_step1 = X[cells_step1].sum(0).A.flatten() 122 | genes_step1 = np.where(genes_cell_count_step1 >= min_cells)[0] 123 | genes_log_gmean_step1 = np.log10(gmean(X[cells_step1][:,genes_step1],axis=0,eps=gmean_eps)) 124 | else: 125 | cells_step1 = np.arange(X.shape[0]) 126 | genes_step1 = genes 127 | genes_log_gmean_step1 = genes_log_gmean 128 | 129 | 130 | umi = X.sum(1).A.flatten() 131 | log_umi = np.log10(umi) 132 | X2=X.copy() 133 | X2.data[:]=1 134 | gene = X2.sum(1).A.flatten() 135 | log_gene = np.log10(gene) 136 | umi_per_gene = umi / gene 137 | log_umi_per_gene = np.log10(umi_per_gene) 138 | 139 | cell_attrs = pd.DataFrame(index = cn, data = np.vstack((umi,log_umi,gene,log_gene,umi_per_gene,log_umi_per_gene)).T, 140 | columns=['umi','log_umi','gene','log_gene','umi_per_gene','log_umi_per_gene']) 141 | 142 | data_step1 = cell_attrs.iloc[cells_step1] 143 | 144 | if n_genes is not None and n_genes < len(genes_step1): 145 | log_gmean_dens = stats.gaussian_kde(genes_log_gmean_step1,bw_method='scott') 146 | xlo = np.linspace(genes_log_gmean_step1.min(),genes_log_gmean_step1.max(),512) 147 | ylo = log_gmean_dens.evaluate(xlo) 148 | xolo = genes_log_gmean_step1 149 | sampling_prob = 1 / (np.interp(xolo,xlo,ylo) + _EPS) 150 | genes_step1 = np.sort(np.random.choice(genes_step1,size=n_genes,p=sampling_prob/sampling_prob.sum(),replace=False)) 151 | genes_log_gmean_step1 = np.log10(gmean(X[cells_step1,:][:,genes_step1],eps=gmean_eps)) 152 | 153 | 154 | bin_ind = np.ceil(np.arange(1,genes_step1.size+1) / bin_size) 155 | max_bin = max(bin_ind) 156 | 157 | ps = Manager().dict() 158 | 159 | for i in range(1,int(max_bin)+1): 160 | genes_bin_regress = genes_step1[bin_ind==i] 161 | umi_bin = X[cells_step1,:][:,genes_bin_regress] 162 | 163 | mm = np.vstack((np.ones(data_step1.shape[0]),data_step1['log_umi'].values.flatten())).T 164 | 165 | pc_chunksize = umi_bin.shape[1] // os.cpu_count() + 1 166 | pool = Pool(os.cpu_count(), _parallel_init, [genes_bin_regress, umi_bin, gn, mm, ps]) 167 | try: 168 | pool.map(_parallel_wrapper, range(umi_bin.shape[1]), chunksize=pc_chunksize) 169 | finally: 170 | pool.close() 171 | pool.join() 172 | 173 | ps = ps._getvalue() 174 | 175 | model_pars = pd.DataFrame(data = np.vstack([ps[x] for x in gn[genes_step1]]), 176 | columns = ['Intercept','log_umi','theta'], 177 | index = gn[genes_step1]) 178 | 179 | min_theta = 1e-7 180 | x = model_pars['theta'].values.copy() 181 | x[x0 189 | 190 | filt = np.invert(outliers) 191 | model_pars = model_pars[filt] 192 | genes_step1 = genes_step1[filt] 193 | genes_log_gmean_step1 = genes_log_gmean_step1[filt] 194 | 195 | z = FFTKDE(kernel='gaussian', bw='ISJ').fit(genes_log_gmean_step1) 196 | z.evaluate(); 197 | bw = z.bw*bw_adjust 198 | 199 | x_points = np.vstack((genes_log_gmean,np.array([min(genes_log_gmean_step1)]*genes_log_gmean.size))).max(0) 200 | x_points = np.vstack((x_points,np.array([max(genes_log_gmean_step1)]*genes_log_gmean.size))).min(0) 201 | 202 | full_model_pars = pd.DataFrame(data = np.zeros((x_points.size,model_pars.shape[1])),index=gn,columns=model_pars.columns) 203 | for i in model_pars.columns: 204 | kr = statsmodels.nonparametric.kernel_regression.KernelReg(model_pars[i].values,genes_log_gmean_step1[:,None],['c'],reg_type='ll',bw=[bw]) 205 | full_model_pars[i] = kr.fit(data_predict=x_points)[0] 206 | 207 | theta = 10**genes_log_gmean / (10**full_model_pars['dispersion'].values - 1) 208 | full_model_pars['theta'] = theta 209 | del full_model_pars['dispersion'] 210 | 211 | model_pars_outliers = outliers 212 | 213 | regressor_data = np.vstack((np.ones(cell_attrs.shape[0]),cell_attrs['log_umi'].values)).T 214 | 215 | 216 | d = X.data 217 | x,y = X.nonzero() 218 | 219 | mud = np.exp(full_model_pars.values[:,0][y] + full_model_pars.values[:,1][y] * cell_attrs['log_umi'].values[x]) 220 | vard = mud+mud**2 / full_model_pars['theta'].values.flatten()[y] 221 | 222 | X.data[:] = (d - mud) / vard**0.5 223 | X.data[X.data<0]=0 224 | X.eliminate_zeros() 225 | 226 | clip = np.sqrt(X.shape[0]/30) 227 | X.data[X.data>clip]=clip 228 | 229 | if inplace: 230 | adata.raw = adata.copy() 231 | 232 | d = dict(zip(np.arange(X.shape[1]),genes_ix)) 233 | x,y = X.nonzero() 234 | y = np.array([d[i] for i in y]) 235 | data = X.data 236 | Xnew = sp.sparse.coo_matrix((data, (x, y)), shape=adata.shape).tocsr() 237 | adata.X = Xnew # TODO: add log1p of corrected umi counts to layers 238 | 239 | for c in full_model_pars.columns: 240 | adata.var[c+'_sct'] = full_model_pars[c] 241 | 242 | for c in cell_attrs.columns: 243 | adata.obs[c+'_sct'] = cell_attrs[c] 244 | 245 | for c in model_pars.columns: 246 | adata.var[c+'_step1_sct'] = model_pars[c] 247 | 248 | z = pd.Series(index=gn,data=np.zeros(gn.size,dtype='int')) 249 | z[gn[genes_step1]]=1 250 | 251 | w = pd.Series(index=gn,data=np.zeros(gn.size,dtype='int')) 252 | w[gn]=genes_log_gmean 253 | adata.var['genes_step1_sct'] = z 254 | adata.var['log10_gmean_sct'] = w 255 | 256 | else: 257 | adata_new = AnnData(X=X) 258 | adata_new.var_names = pd.Index(gn) 259 | adata_new.obs_names = adata.obs_names 260 | adata_new.raw = adata.copy() 261 | 262 | for c in full_model_pars.columns: 263 | adata_new.var[c+'_sct'] = full_model_pars[c] 264 | 265 | for c in cell_attrs.columns: 266 | adata_new.obs[c+'_sct'] = cell_attrs[c] 267 | 268 | for c in model_pars.columns: 269 | adata_new.var[c+'_step1_sct'] = model_pars[c] 270 | 271 | z = pd.Series(index=gn,data=np.zeros(gn.size,dtype='int')) 272 | z[gn[genes_step1]]=1 273 | adata_new.var['genes_step1_sct'] = z 274 | adata_new.var['log10_gmean_sct'] = genes_log_gmean 275 | return adata_new 276 | -------------------------------------------------------------------------------- /SCTransform_Example.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "toxic-falls", 6 | "metadata": {}, 7 | "source": [ 8 | "## Imports" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 1, 14 | "id": "measured-tuition", 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "from SCTransform import SCTransform\n", 19 | "import scanpy as sc\n", 20 | "import matplotlib.pyplot as plt\n", 21 | "import numpy as np" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "perfect-variety", 27 | "metadata": {}, 28 | "source": [ 29 | "## Load data" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 2, 35 | "id": "thick-applicant", 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "#adata = sc.datasets.pbmc3k()\n", 40 | "adata = sc.read_h5ad('../data/pbmc_33k.h5ad')" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "id": "judicial-feelings", 46 | "metadata": {}, 47 | "source": [ 48 | "## Run SCTransform" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 3, 54 | "id": "aerial-joseph", 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "name": "stdout", 59 | "output_type": "stream", 60 | "text": [ 61 | "CPU times: user 8.6 s, sys: 1.19 s, total: 9.79 s\n", 62 | "Wall time: 3min 11s\n" 63 | ] 64 | } 65 | ], 66 | "source": [ 67 | "%%time\n", 68 | "adata_sct = SCTransform(adata,\n", 69 | " min_cells=5,\n", 70 | " gmean_eps=1,\n", 71 | " n_genes=2000,\n", 72 | " n_cells=None, #use all cells\n", 73 | " bin_size=500,\n", 74 | " bw_adjust=3,\n", 75 | " inplace=False)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "id": "sudden-density", 81 | "metadata": {}, 82 | "source": [ 83 | "## Plot the fit parameters" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 4, 89 | "id": "empirical-salmon", 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "image/png": "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\n", 95 | "text/plain": [ 96 | "
" 97 | ] 98 | }, 99 | "metadata": { 100 | "needs_background": "light" 101 | }, 102 | "output_type": "display_data" 103 | } 104 | ], 105 | "source": [ 106 | "# Pull out the fit parameters (both step1 and extrapolated)\n", 107 | "intercept1 = adata_sct.var['Intercept_step1_sct'].values\n", 108 | "filt = np.invert(np.isnan(intercept1))\n", 109 | "\n", 110 | "gmean = 10**adata_sct.var['log10_gmean_sct'].values\n", 111 | "gmean1 = gmean[filt]\n", 112 | "intercept1 = intercept1[filt]\n", 113 | "\n", 114 | "intercept = adata_sct.var['Intercept_sct'].values\n", 115 | "logumi = adata_sct.var['log_umi_sct'].values\n", 116 | "logumi1 = adata_sct.var['log_umi_step1_sct'].values[filt]\n", 117 | "theta = adata_sct.var['theta_sct'].values\n", 118 | "theta1 = adata_sct.var['dispersion_step1_sct'].values[filt]\n", 119 | "theta1 = gmean1 / (10**theta1 - 1)\n", 120 | "\n", 121 | "# Do the plotting\n", 122 | "fig,axs = plt.subplots(nrows=3,ncols=1)\n", 123 | "fig.set_size_inches((5,12))\n", 124 | "ax=axs[0]\n", 125 | "ax.scatter(gmean1,intercept1,color='k'); \n", 126 | "ax.scatter(gmean,intercept,color='pink',s=5);\n", 127 | "ax.set_ylabel('Fit parameter for intercept')\n", 128 | "ax.set_xscale('log')\n", 129 | "\n", 130 | "ax=axs[1]\n", 131 | "ax.scatter(gmean1,logumi1,color='k'); \n", 132 | "ax.scatter(gmean,logumi,color='pink',s=5);\n", 133 | "ax.set_ylabel('Fit parameter for log(library sizes)')\n", 134 | "ax.set_xscale('log')\n", 135 | "\n", 136 | "ax=axs[2]\n", 137 | "ax.scatter(gmean1,np.log(theta1),color='k'); \n", 138 | "ax.scatter(gmean,np.log(theta),color='pink',s=5);\n", 139 | "ax.set_xlabel('Gene geometric means')\n", 140 | "ax.set_ylabel('log(theta)')\n", 141 | "ax.set_xscale('log')\n", 142 | "fig.tight_layout()" 143 | ] 144 | } 145 | ], 146 | "metadata": { 147 | "kernelspec": { 148 | "display_name": "Python 3", 149 | "language": "python", 150 | "name": "python3" 151 | }, 152 | "language_info": { 153 | "codemirror_mode": { 154 | "name": "ipython", 155 | "version": 3 156 | }, 157 | "file_extension": ".py", 158 | "mimetype": "text/x-python", 159 | "name": "python", 160 | "nbconvert_exporter": "python", 161 | "pygments_lexer": "ipython3", 162 | "version": "3.8.5" 163 | } 164 | }, 165 | "nbformat": 4, 166 | "nbformat_minor": 5 167 | } 168 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | from setuptools import setup 2 | __version__ = "0.0.1" 3 | 4 | 5 | setup( 6 | name="SCTransform", 7 | version=__version__, 8 | author="Alexander Tarashansky", 9 | author_email="tarashanst@gmail.com", 10 | url="", 11 | description="Python port of SCTransform from the Seurat package.", 12 | install_requires=[ 13 | "numpy", 14 | "scipy", 15 | "statsmodels", 16 | "KDEpy", 17 | "pandas", 18 | "anndata", 19 | ], 20 | py_modules=['SCTransform'], 21 | ) 22 | --------------------------------------------------------------------------------