def main():
print "Starting main()\n"
u.setup()
u.calibrate()
a.hold_cube_and_deliver_ambulance()
a.hold_cube_and_get_prism()
u.sd()
def deliver_ambulance_and_blocks():
w.check_zones_hospital()
if c.SAFE_HOSPITAL == c.NEAR_ZONE:
g.drive_gyro_through_line_right()
s.align_far()
m.open_claw(1, 1, c.CLAW_WAY_OPEN_POS)
msleep(500)
m.move_arm(c.ARM_HIGH_POS)
#m.move_claw(c.CLAW_WAY_OPEN_POS)
#w.close_graphics_window()
g.turn_left_gyro(190)
else:
u.halve_speeds()
g.drive_gyro_through_line_right()
s.align_far()
s.left_forwards_until_white(0)
s.left_forwards_until_black()
m.open_claw(1, 1, c.CLAW_WAY_OPEN_POS)
msleep(500)
m.move_arm(c.ARM_HIGH_POS)
#m.move_claw(c.CLAW_WAY_OPEN_POS)
u.normalize_speeds()
#w.close_graphics_window()
u.sd()
g.turn_left_gyro(190)
g.backwards_gyro_through_line_left(1100)
m.lower_ambulance_arm()
g.backwards_gyro(500)
def cluster(xs):
"""given scalars xs, perform 2-component Gaussian clustering via EM"""
mu0 = min(xs)
mu1 = max(xs)
sigma0 = 1
sigma1 = 1
for i in range(10):
probs0 = [dnorm(x, mu0, sigma0) for x in xs]
probs1 = [dnorm(x, mu1, sigma1) for x in xs]
assignments = [
int(prob1 > prob0) for prob0, prob1 in zip(probs0, probs1)
]
xs0 = [x for (x, a) in zip(xs, assignments) if a == 0]
xs1 = [x for (x, a) in zip(xs, assignments) if a == 1]
mu0, sigma0 = mean(xs0), sd(xs0, correct=False)
mu1, sigma1 = mean(xs1), sd(xs1, correct=False)
if sigma0 == 0:
sigma0 = sigma1
if sigma1 == 0:
sigma1 = sigma0
print "mu0: {} sigma0: {} mu1: {}: sigma1: {} xs0: {} xs1: {}".format(
mu0, sigma0, mu1, sigma1, len(xs0), len(xs1))
def f(x):
return dnorm(x, mu1,
sigma1) / (dnorm(x, mu0, sigma0) + dnorm(x, mu1, sigma1))
return f
def compute_correlation_matrix_loop(x):
feature_dim = x.shape[1]
z = np.zeros((feature_dim, feature_dim))
for i in range(feature_dim):
for j in range(feature_dim):
if (sd_i := sd(x, i) != 0) and (sd_j := sd(x, j) != 0):
z[i][j] = variance_(x, (i, j)) / (sd_i * sd_j)
def compute_correlation_matrix_loop(x):
feature_dim = x.shape[1]
z = np.zeros((feature_dim, feature_dim))
for i in range(feature_dim):
for j in range(feature_dim):
z[i][j] = covar(x, (i, j)) / (sd(x, i) * sd(x, j))
return z
def bisect_interval_noisy(f, epsilon=0.01, sigma=None, debug=False):
"""find zero of stochastic function f using linear regression"""
print "in bisect"
xmin = 1
xmax = 2
xs = [xmin, xmax]
print xmin, xmax
print f(1)
ys = map(f, xs)
print ys
print "ys[-1]:", ys[-1]
while ys[-1] < 0:
xmax += 1
xs.append(xmax)
y = f(xmax)
ys.append(y)
xs2 = [x + xs[-1] for x in xs]
ys2 = map(f, xs2)
xs = xs + xs2
ys = ys + ys2
#xs = list(np.linspace(lb,ub,10))
#ys = map(f,xs)
print "xs,ys:", xs, ys
i = 1
while sd(xs[-3:]) > epsilon:
print "starting round", i
i += 1
### select xp
# m = (y2-y1)/float(x2-x1)
# xp = -y1/m + x1
# yp = f(xp)
if sigma is None:
print "interpolating on:", xs, ys
r = kde_interpolate(xs, ys, sigma=sd(xs) / 3.0)
else:
r = kde_interpolate(xs, ys, sigma=sigma)
try:
xp = bisect_interval(r, min(xs), max(xs))
print "selected xp:", xp
except:
"secant regression failed!"
Exception()
if debug:
plt.scatter(xs, ys)
plt.plot(*pl(r, np.linspace(min(xs), max(xs), 1000)))
plt.plot([xp, xp], [-10, 10])
plt.plot([min(xs), max(xs)], [0, 0])
plt.show()
yp = f(xp)
### end select xp
print "xp,yp:", xp, yp
xs.append(xp)
ys.append(yp)
#js = sorted_indices(xs)
#xs = rslice(xs,js)
#ys = rslice(ys,js)
#assert xs == sorted(xs)
return xp, (xs, ys)
def sigma_from_matrix(matrix):
"""given a GLE matrix, estimate standard deviation of cell weights,
correcting for bias of sd estimate. See:
https://en.wikipedia.org/wiki/Unbiased_estimation_of_standard_deviation
"""
c = 2*sqrt(2/(3*pi))
return mean(map(lambda x:sd(x,correct=True),matrix))/c
def approximate_max_fitness(N=100000):
"""Approximate max fitness from sample, assuming fitnesses log-normally distributed"""
log_num_bds = (L - 1) * log(num_AAS)
log_num_motifs = L * n * log(4)
log_num_genotypes = log_num_bds + log_num_motifs
random_fits = ([fitness(sample_species()) for i in trange(N)])
log_fits = map(log, random_fits)
m, s = mean(log_fits), sd(log_fits)
standard_max = sqrt(2 * log_num_genotypes)
shifted_max = standard_max * s + m
def main():
print "Starting main()\n"
u.setup()
u.calibrate()
a.only_first_three()
# m.backwards(1300)
m.turn_right()
m.backwards(4500)
u.sd()
a.get_low_poms_cheeky()
a.get_frisbee()
a.get_mid_poms()
a.get_high_poms_cheeky()
a.get_farther_high_poms()
a.get_farther_mid_poms()
a.get_farther_low_poms()
print "Finished main\n"
u.shutdown(86)
def test_fw_method2(mu, sigma, N, trials=10000):
xs = [
sum(exp(random.gauss(mu, sigma)) for i in range(N))
for j in xrange(trials)
]
M, V = mean(xs), variance(xs)
print "obs M,V,log(V/(M**2)):", M, V, log(V / (M**2))
ys = map(log, xs)
m_obs, s_obs = mean(ys), sd(ys)
m, s = fw_method(mu, sigma, N)
print "pred:", m, s
print "obs:", m_obs, s_obs
def stoch_logistic_reg(f,
xmin,
xmax,
ymax,
desired_ic,
stop_sd=0.01,
debug=False):
ymin = 0
def sigmoid(params, x):
x0, k, ymax = params
y = ymax / (1 + np.exp(-k * (x - x0))) + ymin
return y
def residuals(params, x, y):
return y - sigmoid(params, x)
xs = list(np.linspace(xmin, xmax, 10))
ys = map(f, xs)
params = (2, 1, desired_ic * 2)
while True:
p_guess = params
params, cov, infodict, mesg, ier = leastsq(residuals,
p_guess,
args=(xs, ys),
full_output=1)
try:
x = secant_interval(lambda x: sigmoid(params, x) - desired_ic,
xmin, xmax)
except:
print "failed secant interval"
print params, xs, ys
raise Exception()
y = f(x)
xs.append(x)
ys.append(y)
if sd(xs[-3:]) < stop_sd:
break
if debug:
plt.scatter(xs, ys)
plt.plot(*pl(lambda x: sigmoid(params, x),
np.linspace(xmin, xmax, 1000)))
plt.plot(*pl(lambda x: desired_ic, np.linspace(xmin, xmax, 1000)))
plt.plot([x, x], [0, 2 * L])
plt.show()
# end with one more round of interpolation
params, cov, infodict, mesg, ier = leastsq(residuals,
p_guess,
args=(xs, ys),
full_output=1)
x = secant_interval(lambda x: sigmoid(params, x) - desired_ic, xmin, xmax)
return x, (xs, ys)
def evaluate(model, loader):
model.eval()
y_hat_list = []
y_list = []
for batch_data in loader:
a2a_g, b2a_g, b2b_gl, feats, types, counts, y = batch_data
_, y_hat = model(a2a_g, b2a_g, b2b_gl, types, counts)
y_hat_list += y_hat.tolist()
y_list += y.tolist()
y_hat = np.array(y_hat_list).reshape(-1,)
y = np.array(y_list).reshape(-1,)
return rmse(y, y_hat), mae(y, y_hat), sd(y, y_hat), pearson(y, y_hat)
def trim_motif(motif):
L = len(motif[0])
col_hs = map(lambda col: entropy(col, correct=True, alphabet_size=4),
transpose(motif))
mu, sigma = mean(col_hs), sd(col_hs)
threshold = mu + 1.96 * sigma
l, r = 0, L - 1
while col_hs[l] > threshold:
print "trimming left endpoint:", l, col_hs[l]
l += 1
while col_hs[r] > threshold:
print "trimming left endpoint:", col_hs[r]
r -= 1
return [site[l:r + 1] for site in motif]
def test_Zb_approx(trials=10, G=5 * 10**6, L=10):
predicted_Zb = exp(L * sigma**2 / 2.0 + log(G)) # a priori prediction
matrix = [[random.gauss(0, sigma) for j in range(4)] for i in range(L)]
score_mu = sum(mean(row) for row in matrix)
score_sigma_sq = sum(variance(row, correct=False) for row in matrix)
predicted_Zb2 = exp(score_mu + score_sigma_sq / 2 +
log(G)) # prediction given matrix
Zbs = []
for trial in trange(trials):
eps = [sum(random.choice(row) for row in matrix) for i in range(G)]
Zb = sum(exp(-ep) for ep in eps)
Zbs.append(Zb)
print "Predicted: %1.3e +/- %1.3e" % (predicted_Zb,
sqrt(var_Zb(sigma, L, G)))
print "Predicted2: %1.3e" % (predicted_Zb2)
print "Actual: %1.3e +/- %1.3e" % (mean(Zbs), sd(Zbs))
def stoch_lin_reg(f, lb=1, ub=50, stop_sd=0.1):
xs = [lb, ub]
ys = map(f, xs)
while True:
m, b = polyfit(xs, ys, 1)
x = -b / float(m)
if x < 1:
x = random.random() * (max(xs) - min(xs)) + min(xs)
y = f(x)
xs.append(x)
ys.append(y)
if sd(xs[-3:]) < stop_sd:
break
# end with one more round of interpolation
m, b = polyfit(xs, ys, 1)
x = -b / float(m)
y = f(x)
return x, (xs, ys)
def ou_param_recovery(xs):
"""return MLE estimate of ou parameters: dX = -beta*(X-k) + sigma*dW """
xs = np.array(xs)
ys = np.diff(xs)
xs_ = xs[:-1]
x0 = xs[0]
neg_beta, _ = polyfit(xs_, ys, 1) # find MLE estimate of beta
beta = -neg_beta
if beta < 0:
print "Warning: beta negative"
return None, None, None
sigma = sd(ys + beta * xs_)
rel_time = ou_relaxation_time(beta, sigma, x0)
if rel_time < len(xs):
print "estimated relaxation time:", rel_time
k = mean(xs[int(rel_time):]
) # estimate mean from series after relaxation time
else:
print "Warning: process predicted not to reach relaxation time."
k = None
return beta, sigma, k
def analyze_bio_motifs(Nes,trials=20):
results = {}
for tf_idx,tf in enumerate(Escherichia_coli.tfs):
Ne = Nes[tf]
bio_motif = getattr(Escherichia_coli,tf)
n,L = len(bio_motif),len(bio_motif[0])
bio_matrix = matrix_from_motif(bio_motif)
sigma = sigma_from_matrix(bio_matrix)
matrix_chains = [sella_hirsch_mh(n=n,L=L,sigma=sigma,Ne=Ne,init='ringer') for i in range(trials)]
ics = [mean(map(motif_ic,chain[-1000:])) for (matrix,chain) in matrix_chains]
ginis = [mean(map(motif_gini,chain[-1000:])) for (matrix,chain) in matrix_chains]
mis = [mean(map(total_motif_mi,chain[-1000:])) for (matrix,chain) in matrix_chains]
print "results for:",tf,tf_idx
print motif_ic(bio_motif),mean(ics),sd(ics)
print motif_gini(bio_motif),mean(ginis),sd(ginis)
print total_motif_mi(bio_motif),mean(mis),sd(mis)
results[tf] = (mean(ics),sd(ics),mean(ginis),sd(ginis),mean(mis),sd(mis))
return results
def estimate_site_sigma_from_matrix(matrix,n=1000):
L = len(matrix)
return sd([score_seq(matrix,random_site(L)) for i in xrange(n)])
def test_sample_mean_Zb(L, sigma, trials=1000):
Zbs = [sample_mean_Zb(L, sigma) for i in trange(trials)]
pred_mean, pred_sd = predict_mean_Zb(L, sigma)
obs_mean, obs_sd = mean(Zbs), sd(Zbs)
print "pred:", pred_mean, pred_sd
print "obs:", obs_mean, obs_sd
def code_statistics(code):
mus = [mean([code[(aa, b)] for aa in range(AAS)]) for b in "ACGT"]
sigmas = [sd([code[(aa, b)] for aa in range(AAS)]) for b in "ACGT"]
return sum(mus), sum(sigmas)
def compare_Zb2(G, L, sigma, trials=100):
Zbs = [sample_Zb(G, L, sigma) for trial in trange(trials)]
Zb_mu, Zb_sigma = predict_Zb2(G, L, sigma)
print "expected:", Zb_mu, Zb_sigma
print "observed:", mean(Zbs), sd(Zbs)
def code_statistics(code):
mus = [mean([code[(aa,b)] for aa in range(AAS)]) for b in "ACGT"]
sigmas = [sd([code[(aa,b)] for aa in range(AAS)]) for b in "ACGT"]
return sum(mus),sum(sigmas)
def test_predict_mean_Zb_from_matrix(matrix, G, trials=100):
# works.
Zbs = [sample_Zb_from_matrix(matrix, G) for i in trange(trials)]
m, s = predict_mean_Zb_from_matrix(matrix, G)
print "expected:", m, s
print "observed:", mean(Zbs), sd(Zbs)
def score_sd(motif):
matrix = matrix_from_motif(motif)
eps = [score_seq(matrix, site) for site in motif]
return sd(eps)
