Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
if isinstance(var_names, str) and var_names not in adata.var_names:
var_names = adata.var_names[adata.var[var_names] == True] if 'genes' in var_names and var_names in adata.var.keys() \
else adata.var_names if 'all' in var_names or 'genes' in var_names else var_names
var_names = make_unique_list(var_names, allow_array=True)
var_names = [name for name in var_names if name in adata.var_names]
if len(var_names) == 0:
raise ValueError('Variable name not found in var keys.')
if fit_connected_states:
fit_connected_states = get_connectivities(adata)
alpha, beta, gamma, t_, scaling = read_pars(adata)
idx = []
L, P, T = [], [], adata.layers['fit_t'] if 'fit_t' in adata.layers.keys() else np.zeros(adata.shape) * np.nan
progress = logg.ProgressReporter(len(var_names))
for i, gene in enumerate(var_names):
dm = DynamicsRecovery(adata, gene, use_raw=use_raw, load_pars=load_pars, fit_time=fit_time, fit_alpha=fit_alpha,
fit_switching=fit_switching, fit_scaling=fit_scaling, fit_steady_states=fit_steady_states,
fit_connected_states=fit_connected_states)
if max_iter > 1:
dm.fit(max_iter, learning_rate, assignment_mode=assignment_mode, min_loss=min_loss, method=method, **kwargs)
ix = np.where(adata.var_names == gene)[0][0]
idx.append(ix)
alpha[ix], beta[ix], gamma[ix], t_[ix], scaling[ix] = dm.pars[:, -1]
T[:, ix] = dm.t
L.append(dm.loss)
if plot_results and i < 4:
P.append(dm.pars)
groups = clusters.cat.categories
pars_names = ["diff_kinetics", "pval_kinetics"]
diff_kinetics, pval_kinetics = read_pars(adata, pars_names=pars_names)
pvals = None
if "fit_pvals_kinetics" in adata.varm.keys():
pvals = pd.DataFrame(adata.varm["fit_pvals_kinetics"]).to_numpy()
if pvals is None or pvals.shape[1] != len(groups):
pvals = np.zeros((adata.n_vars, len(groups))) * np.nan
if "fit_diff_kinetics" in adata.var.keys():
diff_kinetics = np.array(adata.var["fit_diff_kinetics"])
else:
diff_kinetics = np.empty(adata.n_vars, dtype="|U16")
idx = []
progress = logg.ProgressReporter(len(var_names))
for i, gene in enumerate(var_names):
dm = DynamicsRecovery(adata, gene, use_raw=use_raw, load_pars=True, max_iter=0)
if dm.recoverable:
dm.differential_kinetic_test(clusters, **kwargs)
ix = np.where(adata.var_names == gene)[0][0]
idx.append(ix)
diff_kinetics[ix], pval_kinetics[ix], = dm.diff_kinetics, dm.pval_kinetics
pvals[ix] = np.array(dm.pvals_kinetics)
progress.update()
else:
logg.warn(dm.gene, "not recoverable due to insufficient samples.")
dm = None
progress.finish()
def compute_cosines(self):
vals, rows, cols, uncertainties, n_obs = [], [], [], [], self.X.shape[0]
progress = logg.ProgressReporter(n_obs)
if self.compute_uncertainties:
m = get_moments(self.adata, np.sign(self.V_raw), second_order=True)
for i in range(n_obs):
if self.V[i].max() != 0 or self.V[i].min() != 0:
neighs_idx = get_iterative_indices(
self.indices, i, self.n_recurse_neighbors, self.max_neighs
)
if self.t0 is not None:
t0, t1 = self.t0[i], self.t1[i]
if t0 >= 0 and t1 > 0:
t1_idx = np.where(self.t0 == t1)[0]
if len(t1_idx) > len(neighs_idx):
t1_idx = np.random.choice(
alpha, beta, gamma, t_, scaling, std_u, std_s, likelihood = pars[:8]
u0, s0, pval, steady_u, steady_s, varx = pars[8:]
# likelihood[np.isnan(likelihood)] = 0
idx, L, P = [], [], []
T = np.zeros(adata.shape) * np.nan
Tau = np.zeros(adata.shape) * np.nan
Tau_ = np.zeros(adata.shape) * np.nan
if "fit_t" in adata.layers.keys():
T = adata.layers["fit_t"]
if "fit_tau" in adata.layers.keys():
Tau = adata.layers["fit_tau"]
if "fit_tau_" in adata.layers.keys():
Tau_ = adata.layers["fit_tau_"]
conn = get_connectivities(adata) if fit_connected_states else None
progress = logg.ProgressReporter(len(var_names))
for i, gene in enumerate(var_names):
dm = DynamicsRecovery(
adata,
gene,
use_raw=use_raw,
load_pars=load_pars,
max_iter=max_iter,
fit_time=fit_time,
fit_steady_states=fit_steady_states,
fit_connected_states=conn,
fit_scaling=fit_scaling,
fit_basal_transcription=fit_basal_transcription,
steady_state_prior=steady_state_prior,
**kwargs,
)
if dm.recoverable: