def test_power_arg0():
# the +1.'s here are to avoid regimes where numerical diffs fail
make_fun = lambda y: lambda x: np.power(x, y)
fun = make_fun(npr.randn()**2 + 1.)
check_grads(fun)(npr.rand()**2 + 1.)
# test y == 0. as a special case, c.f. #116
fun = make_fun(0.)
assert grad(fun)(0.) == 0.
assert grad(grad(fun))(0.) == 0.
def train_loss(wb_vect, unflattener, i):
wb_struct = unflattener(wb_vect)
preds = predict(wb_struct, graph_arr, nodes_nbrs_compressed,
graph_idxs, layers)
graph_scores = get_actual(graph_idxs, df, preds)
mse = np.mean(np.power(preds - graph_scores, 2))
train_losses.append(mse)
preds_iter.append(preds)
actual_iter.append(graph_scores)
gc.collect()
return mse
def train_loss(wb_vect, unflattener, cv=False, batch=True, batch_size=10,
debug=False):
"""
Training loss is MSE.
We pass in a flattened parameter vector and its unflattener.
"""
wb_struct = unflattener(wb_vect)
if batch:
batch_size = batch_size
else:
batch_size = len(graphs)
if cv:
samp_graphs, samp_inputs = batch_sample(test_graphs,
input_shape,
batch_size=batch_size)
else:
samp_graphs, samp_inputs = batch_sample(graphs,
input_shape,
batch_size=batch_size)
print('batch size: {0}'.format(len(samp_graphs)))
preds = predict(wb_struct, samp_inputs, samp_graphs)
graph_ids = [g.graph['seqid'] for g in samp_graphs]
graph_scores = drug_data.set_index('seqid').ix[graph_ids]['FPV'].values.\
reshape(preds.shape)
assert preds.shape == graph_scores.shape
mse = np.mean(np.power(preds - graph_scores, 2))
if debug:
print(graph_ids)
print('Predictions:')
print(preds)
print('Mean: {0}'.format(np.mean(preds)))
print('')
print('Actual')
print(graph_scores)
print('Mean: {0}'.format(np.mean(graph_scores)))
print('')
print('Difference')
print(preds - graph_scores)
print('Mean Squared Error: {0}'.format(mse))
print('')
return mse
def integrate_rkdp5(
rhs,
x_eval,
x_initial,
y_initial,
atol=1e-12,
rtol=0.,
step_safety_factor=0.9,
step_update_factor_max=10,
step_update_factor_min=2e-1,
):
"""
Integrate using the RKDP5(4) method. For quick intuition, consult [2] and [3].
See table 5.2 on pp. 178 of [1] or [3] for the Butcher tableau. See pp. 167-169 of [1]
for automatic step size control and starting step size. Scipy's RK45 implementation
in python [4] was used as a reference for this implementation.
References:
[1] E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential Equations
i. Nonstiff Problems. 2nd edition. Springer Series in Computational Mathematics,
Springer-Verlag (1993)
[2] https://en.wikipedia.org/wiki/Runge–Kutta_methods
[3] https://en.wikipedia.org/wiki/Dormand–Prince_method
[4] https://github.com/scipy/scipy/blob/master/scipy/integrate/_ivp/rk.py
[5] https://math.stackexchange.com/questions/2947231/how-can-i-derive-the-dense-output-of-ode45/2948244
Arguments:
atol :: float or array(N) - the absolute tolerance of the component-wise
local error, i.e. "Atoli" in e.q. 4.10 on pp. 167 of [1]
rhs :: (x :: float, y :: array(N)) -> dy_dx :: array(N)
- the right-hand side of the equation dy_dx = rhs(x, y)
that defines the first order differential equation
rtol :: float or array(N) - the relative tolerance of the component-wise
local error, i.e. "Rtoli" in e.q. 4.10 on pp. 167 of [1]
step_safety_factor :: float - the safety multiplication factor used in the
step update rule, i.e. "fac" in e.q. 4.13 on pp. 168 of [1]
step_update_factor_max :: float - the maximum step multiplication factor used in the
step update rule, i.e. "facmax" in e.q. 4.13 on pp. 168 of [1]
step_update_factor_min :: float - the minimum step multiplication factor used in the
step update rule, i.e. "facmin"in e.q.e 4.13 on pp. 168 of [1]
x_eval :: ndarray (eval_count) - an array of points `x` whose
corresponding `y` value should be evaluated. It is assumed
that this list does not contain duplicates, that
the values are sorted in increasing order, and that
all values are greater than `x_initial`.
x_final :: float - the final value of x (inclusive) that concludes the integration interval
x_initial :: float - the initial value of x (inclusive) that begins the integration interval
y_initial :: array(N) - the initial value of y
Returns:
y_evald :: ndarray (eval_count x N) - an array of points `y` whose
corresponding `x` value is specified in x_eval
"""
# Determine how far to integrate to.
if len(x_eval) == 0:
raise ValueError("No output was specified.")
else:
x_final = x_eval[-1]
# Compute initial step size per pp. 169 of [1].
f0 = rhs(x_initial, y_initial)
d0 = rms_norm(y_initial)
d1 = rms_norm(f0)
if d0 < 1e-5 or d1 < 1e-5:
h0 = 1e-6
else:
h0 = 0.01 * d0 / d1
y1 = y_initial + h0 * f0
f1 = rhs(x_initial + h0, y1)
d2 = rms_norm(f1 - f0) / h0
if anp.maximum(d1, d2) <= 1e-15:
h1 = anp.maximum(1e-6, h0 * 1e-3)
else:
h1 = anp.power(0.01 / anp.maximum(d1, d2), 1 / (P + 1))
step_current = anp.minimum(100 * h0, h1)
# Integrate.
y_eval_list = list()
x_current = x_initial
y_current = y_initial
k1 = f0
while x_current <= x_final:
step_rejected = False
step_accepted = False
# Repeatedly attempt to move to the next position in the mesh
# until the step size is adapted such that the local step error
# is within an acceptable tolerance.
while not step_accepted:
# Attempt to step by `step_current`.
ks, y1, y1h = integrate_rkdp5_step(step_current,
rhs,
x_current,
y_current,
k1=k1)
# Before the step size is updated for the next step, note where
# the current attempted step size places us in the mesh.
x_new = x_current + step_current
# Compute the local error associated with the attempted step.
scale = atol + anp.maximum(anp.abs(y1), anp.abs(y1h)) * rtol
error_norm = rms_norm((y1 - y1h) / scale)
# If the step is accepted, increase the step size,
# and move to the next step.
if error_norm < 1:
step_accepted = True
# Avoid division by zero in update.
if error_norm == 0:
step_update_factor = step_update_factor_max
else:
step_update_factor = anp.minimum(
step_update_factor_max,
step_safety_factor * anp.power(error_norm, ERROR_EXP))
# Avoid an extraneous update in next step.
if step_rejected:
step_update_factor = anp.minimum(1, step_update_factor)
step_current = step_current * step_update_factor
# If the step was rejected, decrease the step size,
# and reattempt the step.
else:
step_rejected = True
step_update_factor = anp.maximum(
step_update_factor_min,
step_safety_factor * anp.power(error_norm, ERROR_EXP))
step_current = step_current * step_update_factor
#ENDWHILE
# Interpolate any output points that ocurred in the step.
x_eval_step_indices = anp.nonzero(
anp.logical_and(x_current <= x_eval, x_eval <= x_new))[0]
x_eval_step = x_eval[x_eval_step_indices]
if len(x_eval_step) != 0:
y_eval_step = rkdp5_dense(ks, x_current, x_new, x_eval_step,
y_current, y1)
for y_eval_ in y_eval_step:
y_eval_list.append(y_eval_)
# Update the position in the mesh.
x_current = x_new
y_current = y1
k1 = ks[6] # k[6] = k7
#ENDWHILE
return anp.stack(y_eval_list)
def hillPlus(A, k, n):
return np.power(A, n) / (np.power(A, n) + np.power(k, n))
from __future__ import absolute_import
import autograd.numpy as np
import scipy.stats
from autograd.extend import primitive, defvjp
from autograd.numpy.numpy_vjps import unbroadcast_f
from autograd.scipy.special import gamma, psi
cdf = primitive(scipy.stats.gamma.cdf)
logpdf = primitive(scipy.stats.gamma.logpdf)
pdf = primitive(scipy.stats.gamma.pdf)
def grad_gamma_logpdf_arg0(x, a):
return (a - x - 1) / x
def grad_gamma_logpdf_arg1(x, a):
return np.log(x) - psi(a)
defvjp(cdf, lambda ans, x, a: unbroadcast_f(x, lambda g: g * np.exp(-x) * np.power(x, a-1) / gamma(a)), argnums=[0])
defvjp(logpdf,
lambda ans, x, a: unbroadcast_f(x, lambda g: g * grad_gamma_logpdf_arg0(x, a)),
lambda ans, x, a: unbroadcast_f(a, lambda g: g * grad_gamma_logpdf_arg1(x, a)))
defvjp(pdf,
lambda ans, x, a: unbroadcast_f(x, lambda g: g * ans * grad_gamma_logpdf_arg0(x, a)),
lambda ans, x, a: unbroadcast_f(a, lambda g: g * ans * grad_gamma_logpdf_arg1(x, a)))
def rank_2_B_update(B,y,s,c):
normalizer = np.dot(s,c)
temp = np.outer(y - np.matmul(B, s), np.transpose(c))
symmetric_term = (temp + np.transpose(temp)) /normalizer
residual_term = (np.dot(np.transpose(s), y-np.matmul(B,s) ) * np.outer(c,np.transpose(c)))/np.power(normalizer, 2)
return B + symmetric_term - residual_term
def _cfun(self, d):
return np.power(d,2) / (2 * (d + 1))
from __future__ import absolute_import
import scipy.special
import autograd.numpy as np
from autograd.extend import primitive, defvjp
from autograd.numpy.numpy_vjps import unbroadcast_f
### Beta function ###
beta = primitive(scipy.special.beta)
betainc = primitive(scipy.special.betainc)
betaln = primitive(scipy.special.betaln)
defvjp(beta,
lambda ans, a, b: unbroadcast_f(a, lambda g: g * ans * (psi(a) - psi(a + b))),
lambda ans, a, b: unbroadcast_f(b, lambda g: g * ans * (psi(b) - psi(a + b))))
defvjp(betainc,
lambda ans, a, b, x: unbroadcast_f(x, lambda g: g * np.power(x, a - 1) * np.power(1 - x, b - 1) / beta(a, b)),
argnums=[2])
defvjp(betaln,
lambda ans, a, b: unbroadcast_f(a, lambda g: g * (psi(a) - psi(a + b))),
lambda ans, a, b: unbroadcast_f(b, lambda g: g * (psi(b) - psi(a + b))))
### Gamma functions ###
polygamma = primitive(scipy.special.polygamma)
psi = primitive(scipy.special.psi) # psi(x) is just polygamma(0, x)
digamma = primitive(scipy.special.digamma) # digamma is another name for psi.
gamma = primitive(scipy.special.gamma)
gammaln = primitive(scipy.special.gammaln)
gammainc = primitive(scipy.special.gammainc)
gammaincc = primitive(scipy.special.gammaincc)
gammasgn = primitive(scipy.special.gammasgn)
rgamma = primitive(scipy.special.rgamma)
def test_power_arg1_zero():
fun = lambda y: np.power(0., y)
check_grads(fun)(npr.rand()**2)
def test_power_arg1_zero():
fun = lambda y : np.power(0., y)
d_fun = grad(fun)
check_grads(fun, npr.rand()**2)
check_grads(d_fun, npr.rand()**2)
def norm2(x):
# if np.ndim(x) > 1:
# raise ValueError("Expected dimension greater than 2, but received")
# else:
return np.sqrt(np.sum(np.power(x, 2)))
def test_power_arg1():
x = npr.randn()**2
fun = lambda y: np.power(x, y)
check_grads(fun)(npr.rand()**2)
def populate_coordinates(self):
# Populates a variable called self.coordinates with the coordinates of the airfoil.
name = self.name.lower().strip()
# If it's a NACA 4-series airfoil, try to generate it
if "naca" in name:
nacanumber = name.split("naca")[1]
if nacanumber.isdigit():
if len(nacanumber) == 4:
# Parse
max_camber = int(nacanumber[0]) * 0.01
camber_loc = int(nacanumber[1]) * 0.1
thickness = int(nacanumber[2:]) * 0.01
# Set number of points per side
n_points_per_side = 100
# Referencing https://en.wikipedia.org/wiki/NACA_airfoil#Equation_for_a_cambered_4-digit_NACA_airfoil
# from here on out
# Make uncambered coordinates
x_t = cosspace(n_points=n_points_per_side
) # Generate some cosine-spaced points
y_t = 5 * thickness * (
+0.2969 * np.power(x_t, 0.5) - 0.1260 * x_t -
0.3516 * np.power(x_t, 2) + 0.2843 * np.power(x_t, 3) -
0.1015 * np.power(
x_t, 4) # 0.1015 is original, #0.1036 for sharp TE
)
if camber_loc == 0:
camber_loc = 0.5 # prevents divide by zero errors for things like naca0012's.
# Get camber
y_c_piece1 = max_camber / camber_loc**2 * (
2 * camber_loc * x_t[x_t <= camber_loc] -
x_t[x_t <= camber_loc]**2)
y_c_piece2 = max_camber / (1 - camber_loc)**2 * (
(1 - 2 * camber_loc) + 2 * camber_loc *
x_t[x_t > camber_loc] - x_t[x_t > camber_loc]**2)
y_c = np.hstack((y_c_piece1, y_c_piece2))
# Get camber slope
dycdx_piece1 = 2 * max_camber / camber_loc**2 * (
camber_loc - x_t[x_t <= camber_loc])
dycdx_piece2 = 2 * max_camber / (1 - camber_loc)**2 * (
camber_loc - x_t[x_t > camber_loc])
dycdx = np.hstack((dycdx_piece1, dycdx_piece2))
theta = np.arctan(dycdx)
# Combine everything
x_U = x_t - y_t * np.sin(theta)
x_L = x_t + y_t * np.sin(theta)
y_U = y_c + y_t * np.cos(theta)
y_L = y_c - y_t * np.cos(theta)
# Flip upper surface so it's back to front
x_U, y_U = np.flipud(x_U), np.flipud(y_U)
# Trim 1 point from lower surface so there's no overlap
x_L, y_L = x_L[1:], y_L[1:]
x = np.hstack((x_U, x_L))
y = np.hstack((y_U, y_L))
coordinates = np.column_stack((x, y))
self.coordinates = coordinates
return
else:
print(
"Unfortunately, only 4-series NACA airfoils can be generated at this time."
)
# Try to read from airfoil database
try:
import importlib.resources
from . import airfoils
raw_text = importlib.resources.read_text(airfoils, name + '.dat')
trimmed_text = raw_text[raw_text.find('\n'):]
coordinates1D = np.fromstring(
trimmed_text,
sep='\n') # returns the coordinates in a 1D array
assert len(
coordinates1D
) % 2 == 0, 'File was found in airfoil database, but it could not be read correctly!' # Should be even
coordinates = np.reshape(coordinates1D, (-1, 2))
self.coordinates = coordinates
return
except FileNotFoundError:
print("File was not found in airfoil database!")
def gammainc_vjp_arg1(ans, a, x):
coeffs = sign * np.exp(-x) * np.power(x, a - 1) / gamma(a)
return unbroadcast_f(x, lambda g: g * coeffs)
from autograd.numpy.numpy_vjps import unbroadcast_f
### Beta function ###
beta = primitive(scipy.special.beta)
betainc = primitive(scipy.special.betainc)
betaln = primitive(scipy.special.betaln)
defvjp(
beta,
lambda ans, a, b: unbroadcast_f(a, lambda g: g * ans *
(psi(a) - psi(a + b))),
lambda ans, a, b: unbroadcast_f(b, lambda g: g * ans *
(psi(b) - psi(a + b))))
defvjp(betainc,
lambda ans, a, b, x: unbroadcast_f(
x, lambda g: g * np.power(x, a - 1) * np.power(1 - x, b - 1) / beta(
a, b)),
argnums=[2])
defvjp(betaln,
lambda ans, a, b: unbroadcast_f(a, lambda g: g * (psi(a) - psi(a + b))),
lambda ans, a, b: unbroadcast_f(b, lambda g: g * (psi(b) - psi(a + b))))
### Gamma functions ###
polygamma = primitive(scipy.special.polygamma)
psi = primitive(scipy.special.psi) # psi(x) is just polygamma(0, x)
digamma = primitive(scipy.special.digamma) # digamma is another name for psi.
gamma = primitive(scipy.special.gamma)
gammaln = primitive(scipy.special.gammaln)
gammainc = primitive(scipy.special.gammainc)
gammaincc = primitive(scipy.special.gammaincc)
gammasgn = primitive(scipy.special.gammasgn)
def get_learning_rate_exp_decay(global_step, base_lr=0.01, decay_rate=0.9, decay_steps=2, staircase=True):
if staircase:
exponent = global_step / decay_steps # integer division
else:
exponent = global_step / np.float(decay_steps)
return base_lr * np.power(decay_rate, exponent)
def _calc_pareto_front(self, n_pareto_points=100):
x = anp.linspace(0, 1, n_pareto_points)
return anp.array([x, 1 - anp.power(x, 2)]).T
def ll(x, num_peds, ess, robot_mu_x, robot_mu_y, ped_mu_x, ped_mu_y, \
cov_robot_x, cov_robot_y, inv_cov_robot_x, inv_cov_robot_y, \
cov_ped_x, cov_ped_y, inv_cov_ped_x, inv_cov_ped_y, \
one_over_cov_sum_x, one_over_cov_sum_y, \
one_over_cov_sumij_x, one_over_cov_sumij_y, normalize, T):
quad_mu_x = np.dot((x[:T]-robot_mu_x).T, np.dot(inv_cov_robot_x, \
x[:T]-robot_mu_x))
quad_mu_y = np.dot((x[T:2*T]-robot_mu_y).T, np.dot(inv_cov_robot_y, \
x[T:2*T]-robot_mu_y))
llambda = -0.5*quad_mu_x - 0.5*quad_mu_y
i = 2
for ped in range(ess):
quad_mu_x = np.dot((x[i*T:(i+1)*T]-ped_mu_x[ped]).T, np.dot(\
inv_cov_ped_x[ped], x[i*T:(i+1)*T]-ped_mu_x[ped]))
quad_mu_y = np.dot((x[(i+1)*T:(i+2)*T]-ped_mu_y[ped]).T, np.dot(\
inv_cov_ped_y[ped], x[(i+1)*T:(i+2)*T]-ped_mu_y[ped]))
llambda = llambda -0.5*quad_mu_x - 0.5*quad_mu_y
i = i + 2
i = 2#robot-agent CCA
for ped in range(ess):
vel_x = np.tile(x[:T],(T,1)).T - np.tile(x[i*T:(i+1)*T], (T,1))
vel_y = np.tile(x[T:2*T],(T,1)).T - np.tile(x[(i+1)*T:(i+2)*T],(T,1))
vel_x = np.diag(vel_x)
vel_y = np.diag(vel_y)
i = i + 2
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_x = np.multiply(vel_x_2, one_over_cov_sum_x[ped])
quad_y = np.multiply(vel_y_2, one_over_cov_sum_y[ped])
Z_x = np.exp(-0.5*quad_x)
Z_y = np.exp(-0.5*quad_y)
Z = np.multiply(Z_x, Z_y)
log_znot_norm = np.sum(np.log1p(-Z))
llambda = llambda + log_znot_norm
# agent-agent CCA
i = 2
j = 4
for ped_i in range(ess):
ped_j = int(j/2) - 1
while j<=2*ess:
vel_x = np.tile(\
x[i*T:(i+1)*T],(T,1)).T - np.tile(x[(j)*T:(j+1)*T], (T,1))
vel_y = np.tile(\
x[(i+1)*T:(i+2)*T],(T,1)).T - np.tile(x[(j+1)*T:(j+2)*T],(T,1))
vel_x = np.diag(vel_x)
vel_y = np.diag(vel_y)
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_x = np.multiply(vel_x_2, one_over_cov_sumij_x[ped_i][ped_j])
quad_y = np.multiply(vel_y_2, one_over_cov_sumij_y[ped_i][ped_j])
Z_x = np.exp(-0.5*quad_x)
Z_y = np.exp(-0.5*quad_y)
Z = np.multiply(Z_x, Z_y)
log_znot_norm = np.sum(np.log1p(-Z))
llambda = llambda + log_znot_norm
j = j + 2
i = i + 2
j = i + 2
return -1.*llambda
def dd_ll(x, num_peds, ess, robot_mu_x, robot_mu_y, ped_mu_x, ped_mu_y, \
cov_robot_x, cov_robot_y, inv_cov_robot_x, inv_cov_robot_y, \
cov_ped_x, cov_ped_y, inv_cov_ped_x, inv_cov_ped_y, \
one_over_cov_sum_x, one_over_cov_sum_y, normalize):
T = np.size(robot_mu_x)
H = np.zeros((2 * T * np.int(ess + 1), 2 * T * np.int(ess + 1)), float)
sum_d_alpha = [0. for _ in range(2 * T * np.int(np.round(ess + 1)))]
n = 2
for ped in range(ess):
# if normalize == True:
# # normalize_x = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_x[ped])
# # normalize_y = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_y[ped])
# else:
normalize_x = 1.
normalize_y = 1.
vel_robot_x = np.tile(x[:T],
(T, 1)).T - np.tile(x[n * T:(n + 1) * T], (T, 1))
vel_robot_y = np.tile(x[T:2 * T],
(T, 1)).T - np.tile(x[(n + 1) * T:(n + 2) * T],
(T, 1))
vel_robot_x_2 = np.power(vel_robot_x, 2)
vel_robot_y_2 = np.power(vel_robot_y, 2)
vel_robot_x_y = np.multiply(vel_robot_x, vel_robot_y)
one_over_cov_x_y = np.multiply(one_over_cov_sum_x[ped], \
one_over_cov_sum_y[ped])
quad_robot_x = np.multiply(one_over_cov_sum_x[ped], vel_robot_x_2)
quad_robot_y = np.multiply(one_over_cov_sum_y[ped], vel_robot_y_2)
Z_x = np.multiply(normalize_x, np.exp(-0.5 * quad_robot_x))
Z_y = np.multiply(normalize_y, np.exp(-0.5 * quad_robot_y))
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1. - Z)
X_2 = np.power(X, 2)
X_plus_X2 = np.add(X, X_2)
d_alpha_x = np.multiply(X, one_over_cov_sum_x[ped])
d_alpha_x = np.add(d_alpha_x, -np.multiply(X_plus_X2, np.power(\
np.multiply(vel_robot_x, one_over_cov_sum_x[ped]), 2)))
d_alpha_y = np.multiply(X, one_over_cov_sum_y[ped])
d_alpha_y = np.add(d_alpha_y, -np.multiply(X_plus_X2, np.power(\
np.multiply(vel_robot_y, one_over_cov_sum_y[ped]), 2)))
sum_d_alpha[:T] = np.add(sum_d_alpha[:T], np.sum(d_alpha_x, axis=1))
sum_d_alpha[T:2 * T] = np.add(sum_d_alpha[T:2 * T],
np.sum(d_alpha_y, axis=1))
d_off_alpha = -np.multiply(X_plus_X2, np.multiply(vel_robot_x_y, \
one_over_cov_x_y))
# OFF DIAGONALS
H[:T, T:2 * T] = np.add(H[:T, T:2 * T],
np.diag(np.sum(d_off_alpha, axis=1)))
H[:T, n * T:(n + 1) * T] = -1. * d_alpha_x
H[n * T:(n + 1) * T, :T] = H[:T, n * T:(n + 1) * T].T
H[T:2 * T, (n + 1) * T:(n + 2) * T] = -1. * d_alpha_y
H[(n + 1) * T:(n + 2) * T, T:2 * T] = H[T:2 * T,
(n + 1) * T:(n + 2) * T].T
H[T:2*T,n*T:(n+1)*T] = np.multiply(X_plus_X2, np.multiply(vel_robot_x_y, \
one_over_cov_x_y))
H[n * T:(n + 1) * T, T:2 * T] = H[T:2 * T, n * T:(n + 1) * T].T
H[:T,(n+1)*T:(n+2)*T] = np.multiply(X_plus_X2, np.multiply(vel_robot_x_y, \
one_over_cov_x_y))
H[(n + 1) * T:(n + 2) * T, :T] = H[:T, (n + 1) * T:(n + 2) * T].T
n = n + 2
H[:T, :T] = np.add(np.diag(sum_d_alpha[:T]), -1. * inv_cov_robot_x)
H[T:2 * T, T:2 * T] = np.add(np.diag(sum_d_alpha[T:2 * T]),
-1. * inv_cov_robot_y)
H[T:2 * T, :T] = H[:T, T:2 * T].T
# PED DIAGONALS
n = 2
for ped in range(ess):
# if normalize == True:
# # normalize_x = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_x[ped])
# # normalize_y = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_y[ped])
# else:
normalize_x = 1.
normalize_y = 1.
vel_ped_x = np.tile(x[:T], (T, 1)) - np.tile(x[n * T:(n + 1) * T],
(T, 1)).T
vel_ped_y = np.tile(x[T:2 * T],
(T, 1)) - np.tile(x[(n + 1) * T:(n + 2) * T],
(T, 1)).T
vel_ped_x_2 = np.power(vel_ped_x, 2)
vel_ped_y_2 = np.power(vel_ped_y, 2)
vel_ped_x_y = np.multiply(vel_ped_x, vel_ped_y)
one_over_cov_x_y = np.multiply(one_over_cov_sum_x[ped], \
one_over_cov_sum_y[ped])
quad_ped_x = np.multiply(one_over_cov_sum_x[ped], vel_ped_x_2)
quad_ped_y = np.multiply(one_over_cov_sum_y[ped], vel_ped_y_2)
Z_x = np.multiply(normalize_x, np.exp(-0.5 * quad_ped_x))
Z_y = np.multiply(normalize_y, np.exp(-0.5 * quad_ped_y))
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1. - Z)
X_2 = np.power(X, 2)
X_plus_X2 = np.add(X, X_2)
d_alpha_x = np.multiply(X, one_over_cov_sum_x[ped])
d_alpha_x = np.add(d_alpha_x, -np.multiply(X_plus_X2, np.power(\
np.multiply(vel_ped_x, one_over_cov_sum_x[ped]), 2)))
d_alpha_y = np.multiply(X, one_over_cov_sum_y[ped])
d_alpha_y = np.add(d_alpha_y, -np.multiply(X_plus_X2, np.power(\
np.multiply(vel_ped_y, one_over_cov_sum_y[ped]), 2)))
H[n*T:(n+1)*T,n*T:(n+1)*T] = np.diag(np.sum(d_alpha_x, axis=1)) - \
inv_cov_ped_x[ped]
H[(n+1)*T:(n+2)*T,(n+1)*T:(n+2)*T] = np.diag(np.sum(d_alpha_y, axis=1)) - \
inv_cov_ped_y[ped]
H[n*T:(n+1)*T,(n+1)*T:(n+2)*T] = -np.diag(np.sum(np.multiply(X_plus_X2, \
np.multiply(vel_ped_x_y, one_over_cov_x_y)), axis=1))
H[(n + 1) * T:(n + 2) * T,
n * T:(n + 1) * T] = H[n * T:(n + 1) * T, (n + 1) * T:(n + 2) * T].T
n = n + 2
return -1. * H
from __future__ import absolute_import, division
import autograd.numpy as np
import scipy.stats
from autograd.extend import primitive, defvjp
from autograd.numpy.numpy_vjps import unbroadcast_f
from autograd.scipy.special import gamma
cdf = primitive(scipy.stats.chi2.cdf)
logpdf = primitive(scipy.stats.chi2.logpdf)
pdf = primitive(scipy.stats.chi2.pdf)
def grad_chi2_logpdf(x, df):
return np.where(df % 1 == 0, (df - x - 2) / (2 * x), 0)
defvjp(cdf, lambda ans, x, df: unbroadcast_f(x, lambda g: g * np.power(2., -df/2) * np.exp(-x/2) * np.power(x, df/2 - 1) / gamma(df/2)), argnums=[0])
defvjp(logpdf, lambda ans, x, df: unbroadcast_f(x, lambda g: g * grad_chi2_logpdf(x, df)), argnums=[0])
defvjp(pdf, lambda ans, x, df: unbroadcast_f(x, lambda g: g * ans * grad_chi2_logpdf(x, df)), argnums=[0])
def d_ll(x, num_peds, ess, robot_mu_x, robot_mu_y, ped_mu_x, ped_mu_y, \
cov_robot_x, cov_robot_y, inv_cov_robot_x, inv_cov_robot_y, \
cov_ped_x, cov_ped_y, inv_cov_ped_x, inv_cov_ped_y, \
one_over_cov_sum_x, one_over_cov_sum_y, normalize):
T = np.size(robot_mu_x)
d_alpha = [0. for _ in range(2 * T * np.int(np.round(ess + 1)))]
d_beta = [0. for _ in range(2 * T * np.int(np.round(ess + 1)))]
d_llambda = np.asarray(
[0. for _ in range(2 * T * np.int(np.round(ess + 1)))])
n = 2
for ped in range(ess):
# if normalize == True:
# # normalize_x = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_x[ped])
# # normalize_y = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_y[ped])
# else:
normalize_x = 1.
normalize_y = 1.
vel_robot_x = np.tile(x[:T],
(T, 1)).T - np.tile(x[n * T:(n + 1) * T], (T, 1))
vel_robot_y = np.tile(x[T:2 * T],
(T, 1)).T - np.tile(x[(n + 1) * T:(n + 2) * T],
(T, 1))
n = n + 2
vel_robot_x_2 = np.power(vel_robot_x, 2)
vel_robot_y_2 = np.power(vel_robot_y, 2)
quad_robot_x = np.multiply(one_over_cov_sum_x[ped], vel_robot_x_2)
quad_robot_y = np.multiply(one_over_cov_sum_y[ped], vel_robot_y_2)
Z_x = np.multiply(normalize_x, np.exp(-0.5 * quad_robot_x))
Z_y = np.multiply(normalize_y, np.exp(-0.5 * quad_robot_y))
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1. - Z)
alpha_x = np.multiply(
X, np.multiply(vel_robot_x, one_over_cov_sum_x[ped]))
alpha_y = np.multiply(
X, np.multiply(vel_robot_y, one_over_cov_sum_y[ped]))
# X and Y COMPONENT OF R DERIVATIVE
d_alpha[:T] = np.add(d_alpha[:T], np.sum(alpha_x, axis=1))
d_alpha[T:2 * T] = np.add(d_alpha[T:2 * T], np.sum(alpha_y, axis=1))
d_beta[:T] = -np.dot(x[:T] - robot_mu_x, inv_cov_robot_x)
d_beta[T:2 * T] = -np.dot(x[T:2 * T] - robot_mu_y, inv_cov_robot_y)
d_llambda[0:2 * T] = np.add(d_alpha[0:2 * T], d_beta[0:2 * T])
# X AND Y COMPONENT OF PED DERIVATIVE
n = 2
for ped in range(ess):
# if normalize == True:
# # normalize_x = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_x[ped])
# # normalize_y = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_y[ped])
# else:
normalize_x = 1.
normalize_y = 1.
vel_ped_x = np.tile(x[:T], (T, 1)) - np.tile(x[n * T:(n + 1) * T],
(T, 1)).T
vel_ped_y = np.tile(x[T:2 * T],
(T, 1)) - np.tile(x[(n + 1) * T:(n + 2) * T],
(T, 1)).T
vel_ped_x_2 = np.power(vel_ped_x, 2)
vel_ped_y_2 = np.power(vel_ped_y, 2)
quad_ped_x = np.multiply(one_over_cov_sum_x[ped], vel_ped_x_2)
quad_ped_y = np.multiply(one_over_cov_sum_y[ped], vel_ped_y_2)
Z_x = np.multiply(normalize_x, np.exp(-0.5 * quad_ped_x))
Z_y = np.multiply(normalize_y, np.exp(-0.5 * quad_ped_y))
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1. - Z)
alpha_x = np.multiply(X, np.multiply(vel_ped_x,
one_over_cov_sum_x[ped]))
alpha_y = np.multiply(X, np.multiply(vel_ped_y,
one_over_cov_sum_y[ped]))
d_alpha[n * T:(n + 1) * T] = -np.sum(alpha_x, axis=1)
d_alpha[(n + 1) * T:(n + 2) * T] = -np.sum(alpha_y, axis=1)
d_beta[n*T:(n+1)*T] = -np.dot(x[n*T:(n+1)*T]-ped_mu_x[ped], \
inv_cov_ped_x[ped])
d_beta[(n+1)*T:(n+2)*T] = -np.dot(x[(n+1)*T:(n+2)*T]-ped_mu_y[ped], \
inv_cov_ped_y[ped])
n = n + 2
d_llambda[2 * T:] = np.add(d_alpha[2 * T:], d_beta[2 * T:])
return -1. * d_llambda
def _cfun(self, d, pd_la = 1):
return (np.power(d + 1, pd_la + 1) - (d +1))/(pd_la * (pd_la + 1)) - d / (pd_la + 1)
def get_learning_rate_inv_scaling(t, base_lr=0.01, power_t=0.25):
return base_lr / np.power(t + 1, power_t)
def test_power_arg0():
y = npr.randn()**2 + 1.0
fun = lambda x : np.power(x, y)
d_fun = grad(fun)
check_grads(fun, npr.rand()**2)
check_grads(d_fun, npr.rand()**2)
def RKF45_Integrator(t_start, t_stop, h0, x0, A):
# An integrator using a 4(5) RKF method
T_0 = time.time()
"""
x0 = initial conditions
t_start = start time
t_stop = end time
n_step = number of steps
A = A(t) matrix function
"""
Ndim = x0.size
x_ = np.zeros((1, Ndim)) # set up the array of x values
t_ = np.zeros(1) # set up the array of t values
t_[0] = t_start
x_[0, :] = x0
h = h0
h_min = h0 * (10**(-3))
h_max = 3 * h0
n = 0
t = t_start
#
S = 0.99 # safety factor
#
while n < n_step:
x_n = x_[n, :].reshape(Ndim, 1)
Err_small = False
h_new = h
while Err_small == False:
# compute the predictions using 4th and 5th order RK methods
k1 = h * A(t) @ x_n
k2 = h * A(t + 0.25 * h) @ (x_n + 0.25 * k1)
k3 = h * A(t + (3 / 8) * h) @ (x_n + (3 / 32) * k1 + (9 / 32) * k2)
k4 = h * A(t + (12 / 13) * h) @ (x_n + (1932 / 2197) * k1 -
(7200 / 2197) * k2 +
(7296 / 2197) * k3)
k5 = h * A(t + h) @ (x_n + (439 / 216) * k1 - 8 * k2 +
(3680 / 513) * k3 - (845 / 4104) * k4)
k6 = h * A(t + 0.5 * h) @ (x_n - (8 / 27) * k1 + 2 * k2 -
(3544 / 2565) * k3 +
(1859 / 4104) * k4 - (11 / 40) * k5)
y_np1 = x_n + (25 / 216) * k1 + (1408 / 2565) * k3 + (
2197 / 4101) * k4 - (11 / 40) * k5
z_np1 = x_n + (16 / 135) * k1 + (6656 / 12825) * k3 + (
28561 / 56430) * k4 - (9 / 50) * k5 + (2 / 55) * k6
#
Err = ferr(y_np1, z_np1)
Err_max = epsilon_RK * np.abs(z_np1[0, 0] + epsilon_RK)
Err_ratio = np.abs(Err / Err_max)
#
if Err_ratio <= 1:
h_new = h * S * np.power(Err_ratio, -1.0 / (5))
"""
or h_new = h*(epsilon*h/max(np.abs(y_np1 - z_np1)))**(1/4)
"""
if h_new > h_max: # limit the maximum step size
h_new = h_max
Err_small = True # break loop
elif Err_ratio > 1:
h_new = h * S * np.power(Err_ratio, -1.0 / (4))
#print(" h_new = ", h_new)
if h_new < h_min:
#print("h < h_min")
h_new = h_min
Err_small = True # break loop
elif h_new >= h_min:
h = h_new
t = t + h
x_ = np.vstack(
(x_, x_np1_l.reshape(1,
Ndim))) # add x_n+1 to the array of x values
t_ = np.append(t_, t) # add t_n+1 to the array of t values
n = n + 1
h = h_new
if True: #np.round(((t-t_start)/(t_stop-t_start))*100000) % 1000 == 0:
print("\r" + "integrated {:.1%}".format(
(t - t_start) / (t_stop - t_start)),
end='')
T = time.time() - T_0
print(" done in {:.5g}s".format(T))
return (t_, x_, T)
def test_pow_f64(): grad_test(lambda x: 0.4 ** x, lambda x: np.power(0.4, x), default_fp=ti.f64) grad_test(lambda y: y ** 0.4, lambda y: np.power(y, 0.4), default_fp=ti.f64)
def Magnus_Integrator(t_start, t_stop, h0, x0, A, alpha, order):
T_0 = time.time()
"""
x0 = initial conditions
t_start = start time
t_stop = end time
h0 = initial step size
A = A(t) matrix function
alpha = alpha generating function
order = 4 or 6
"""
Ndim = x0.size
x_ = np.zeros((1, Ndim)) # set up the array of x values
t_ = np.zeros(1) # set up the array of t values
t_[0] = t_start
x_[0, :] = x0
h = h0
h_min = h0 * (10**(-3))
h_max = 3 * h0
n = 0
t = t_start
#
S = 0.99 # safety factor
#
def M(time, hstep):
M_ = linalg.expm(Omega(time, time + hstep, A, alpha, order))
return M_
#
while t <= t_stop:
x_n = x_[n, :].reshape(Ndim, 1)
Err_small = False
h_new = h
while Err_small == False:
# compute the predictions using one step of h & two steps of h/2
#print("\r" + "trying step " + str(n) + " h=" + str(h) + " ...", end='')
x_np1_0 = M(t, h) @ x_n
x_np1_l = M(t + 0.5 * h, 0.5 * h) @ (M(t, 0.5 * h) @ x_n)
# compute error
Err = ferr(x_np1_0, x_np1_l)
Err_max = epsilon * np.abs(
x_np1_l[0, 0] +
epsilon) #h*(A(t) @ x_n)[0,0]) # maximum error allowed
#Err_ratio = Err / Err_max
#
if Err <= Err_max:
h_new = h * 1.5 #h*S*np.power(np.abs(Err/Err_max), 1.0/(order + 1))
if h_new > h_max: # limit the maximum step size
h_new = h_max
Err_small = True # break loop
elif Err > Err_max:
h_new = h * S * np.power(Err_max / Err, 1.0 / (order))
#print(" h_new = ", h_new)
if h_new < h_min:
#print("h < h_min")
h_new = h_min
Err_small = True # break loop
elif h_new >= h_min:
h = h_new
t = t + h
x_ = np.vstack(
(x_, x_np1_l.reshape(1,
Ndim))) # add x_n+1 to the array of x values
t_ = np.append(t_, t) # add t_n+1 to the array of t values
n = n + 1
h = h_new
if True: #np.round(((t-t_start)/(t_stop-t_start))*100000) % 1000 == 0:
print("\r" + "integrated {:.1%}".format(
(t - t_start) / (t_stop - t_start)),
end='')
T = time.time() - T_0
print(" done in {:.5g}s".format(T))
return (t_, x_, T)
def train_model(args, mdl, mdl_test, results):
coeff = []
ang_sb = []
ang_np = []
p_angles = []
all_w = []
results['args'] = args
loss = []
init_loss = mdl.loss(mdl.params_flat)
init_grad_norm = np.linalg.norm(mdl.gradient(mdl.params_flat))
print(
"\n===============================================================================================\n"
)
print('Initial loss: {}, norm grad: {}\n'.format(init_loss,
init_grad_norm))
results['init_full_loss'] = init_loss
results['init_full_grad_norm'] = init_grad_norm
results['history1'] = []
results['history1_columns'] = [
'iter_no', 'batch_loss', 'batch_grad_norm', 'batch_param_norm'
]
results['history2'] = []
results['history2_columns'] = ['full_hessian', 'full_hessian_evals']
for iter_no in tqdm(range(args.max_iterations),
desc="Training Progress",
dynamic_ncols=True):
inputs, targets = get_batch_samples(iter_no, args, mdl)
batch_loss = mdl.loss(mdl.params_flat, inputs, targets)
batch_grad = mdl.gradient(mdl.params_flat, inputs, targets)
batch_grad_norm = np.linalg.norm(batch_grad)
batch_param_norm = np.linalg.norm(mdl.params_flat)
if iter_no % args.freq == 0:
# calculating hessian
hess = mdl.hessian(mdl.params_flat) # Calculating Hessian
hess = torch.tensor(
hess).float() # Converting the Hessian to Tensor
eigenvalues, eigenvec = torch.symeig(
hess, eigenvectors=True
) # Extracting the eigenvalues and Eigen Vectors from the Calculated Hessian
if iter_no == 0:
prev_hess = hess
prev_eigval = eigenvalues
prev_eigvec = eigenvec
top = args.top # This decides how many top eigenvectors are considered
dom = eigenvec[:,
-top:] # |The reason for negative top :: torch.symeig outputs eigen vectors in the increasing order and as a result |
# | the top (maximum) eigenvectors will be atlast. |
dom = dom.float()
alpha = torch.rand(
top
) # A random vector which is of the dim of variable "top" is being initialized
# Finding the top vector
vec = (alpha * dom.float()).sum(
1) # Representing alpha onto dominant eigen vector
vec = vec / torch.sqrt(
(vec * vec).sum()) # Normalization of top vector
# vec = vec*5
# Finding gradient at top vec using Dummy network.
mdl_test.params_flat = np.array(vec)
batch_grad_mdl_test = mdl_test.gradient(mdl_test.params_flat,
inputs, targets)
mdl_test.params_flat -= batch_grad_mdl_test * args.learning_rate
# Find coeff and append. But why do we need to find the coeffs ?
c = torch.mv(hess.transpose(0, 1),
torch.tensor(mdl_test.params_flat).float())
if np.size(coeff) == 0:
coeff = c.detach().cpu().numpy()
coeff = np.expand_dims(coeff, axis=0)
else:
coeff = np.concatenate(
(coeff, np.expand_dims(c.detach().cpu().numpy(), axis=0)),
0)
# Statistics of subspaces, (1) Angle between top subpaces
eigenvalues_prev, eigenvec_prev = torch.symeig(prev_hess,
eigenvectors=True)
dom_prev = eigenvec_prev[:,
-top:] # Is it not the same as the variable "dom" that was calculated earlier ?
# calculation 1 norm, which is nothing but angle between subspaces
ang = np.linalg.norm(
torch.mm(dom_prev, dom.transpose(0, 1)).numpy(), 1)
ang_sb.append(ang)
ang = np.rad2deg(subspace_angles(dom_prev, dom))
ang_np.append(ang)
# Calculating principal angles
u, s, v = torch.svd(torch.mm(dom.transpose(0, 1), dom_prev))
# Output in radians
s = torch.acos(torch.clamp(s, min=-1, max=1))
s = s * 180 / math.pi
# Attach 's' to p_angles
if np.size(p_angles) == 0:
p_angles = s.detach().cpu().numpy()
p_angles = np.expand_dims(p_angles, axis=0)
else:
p_angles = np.concatenate(
(p_angles, np.expand_dims(s.detach().cpu().numpy(),
axis=0)), 0)
prev_hess = hess
prev_eigval = eigenvalues
prev_eigvec = eigenvec
# saving weights in all iterations
if batch_grad_norm <= args.stopping_grad_norm:
break
mdl.params_flat -= batch_grad * args.learning_rate
#print(mdl.params_flat)
all_w.append(np.power(math.e, mdl.params_flat))
# print('{:06d} {} loss: {:.8f}, norm grad: {:.8f}'.format(iter_no, datetime.now(), batch_loss, batch_grad_norm))
loss.append(batch_loss)
final_loss = mdl.loss(mdl.params_flat)
final_grad_norm = np.linalg.norm(mdl.gradient(mdl.params_flat))
print('\nFinal loss: {}, norm grad: {}'.format(final_loss,
final_grad_norm))
args.suffix = args.results_folder + '/coeff.npy'
np.save(args.suffix, coeff)
args.suffix = args.results_folder + '/ang_sb.npy'
np.save(args.suffix, ang_sb)
args.suffix = args.results_folder + '/ang_np.npy'
np.save(args.suffix, ang_np)
args.suffix = args.results_folder + '/p_angles.npy'
np.save(args.suffix, p_angles)
args.suffix = args.results_folder + '/all_weights.npy'
np.save(args.suffix, np.array(all_w))
# Saving png plots
coeff = torch.tensor(coeff)
for i in range(coeff.shape[0]):
a = torch.zeros(coeff[i].shape[0]).long()
b = torch.arange(0, coeff[i].shape[0])
c = torch.where(((coeff[i] > -0.1) & (coeff[i] < 0.1)), b, a)
z = torch.zeros(coeff[i].shape[0]).fill_(0)
z[torch.nonzero(c)] = coeff[i][torch.nonzero(c)]
z = np.array(z)
plt.plot(z)
plt.xlabel('Dimension', fontsize=14)
plt.ylabel('Coefficient', fontsize=14)
pnpy = args.results_folder + '/plot1'
plt.savefig(pnpy, format='png', pad_inches=5)
return args.results_folder
return np.sum(np.power(predictions - train_Y, 2)) / N
# Function that returns gradients of loss function
gradient_fun = elementwise_grad(loss)
# Optimizable parameters with random initialization
weight = rng.randn()
bias = rng.randn()
for epoch in range(training_epochs):
gradients = gradient_fun((weight, bias))
weight -= gradients[0] * learning_rate
bias -= gradients[1] * learning_rate
# Train error
print('Train error={}'.format(loss((weight, bias))))
# Test error
predictions = (test_X * weight) + bias
print('Test error={}'.format(np.sum(np.power(predictions - test_Y, 2)) / N))
# Optimization results
print('Weight={} Bias={}'.format(weight, bias))
# Graphic display
plt.plot(train_X, train_Y, 'ro', label='Original data')
plt.plot(train_X, weight * train_X + bias, label='Fitted line')
plt.legend()
plt.show()
def test_power_arg1():
x = npr.randn()**2
fun = lambda y : np.power(x, y)
d_fun = grad(fun)
check_grads(fun, npr.rand()**2)
check_grads(d_fun, npr.rand()**2)
def loss((weight, bias)):
""" Loss function: Mean Squared Error """
predictions = (train_X * weight) + bias
return np.sum(np.power(predictions - train_Y, 2)) / N
def f_test(x, y):
return np.power(x, 2) + np.power(y - 1, 2)
def alpha(omega, q, chi2l, chi2):
return (
(-0.18229166666666666 - (5 * (1 + q) * (1 / (1 + q) - q / (1 + q))) /
(64. * q)) / omega +
((-35 * chi2l * q) / 128. -
(15 * chi2l * (1 + q) *
(1 / (1 + q) - q /
(1 + q))) / 128.) / np.power(omega, 0.6666666666666666) +
(-1.7952473958333333 -
(35 * np.power(chi2, 2) * np.power(q, 2)) / 128. - (515 * q) /
(384. * np.power(1 + q, 2)) - (175 * (1 / (1 + q) - q /
(1 + q))) / (256. * (1 + q)) -
(4555 * (1 + q) * (1 / (1 + q) - q /
(1 + q))) / (7168. * q) -
(15 * np.power(chi2, 2) * q * (1 + q) *
(1 / (1 + q) - q /
(1 + q))) / 128. - (15 * np.power(1 / (1 + q) - q /
(1 + q), 2)) /
(256. * q)) / np.power(omega, 0.3333333333333333) +
(4.318908476114694 - (35 * chi2l * np.pi * q) / 16. +
(475 * np.power(chi2, 2) * np.power(q, 2)) / 6144. -
(35 * np.power(chi2, 4) * np.power(q, 4)) / 512. +
(35 * np.power(chi2, 2) * np.power(chi2l, 2) * np.power(q, 4)) / 128.
+ (955 * np.power(q, 2)) / (576. * np.power(1 + q, 4)) + (39695 * q) /
(86016. * np.power(1 + q, 2)) +
(575 * np.power(chi2, 2) * np.power(q, 3)) /
(1536. * np.power(1 + q, 2)) +
(1645 * np.power(chi2l, 2) * np.power(q, 3)) /
(192. * np.power(1 + q, 2)) + (2725 * q * (1 / (1 + q) - q /
(1 + q))) /
(3072. * np.power(1 + q, 3)) - (265 * (1 / (1 + q) - q /
(1 + q))) /
(14336. * (1 + q)) + (145 * np.power(chi2, 2) * np.power(q, 2) *
(1 / (1 + q) - q /
(1 + q))) / (512. * (1 + q)) +
(1815 * np.power(chi2l, 2) * np.power(q, 2) * (1 / (1 + q) - q /
(1 + q))) /
(256. * (1 + q)) - (15 * chi2l * np.pi * (1 + q) *
(1 / (1 + q) - q /
(1 + q))) / 16. +
(27895885 * (1 + q) * (1 / (1 + q) - q /
(1 + q))) / (2.1676032e7 * q) -
(485 * np.power(chi2, 2) * q * (1 + q) *
(1 / (1 + q) - q /
(1 + q))) / 14336. - (15 * np.power(chi2, 4) * np.power(q, 3) *
(1 + q) * (1 / (1 + q) - q /
(1 + q))) / 512. +
(15 * np.power(chi2, 2) * np.power(chi2l, 2) * np.power(q, 3) *
(1 + q) *
(1 / (1 + q) - q /
(1 + q))) / 128. + (1615 * np.power(1 / (1 + q) - q /
(1 + q), 2)) / (28672. * q) +
(15 * np.power(chi2, 2) * q * np.power(1 / (1 + q) - q /
(1 + q), 2)) / 256. +
(375 * np.power(chi2l, 2) * q * np.power(1 / (1 + q) - q /
(1 + q), 2)) / 256. +
(35 * np.power(1 / (1 + q) - q /
(1 + q), 2)) / (256. * np.power(1 + q, 2)) +
(15 * np.power(1 / (1 + q) - q / (1 + q), 3)) /
(1024. * q * (1 + q))) * np.power(omega, 0.3333333333333333) -
(35 * np.pi * np.log(omega)) / 48. +
(2995 * chi2l * q * np.log(omega)) / 9216. -
(35 * np.power(chi2, 2) * chi2l * np.power(q, 3) * np.log(omega)) /
384. + (2545 * chi2l * np.power(q, 2) * np.log(omega)) /
(1152. * np.power(1 + q, 2)) +
(5 * chi2l * q * (1 / (1 + q) - q / (1 + q)) * np.log(omega)) /
(3. * (1 + q)) + (2035 * chi2l * (1 + q) *
(1 / (1 + q) - q /
(1 + q)) * np.log(omega)) / 21504. -
(5 * np.pi * (1 + q) * (1 / (1 + q) - q / (1 + q)) * np.log(omega)) /
(16. * q) - (5 * np.power(chi2, 2) * chi2l * np.power(q, 2) * (1 + q) *
(1 / (1 + q) - q / (1 + q)) * np.log(omega)) / 128. +
(5 * chi2l * np.power(1 / (1 + q) - q /
(1 + q), 2) * np.log(omega)) / 16.)
def get_learning_rate_inv_scaling(t, base_lr=0.01, power_t=0.25): return base_lr / np.power(t+1, power_t)
def test_power_arg1():
x = npr.randn()**2
fun = lambda y : np.power(x, y)
check_grads(fun)(npr.rand()**2)
def lms_loss(params,inputs,targets,l2_reg) :
reg_prior = l2_reg * l2_norm(params)
lms = auto_np.sum(auto_np.power(neural_net_predict(params,inputs) - targets,2))
return lms + reg_prior
def weibull(t, k=1.5, l=1, w=7):
x = t/float(w)*2.5 # transform to [0, 3]
return (k/l) * np.power((x/l), k-1) * np.exp(-1 * np.power((x/l), k)) if x > 0 else 0
def calc_linear_loss(W):
y_pred = np.dot(XMat, W)
return np.sqrt((np.power(yMat - y_pred, 2))).mean()
def d_ll(x, num_peds, ess, robot_mu_x, robot_mu_y, ped_mu_x, ped_mu_y, \
cov_robot_x, cov_robot_y, inv_cov_robot_x, inv_cov_robot_y, \
cov_ped_x, cov_ped_y, inv_cov_ped_x, inv_cov_ped_y, \
one_over_cov_sum_x, one_over_cov_sum_y, \
one_over_cov_sumij_x, one_over_cov_sumij_y, normalize, T):
d_beta = [0. for _ in range(2*T*np.int(np.round(ess+1)))]
d_llambda = np.asarray([0. for _ in range(2*T*np.int(np.round(ess+1)))])
# DERIVATIVE WRT ROBOT
i = 2
for ped in range(ess):
vel_x = np.tile(x[:T],(T,1)).T - np.tile(x[i*T:(i+1)*T],(T,1))
vel_y = np.tile(x[T:2*T],(T,1)).T - np.tile(x[(i+1)*T:(i+2)*T],(T,1))
vel_x = np.diag(vel_x)
vel_y = np.diag(vel_y)
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_x = np.multiply(one_over_cov_sum_x[ped], vel_x_2)
quad_y = np.multiply(one_over_cov_sum_y[ped], vel_y_2)
Z_x = np.exp(-0.5*quad_x)
Z_y = np.exp(-0.5*quad_y)
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1.-Z)
alpha_x = np.multiply(X, np.multiply(vel_x, one_over_cov_sum_x[ped]))
alpha_y = np.multiply(X, np.multiply(vel_y, one_over_cov_sum_y[ped]))
d_llambda[:T] = np.add(d_llambda[:T], np.sum(alpha_x, axis=1))
d_llambda[T:2*T] = np.add(d_llambda[T:2*T], np.sum(alpha_y, axis=1))
i = i + 2
d_beta[:T] = -np.dot(x[:T]-robot_mu_x, inv_cov_robot_x)
d_beta[T:2*T] = -np.dot(x[T:2*T]-robot_mu_y, inv_cov_robot_y)
d_llambda[0:2*T] = np.add(d_llambda[0:2*T], d_beta[0:2*T])
# DERIVATIVE WRT PED: ROBOT-PED DERIVATIVE, FIRST TERM
i = 2
for ped in range(ess):
vel_x = np.tile(x[:T],(T,1)) - np.tile(x[i*T:(i+1)*T],(T,1)).T
vel_y = np.tile(x[T:2*T],(T,1)) - np.tile(x[(i+1)*T:(i+2)*T],(T,1)).T
vel_x = np.diag(vel_x)
vel_y = np.diag(vel_y)
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_x = np.multiply(vel_x_2, one_over_cov_sum_x[ped])
quad_y = np.multiply(vel_y_2, one_over_cov_sum_y[ped])
Z_x = np.exp(-0.5*quad_x)
Z_y = np.exp(-0.5*quad_y)
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1.-Z)
alpha_x = np.multiply(X, np.multiply(vel_x, one_over_cov_sum_x[ped]))
alpha_y = np.multiply(X, np.multiply(vel_y, one_over_cov_sum_y[ped]))
d_llambda[i*T:(i+1)*T] = -np.sum(alpha_x, axis=1)
d_llambda[(i+1)*T:(i+2)*T] = -np.sum(alpha_y, axis=1)
i = i + 2
# DERIVATIVE WRT PED: PED-PED DERIVATIVE, SECOND TERM
i = 2
j = 2
for ped_i in range(ess):
for ped_j in range(ess):
if i != j:
vel_x = np.tile(x[i*T:(i+1)*T],(T,1)).T - np.tile(x[j*T:(j+1)*T], (T,1))
vel_y = np.tile(\
x[(i+1)*T:(i+2)*T],(T,1)).T - np.tile(x[(j+1)*T:(j+2)*T],(T,1))
vel_x = np.diag(vel_x)
vel_y = np.diag(vel_y)
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_x = np.multiply(vel_x_2, one_over_cov_sumij_x[ped_i][ped_j])
quad_y = np.multiply(vel_y_2, one_over_cov_sumij_y[ped_i][ped_j])
Z_x = np.exp(-0.5*quad_x)
Z_y = np.exp(-0.5*quad_y)
Z = np.multiply(Z_x, Z_y)
X = np.divide(Z, 1.-Z)
alpha_x = np.multiply(X, np.multiply(vel_x, \
one_over_cov_sumij_x[ped_i][ped_j]))
alpha_y = np.multiply(X, np.multiply(vel_y, \
one_over_cov_sumij_y[ped_i][ped_j]))
d_llambda[i*T:(i+1)*T] = np.add(d_llambda[i*T:(i+1)*T], \
np.sum(alpha_x, axis=1))
d_llambda[(i+1)*T:(i+2)*T] = np.add(d_llambda[(i+1)*T:(i+2)*T], \
np.sum(alpha_y, axis=1))
j = j + 2
i = i + 2
j = 2
# DERIVATIVE WRT PED: PED-PED DERIVATIVE, THIRD TERM
i = 2
for ped in range(ess):
d_beta[i*T:(i+1)*T] = -np.dot(x[i*T:(i+1)*T]-ped_mu_x[ped], \
inv_cov_ped_x[ped])
d_beta[(i+1)*T:(i+2)*T] = -np.dot(x[(i+1)*T:(i+2)*T]-ped_mu_y[ped], \
inv_cov_ped_y[ped])
i = i + 2
d_llambda[2*T:] = np.add(d_llambda[2*T:], d_beta[2*T:])
return -1.*d_llambda
def test_power_arg1_zero():
fun = lambda y : np.power(0., y)
check_grads(fun)(npr.rand()**2)
def calc_linear_loss(W):
y_pred = np.dot(XMat, W)
return np.sqrt((np.power(yMat - y_pred, 2))).mean() \
+ np.sum(self.alpha * W[0:-1] * W[0:-1])
def _cfun(self, d):
return 2 * np.power( np.power( d + 1 , .5) - 1, 2)
def incremental_ll(theta, mu, y, C, V, eta_k, lmd, d, t):
return 0.5 * d * np.log(normnon(theta, mu, V, t) + eta_k) + (
(d + lmd) / 2.0
) * np.log(1 + np.power(
np.linalg.norm(y - C @ self.nonlinearity(theta, mu, t)), 2) /
(lmd * (eta_k + normnon(theta, mu, V, t))))
def _cfun(self, d):
return np.power(d,2) / (d + 2)
def GammaCorrect(im):
return 255.0 * np.power(im.astype(np.float32) * (1.0 / 255.0), 2.2)
def mags2nanomaggies(self, mags):
return np.power(10., (mags - 22.5)/-2.5)
#
# m_hat = m/(1-np.power(b1,i))
# v_hat = v/(1-np.power(b2,i))
#
# param = param - (eta*m_hat)/(np.sqrt(v_hat) + e)
for i in range(1,it+1):
gradw1 = gw1(w1,w2,w3,b1,b2,b3)
gradw2 = gw2(w1,w2,w3,b1,b2,b3)
gradw3 = gw3(w1,w2,w3,b1,b2,b3)
gradb1 = gb1(w1,w2,w3,b1,b2,b3)
gradb2 = gb2(w1,w2,w3,b1,b2,b3)
gradb3 = gb3(w1,w2,w3,b1,b2,b3)
gradw1_2 = np.power(gradw1,2)
gradw2_2 = np.power(gradw2,2)
gradw3_2 = np.power(gradw3,2)
gradb1_2 = np.power(gradb1,2)
gradb2_2 = np.power(gradb2,2)
gradb3_2 = np.power(gradb3,2)
mw1 = b1*mw1 + (1-b1)*gradw1
vw1 = b2*vw1 + (1-b2)*gradw1_2
m_hatw1 = mw1/(1-np.power(b1,i))
v_hatw1 = vw1/(1-np.power(b2,i))
mw2 = b1*mw2 + (1-b1)*gradw2
vw2 = b2*vw2 + (1-b2)*gradw2_2
m_hatw2 = mw2/(1-np.power(b1,i))
v_hatw2 = vw2/(1-np.power(b2,i))
def gammainc_vjp_arg1(ans, a, x):
coeffs = sign * np.exp(-x) * np.power(x, a - 1) / gamma(a)
return unbroadcast_f(x, lambda g: g * coeffs)
pix_1d = np.linspace(0., 1., n_grid) # pixel gridding
fdensity_true = float(Ndata)/float(n_grid**2); #number density of obj in 1d
sig_psf = 0.01 # psf width
sig_noise = 0.01 # noise level
mid = int(n_grid/2);
x,y = np.meshgrid(pix_1d,pix_1d);
psf = np.exp(-((y-pix_1d[mid])**2 + (x - pix_1d[mid])**2)/2/sig_psf**2); #keep in mind difference between x and y position and indices! Here, you are given indices, but meshgrid is in x-y coords
#these are values for the power law function for sampling intensities
w_interval = (1,2);
w_lin = np.linspace(1,2,100);
alpha_true = 2;
w_norm = (50**(alpha_true+1) - w_interval[0]**(alpha_true+1))/(alpha_true+1);
w_func = np.power(w_lin,alpha_true)/w_norm;
w_true = w_norm*np.random.choice(w_func,Ndata);
def psi(pos):
''' measurement model, which in our case is just a 1d gaussian of width
sigma (PSF) written out to a meshgrid created by pix1d
'''
x,y = np.meshgrid(pix_1d,pix_1d);
return np.exp(-((y-pix_1d[pos[0]])**2 + (x - pix_1d[pos[1]])**2)/2/sig_psf**2); #keep in mind difference between x and y position and indices! Here, you are given indices, but meshgrid is in x-y coords
def gaussian(x, loc=None, scale=None):
'''
scipy's gaussian pdf didn't work idk
'''
y = (x - loc)/scale
def test_power_arg1():
x = npr.randn()**2
fun = lambda y : np.power(x, y)
d_fun = grad(fun)
check_grads(fun, npr.rand()**2)
check_grads(d_fun, npr.rand()**2)
def test_pow(): grad_test(lambda x: 0.4 ** x, lambda x: np.power(0.4, x)) grad_test(lambda y: y ** 0.4, lambda y: np.power(y, 0.4))
