def test_multivariate_normal_logpdf_batches_and_states_masked(D=10):
# Test broadcasting over B batches, N datapoints, and K parameters with masks
B = 3
N = 100
K = 5
x = npr.randn(B, N, D)
mask = npr.rand(B, N, D) < .5
mu = npr.randn(K, D)
L = npr.randn(K, D, D)
Sigma = np.matmul(L, np.swapaxes(L, -1, -2))
ll1 = multivariate_normal_logpdf(x[:, :, None, :],
mu,
Sigma,
mask=mask[:, :, None, :])
assert ll1.shape == (B, N, K)
ll2 = np.empty((B, N, K))
for b in range(B):
for n in range(N):
m = mask[b, n]
if m.sum() == 0:
ll2[b, n] = 0
else:
for k in range(K):
ll2[b, n, k] = mvn.logpdf(x[b, n][m], mu[k][m],
Sigma[k][np.ix_(m, m)])
assert np.allclose(ll1, ll2)
def convolve_with_basis(self, signal):
"""
Convolve each column of the event count matrix with this basis
:param S: signal: an array-like data, each series is (1, T) shape
:return: TxB of inputs convolved with bases
"""
(T,_) = signal.shape
(R,B) = self.basis.shape
# Initialize array for filtered stimulus
F = np.empty((T,B))
# Compute convolutions fo each basis vector, one at a time
for b in np.arange(B):
F[:,b] = sig.fftconvolve(signal,
np.reshape(self.basis[:,b],(R,1)),
'full')[:T,:]
# Check for positivity
if np.amin(self.basis) >= 0 and np.amin(signal) >= 0:
np.clip(F, 0, np.inf, out=F)
assert np.amin(F) >= 0, "convolution should be >= 0"
return F
def _ntied_transmat_prior(self, transmat_val): # TODO: document choices
transmat = np.empty((0, self.n_components))
for r in range(self.n_unique):
row = np.empty((self.n_chain, 0))
for c in range(self.n_unique):
if r == c:
subm = np.array(
sp.diags([transmat_val[r, c], 1.0], [0, 1],
shape=(self.n_chain, self.n_chain)).todense())
else:
lower_left = np.zeros((self.n_chain, self.n_chain))
lower_left[self.n_tied, 0] = 1.0
subm = np.kron(transmat_val[r, c], lower_left)
row = np.hstack((row, subm))
transmat = np.vstack((transmat, row))
return transmat
def load_cg_merged(filename):
csvfile = open(filename,"rb")
csvreader = csv.reader(csvfile)
lines = [line for line in csvreader]
csvfile.close()
# number of samples
n_instances = len(lines) - 1
# number of features
n_features = len(lines[0]) - 1
# extract feature names
feature_name = lines[0][1:]
# extract case ids
case_id = []
# extract dataset
data = np.empty((n_instances,n_features),dtype=list)
for i in range(n_instances):
case_id.append(lines[i+1][0])
data[i,:] = lines[i+1][1:]
return (feature_name,case_id,data)
def _ntied_transmat_prior(self, transmat_val): # TODO: document choices
transmat = np.empty((0, self.n_components))
for r in range(self.n_unique):
row = np.empty((self.n_chain, 0))
for c in range(self.n_unique):
if r == c:
subm = np.array(sp.diags([transmat_val[r, c],
1.0], [0, 1],
shape=(self.n_chain, self.n_chain)).todense())
else:
lower_left = np.zeros((self.n_chain, self.n_chain))
lower_left[self.n_tied, 0] = 1.0
subm = np.kron(transmat_val[r, c], lower_left)
row = np.hstack((row, subm))
transmat = np.vstack((transmat, row))
return transmat
def level_curve_question_8(f, x0, y0, oversampling=1, delta=0.1, N=N, eps=eps):
if (oversampling == 1):
return (level_curve_question_7(f, x0, y0))
else: # on utilise le squelette de la fonction level_curve
res = np.empty((2, oversampling * N), dtype=float)
c = f(x0, y0)
# on calcule les bornes du premier segment
a = np.array([x0, y0])
res[:, 0] = a
gradient = grad(f)(x0, y0)
# On calcule le nouveau point
u = mat_rot.dot(gradient)
norme_u = np.linalg.norm(u)
nouveau_point = np.array([x0, y0]) + (delta / norme_u) * u
x, y = Newton(fonction_level_curve(f, x0, y0, c, delta),
nouveau_point[0], nouveau_point[1])
b = np.array([x, y])
res[:, 1 * oversampling] = b
x0, y0 = x, y
# puis on "remplit" entre a et b
res[:, 1:oversampling] = interpolation(f, a, b, oversampling)
# on calcule un troisième point
gradient = grad(f)(x0, y0)
u = mat_rot.dot(gradient)
norme_u = np.linalg.norm(u)
nouveau_point = np.array([x0, y0]) + (delta / norme_u) * u
x, y = Newton(fonction_level_curve(f, x0, y0, c, delta),
nouveau_point[0], nouveau_point[1])
res[:, 2 * oversampling] = np.array([x, y])
x0, y0 = x, y
# on remplit entre b et ce nouveau point
res[:, 1 * oversampling + 1:2 * oversampling] = interpolation(
f, b, np.array([x, y]), oversampling)
# puis on calcule les suivants
for i in range(3, N):
gradient = grad(f)(x0, y0)
# on se place à un nouveau point "dans le sens de grad(f)"
u = mat_rot.dot(gradient)
norme_u = np.linalg.norm(u)
nouveau_point = np.array([x0, y0]) + (delta / norme_u) * u
# on trouve les nouvelles coordonnées, sur le cercle de centre (x0, y0) et de rayon delta
x, y = Newton(fonction_level_curve(f, x0, y0, c, delta),
nouveau_point[0], nouveau_point[1])
res[:, i * oversampling] = np.array([x, y])
# on remplit res entre ce nouveau point et celui trouvé à l'itération précédente
res[:,
(i - 1) * oversampling + 1:i * oversampling] = interpolation(
f, res[:, (i - 1) * oversampling], np.array([x, y]),
oversampling)
# test d'auto-intersection
if closed_segment_intersect(a, b, res[:, (i - 1) * oversampling],
np.array([x, y])):
print(f"Auto-intersection après {i} points.")
return res[:, :i * oversampling]
x0, y0 = x, y
return res
def gamma(t: np.ndarray, P1: tuple or np.ndarray, P2: tuple or np.ndarray,
u1: tuple or np.ndarray, u2: tuple or np.ndarray) -> np.ndarray:
"""
This function generates a polynomial interpolation between two points in a 2D plane.
:param t: The interpolated curve's normalized parameter
:param P1: The first point tuple
:param P2: The second point tuple
:param u1: The first derivative vector
:param u2: The second derivative vector
:returns: The interpolated points' array
"""
# 1. Unpacking the variables for easier processing
u11, u12 = u1
u21, u22 = u2
x1, y1 = P1
x2, y2 = P2
# 2. Calculating the determinant of the (u1, u2) couple
denom = (u12 * u21) - (u11 * u22)
# 3.1. Using the second-degree polynomial interpolation method when possible
if not np.isclose(denom, 0):
# 3.1.1. Calculating the values of k1 and k2
k1 = 2 * (((y2 - y1) * u21) - ((x2 - x1) * u22)) / denom
k2 = 2 * (((x2 - x1) * u12) - ((y2 - y1) * u11)) / denom
# 3.1.2. Calculating the explicit values of the a, b, c, d, e, f parameters
a = x1
b = k1 * u11
c = k2 * u21 + x1 - x2
d = y1
e = k1 * u12
f = k2 * u22 + y1 - y2
# 3.1.3. Calculating the values of the x, y variables
x = a + b * t + c * t**2
y = d + e * t + f * t**2
# 3.2. Switching to a linear interpolation method (ignoring the derivative vectors) if u1 and u2 are parallel vectors
else:
# 3.2.1. Calculating the explicit values of the a, b, c, d parameters
a = x1
b = x2 - x1
c = y1
d = y2 - y1
# 3.2.2. Calculating the values of the x, y variables
x = a + b * t
y = c + d * t
# 4. Concatenating the results into a single coordinates array
points_interpolated = np.empty((2, t.shape[0]))
points_interpolated[0, :] = x
points_interpolated[1, :] = y
return points_interpolated
def test_stress(self):
for structure in ('fcc', 'bcc', 'hcp', 'diamond', 'sc'):
for repeat in ((1, 1, 1), (1, 2, 3)):
for a in [3.0, 4.0]:
atoms = bulk('Cu', structure, a=a).repeat(repeat)
atoms.rattle()
atoms.set_calculator(EMT())
# Numerically calculate the ase stress
d = 1e-9 # a delta strain
ase_stress = np.empty((3, 3)).flatten()
cell0 = atoms.cell
# Use a finite difference approach that is centered.
for i in [0, 4, 8, 5, 2, 1]:
strain_tensor = np.zeros((3, 3))
strain_tensor = strain_tensor.flatten()
strain_tensor[i] = d
strain_tensor = strain_tensor.reshape((3, 3))
strain_tensor += strain_tensor.T
strain_tensor /= 2
strain_tensor += np.eye(3, 3)
cell = np.dot(strain_tensor, cell0.T).T
positions = np.dot(strain_tensor, atoms.positions.T).T
atoms.cell = cell
atoms.positions = positions
ep = atoms.get_potential_energy()
strain_tensor = np.zeros((3, 3))
strain_tensor = strain_tensor.flatten()
strain_tensor[i] = -d
strain_tensor = strain_tensor.reshape((3, 3))
strain_tensor += strain_tensor.T
strain_tensor /= 2
strain_tensor += np.eye(3, 3)
cell = np.dot(strain_tensor, cell0.T).T
positions = np.dot(strain_tensor, atoms.positions.T).T
atoms.cell = cell
atoms.positions = positions
em = atoms.get_potential_energy()
ase_stress[i] = (ep - em) / (2 * d) / atoms.get_volume()
ase_stress = np.take(ase_stress.reshape((3, 3)), [0, 4, 8, 5, 2, 1])
ag_stress = stress(parameters, atoms.positions, atoms.numbers, atoms.cell)
# I picked the 0.03 tolerance here. I thought it should be closer, but
# it is a simple numerical difference I am using for the derivative,
# and I am not sure it is totally correct.
self.assertTrue(np.all(np.abs(ase_stress - ag_stress) <= 0.03),
f'''
ase: {ase_stress}
ag : {ag_stress}')
diff {ase_stress - ag_stress}
''')
def cpeps(peps, config):
shape = peps.shape
cpeps = np.empty(shape, dtype=np.object)
peps_config = np.reshape(config, peps.shape)
for i in range(shape[0]):
for j in range(shape[1]):
cpeps[i, j] = peps[i, j][peps_config[i, j], :, :, :, :]
return cpeps
def mcmc(self,
N=1000,
burn=0,
single=False,
ptype="corr",
s=1.,
update_hess=False,
new=False,
use_tqdm=True):
"""
:param N:
:param burn:
:param single:
:param ptype:
:param s:
:param update_hess:
:param new:
:return:
"""
if new is True:
self.n_accepted = np.zeros(self.n_params, dtype=int)
self.errors = []
#build chain
new_chain = np.empty((N, self.n_params + 1))
#single or joint sampler
if single is True: sample_fun = self._single_sample
else: sample_fun = self._joint_sample
#burn in if it's a new chain
if self._chain.sum() == 0.:
for _ in range(burn):
try:
sample_fun(is_burn=True, ptype=ptype, s=s)
except:
pass
#sample
if use_tqdm is True:
range_fun = lambda n: tqdm(range(n))
else:
range_fun = lambda n: range(n)
for i in range_fun(N):
try:
sample_fun(ptype=ptype, s=s)
except:
self.errors.append(i)
new_chain[i, 0] = self.last_log_p
new_chain[i, 1:] = self.params
#either save chain or add new_chain to existing chain
if self._chain.sum() == 0. or new is True:
self._chain = new_chain
else:
self._chain = np.vstack((self._chain, new_chain))
print(self.a_rates)
def maxFlatPoly(tau, P):
a = np.empty(P + 1)
i = np.arange(P + 1)
for k in range(P + 1):
a[k] = (-1)**k * binom(P, k) * np.prod(
(2 * tau + i) / (2 * tau + k + i))
a /= a.sum()
return a
def ba_objective(cams, X, w, obs, feats):
p = obs.shape[0]
reproj_err = np.empty((p,2))
for i in range(p):
reproj_err[i] = compute_reproj_err(cams[obs[i,0]],X[obs[i,1]],w[i],feats[i])
w_err = 1. - np.square(w)
return (reproj_err, w_err)
def animate(*args, **kwargs):
global i
ax0.clear()
ax1.clear()
ax0.set_xlim(-2, 4)
ax0.set_ylim(-1, 5)
ax1.set_xlim(0, len(hist_nloglik))
ax1.set_ylim(min(hist_nloglik), max(hist_nloglik))
N = 64
X = np.linspace(-2, 4, N)
Y = np.linspace(-1, 5, N)
X, Y = np.meshgrid(X, Y)
# Pack X and Y into a single 3-dimensional array
pos = np.empty(X.shape + (2,))
pos[:, :, 0] = X
pos[:, :, 1] = Y
rv = multivariate_normal(true_mean, true_cov)
Z = rv.pdf(pos)
levelsf = MaxNLocator(nbins=8).tick_values(Z.min(), Z.max())
ax0.contourf(X, Y, Z, levels=levelsf, antialiased = True)
X = np.linspace(hist_vi_mean[i][0] - 5 * np.exp(hist_vi_logvars[i][0]),
hist_vi_mean[i][0] + 5 * np.exp(hist_vi_logvars[i][0]), 32)
Y = np.linspace(hist_vi_mean[i][1] - 5 * np.exp(hist_vi_logvars[i][1]),
hist_vi_mean[i][1] + 5 * np.exp(hist_vi_logvars[i][1]), 32)
X, Y = np.meshgrid(X, Y)
# Pack X and Y into a single 3-dimensional array
pos = np.empty(X.shape + (2,))
pos[:, :, 0] = X
pos[:, :, 1] = Y
rv = multivariate_normal(hist_vi_mean[i], np.diag(np.exp(hist_vi_logvars[i])))
Z = rv.pdf(pos)
levelsf = MaxNLocator(nbins=10).tick_values(Z.min(), Z.max())
ax0.contour(X, Y, Z, levels=levelsf, cmap='YlOrRd',)
ax1.plot(hist_nloglik[:i])
# ax0.legend()
i += step
i = min(i, len(hist_nloglik) - 1)
return ax0, ax1
def atoms_mapfn(a):
d = positions0 + displacement - positions0[a]
i = indices[(d**2).sum(1) < (cutoff_radius**2 + skin)]
if n1 == 0 and n2 == 0 and n3 == 0:
i = i[i > a]
neighbors[a] = np.concatenate((neighbors[a], i))
disp = np.empty((len(i), 3), int)
disp[:] = (n1, n2, n3)
disp += offsets[i] - offsets[a]
displacements[a] = np.concatenate((displacements[a], disp))
def __init__(self,
potential_energy,
kinetic_energy,
kinetic_energy_distribution,
random=None,
diagnostic_mode=False):
if random is not None:
self.random = random
else:
self.random = np.random.RandomState(0)
self.D = np.max(kinetic_energy_distribution(1).shape)
self.potential_energy = potential_energy
self.kinetic_energy = kinetic_energy
self.total_energy = lambda position, momentum: potential_energy(
position) + kinetic_energy(momentum)
self.sample_momentum = lambda n: kinetic_energy_distribution(
n).reshape((1, self.D))
self.grad_potential_energy = grad(potential_energy)
self.params = {
'step_size': 0.1,
'leapfrog_steps': 10,
'total_samples': 1000,
'burn_in': 0.1,
'thinning_factor': 1,
'diagnostic_mode': diagnostic_mode
}
self.accepts = 0.
self.iterations = 0.
self.trace = np.empty((1, self.D))
self.potential_energy_trace = np.empty((1, ))
assert self.sample_momentum(1).shape == (1, self.D)
assert isinstance(self.potential_energy(self.sample_momentum(1)),
float)
assert isinstance(self.kinetic_energy(self.sample_momentum(1)), float)
assert isinstance(
self.total_energy(self.sample_momentum(1),
self.sample_momentum(1)), float)
assert self.grad_potential_energy(
self.sample_momentum(1)).shape == (1, self.D)
def ba_objective(cams, X, w, obs, feats):
p = obs.shape[0]
reproj_err = np.empty((p, 2))
for i in range(p):
reproj_err[i] = compute_reproj_err(cams[obs[i, 0]], X[obs[i, 1]], w[i],
feats[i])
w_err = 1. - np.square(w)
return (reproj_err, w_err)
def broadcast1024(*args):
"""Extend numpy.broadcast to accept 1024 inputs, rather than the default 32."""
ngroups = int(np.ceil(len(args) / 32))
if ngroups == 1:
return np.broadcast(*args)
else:
return np.broadcast(*[
np.empty(np.broadcast(*args[n * 32:(n + 1) * 32]).shape)
for n in range(ngroups)
])
def triang_to_flat(L):
D, _, M = L.shape
N = M * (M + 1) // 2
flat = np.empty((N, D))
for d in range(D):
count = 0
for m in range(M):
for mm in range(m + 1):
flat[count, d] = L[d, m, mm]
count = count + 1
return flat
def liquid_density_star(self, temperature_star, quadrupole_star, bond_length_star):
"""Computes the reduced liquid density of the two-center
Lennard-Jones model for a given set of model parameters over
a specified range of temperatures.
Parameters
----------
temperature_star: numpy.ndarray
The reduced temperatures to evaluate the reduced density at.
quadrupole_star: float
The reduced quadrupole parameter.
bond_length_star: float
The reduced bond-length parameter
Returns
-------
numpy.ndarray
The reduced density.
"""
_b_C1, _b_C2, _b_C3 = (
self._b_C1,
self._b_C2_L,
self._b_C3_L,
)
t_c_star = self.critical_temperature_star(quadrupole_star, bond_length_star)
rho_c_star = self.critical_density_star(quadrupole_star, bond_length_star)
tau = t_c_star - temperature_star
if np.all(tau > 0):
coefficient_1 = self._correlation_function_1(
quadrupole_star, bond_length_star, _b_C1
)
coefficient_2 = self._correlation_function_2(
quadrupole_star, bond_length_star, _b_C2
)
coefficient_3 = self._correlation_function_3(
quadrupole_star, bond_length_star, _b_C3
)
x_0 = 1.0 * rho_c_star
x_1 = tau ** (1.0 / 3.0) * coefficient_1
x_2 = tau * coefficient_2
x_3 = tau ** (3.0 / 2.0) * coefficient_3
rho_star = x_0 + x_1 + x_2 + x_3
else:
rho_star = np.empty(temperature_star.shape) * np.nan
return rho_star
def fisher_information_matrix(self, theta):
n_params = len(np.atleast_1d(theta))
fisher = np.empty(shape=(n_params, n_params))
grad_mean = self.mean.gradient(*theta)
mean = self.mean(*theta)
for i in range(n_params):
for j in range(i, n_params):
fisher[i, j] = (grad_mean[i] * grad_mean[j] / mean).sum()
fisher[j, i] = fisher[i, j]
return len(self.data) * fisher / (1 - self.mean(*theta))
def test_policy(p,
n,
visible=False,
sd=0.03,
bottom=False,
nlm=None,
Top=False):
system = CartPole(visual=visible)
#system.setState(np.array([0,0.01,-0.01,-0.01]))
system.setState(
np.array([
random.normalvariate(0, sd),
random.normalvariate(0, sd),
random.normalvariate(0, sd),
random.normalvariate(0, sd)
]))
if nlm != None and Top == False: bottom = True
if bottom:
system.setState(np.array([0, 0, np.pi, 0]))
#sd=1
#system.setState(np.array([random.normalvariate(0, sd), random.normalvariate(0, sd), np.pi ,random.normalvariate(0, sd)]))
#system.setState(np.array([-5.5,-3.36,-0.56,0.42]))
state_history = np.empty((n, 4))
#system.setState(np.array([0, 0, 0,5.1]))
#system.setState(np.array([0, 0.2, 0.05, -0.2])*5)
# system.setState(np.array([0, 0.2, 1, -4]) ) #get it to 1 rad at -4rads^1 and itll settle
for i in range(n):
x = system.getState()
if x.ndim == 1:
state_history[i, :] = x
else:
state_history[i, :] = x.reshape((4))
if nlm == None:
force = np.matmul(p, x)
else:
x_ext = nlm.transform_x(x)
force = np.matmul(p, x_ext)
#state_history[i,2]=force
system.performAction(force)
system.remap_angle()
plt.plot(state_history[:, 2], label=r'$\theta$')
plt.plot(state_history[:, 1], label='v')
plt.plot(state_history[:, 3], label=r'$\dot{\theta}$')
plt.plot(state_history[:, 0], label='x')
plt.xlabel('Iteration')
#plt.ylabel(r'$\theta$')
plt.legend(loc='lower left')
plt.title('P=' + str(p))
#plt.ylim([-0.2,0.2])
plt.show()
def parse_display(spec):
mean = np.array(ast.literal_eval(read(
spec['mean']))) if 'mean' in spec else np.array([0])
std = np.array(ast.literal_eval(read(
spec['std']))) if 'std' in spec else np.array([1])
resolution = np.array(ast.literal_eval(read(
spec['resolution']))) if 'resolution' in spec else np.empty(0)
display = Display(mean, std, resolution)
return display
def train_lstm(self):
num_epochs = 100
# sanity check: check the shape of train input, train output, and test input
# print('shape of train input: {0}, train output: {1}, test input: {2}'.format(self.train_input.shape, self.train_output.shape, self.test_input.shape))
callbacks = [EarlyStopping(monitor='val_loss', patience=10)]
iter_cnt = 0
pred_train_output_mat = np.empty((0, self.len_train_output), np.float)
pred_test_output_mat = np.empty((0, self.num_output), np.float)
while iter_cnt < self.num_ensemble:
self.history = self.model.fit(self.train_input, self.train_output, validation_split=0.15, shuffle=False,
batch_size=1, epochs=num_epochs, callbacks=callbacks, verbose=0)
# get the predicted train output
pred_train_output = self.model.predict(self.train_input)
pred_train_output_mat = np.zeros(shape=(self.num_output, self.len_train_output), dtype=np.float)
pred_train_output_mat.fill(np.nan)
for i in range(self.num_sequence):
seq_pred_train_output = post_process_results(pred_train_output[i],
denom=self.train_denom_list[i],
ts_seasonality_in=self.ts_seasonality_in,
shift=i,
freq=self.freq).ravel()
pred_train_output_mat[i % self.num_output, i: i + self.num_output] = seq_pred_train_output
iter_pred_train_output = np.nanmean(pred_train_output_mat, axis=0)
iter_train_smape, _ = smape(self.true_train_output, iter_pred_train_output)
if iter_train_smape < 150:
# get the predicted test output
iter_pred_test_output = self.model.predict(self.test_input).ravel()
iter_pred_test_output = post_process_results(iter_pred_test_output,
denom=self.test_denom,
ts_seasonality_in=self.ts_seasonality_in,
shift=self.len_train_output,
freq=self.freq).ravel()
pred_train_output_mat = np.vstack((pred_train_output_mat, iter_pred_train_output))
pred_test_output_mat = np.vstack((pred_test_output_mat, iter_pred_test_output))
iter_cnt += 1
self.pred_train_output = np.nanmean(pred_train_output_mat, axis=0)
self.pred_test_output = np.nanmean(pred_test_output_mat, axis=0)
def lds_simulate_loop(T, A, C, Q, R, mu0, Q0, ntrials):
# write version that broadcasts over trials at some point
d = A.shape[1]
D = C.shape[0]
x = np.empty((ntrials, T, d))
y = np.empty((ntrials, T, D))
L_R = np.linalg.cholesky(R)
L_Q = np.linalg.cholesky(Q)
for n in range(ntrials):
x[n,0] = np.random.multivariate_normal(mu0, cov=Q0)
y[n,0] = np.dot(C, x[n,0]) + np.dot(L_R, np.random.randn(D))
for t in range(1, T):
x[n,t] = np.dot(A[t-1], x[n,t-1]) + np.dot(L_Q[t-1], np.random.randn(d))
y[n,t] = np.dot(C, x[n,t]) + np.dot(L_R, np.random.randn(D))
return x, y
def general_rank_2_QN(k,f,gradient,c,x_0, init_b0):
# B_0 is our HESSIAN approximation (NOT hessian inverse). This is very critical!
B_0 = init_b0
counter = 0
x_k = x_0
B_k = B_0
cond = True
# Initalize the plots
x_iterates = np.empty((k + 1, 2))
x_iterates[0] = x_0
'''
Inner function which specifies the update rule
'''
def update(B_k, y_k, s_k ):
return rank_2_B_update(B_k, y_k, s_k, s_k)
pass
while cond:
# new iterates
search_direction = np.linalg.solve(B_k, gradient(x_k))
x_k_and_1 = x_k - search_direction #equiv to finding B^{-1} * grad. equiv again to solving B\delta = grad; for \delta
# compute k+1 quantities
y_k = gradient(x_k_and_1) - gradient(x_k)
s_k = x_k_and_1 - x_k
# Terminate if we have converged in finite steps
if not np.any(s_k):
# Fix rest of iterates to the converged value
for j in range(counter, k+1):
x_iterates[j] = x_k
break
# compute the next B_{k+1} iteration
B_k_and_1 = update(B_k, y_k, s_k )
# update the matrix:
B_k = B_k_and_1
x_k = x_k_and_1
# logic for checking whether to terminate or not
not_done = True
counter += 1
cond = counter < k and not_done
x_iterates[counter] = x_k
return x_k, x_iterates
def epeps(pepsa, pepsb):
shape = pepsa.shape
epeps = np.empty(shape, dtype=np.object)
for i in range(shape[0]):
for j in range(shape[1]):
epeps[i, j] = einsum("pludr,pLUDR->lLuUdDrR", pepsa[i, j],
pepsb[i, j])
eshape = epeps[i, j].shape
epeps[i, j] = np.reshape(
epeps[i, j], (eshape[0] * eshape[1], eshape[2] * eshape[3],
eshape[4] * eshape[5], eshape[6] * eshape[7]))
return epeps
def gd(n,f,dfdx,x_start,GD_alpha):
# Initialize xs
xs = np.empty((n + 1, 2))
xs[0] = x_start
# Get gradient at start location (df/dx or grad(f))
for i in range(n):
gs = dfdx(xs[i])
# Compute search direction and magnitude (dx)
# with dx = - grad but no line searching
xs[i + 1] = xs[i] - np.dot(GD_alpha, dfdx(xs[i]))
return xs
def __init__(self, X_L, y_L, X_H, y_H):
self.D = X_H.shape[1]
self.X_L = X_L
self.y_L = y_L
self.X_H = X_H
self.y_H = y_H
self.L = np.empty([0,0])
self.hyp = self.init_params()
print("Total number of parameters: %d" % (self.hyp.shape[0]))
self.jitter = 1e-8
def gradient_descent(m, lambda_flows, grad_energy_bound, samples):
'''
Gradient descent for finding parameters. This may not work anymore since switching over
to the Adam optimizer.
'''
energy_hist = np.empty(m)
joint_hist = np.empty(m)
flow_hist = np.empty(m)
lambda_hist = np.empty((m, *lambda_flows.shape))
samples_flowed = samples
for i in tqdm(range(m)):
beta = min(1, 0.01 + i / 10000)
samples_flowed = flow_samples(lambda_flows, samples, h)
gradient = grad_energy_bound(lambda_flows, samples, h, beta)
lambda_flows -= step_size * gradient
#lambda_flows = autograd.misc.optimizers.adam(grad_energy_bound, lambda_flows)
# Debug
energy_hist[i] = energy_bound(lambda_flows, samples, h)
joint_hist[i] = get_joint_exp(lambda_flows, samples, h)
flow_hist[i] = get_flow_exp(lambda_flows, samples, h)
lambda_hist[i] = lambda_flows
# Plot
if i % 20 == 0:
if (i == 0):
leading_zeros = int(np.log(m) / np.log(10))
elif (i == 1000):
leading_zeros = int(np.log(m) / np.log(10)) - int(
np.log(i) / np.log(10)) - 1
else:
leading_zeros = int(np.log(m) / np.log(10)) - int(
np.log(i) / np.log(10))
zeros = '0' * leading_zeros
ax = setup_plot(u_func)
ax.scatter(samples_flowed[:, 0], samples_flowed[:, 1], alpha=.5)
plt.savefig("./plots/{}{}.png".format(zeros, i))
plt.close()
def _ntied_transmat(self, transmat_val): # TODO: document choices
# +-----------------+
# |a|1|0|0|0|0|0|0|0|
# +-----------------+
# |0|a|1|0|0|0|0|0|0|
# +-----------------+
# +---+---+---+ |0|0|a|b|0|0|c|0|0|
# | a | b | c | +-----------------+
# +-----------+ |0|0|0|e|1|0|0|0|0|
# | d | e | f | +----> +-----------------+
# +-----------+ |0|0|0|0|e|1|0|0|0|
# | g | h | i | +-----------------+
# +---+---+---+ |d|0|0|0|0|e|f|0|0|
# +-----------------+
# |0|0|0|0|0|0|i|1|0|
# +-----------------+
# |0|0|0|0|0|0|0|i|1|
# +-----------------+
# |g|0|0|h|0|0|0|0|i|
# +-----------------+
# for a model with n_unique = 3 and n_tied = 2
transmat = np.empty((0, self.n_components))
for r in range(self.n_unique):
row = np.empty((self.n_chain, 0))
for c in range(self.n_unique):
if r == c:
subm = np.array(sp.diags([transmat_val[r, c],
1 - transmat_val[r, c]], [0, 1],
shape=(self.n_chain,
self.n_chain)).todense())
else:
lower_left = np.zeros((self.n_chain, self.n_chain))
lower_left[self.n_tied, 0] = 1.0
subm = np.kron(transmat_val[r, c], lower_left)
row = np.hstack((row, subm))
transmat = np.vstack((transmat, row))
return transmat
def _ntied_transmat(self, transmat_val): # TODO: document choices
# +-----------------+
# |a|1|0|0|0|0|0|0|0|
# +-----------------+
# |0|a|1|0|0|0|0|0|0|
# +-----------------+
# +---+---+---+ |0|0|a|b|0|0|c|0|0|
# | a | b | c | +-----------------+
# +-----------+ |0|0|0|e|1|0|0|0|0|
# | d | e | f | +----> +-----------------+
# +-----------+ |0|0|0|0|e|1|0|0|0|
# | g | h | i | +-----------------+
# +---+---+---+ |d|0|0|0|0|e|f|0|0|
# +-----------------+
# |0|0|0|0|0|0|i|1|0|
# +-----------------+
# |0|0|0|0|0|0|0|i|1|
# +-----------------+
# |g|0|0|h|0|0|0|0|i|
# +-----------------+
# for a model with n_unique = 3 and n_tied = 2
transmat = np.empty((0, self.n_components))
for r in range(self.n_unique):
row = np.empty((self.n_chain, 0))
for c in range(self.n_unique):
if r == c:
subm = np.array(
sp.diags([transmat_val[r, c], 1 - transmat_val[r, c]],
[0, 1],
shape=(self.n_chain, self.n_chain)).todense())
else:
lower_left = np.zeros((self.n_chain, self.n_chain))
lower_left[self.n_tied, 0] = 1.0
subm = np.kron(transmat_val[r, c], lower_left)
row = np.hstack((row, subm))
transmat = np.vstack((transmat, row))
return transmat
def alleged_BFGS(n, f, dfdx,x_start, TEMP_B0, BFGS_alpha):
# Initialize delta_xq and gamma
delta_xq = np.zeros((2, 1))
gamma = np.zeros((2, 1))
part1 = np.zeros((2, 2))
part2 = np.zeros((2, 2))
part3 = np.zeros((2, 2))
part4 = np.zeros((2, 2))
part5 = np.zeros((2, 2))
part6 = np.zeros((2, 1))
part7 = np.zeros((1, 1))
part8 = np.zeros((2, 2))
part9 = np.zeros((2, 2))
# Initialize xq
xq = np.empty((n + 1, 2))
xq[0] = x_start
# Initialize gradient storage
g = np.zeros((n + 1, 2))
g[0] = dfdx(xq[0])
# Initialize hessian storage
h = np.zeros((n + 1, 2, 2))
h[0] = TEMP_B0
for i in range(n):
search_dirn = np.linalg.solve(h[i], g[i])
# Compute search direction and magnitude (dx)
# with dx = -alpha * inv(h) * grad
delta_xq = -np.dot(BFGS_alpha[i], np.linalg.solve(h[i], g[i]))
# delta_xq = - np.linalg.solve(h[i], g[i])
xq[i + 1] = xq[i] + delta_xq
# Get gradient update for next step
g[i + 1] = dfdx(xq[i + 1])
# Get hessian update for next step
gamma = g[i + 1] - g[i]
part1 = np.outer(gamma, gamma)
part2 = np.outer(gamma, delta_xq)
part3 = np.dot(np.linalg.pinv(part2), part1)
part4 = np.outer(delta_xq, delta_xq)
part5 = np.dot(h[i], part4)
part6 = np.dot(part5, h[i])
part7 = np.dot(delta_xq, h[i])
part8 = np.dot(part7, delta_xq)
part9 = np.dot(part6, 1 / part8)
h[i + 1] = h[i] + part3 - part9
return xq
def grassman_cost_function(self, W):
new_X = np.dot(self.db['Dloader'].X, W)
σ = self.db['Dloader'].σ
γ = self.db['compute_γ']()
# compute gaussian kernel
bs = new_X.shape[0]
K = np.empty((0, bs))
for i in range(bs):
Δx = new_X[i, :] - new_X
exp_val = -np.sum(Δx * Δx, axis=1) / (2 * σ * σ)
K = np.vstack((K, e**(exp_val)))
return -np.sum(γ * K)
def __init__(self, order, precision, reg=5e-3, process_noise=.01, loss_threshold=.001, color=-1):
super(Bezier, self).__init__()
self.bernstein = get_bernstein(precision=precision, order=order)
self.controls = np.empty((order, 2))
self.cloud = None
self.reg = reg
self.loss_threshold = loss_threshold
self.filter = KalmanFilter(dimension=order, process_noise=process_noise)
self.color = COLORS[color]
def test_multivariate_normal_logpdf_unique_params(D=10):
# Test broadcasting over datapoints and corresponding parameters
leading_ndim = npr.randint(1, 4)
shp = npr.randint(1, 10, size=leading_ndim)
x = npr.randn(*shp, D)
mu = npr.randn(*shp, D)
L = npr.randn(*shp, D, D)
Sigma = np.matmul(L, np.swapaxes(L, -1, -2))
ll1 = multivariate_normal_logpdf(x, mu, Sigma)
ll2 = np.empty(shp)
for inds in product(*[np.arange(s) for s in shp]):
ll2[inds] = mvn.logpdf(x[inds], mu[inds], Sigma[inds])
assert np.allclose(ll1, ll2)
def run_dataset(prob_label):
"""Run the experiment"""
list_ss = get_sample_source_list(prob_label)
dimensions = [ss.dim() for ss in list_ss]
# /////// submit jobs //////////
# create folder name string
home = os.path.expanduser("~")
foldername = os.path.join(home, "freqopttest_slurm", 'e%d'%ex)
logger.info("Setting engine folder to %s" % foldername)
# create parameter instance that is needed for any batch computation engine
logger.info("Creating batch parameter instance")
batch_parameters = BatchClusterParameters(
foldername=foldername, job_name_base="e%d_"%ex, parameter_prefix="")
# Use the following line if Slurm queue is not used.
#engine = SerialComputationEngine()
engine = SlurmComputationEngine(batch_parameters)
n_methods = len(method_job_funcs)
# repetitions x len(dimensions) x #methods
aggregators = np.empty((reps, len(dimensions), n_methods ), dtype=object)
for r in range(reps):
for di, d in enumerate(dimensions):
for mi, f in enumerate(method_job_funcs):
# name used to save the result
func_name = f.__name__
fname = '%s-%s-J%d_r%d_n%d_d%d_a%.3f_trp%.2f.p' \
%(prob_label, func_name, J, r, sample_size, d, alpha, tr_proportion)
if not is_rerun and glo.ex_file_exists(ex, prob_label, fname):
logger.info('%s exists. Load and return.'%fname)
test_result = glo.ex_load_result(ex, prob_label, fname)
sra = SingleResultAggregator()
sra.submit_result(SingleResult(test_result))
aggregators[r, di, mi] = sra
else:
# result not exists or rerun
job = Ex2Job(SingleResultAggregator(), list_ss[di],
prob_label, r, f)
agg = engine.submit_job(job)
aggregators[r, di, mi] = agg
# let the engine finish its business
logger.info("Wait for all call in engine")
engine.wait_for_all()
# ////// collect the results ///////////
logger.info("Collecting results")
test_results = np.empty((reps, len(dimensions), n_methods), dtype=object)
for r in range(reps):
for di, d in enumerate(dimensions):
for mi, f in enumerate(method_job_funcs):
logger.info("Collecting result (%s, r=%d, d=%d)" % (f.__name__, r, d))
# let the aggregator finalize things
aggregators[r, di, mi].finalize()
# aggregators[i].get_final_result() returns a SingleResult instance,
# which we need to extract the actual result
test_result = aggregators[r, di, mi].get_final_result().result
test_results[r, di, mi] = test_result
func_names = [f.__name__ for f in method_job_funcs]
func2labels = exglobal.get_func2label_map()
method_labels = [func2labels[f] for f in func_names if f in func2labels]
# save results
results = {'test_results': test_results, 'dimensions': dimensions,
'alpha': alpha, 'J': J, 'list_sample_source': list_ss,
'tr_proportion': tr_proportion, 'method_job_funcs': method_job_funcs,
'prob_label': prob_label, 'sample_size': sample_size,
'method_labels': method_labels}
# class name
fname = 'ex2-%s-me%d_J%d_rs%d_n%d_dmi%d_dma%d_a%.3f_trp%.2f.p' \
%(prob_label, n_methods, J, reps, sample_size, min(dimensions),
max(dimensions), alpha, tr_proportion)
glo.ex_save_result(ex, results, fname)
logger.info('Saved aggregated results to %s'%fname)
def diagonal_covariance(self, test_points):
ret = np.empty((test_points.shape[0], 1))
for i in xrange(test_points.shape[0]):
_, cov = self.no_obs_posterior(test_points[i, :][None, :])
ret[i, 0] = cov
return ret
def cross(a,b):
out = np.empty(3)
out[0] = a[1]*b[2] - a[2]*b[1]
out[1] = a[2]*b[0] - a[0]*b[2]
out[2] = a[0]*b[1] - a[1]*b[0]
return out