def visualize(assembled,
labels,
namespace,
data_names,
gene_names=None,
gene_expr=None,
genes=None,
n_iter=N_ITER,
perplexity=PERPLEXITY,
verbose=VERBOSE,
learn_rate=200.,
early_exag=12.,
embedding=None,
size=1):
# Fit t-SNE.
if embedding is None:
tsne = TSNEApprox(n_iter=n_iter,
perplexity=perplexity,
verbose=verbose,
random_state=69,
learning_rate=learn_rate,
early_exaggeration=early_exag)
tsne.fit(np.concatenate(assembled))
embedding = tsne.embedding_
rand_idx = range(embedding.shape[0])
random.shuffle(rand_idx)
embedding = embedding[rand_idx, :]
labels = labels[rand_idx]
# Plot clusters together.
plot_clusters(embedding, labels, s=size)
plt.title(('Panorama ({} iter, perplexity: {}, sigma: {}, ' +
'knn: {}, hvg: {}, dimred: {}, approx: {})').format(
n_iter, perplexity, SIGMA, KNN, HVG, DIMRED, APPROX))
plt.savefig(namespace + '.svg', dpi=500)
# Plot clusters individually.
for i in range(len(data_names)):
visualize_cluster(embedding,
i,
labels,
cluster_name=data_names[i],
size=size,
viz_prefix=namespace)
# Plot gene expression levels.
if (not gene_names is None) and \
(not gene_expr is None) and \
(not genes is None):
gene_expr = gene_expr[rand_idx, :]
for gene_name in gene_names:
visualize_expr(gene_expr,
embedding,
genes,
gene_name,
size=size,
viz_prefix=namespace)
return embedding
def get_eval(lr=0.01, n_episodes=50, is_train=False, savefig=False):
# mkdir
print('qlearning_nn evaluating...')
base_dir = './results/qlearning_nn'
if not os.path.exists(base_dir):
os.makedirs(base_dir)
log_file = os.path.join(base_dir, 'qlearning_nn.log')
logger = logging(log_file)
results_file = os.path.join(base_dir, 'qlearning_nn.csv')
if os.path.exists(results_file) and not is_train and not savefig:
results = pd.read_csv(results_file)
results = results.sort_values(by=['noisy', 'problem_id'])
return results
else:
if os.path.exists(results_file):
os.remove(results_file)
if os.path.exists(log_file):
os.remove(log_file)
pkl_file = os.path.join(
base_dir,
'qlearning_nn_lr={}_episodes={}.pkl'.format(lr, n_episodes))
if os.path.exists(pkl_file):
q_learning_nn = pickle.load(open(pkl_file, 'rb'))
else:
q_learning_nn = train(lr=lr, n_episodes=n_episodes)
# eval
results = pd.DataFrame([],
columns=[
'problem_id', 'noisy', 'action',
'Total_rewards', 'avg_reward_per_action'
])
for problem_id, noisy, env in get_env():
states, rewards, actions = implement(env,
q_learning_nn,
1,
discount_factor=0.95)
result = {
'problem_id': problem_id,
'noisy': noisy,
'Total_rewards': sum(rewards),
'avg_reward_per_action': sum(rewards) / len(actions)
}
results = results.append(pd.DataFrame(result, index=[0]),
ignore_index=0)
logger(' ' + str(result))
logger(actions)
if savefig:
get_fig(states, rewards)
pic_name = os.path.join(
base_dir,
'problem_id={} noisy={}.jpg'.format(problem_id, noisy))
plt.savefig(dpi=300, fname=pic_name)
plt.close()
env.close()
results = results.sort_values(by=['noisy', 'problem_id'])
results.to_csv(results_file, index=0)
return results
def plot_batch(df, batch):
# Plot 50uM.
df_50uM = df[df.conc == -3]
if batch.startswith('Ala'):
df_dmso = df_50uM[df_50uM.comp == 'DMSO']
for comp in [ 'K252a', 'SU11652', 'TG101209', 'RIF', 'IKK16' ]:
df_comp = df_50uM[df_50uM.comp == comp]
t, p_2side = ss.ttest_ind(df_comp.fluo, df_dmso.fluo)
p_1side = p_2side / 2. if t < 0 else 1. - (p_2side / 2.)
print('{}, one-sided t-test P = {}, n = {}'
.format(comp, p_1side, len(df_comp)))
if batch == 'AlaA':
order = [ 'K252a', 'SU11652', 'TG101209', 'RIF', 'DMSO' ]
elif batch == 'AlaB':
order = [ 'IKK16', 'K252a', 'RIF', 'DMSO' ]
else:
return
plt.figure()
sns.barplot(x='comp', y='fluo', data=df_50uM, ci=95, dodge=False,
hue='control', palette=sns.color_palette("RdBu_r", 7),
order=order, capsize=0.2, errcolor='#888888',)
sns.swarmplot(x='comp', y='fluo', data=df_50uM, color='black',
order=order)
#plt.ylim([ 10, 300000 ])
if not batch.startswith('Ala'):
plt.yscale('log')
plt.savefig('figures/tb_culture_50uM_{}.svg'.format(batch))
plt.close()
# Plot dose-response.
comps = sorted(set(df.comp))
concentrations = sorted(set(df.conc))
plt.figure(figsize=(24, 6))
for cidx, comp in enumerate(order):
df_subset = df[df.comp == comp]
plt.subplot(1, 5, cidx + 1)
sns.lineplot(x='conc', y='fluo', data=df_subset, ci=95,)
sns.scatterplot(x='conc', y='fluo', data=df_subset,
color='black',)
plt.title(comp)
if batch.startswith('Ala'):
plt.ylim([ 0., 1.3 ])
else:
plt.ylim([ 10, 1000000 ])
plt.yscale('log')
plt.xticks(list(range(-3, -6, -1)),
[ '50', '25', '10', ])#'1', '0.1' ])
plt.savefig('figures/tb_culture_{}.svg'.format(batch))
plt.close()
def visualize_heatmap(chem_prot, suffix=''):
plt.figure()
cmap = sns.diverging_palette(220, 10, as_cmap=True)
sns.heatmap(chem_prot, cmap=cmap)
mkdir_p('figures/')
if suffix == '':
plt.savefig('figures/heatmap.png', dpi=300)
else:
plt.savefig('figures/heatmap_{}.png'.format(suffix), dpi=300)
plt.close()
def acquisition_scatter(y_unk_pred, var_unk_pred, acquisition, regress_type):
y_unk_pred = y_unk_pred[:]
y_unk_pred[y_unk_pred > 10000] = 10000
plt.figure()
plt.scatter(y_unk_pred, var_unk_pred, alpha=0.5, c=-acquisition,
cmap='hot')
plt.title(regress_type.title())
plt.xlabel('Predicted score')
plt.ylabel('Variance')
plt.savefig('figures/acquisition_unknown_{}.png'
.format(regress_type), dpi=200)
plt.close()
def plot_values(df, score_fn):
models = ['mlper1', 'sparsehybrid', 'gp', 'real']
plt.figure(figsize=(10, 4))
for midx, model in enumerate(models):
if model == 'gp':
color = '#3e5c71'
elif model == 'sparsehybrid':
color = '#2d574e'
elif model == 'mlper1':
color = '#a12424'
elif model == 'real':
color = '#A9A9A9'
else:
raise ValueError('Invalid model'.format(model))
plt.subplot(1, len(models), midx + 1)
df_subset = df[df.model == model]
compounds = np.array(df_subset.compound_)
if model == 'real':
order = sorted(compounds)
else:
order = compounds[np.argsort(-df_subset.affinity)]
sns.barplot(data=df_subset,
x='compound_',
y='affinity',
color=color,
order=order)
if score_fn == 'rdock':
plt.ylim([0, -40])
else:
plt.ylim([0, -12])
plt.xticks(rotation=45)
plt.savefig('figures/design_docking_{}.svg'.format(score_fn))
plt.close()
print('Score function: {}'.format(score_fn))
print('GP vs MLP: {}'.format(
ttest_ind(
df[df.model == 'gp'].affinity,
df[df.model == 'mlper1'].affinity,
)))
print('Hybrid vs MLP: {}'.format(
ttest_ind(
df[df.model == 'sparsehybrid'].affinity,
df[df.model == 'mlper1'].affinity,
)))
print('')
def score_scatter(y_pred, y, var_pred, regress_type, prefix=''):
y_pred = y_pred[:]
y_pred[y_pred < 0] = 0
y_pred[y_pred > 10000] = 10000
plt.figure()
plt.scatter(y_pred, var_pred, alpha=0.3,
c=(y - y.min()) / (y.max() - y.min()))
plt.viridis()
plt.xlabel('Predicted score')
plt.ylabel('Variance')
plt.savefig('figures/variance_vs_pred_{}regressors{}.png'
.format(prefix, regress_type), dpi=300)
plt.close()
import os
os.mkdir('./output')
output_folder = 'output/'
#Area under the ROC curve
fpr, tpr, thresholds = roc_curve((y_true), y_scores)
AUC_ROC = roc_auc_score(y_true, y_scores)
print("\nArea under the ROC curve: " + str(AUC_ROC))
roc_curve = plt.figure()
plt.plot(fpr, tpr, '-', label='Area Under the Curve (AUC = %0.4f)' % AUC_ROC)
plt.title('ROC curve')
plt.xlabel("FPR (False Positive Rate)")
plt.ylabel("TPR (True Positive Rate)")
plt.legend(loc="lower right")
plt.savefig(output_folder + "ROC.png")
#Precision-recall curve
precision, recall, thresholds = precision_recall_curve(y_true, y_scores)
precision = np.fliplr([precision])[0]
recall = np.fliplr([recall])[0]
AUC_prec_rec = np.trapz(precision, recall)
print("\nArea under Precision-Recall curve: " + str(AUC_prec_rec))
prec_rec_curve = plt.figure()
plt.plot(recall,
precision,
'-',
label='Area Under the Curve (AUC = %0.4f)' % AUC_prec_rec)
plt.title('Precision - Recall curve')
plt.xlabel("Recall")
plt.ylabel("Precision")
import warnings
warnings.filterwarnings('ignore')
# Define the input to be tested
test_image_index = 17
test_image = test_x[[test_image_index]]
test_image_prediction = test_y[test_image_index]
with DeepExplain(session=sess) as de:
log = model(X)
attributions = {
'Gradient * Input':
de.explain('grad*input', log * test_image_prediction, X, test_image),
'Epsilon-LRP':
de.explain('elrp', log * test_image_prediction, X, test_image)
}
# Plot attributions
n_cols = len(attributions) + 1
fig, axes = plt.subplots(nrows=1, ncols=n_cols, figsize=(3 * n_cols, 3))
plot(test_image.reshape(28, 28), cmap='Greys',
axis=axes[0]).set_title('Original')
print(test_image_prediction)
for i in range(len(test_image_prediction)):
if test_image_prediction[i] == float(1):
print("Test output : ", i)
for i, method_name in enumerate(sorted(attributions.keys())):
plt.savefig(
plot(attributions[method_name].reshape(28, 28),
xi=test_image.reshape(28, 28),
axis=axes[1 + i]).set_title(method_name))
datasets, genes_list, n_cells = load_names(data_names)
#datasets, genes = merge_datasets(datasets, genes_list)
#datasets_dimred, genes = process_data(datasets, genes, hvg=hvg)
datasets, genes = correct(datasets, genes_list)
X = np.concatenate(datasets)
X[X < 0] = 0
cell_labels = (
open('data/cell_labels/pancreas_cluster.txt').read().rstrip().split())
er_idx = [i for i, cl in enumerate(cell_labels) if cl == 'beta_er']
beta_idx = [i for i, cl in enumerate(cell_labels) if cl == 'beta']
gadd_idx = list(genes).index('GADD45A')
herp_idx = list(genes).index('HERPUD1')
plt.figure()
plt.boxplot([X[er_idx, gadd_idx], X[beta_idx, gadd_idx]], showmeans=True)
plt.title('GADD45A (p < {})'.format(
ttest_ind(X[er_idx, gadd_idx], X[beta_idx, gadd_idx])[1]))
plt.xticks([1, 2], ['beta_er', 'beta'])
plt.ylabel('Scaled gene expression')
plt.savefig('er_stress_GADD45A.svg')
plt.figure()
plt.boxplot([X[er_idx, herp_idx], X[beta_idx, herp_idx]], showmeans=True)
plt.title('HERPUD1 (p < {})'.format(
ttest_ind(X[er_idx, herp_idx], X[beta_idx, herp_idx])[1]))
plt.xticks([1, 2], ['beta_er', 'beta'])
plt.ylabel('Scaled gene expression')
plt.savefig('er_stress_HERPUD1.svg')
def parse_log(regress_type, experiment, **kwargs):
log_fname = ('iterate_davis2011kinase_{}_{}.log'.format(
regress_type, experiment))
iteration = 0
iter_to_Kds = {}
iter_to_idxs = {}
with open(log_fname) as f:
while True:
line = f.readline()
if not line:
break
if not line.startswith('2019') and not line.startswith('2020'):
continue
if not ' | ' in line:
continue
line = line.split(' | ')[1]
if line.startswith('Iteration'):
iteration = int(line.strip().split()[-1])
if not iteration in iter_to_Kds:
iter_to_Kds[iteration] = []
if not iteration in iter_to_idxs:
iter_to_idxs[iteration] = []
continue
elif line.startswith('\tAcquire '):
fields = line.strip().split()
Kd = float(fields[-1])
iter_to_Kds[iteration].append(Kd)
chem_idx = int(fields[1].lstrip('(').rstrip(','))
prot_idx = int(fields[2].strip().rstrip(')'))
iter_to_idxs[iteration].append((chem_idx, prot_idx))
continue
assert (iter_to_Kds.keys() == iter_to_idxs.keys())
iterations = sorted(iter_to_Kds.keys())
# Plot Kd over iterations.
Kd_iter, Kd_iter_max, Kd_iter_min = [], [], []
all_Kds = []
for iteration in iterations:
Kd_iter.append(np.mean(iter_to_Kds[iteration]))
Kd_iter_max.append(max(iter_to_Kds[iteration]))
Kd_iter_min.append(min(iter_to_Kds[iteration]))
all_Kds += list(iter_to_Kds[iteration])
if iteration == 0:
print('First average Kd is {}'.format(Kd_iter[0]))
elif iteration > 4 and experiment == 'perprot':
break
print('Average Kd is {}'.format(np.mean(all_Kds)))
plt.figure()
plt.scatter(iterations, Kd_iter)
plt.plot(iterations, Kd_iter)
plt.fill_between(iterations, Kd_iter_min, Kd_iter_max, alpha=0.3)
plt.viridis()
plt.title(' '.join([regress_type, experiment]))
plt.savefig('figures/Kd_over_iterations_{}_{}.png'.format(
regress_type, experiment))
plt.close()
return
# Plot differential entropy of acquired samples over iterations.
chems = kwargs['chems']
prots = kwargs['prots']
chem2feature = kwargs['chem2feature']
prot2feature = kwargs['prot2feature']
d_entropies = []
X_acquired = []
for iteration in iterations:
for i, j in iter_to_idxs[iteration]:
chem = chems[i]
prot = prots[j]
X_acquired.append(chem2feature[chem] + prot2feature[prot])
if len(X_acquired) <= 1:
d_entropies.append(float('nan'))
else:
gaussian = GaussianMixture().fit(np.array(X_acquired))
gaussian = multivariate_normal(gaussian.means_[0],
gaussian.covariances_[0])
d_entropies.append(gaussian.entropy())
print('Final differential entropy is {}'.format(d_entropies[-1]))
plt.figure()
plt.scatter(iterations, d_entropies)
plt.plot(iterations, d_entropies)
plt.viridis()
plt.title(' '.join([regress_type, experiment]))
plt.savefig('figures/entropy_over_iterations_{}_{}.png'.format(
regress_type, experiment))
plt.close()
continue
seen.add(zinc)
order_list.append((order, Kd))
order_list = [
order for order, _ in sorted(order_list, key=lambda x: x[1])
]
plt.subplot(1, 3, bidx + 1)
sns.barplot(
x='order',
y='Kdpoint',
data=df_subset,
color=palette[bidx],
order=order_list,
ci=95,
capsize=0.4,
errcolor='#888888',
)
sns.swarmplot(
x='order',
y='Kdpoint',
data=df_subset,
color='black',
order=order_list,
)
plt.ylim([-100, 10100])
plt.savefig('figures/prediction_barplot_{}.svg'.format(model))
plt.close()
def latent_scatter(var_unk_pred, y_unk_pred, acquisition, **kwargs):
chems = kwargs['chems']
chem2feature = kwargs['chem2feature']
idx_obs = kwargs['idx_obs']
idx_unk = kwargs['idx_unk']
regress_type = kwargs['regress_type']
prot_target = kwargs['prot_target']
chem_idx_obs = sorted(set([i for i, _ in idx_obs]))
chem_idx_unk = sorted(set([i for i, _ in idx_unk]))
feature_obs = np.array([chem2feature[chems[i]] for i in chem_idx_obs])
feature_unk = np.array([chem2feature[chems[i]] for i in chem_idx_unk])
from sklearn.neighbors import NearestNeighbors
nbrs = NearestNeighbors(n_neighbors=1).fit(feature_obs)
dist = np.ravel(nbrs.kneighbors(feature_unk)[0])
print('Distance Spearman r = {}, P = {}'.format(
*ss.spearmanr(dist, var_unk_pred)))
print('Distance Pearson rho = {}, P = {}'.format(
*ss.pearsonr(dist, var_unk_pred)))
X = np.vstack([feature_obs, feature_unk])
labels = np.concatenate(
[np.zeros(len(chem_idx_obs)),
np.ones(len(chem_idx_unk))])
sidx = np.argsort(-var_unk_pred)
from fbpca import pca
U, s, Vt = pca(
X,
k=3,
)
X_pca = U * s
from umap import UMAP
um = UMAP(
n_neighbors=15,
min_dist=0.5,
n_components=2,
metric='euclidean',
)
X_umap = um.fit_transform(X)
from MulticoreTSNE import MulticoreTSNE as TSNE
tsne = TSNE(
n_components=2,
n_jobs=20,
)
X_tsne = tsne.fit_transform(X)
if prot_target is None:
suffix = ''
else:
suffix = '_' + prot_target
for name, coords in zip(
['pca', 'umap', 'tsne'],
[X_pca, X_umap, X_tsne],
):
plt.figure()
sns.scatterplot(
x=coords[labels == 1, 0],
y=coords[labels == 1, 1],
color='blue',
alpha=0.1,
)
plt.scatter(
x=coords[labels == 0, 0],
y=coords[labels == 0, 1],
color='orange',
alpha=1.0,
marker='x',
linewidths=10,
)
plt.savefig('figures/latent_scatter_{}_ypred_{}{}.png'.format(
name, regress_type, suffix),
dpi=300)
plt.close()
plt.figure()
plt.scatter(x=coords[labels == 1, 0],
y=coords[labels == 1, 1],
c=ss.rankdata(var_unk_pred),
alpha=0.1,
cmap='coolwarm')
plt.savefig('figures/latent_scatter_{}_var_{}{}.png'.format(
name, regress_type, suffix),
dpi=300)
plt.close()
plt.figure()
plt.scatter(x=coords[labels == 1, 0],
y=coords[labels == 1, 1],
c=-acquisition,
alpha=0.1,
cmap='hot')
plt.savefig('figures/latent_scatter_{}_acq_{}{}.png'.format(
name, regress_type, suffix),
dpi=300)
plt.close()
elif task == 2:
# Distance Transform
axes[n_class, col].imshow(dist_ref_h[:, :, n_class],
cmap=cm.Greys_r)
axes[0, 0].set_title('Patch')
axes[0, 1].set_title('Seg Ref')
axes[0, 2].set_title('Seg Pred')
axes[0, 3].set_title('Bound Ref')
axes[0, 4].set_title('Bound Pred')
axes[0, 5].set_title('Dist Ref')
axes[0, 6].set_title('Dist Pred')
for n_class in range(args.num_classes):
axes[n_class, 0].set_ylabel(f'Class {n_class}')
plt.savefig(os.path.join(args.output_path, f'pred{i}_classes.jpg'))
# Color
fig2, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3, figsize=(10, 5))
ax1.set_title('Original')
ax1.imshow(img)
ax2.set_title('Pred HSV in RGB')
task = 3
hsv_pred = patches_pred[task][i]
# print(f'HSV max {i}: {hsv_patch.max()}, HSV min: {hsv_patch.min()}')
# As long as the normalization process was just img = img / 255
hsv_patch = (hsv_pred * np.array([179, 255, 255])).astype(np.uint8)
rgb_patch = cv2.cvtColor(hsv_patch, cv2.COLOR_HSV2RGB)
ax2.imshow(rgb_patch)
# ax3.set_title('Difference between both')
# diff = np.mean(rgb_patch - img, axis=-1)
def plan(self, start, goal):
self.timer = tic()
# if self.trajectory_completed: # return original trajectory
# return self.trajectory.popleft(), tic() - self.timer
if self.plan_completed: # return smoothed trajectory
return self.trajectory_smoothed.popleft(), tic() - self.timer
if len(self.tree) == 0:
# initialization
self.root = tuple(start)
self.goal = tuple(goal)
self.tree[self.root] = [0, None] # [cost, parent]
self.vol_free = (self.boundary[0, 3] - self.boundary[0, 0]) * \
(self.boundary[0, 4] - self.boundary[0, 1]) * \
(self.boundary[0, 5] - self.boundary[0, 2])
for k in range(self.blocks.shape[0]):
self.vol_free -= (self.blocks[k, 3] - self.blocks[k, 0]) * \
(self.blocks[k, 4] - self.blocks[k, 1]) * \
(self.blocks[k, 5] - self.blocks[k, 2])
self.V = int(self.vol_free)
self.r = 1.1 * 2 * (
(1 + 1 / 3) * (self.vol_free * 3 /
(4 * np.pi)) * np.log(self.V) / self.V)**(1 / 3)
if not self.map_completed:
self.construct_tree()
move_time = tic() - self.timer
if self.display:
self.display_tree()
if self.map_completed:
plt.savefig(
os.path.join('results', self.map_name + '_tree'))
else:
if self.map_completed:
for node in self.tree.keys():
self.ax.plot(node[0:1],
node[1:2],
node[2:],
'go',
markersize=1)
plt.savefig(
os.path.join('results', self.map_name + '_tree'))
return start, move_time
if not self.trajectory_completed:
# planning
cur_node = self.goal
while cur_node:
self.trajectory.appendleft(np.array(cur_node))
cur_node = self.tree[cur_node][1]
if tic() - self.timer > 1.5: # timer, exit if exceeds 1.5 s
self.goal = cur_node
return start, tic() - self.timer
self.trajectory_completed = True
return start, tic() - self.timer
if not self.plan_completed:
# smooth trajectory
while len(self.trajectory) > 1:
if len(self.trajectory_smoothed) == 0:
self.trajectory_smoothed.append(self.trajectory.popleft())
if collision_free(self.trajectory_smoothed[-1],
self.trajectory[1], self.blocks):
self.trajectory.popleft()
else:
next_move = self.trajectory[0]
if dist_sq(next_move, self.trajectory_smoothed[-1]) > 1:
self.trajectory_smoothed.append(
self.trajectory_smoothed[-1] + .8 *
(next_move - self.trajectory_smoothed[-1]) /
dist(next_move, self.trajectory_smoothed[-1]))
else:
self.trajectory_smoothed.append(
self.trajectory.popleft())
if tic() - self.timer > 1.5:
return start, tic() - self.timer
goal = self.trajectory.popleft()
while dist_sq(goal, self.trajectory_smoothed[-1]) > 1:
self.trajectory_smoothed.append(
self.trajectory_smoothed[-1] + .8 *
(goal - self.trajectory_smoothed[-1]) /
dist(goal, self.trajectory_smoothed[-1]))
self.trajectory_smoothed.append(goal)
self.plan_completed = True
return start, tic() - self.timer
fname = 'target/log/train_davis2011kinase_{}.log'.format(model)
data += parse_log(model, fname)
df = pd.DataFrame(data, columns=[
'model', 'metric', 'quadrant', 'value', 'uncertainty',
])
quadrants = sorted(set(df.quadrant))
metrics = sorted(set(df.metric))
for quadrant in quadrants:
for metric in metrics:
df_subset = df[(df.metric == metric) &
(df.quadrant == quadrant)]
plt.figure()
sns.barplot(x='model', y='value', data=df_subset, ci=None,
order=models, hue='uncertainty', dodge=False,
palette=sns.color_palette("RdBu", n_colors=8))
sns.swarmplot(x='model', y='value', data=df_subset, color='black',
order=models)
if (metric == 'Pearson rho' or metric == 'Spearman r') \
and quadrant != 'unknown_all':
plt.ylim([ -0.05, 0.7 ])
if metric == 'MSE' and quadrant != 'unknown_all':
plt.ylim([ -0.01e7, 3e7 ])
plt.savefig('figures/benchmark_cv_{}_{}.svg'
.format(metric, quadrant))
plt.close()
# Project to higher dimension.
Z = np.absolute(np.random.randn(2, 100))
datasets = [np.dot(s, Z) for s in samples]
# Add batch effect "noise."
datasets = [ds + np.random.randn(1, 100) for ds in datasets]
# Normalize datasets.
datasets = [normalize(ds, axis=1) for ds in datasets]
tsne = TSNE(n_iter=400, perplexity=100, verbose=2, random_state=69)
tsne.fit(np.concatenate(datasets[1:]))
plot_clusters(tsne.embedding_, np.concatenate(clusters[1:]), s=500)
plt.title('Uncorrected data')
plt.savefig('simulation_uncorrected.svg')
# Assemble datasets.
assembled = assemble(datasets[1:], verbose=1, sigma=1, knn=10, approx=True)
tsne.fit(datasets[1])
plot_clusters(tsne.embedding_, clusters[1], s=500)
plt.title('Dataset 1')
plt.xlabel('t-SNE 1')
plt.ylabel('t-SNE 2')
plt.savefig('simulation_ds1.svg')
tsne.fit(datasets[2])
plot_clusters(tsne.embedding_, clusters[2], s=500)
plt.title('Dataset 2')
plt.xlabel('t-SNE 1')
plt.ylabel('t-SNE 2')
if __name__ == '__main__':
labels = np.array(open('data/cell_labels/all.txt').read().rstrip().split())
# Scanorama.
X = np.loadtxt('data/panorama_embedding.txt')
idx = np.random.choice(X.shape[0], size=20000, replace=False)
sil_pan = sil(X[idx, :], labels[idx])
print(np.median(sil_pan))
# scran MNN.
X = np.loadtxt('data/mnn_embedding.txt')
idx = np.random.choice(X.shape[0], size=20000, replace=False)
sil_mnn = sil(X[idx, :], labels[idx])
print(np.median(sil_mnn))
# Seurat CCA.
X = np.loadtxt('data/cca_embedding.txt')
idx = np.random.choice(X.shape[0], size=20000, replace=False)
sil_cca = sil(X[idx, :], labels[idx])
print(np.median(sil_cca))
print(ttest_ind(sil_pan, sil_mnn))
print(ttest_ind(sil_pan, sil_cca))
plt.figure()
plt.boxplot([sil_pan, sil_mnn, sil_cca], showmeans=True)
plt.title('Distributions of Silhouette Coefficients')
plt.xticks([1, 2, 3], ['Scanorama', 'scran MNN', 'Seurat CCA'])
plt.ylabel('Silhouette Coefficient')
plt.savefig('silhouette.svg')
ax1 = fig.add_subplot(p)
ax1.set_ylabel('#Keys Moved')
formatter = EngFormatter(places=1)
ax1.yaxis.set_major_formatter(formatter)
ax1.plot(d[i]['x'], d[i]['y'], 'o', label=i, markersize=6)
ax1.text(0.025, 0.95, names[i], va='top', transform=ax1.transAxes, fontsize=textsize)
print "ax1",i,"done"
p = 212
i = 'M'
ax2 = fig.add_subplot(p,sharex=ax1)
ax2.set_ylabel('#Keys Moved')
formatter = EngFormatter(places=1)
ax2.yaxis.set_major_formatter(formatter)
ax2.plot(d[i]['x'], d[i]['y'], 'o', label=i,markersize=6)
ax2.text(0.025, 0.95, names[i], va='top', transform=ax2.transAxes, fontsize=textsize)
print "ax2",i,"done"
ax2.set_xlabel('Time (Seconds)')
else:
fig.set_size_inches(20,2)
axS = fig.add_subplot(111)
axS.yaxis.set_major_formatter(formatter)
axS.plot(s['x'], s['y'], label='Size')
axS.set_ylabel('#Nodes')
axS.text(0.025, 0.95, 'Network size', va='top', transform=axS.transAxes, fontsize=textsize)
axS.set_xlabel('Time (Seconds)')
plt.savefig("bw.pdf",bbox_inches='tight')
if not os.path.exists('./results/RBF'):
os.mkdir('./results/RBF')
for i in range(10):
id = i
for tf in range(2):
env = virl.Epidemic(problem_id=id, noisy=tf)
states, rewards, actions = exec_policy(env,
rbf_func,
verbose=False)
fig = get_fig(states, rewards)
if tf:
tf = 'True'
else:
tf = 'False'
plt.savefig(
dpi=300,
fname='./results/RBF/problem_id={}_noisy={}.jpg'.format(
id, tf))
print("\tproblem_id={} noisy={} Total rewards:{:.4f}".format(
id, tf, sum(rewards)))
plt.close()
fig, ax = plt.subplots(figsize=(8, 6))
for i in range(10):
env = virl.Epidemic(stochastic=True)
states, rewards, actions = exec_policy(env, rbf_func, verbose=False)
ax.plot(np.array(states)[:, 1], label=f'draw {i}')
ax.set_xlabel('weeks since start of epidemic')
ax.set_ylabel('Number of Infectious persons')
ax.set_title('Simulation of 10 stochastic episodes with RBF policy')
ax.legend()
plt.savefig(dpi=300, fname='./results/RBF/stochastic.png')
plt.close()