def Q1E_report(train_images, train_labels, test_images, test_labels,
theta_map):
#average for train
log_likelihood_train = find_log_likelihood(train_images, theta_map, 1 / 10)
avg_likelihood_train = avg_likelihood(train_images, train_labels,
log_likelihood_train)
print("Avg train log likelihood ", avg_likelihood_train)
#average for test
log_likelihood_test = find_log_likelihood(test_images, theta_map, 1 / 10)
avg_likelihood_test = avg_likelihood(test_images, test_labels,
log_likelihood_test)
print("Avg test log likelihood ", avg_likelihood_test)
#predictions for train
predict_train = predict(train_images, theta_map, log_likelihood_train)
total_correct_train = np.sum(
np.nonzero(predict_train)[1] == np.nonzero(train_labels)
[1]) #get total number of correct predictions
accuracy_train = total_correct_train / float(
train_labels.shape[0]) #get accuracy
print('Train Accuracy ', accuracy_train)
#predictions for test
predict_test = predict(test_images, theta_map, log_likelihood_test)
total_correct_test = np.sum(
np.nonzero(predict_test)[1] == np.nonzero(test_labels)
[1]) #get total number of correct predictions
accuracy_test = total_correct_test / float(
test_labels.shape[0]) #get accuracy
print('Test Accuracy ', accuracy_test)
def Q3D_report(train_images, train_labels, test_images, test_labels, w):
#average for train
avg_likelihood_train = avg_pred_log(w, train_images)
print("Avg train log likelihood ", avg_likelihood_train)
#average for test
avg_likelihood_test = avg_pred_log(w, test_images)
print("Avg test log likelihood ", avg_likelihood_test)
#predictions for train
predict_train = predict_regression(train_images, w)
total_correct_train = np.sum(
np.nonzero(predict_train)[1] == np.nonzero(train_labels)
[1]) #get total number of correct predictions
accuracy_train = total_correct_train / float(
train_labels.shape[0]) #get accuracy
print('Train Accuracy ', accuracy_train)
#predictions for test
predict_test = predict_regression(test_images, w)
total_correct_test = np.sum(
np.nonzero(predict_test)[1] == np.nonzero(test_labels)
[1]) #get total number of correct predictions
accuracy_test = total_correct_test / float(
test_labels.shape[0]) #get accuracy
print('Test Accuracy ', accuracy_test)
def get_neighs(vertex, r):
verts = list()
# level_0
verts.append(vertex)
v = vertex
# find closest point in level 1
if sparse.issparse(adj_mtx):
nz = adj_mtx.tolil().rows
ix_list = nz[v]
else:
row = adj_mtx[v]
ix_list = np.nonzero(row)
ix_list = ix_list[0]
dists = []
for j in ix_list:
d = get_dist(coords, v, j)
dists.append(d)
ix_min = ix_list[dists.index(min(dists))]
closest_ix = ix_min
# levels_>=1
for i in range(1, r + 1):
# this is the closest vertex of the new level
# find the ordering of the level
arr = get_order(adj_mtx, coords, ix_list, closest_ix, verts)
verts = verts + arr
# get next level: for each in ix_list, get neighbors that are not in <verts>, then add them to the new list
next_list = []
for j in ix_list:
if sparse.issparse(adj_mtx):
new_row = nz[j]
else:
new_row = adj_mtx[j]
new_row = np.nonzero(new_row)
new_row = new_row[0]
for k in new_row:
if k not in verts:
next_list.append(k)
next_list = list(set(next_list))
# find starting point of next level using line eq
c1 = coords[vertex]
c2 = coords[closest_ix]
line_dists = []
for j in next_list:
c3 = coords[j]
line_dist = LA.norm(np.cross(c2 - c1, c1 - c3)) / LA.norm(
c2 - c1) # calculate distance to line
line_dists.append(line_dist)
ix_list = next_list
closest_ix = next_list[line_dists.index(min(line_dists))]
return verts
def aveFreqDomain(X, SR):
#X = zoInterp(X,2);
x_new = np.tile(x, (numInterp, 1))
X = reshape(x_new, (1, []))
L = X.size
Y = np.fft(X)
P2 = np.abs(Y / L)
P1 = P2[0:L / 2 + 1]
P1[1:-1] = 2 * P1[1:-1]
f = SR * np.arange(L / 2) / L
y = np.zeros((1, 5))
begin = []
stop = []
for i in np.arange(5):
if i == 1:
begin = np.nonzero(np.floor(f) == 5)
begin = begin[0]
stop = np.nonzero(np.floor(f) == 15)
stop = stop[0]
y[0] = np.mean(P1[begin:stop + 1])
elif i == 2:
begin = np.nonzero(np.floor(f) == 20)
begin = begin[0]
stop = np.nonzero(np.floor(f) == 25)
stop = stop[0]
y[1] = np.mean(P1[begin:stop + 1])
elif i == 3:
begin = np.nonzero(np.floor(f) == 75)
begin = begin[0]
stop = np.nonzero(np.floor(f) == 115)
stop = stop[0]
y(3) = np.mean(P1[begin:stop + 1])
elif i == 4:
begin = np.nonzero(np.floor(f) == 125)
begin = begin[0]
stop = np.nonzero(np.floor(f) == 160)
stop = stop[0]
y(4) = np.mean(P1[begin:stop + 1])
elif i == 5:
begin = np.nonzero(np.floor(f) == 160)
begin = begin[0]
stop = np.nonzero(np.floor(f) == 175)
stop = stop[0]
y(5) = np.mean(P1[begin:stop + 1])
return y
def loss_augmented_inference(self, x, y, w, relaxed=False, return_energy=False):
"""Loss-augmented Inference for x relative to y using parameters w.
Finds (approximately)
argmax_y_hat np.dot(w, joint_feature(x, y_hat)) + loss(y, y_hat)
using self.inference_method.
"""
self.inference_calls += 1
self._check_size_w(w) # check if size of w is equal to size of joint feature
# need to compute the joint feature and hinge loss
# return self.loss_augmented_inference_graph_iht(x, y, w, relaxed=relaxed)
# y_hat = x
# y_hat = np.random.rand(len(y))
y_hat = np.zeros_like(y)
yt = np.copy(y_hat)
max_iter = 1000
for iter in range(max_iter):
print("iter {}".format(iter))
print("yt {}\n{}".format(yt, np.nonzero(yt)))
y_prev = np.copy(yt)
gradient = self._get_cost_augment_grad(x, y, w, yt)
print("gradient {}".format(gradient))
yt = yt + 0.001 * gradient
yt[yt <= 0.] = 0.
yt[yt >= 1.0] = 1.0
gap_y = np.linalg.norm(yt - y_prev) ** 2
if gap_y < 1e-6:
break
return yt
def test_PhotometricError(iref, inew, R, T, points, D):
h = 1e-7
hh = 1.0 / h
E0, g0 = PhotometricError(iref, inew, R, T, points, D)
Erx, Ery, Erz = 0, 0, 0
Erx = hh * (PhotometricError(iref, inew, R + np.array([h, 0, 0]), T,
points, D)[0] - E0)
Ery = hh * (PhotometricError(iref, inew, R + np.array([0, h, 0]), T,
points, D)[0] - E0)
Erz = hh * (PhotometricError(iref, inew, R + np.array([0, 0, h]), T,
points, D)[0] - E0)
Etx = hh * (PhotometricError(iref, inew, R, T + np.array([h, 0, 0]),
points, D)[0] - E0)
Ety = hh * (PhotometricError(iref, inew, R, T + np.array([0, h, 0]),
points, D)[0] - E0)
Etz = hh * (PhotometricError(iref, inew, R, T + np.array([0, 0, h]),
points, D)[0] - E0)
n = np.nonzero(g0[6:])[0][0]
print 'nonzero point', n
D[n] += h
Ed = hh * (PhotometricError(iref, inew, R, T, points, D)[0] - E0)
print 'E', E0, 'g:', g0[:7]
print 'numerical gR: (%f %f %f)' % (Erx, Ery, Erz)
print 'numerical gT: (%f %f %f)' % (Etx, Ety, Etz)
print 'numerical D: %f' % Ed
print 'Error_R: (%f %f %f)' % (Erx - g0[0], Ery - g0[1], Erz - g0[2])
print 'Error_T: (%f %f %f)' % (Etx - g0[3], Ety - g0[4], Etz - g0[5])
print 'Error_D:', (Ed - g0[6 + n])
def param_to_tree(param, sparse_info, single_tree):
# we want to iterate over model info and replace it so that we have something that can be compared
# this only works for binary class for now
# this is due to laziness, and difficulty to compare multiclass?
coef, inter, leaf = param
thresholds = (-inter / coef).tolist()
leaves = (leaf).tolist()
tree = copy.deepcopy(single_tree)
# now figure out the columns
feat_splits = []
for col_idx in range(sparse_info.shape[1]):
split_indx = np.nonzero(sparse_info[:, col_idx])[0].tolist()[0]
feat_splits.append(split_indx)
# now combine it all based on model_info...
for idx, threshold in enumerate(thresholds):
# iterate through the tree and replace where
# split_index == idx
tree = update_tree_info(tree.copy(), idx, threshold, feat_splits[idx])
for idx, value in enumerate(leaves):
# iterate through the tree and replace where
# split_index == idx
tree = update_leaf_info(tree.copy(), idx, value)
return tree
def test_PhotometricError(iref, inew, R, T, points, D):
h = 1e-7
hh = 1.0 / h
E0, g0 = PhotometricError(iref, inew, R, T, points, D)
Erx, Ery, Erz = 0, 0, 0
Erx = hh * (PhotometricError(
iref, inew, R + np.array([h, 0, 0]), T, points, D)[0] - E0)
Ery = hh * (PhotometricError(
iref, inew, R + np.array([0, h, 0]), T, points, D)[0] - E0)
Erz = hh * (PhotometricError(
iref, inew, R + np.array([0, 0, h]), T, points, D)[0] - E0)
Etx = hh * (PhotometricError(
iref, inew, R, T + np.array([h, 0, 0]), points, D)[0] - E0)
Ety = hh * (PhotometricError(
iref, inew, R, T + np.array([0, h, 0]), points, D)[0] - E0)
Etz = hh * (PhotometricError(
iref, inew, R, T + np.array([0, 0, h]), points, D)[0] - E0)
n = np.nonzero(g0[6:])[0][0]
print 'nonzero point', n
D[n] += h
Ed = hh * (PhotometricError(iref, inew, R, T, points, D)[0] - E0)
print 'E', E0, 'g:', g0[:7]
print 'numerical gR: (%f %f %f)' % (Erx, Ery, Erz)
print 'numerical gT: (%f %f %f)' % (Etx, Ety, Etz)
print 'numerical D: %f' % Ed
print 'Error_R: (%f %f %f)' % (Erx - g0[0], Ery - g0[1], Erz - g0[2])
print 'Error_T: (%f %f %f)' % (Etx - g0[3], Ety - g0[4], Etz - g0[5])
print 'Error_D:', (Ed - g0[6 + n])
def cost(self, controls, states, system_eval_step):
"""
Compute the penalty.
Arguments:
controls
states
system_eval_step
Returns:
cost
"""
cost = 0
# Iterate over the controls, penalize each control that has
# frequencies greater than its maximum frequency.
for i, max_bandwidth in enumerate(self.max_bandwidths):
control_fft = anp.fft.fft(controls[:, i])
control_fft_sq = anp.abs(control_fft)
penalty_freq_indices = anp.nonzero(self.freqs >= max_bandwidth)[0]
penalized_ffts = control_fft_sq[penalty_freq_indices]
penalty = anp.sum(penalized_ffts)
penalty_normalized = penalty / (penalty_freq_indices.shape[0] *
anp.max(penalized_ffts))
cost = cost + penalty_normalized
cost_normalized = cost / self.control_count
return cost_normalized * self.cost_multiplier
def _calculate_observables(self, state):
# Note that this is very different from the original paper, which uses an observation model tailored to the
# collected data
# Proportion of individuals with the most common strain (Numminem cross-check)
strain_observations = np.sum(state, axis=0)
most_common_strain = np.argmax(strain_observations)
prevalence_most_common_strain = np.sum(state[:, most_common_strain],
dtype=np.float) / float(
self.n_individuals)
# Number of singleton strains (= only on 1 individual, Numminem cross-check)
n_singleton_strains = np.sum(strain_observations == 1)
# Number of observed strains (Numminen 2)
n_observed_strains = len(
strain_observations[np.nonzero(strain_observations)])
# Shannon entropy of observed strain distribution (Numminen 1)
p_observed_strains = strain_observations[np.nonzero(
strain_observations)] # Remove zeros
p_observed_strains = p_observed_strains.astype(np.float) / float(
np.sum(p_observed_strains)) # Normalize
shannon_entropy = -np.sum(
p_observed_strains * np.log(p_observed_strains))
# Any / multiple infections of individuals
any_infection = (np.sum(state, axis=1) > 0)
multiple_infections = (np.sum(state, axis=1) > 1)
# Prevalence of any infection (Numminen 3)
prevalence_any = np.sum(any_infection,
dtype=np.float) / self.n_individuals
# Prevalence of multiple infections (Numminen 4)
prevalence_multiple = np.sum(multiple_infections,
dtype=np.float) / self.n_individuals
# Combine summary statistics
summary_statistics = np.array([
shannon_entropy, n_observed_strains, prevalence_any,
prevalence_multiple, prevalence_most_common_strain,
n_singleton_strains
])
return summary_statistics
def _get_nu_star(self, x, y):
"""Compute nu_star if not provided by the problem's solver."""
if np.all(np.abs(self.fY(x, y)) < self.eps):
return np.nan # flag that unconstrained gradient should be used
indx = np.nonzero(self.hY(x, y))
if len(indx[0]) == 0:
return 0.0 # still use constrained gradient
return self.fY(x, y)[indx[0][0]] / self.hY(x, y)[indx[0][0]]
def PhotometricError(iref, inew, R, T, points, D):
# points is a tuple ([y], [x]); convert to homogeneous
siz = iref.shape
npoints = len(points[0])
f = siz[1] # focal length, FIXME
Xref = np.vstack(((points[1] - siz[1]*0.5) / f, # x
(siz[0]*0.5 - points[0]) / f, # y (left->right hand)
np.ones(npoints))) # z = 1
# this is confusingly written -- i am broadcasting the translation T to
# every column, but numpy broadcasting only works if it's rows, hence all
# the transposes
# print D * Xref
Xnew = (np.dot(so3.exp(R), (D * Xref)).T + T).T
# print Xnew
# right -> left hand projection
proj = Xnew[0:2] / Xnew[2]
p = (-proj[1]*f + siz[0]*0.5, proj[0]*f + siz[1]*0.5)
margin = 10 # int(siz[0] / 5)
inwindow_mask = ((p[0] >= margin) & (p[0] < siz[0]-margin-1) &
(p[1] >= margin) & (p[1] < siz[1]-margin-1))
npts_inw = sum(inwindow_mask)
if npts_inw < 10:
return 1e6, np.zeros(6 + npoints)
# todo: filter points which are now out of the window
oldpointidxs = (points[0][inwindow_mask],
points[1][inwindow_mask])
newpointidxs = (p[0][inwindow_mask], p[1][inwindow_mask])
origpointidxs = np.nonzero(inwindow_mask)[0]
E = InterpolatedValues(inew, newpointidxs) - iref[oldpointidxs]
# dE/dk ->
# d/dk r_p^2 = d/dk (Inew(w(r, T, D, p)) - Iref(p))^2
# = -2r_p dInew/dp dp/dw dw/dX dX/dk
# = -2r_p * g(w(r, T, D, p)) * dw(r, T, D, p)
# intensity gradients for each point
Ig = InterpolatedGradients(inew, newpointidxs)
# TODO: use tensors for this
# gradients for R, T, and D
gradient = np.zeros(6 + npoints)
for i in range(npts_inw):
# print 'newidx (y,x) = ', newpointidxs[0][i], newpointidxs[1][i]
# Jacobian of w
oi = origpointidxs[i]
Jw = dw(Xref[0][oi], Xref[1][oi], D[oi], R, T)
# scale back up into pixel space, right->left hand coords to get
# Jacobian of p
Jp = f * np.vstack((-Jw[1], Jw[0]))
# print origpointidxs[i], 'Xref', Xref[:, i], 'Ig', Ig[:, i], \
# 'dwdRz', Jw[:, 2], 'dpdRz', Jp[:, 2]
# full Jacobian = 2*E + Ig * Jp
J = np.sign(E[i]) * np.dot(Ig[:, i], Jp)
# print '2 E[i]', 2*E[i], 'Ig*Jp', np.dot(Ig[:, i], Jp)
gradient[:6] += J[:6]
# print J[:6]
gradient[6+origpointidxs[i]] += J[6]
print R, T, np.sum(np.abs(E)), npts_inw
# return ((0.2*(npoints - npts_inw) + np.dot(E, E)), gradient)
return np.sum(np.abs(E)) / (npts_inw), gradient / (npts_inw)
def PhotometricError(iref, inew, R, T, points, D):
# points is a tuple ([y], [x]); convert to homogeneous
siz = iref.shape
npoints = len(points[0])
f = siz[1] # focal length, FIXME
Xref = np.vstack((
(points[1] - siz[1] * 0.5) / f, # x
(siz[0] * 0.5 - points[0]) / f, # y (left->right hand)
np.ones(npoints))) # z = 1
# this is confusingly written -- i am broadcasting the translation T to
# every column, but numpy broadcasting only works if it's rows, hence all
# the transposes
# print D * Xref
Xnew = (np.dot(so3.exp(R), (D * Xref)).T + T).T
# print Xnew
# right -> left hand projection
proj = Xnew[0:2] / Xnew[2]
p = (-proj[1] * f + siz[0] * 0.5, proj[0] * f + siz[1] * 0.5)
margin = 10 # int(siz[0] / 5)
inwindow_mask = ((p[0] >= margin) & (p[0] < siz[0] - margin - 1) &
(p[1] >= margin) & (p[1] < siz[1] - margin - 1))
npts_inw = sum(inwindow_mask)
if npts_inw < 10:
return 1e6, np.zeros(6 + npoints)
# todo: filter points which are now out of the window
oldpointidxs = (points[0][inwindow_mask], points[1][inwindow_mask])
newpointidxs = (p[0][inwindow_mask], p[1][inwindow_mask])
origpointidxs = np.nonzero(inwindow_mask)[0]
E = InterpolatedValues(inew, newpointidxs) - iref[oldpointidxs]
# dE/dk ->
# d/dk r_p^2 = d/dk (Inew(w(r, T, D, p)) - Iref(p))^2
# = -2r_p dInew/dp dp/dw dw/dX dX/dk
# = -2r_p * g(w(r, T, D, p)) * dw(r, T, D, p)
# intensity gradients for each point
Ig = InterpolatedGradients(inew, newpointidxs)
# TODO: use tensors for this
# gradients for R, T, and D
gradient = np.zeros(6 + npoints)
for i in range(npts_inw):
# print 'newidx (y,x) = ', newpointidxs[0][i], newpointidxs[1][i]
# Jacobian of w
oi = origpointidxs[i]
Jw = dw(Xref[0][oi], Xref[1][oi], D[oi], R, T)
# scale back up into pixel space, right->left hand coords to get
# Jacobian of p
Jp = f * np.vstack((-Jw[1], Jw[0]))
# print origpointidxs[i], 'Xref', Xref[:, i], 'Ig', Ig[:, i], \
# 'dwdRz', Jw[:, 2], 'dpdRz', Jp[:, 2]
# full Jacobian = 2*E + Ig * Jp
J = np.sign(E[i]) * np.dot(Ig[:, i], Jp)
# print '2 E[i]', 2*E[i], 'Ig*Jp', np.dot(Ig[:, i], Jp)
gradient[:6] += J[:6]
# print J[:6]
gradient[6 + origpointidxs[i]] += J[6]
print R, T, np.sum(np.abs(E)), npts_inw
# return ((0.2*(npoints - npts_inw) + np.dot(E, E)), gradient)
return np.sum(np.abs(E)) / (npts_inw), gradient / (npts_inw)
def normalise_points(pts):
"""
Function translates and normalises a set of 2D or 3d homogeneous points
so that their centroid is at the origin and their mean distance from
the origin is sqrt(2). This process typically improves the
conditioning of any equations used to solve homographies, fundamental
matrices etc.
Inputs:
pts: 3xN array of 2D homogeneous coordinates
Returns:
newpts: 3xN array of transformed 2D homogeneous coordinates. The
scaling parameter is normalised to 1 unless the point is at
infinity.
T: The 3x3 transformation matrix, newpts = T*pts
"""
if pts.shape[0] == 4:
pts = hom_3d_to_2d(pts)
if pts.shape[0] != 3 and pts.shape[0] != 4 :
print "Shape error"
finiteind = np.nonzero(abs(pts[2,:]) > np.spacing(1))
if len(finiteind[0]) != pts.shape[1]:
print('Some points are at infinity')
dist = []
pts = pts/pts[2,:]
for i in finiteind:
#Replaced below for autograd
# pts[0,i] = pts[0,i]/pts[2,i]
# pts[1,i] = pts[1,i]/pts[2,i]
# pts[2,i] = 1;
c = np.mean(pts[0:2,i].T, axis=0).T
newp1 = pts[0,i]-c[0]
newp2 = pts[1,i]-c[1]
dist.append(np.sqrt(newp1**2 + newp2**2))
dist = np.array(dist)
meandist = np.mean(dist)
scale = np.sqrt(2)/meandist
T = np.array([[scale, 0, -scale*c[0]], [0, scale, -scale*c[1]], [0, 0, 1]])
newpts = np.dot(T,pts)
return newpts, T
def get_orthogonality_score(C_matrix, verbose=True):
"""
Gets the angle between each subspace and the other ones.
Note the we leave the diagonal as zeros, because the angles are 1 anyway
And it helps to have a more representative mean.
"""
in_degree = True
len_1, len_2 = C_matrix.shape
orthogonality_matrix = np.zeros((len_2, len_2))
for lat_i in range(0, len_2):
for lat_j in range(lat_i + 1, len_2):
angle = np.dot(C_matrix[:, lat_i], C_matrix[:, lat_j]) / (np.dot(
np.linalg.norm(C_matrix[:, lat_i]),
np.linalg.norm(C_matrix[:, lat_j])))
orthogonality_matrix[lat_i, lat_j] = np.arccos(np.abs(angle))
orthogonality_matrix[lat_j, lat_i] = np.arccos(np.abs(angle))
if in_degree:
orthogonality_matrix = 180 * orthogonality_matrix / np.pi
mean_per_sub_space = np.sum(np.abs(orthogonality_matrix), 1) / (len_2 - 1)
glob_mean = np.mean(mean_per_sub_space)
try:
all_non_diag = orthogonality_matrix.flatten()
all_non_diag = all_non_diag[np.nonzero(all_non_diag)]
tenth_percentil = np.percentile(all_non_diag, 25)
ninetith_percentil = np.percentile(all_non_diag, 75)
small_avr = np.average(
all_non_diag,
weights=(all_non_diag <= tenth_percentil).astype(int))
high_avr = np.average(
all_non_diag,
weights=(all_non_diag >= ninetith_percentil).astype(int))
except:
small_avr = glob_mean
high_avr = glob_mean
if verbose:
print(np.around(orthogonality_matrix, 2))
print("Mean abs angle per subspace: ", mean_per_sub_space)
print("Mean abs angle overall: ", glob_mean)
#print("Std abs angle overall: ", np.std(mean_per_sub_space))
# print(small_avr, high_avr)
if len_2 <= 1:
glob_mean = small_avr = high_avr = 0
return glob_mean, small_avr, high_avr
def map_to_index_set(_map, threshold=0.9, max_set_size=K):
thresholded_map = np.where(_map > threshold, _map, 0.0)
map_diagonal = np.diag(thresholded_map)
assert np.array_equal(np.diag(map_diagonal), thresholded_map)
nonzeros = np.nonzero(map_diagonal)[0]
assert len(nonzeros) <= max_set_size
index_set = tuple(nonzeros)
return index_set
def lossfunction_all(rating_matrix, movie_vectors, user_vectors, flag):
if flag == 1: # used in user tree construction, user_vectors is a 1*K vector
user_vectors = np.array(
[user_vectors for i in range(len(rating_matrix))])
if flag == 0: # used in item tree construction, movie_vectors is a 1*K vector
movie_vectors = np.array(
[movie_vectors for i in range(rating_matrix.shape[1])])
value = 0
# Add regularization term
user_l = user_vectors[np.nonzero(user_vectors)]
value = value + lmd_u * np.dot(user_l, user_l)
mov_l = movie_vectors[np.nonzero(movie_vectors)]
value = value + lmd_v * np.dot(mov_l, mov_l)
if len(rating_matrix) == 0:
return value
predict = np.dot(user_vectors, movie_vectors.T)
P = predict[np.nonzero(rating_matrix)]
R = rating_matrix[np.nonzero(rating_matrix)]
Err = P - R
value = value + np.dot(Err, Err)
np.random.seed(0)
num_pair = 20
num_user, num_item = rating_matrix.shape
for i in range(num_pair):
c1, c2 = np.random.randint(0, num_item * num_user, 2)
u1, i1 = c1 // num_item, c1 % num_item
u2, i2 = c2 // num_item, c2 % num_item
if rating_matrix[u1][i1] > rating_matrix[u2][i2]:
diff = np.dot(user_vectors[u1, :].T,
movie_vectors[i1, :]) - np.dot(
user_vectors[u2, :].T, movie_vectors[i2, :])
diff = -diff
value = value + lmd_BPR * np.log(1 + np.exp(diff))
return value
def normalise_points_RadiusScale(pts, radius):
"""
Function translates and normalises a set of 2D or 3d homogeneous points
so that their centroid is at the origin
Add radius(distance between camera and marker) as one influenced factor of Scale
This process typically improves the
conditioning of any equations used to solve homographies, fundamental
matrices etc.
Inputs:
pts: 3xN array of 2D homogeneous coordinates
Returns:
newpts: 3xN array of transformed 2D homogeneous coordinates. The
scaling parameter is normalised to 1 unless the point is at
infinity.
"""
if pts.shape[0] == 4:
pts = hom_3d_to_2d(pts)
if pts.shape[0] != 3 and pts.shape[0] != 4:
print "Shape error"
finiteind = np.nonzero(abs(pts[2, :]) > np.spacing(1))
if len(finiteind[0]) != pts.shape[1]:
print('Some points are at infinity')
dist = []
pts = pts / pts[2, :]
for i in finiteind:
c = np.mean(pts[0:2, i].T, axis=0).T
newp1 = pts[0, i] - c[0]
newp2 = pts[1, i] - c[1]
dist.append(np.sqrt(newp1**2 + newp2**2))
dist = np.array(dist)
meandist = np.mean(dist)
# scale = np.sqrt(2) / meandist # translate and scaling
# scale = 1 # Only translate, no scaling
scale = radius * np.sqrt(
2
) / meandist # translate and set the scale increasing with the radius(distance from cam to marker)
T = np.array([[scale, 0, -scale * c[0]], [0, scale, -scale * c[1]],
[0, 0, 1]])
newpts = np.dot(T, pts)
return newpts, T
def find_argmax(natparam_grad, num_nodes):
"""Given the gradient of tree_categorical_maximum w.r.t. the natural
parameters, finds the argmax of the tree categorical's log-joint."""
not_found = set(
range(num_nodes)) # haven't found the argmax for these nodes
argmax = [0 for _ in range(num_nodes)]
factor_iter = chain(natparam_grad.single_onehot_xis.iteritems(),
natparam_grad.joint_onehot_xis.iteritems())
while not_found:
factor, param = factor_iter.next()
if not_found.intersection(set(factor)):
nonzero = np.nonzero(param)
for i, node in enumerate(factor):
argmax[node] = int(nonzero[i][0])
not_found.discard(node)
return argmax
def __init__(self, vec, other_vec, whole, otherwhole, actInd, **kwargs):
actInd = (int(actInd[0]), int(actInd[1]))
DistanceMat = np.array([[distance(i, j) for j in otherwhole]
for i in whole])
# print("Mindistance:", np.min(DistanceMat))
# print("len(whole),len(otherwhole)",len(whole),len(otherwhole))
insectPT = np.nonzero(
DistanceMat < INTERSECTLIM) # The index of the intersection point
try:
insectPT = (insectPT[0][0], insectPT[1][0])
except IndexError: # the case where is no pair of points fall in the threshold, find the least distance point instead
insectPT = np.unravel_index(np.argmin(DistanceMat, axis=None),
DistanceMat.shape)
egopath = whole[actInd[0]:insectPT[0]]
otherpath = otherwhole[actInd[1]:insectPT[1]]
# path a None in is just to call the lambda function
egoPTs = np.sum(
(self._distance(self._diff(lambda x: egopath[:, 0]),
self._diff(lambda y: egopath[:, 1])))(None))
otherPTs = np.sum(
self._distance(self._diff(lambda x: otherpath[:, 0]),
self._diff(lambda y: otherpath[:, 1]))(None))
otherDistance = self._cumsum(
self._distance(
self._diff(lambda x: otherwhole[actInd[1]:, 0]),
self._diff(lambda y: otherwhole[actInd[1]:, 1])))(None)
self.other_vec = other_vec
self.whole = whole
self.otherwhole = otherwhole
self.actInd = actInd
self.insectPT = insectPT
self.egoPTs = egoPTs
self.otherPTs = otherPTs
self.otherDistance = otherDistance
super().__init__(vec,
other_vec,
whole=whole,
otherwhole=otherwhole,
actInd=actInd,
intersectInd=insectPT,
intersectPTs=(self.egoPTs, self.otherPTs),
otherDist=otherDistance,
**kwargs)
def aff2rfnorm(aff):
"""Mirror plane normal vector and point from affine `aff`
Parameters
----------
aff : array-like, shape (4,4)
Returns
-------
normal : array shape (3,)
vector normal to point (and therefore mirror plane).
point : array shape (3,)
x, y, x coordinates of point that, together with normal, define the
reflection plane.
Raises
------
ValueError
If there is no eigenvector for ``aff[:3,:3]`` with eigenvalue -1
ValueError
If determinant of ``aff[:3, :3]`` is not close to -1
ValueError
If there is no eigenvector for `aff` with eigenvalue 1.
Examples
--------
>>> v0 = np.random.random(3) - 0.5
>>> v1 = np.random.random(3) - 0.5
>>> M0 = rfnorm2aff(v0, v1)
>>> normal, point = aff2rfnorm(M0)
>>> M1 = rfnorm2aff(normal, point)
>>> np.allclose(M0, M1)
True
"""
aff = np.asarray(aff)
normal = mat2rfnorm(aff[:3, :3])
# point: any unit eigenvector corresponding to eigenvalue 1
l, V = np.linalg.eig(aff)
near_1, = np.nonzero(abs(np.real(l.squeeze()) - 1.0) < 1e-8)
if near_1.size == 0:
raise ValueError("no eigenvector corresponding to eigenvalue 1")
point = np.real(V[:, near_1[-1]]).squeeze()
point = point[:3] / point[3]
return normal, point
def mat2rfnorm(mat):
"""Mirror plane normal vector from `mat` matrix.
Parameters
----------
mat : array-like, shape (3,3)
Returns
-------
normal : array shape (3,)
vector normal to point (and therefore mirror plane)
Raises
------
ValueError
If there is no eigenvector with eigenvalue -1
ValueError
If determinant of `mat` is not close to -1
Examples
--------
>>> normal = np.random.random(3) - 0.5
>>> M0 = rfnorm2mat(normal)
>>> normal = mat2rfnorm(M0)
>>> M1 = rfnorm2mat(normal)
>>> np.allclose(M0, M1)
True
"""
mat = np.asarray(mat)
# normal: unit eigenvector corresponding to eigenvalue -1
L, V = np.linalg.eig(mat)
m1_factors, = np.nonzero(abs(np.real(L.squeeze()) + 1.0) < 1e-8)
if m1_factors.size == 0:
raise ValueError("no unit eigenvector corresponding to eigenvalue -1")
if not np.abs(np.prod(L) + 1) < 1e-8:
raise ValueError('Determinant should be -1')
return np.real(V[:, m1_factors[0]]).squeeze()
def alternateOptimization(opinion_matrix, opinion_matrix_I, rating_matrix,
NUM_OF_FACTORS, MAX_DEPTH, File):
# Save and print the Number of Users and Movies
NUM_USERS = rating_matrix.shape[0]
NUM_MOVIES = rating_matrix.shape[1]
NUM_FEATURE = opinion_matrix.shape[1]
print("Number of Users", NUM_USERS)
print("Number of Item", NUM_MOVIES)
print("Number of Feature", NUM_FEATURE)
print("Number of Latent Factors: ", NUM_OF_FACTORS)
# Create the user and item profile vector of appropriate size.
# Initialize the item vectors according to MF
user_vectors, item_vectors = MF(20, 0.05, 0.02, 0.02, 50, File)
#user_vectors = np.random.rand(NUM_USERS, NUM_OF_FACTORS)
#item_vectors = np.random.rand(NUM_MOVIES, NUM_OF_FACTORS)
i = 0
print("Entering Main Loop of alternateOptimization")
decTree = dtree.Tree(dtree.Node(None, 1), NUM_OF_FACTORS, MAX_DEPTH)
# Do converge Check
while i < 5:
# Create the decision Tree based on item_vectors
print("Creating Tree.. for i = ", i, "for user")
decTree = dtree.Tree(dtree.Node(None, 1), NUM_OF_FACTORS, MAX_DEPTH)
decTree.fitTree_U(decTree.root, opinion_matrix, rating_matrix,
item_vectors, NUM_OF_FACTORS)
print("Getting the user vectors from tree")
# Calculate the User vectors using dtree
user_vectors_before = user_vectors
user_vectors = decTree.getVectors_f(opinion_matrix, NUM_OF_FACTORS)
# adding personalized term
for index in range(len(rating_matrix)):
indice = np.array([index])
user_vectors[index] = opt.cf_user(rating_matrix, item_vectors,
user_vectors[index], indice,
NUM_OF_FACTORS)
print("Creating Tree.. for i = ", i, "for item")
decTreeI = dtree.Tree(dtree.Node(None, 1), NUM_OF_FACTORS, MAX_DEPTH)
decTreeI.fitTree_I(decTreeI.root, opinion_matrix_I, rating_matrix,
user_vectors, NUM_OF_FACTORS)
print("Getting the item vectors from tree")
item_vectors_before = item_vectors
item_vectors = decTreeI.getVectors_f(opinion_matrix_I, NUM_OF_FACTORS)
for index in range(len(rating_matrix[0])):
indice = np.array([index])
item_vectors[index] = opt.cf_item(rating_matrix, user_vectors,
item_vectors[index], indice,
NUM_OF_FACTORS)
# Calculate Error for Convergence check
Pred_before = np.dot(user_vectors_before, item_vectors_before.T)
Pred = np.dot(user_vectors, item_vectors.T)
Error = Pred_before - Pred
Error = Error[np.nonzero(Error)]
error = np.dot(Error, Error)
if error < 0.1:
break
i = i + 1
return decTree, decTreeI, user_vectors, item_vectors
save_images(sample[0, :, :], 'a3plotsample.png')
## uncomment for Question 2f)
# plot_posterior_contours(mean_params,logstd_params)
print(iter)
print(objective(var_params,iter))
# The optimizers provided by autograd can optimize lists, tuples, or dicts of parameters.
# You may use these optimizers for Q4, but implement your own gradient descent optimizer for Q3!
optimized_params = adam(objective_grad, init_params, step_size=0.05, num_iters=60, callback=print_perf)
#predictions for test
predict_test = predict_regression(test_images, np.transpose(optimized_params[0])) #A3 q1/A2 code
total_correct_test = np.sum(np.nonzero(predict_test)[1] == np.nonzero(test_labels)[1]) #get total number of correct predictions
accuracy_test = total_correct_test/float(test_labels.shape[0]) #get accuracy
print('\nTest Accuracy ',accuracy_test)
##testing a bunch of std values, std = 1 is best with 77.68% and std =9 is second best 77.09%
#for i in range(1,10):
#prior_std = i**2 # from 5 to 100
#print(prior_std)
#optimized_params = adam(objective_grad, init_params, step_size=0.05, num_iters=100, callback=print_perf)
#predict_test = predict_regression(test_images, np.transpose(optimized_params[0])) #A3 q1/A2 code
#total_correct_test = np.sum(np.nonzero(predict_test)[1] == np.nonzero(test_labels)[1]) #get total number of correct predictions
#accuracy_test = total_correct_test/float(test_labels.shape[0]) #get accuracy
#print('\nTest Accuracy ',accuracy_test)
#prior_std = 1/i**2 #from 1 to 1/100
#print(prior_std)
def reconstruct_ptychography(
# ______________________________________
# |Raw data and experimental parameters|________________________________
fname, probe_pos, probe_size, obj_size, theta_st=0, theta_end=PI, n_theta=None, theta_downsample=None,
energy_ev=5000, psize_cm=1e-7, free_prop_cm=None,
# ___________________________
# |Reconstruction parameters|___________________________________________
n_epochs='auto', crit_conv_rate=0.03, max_nepochs=200, alpha_d=None, alpha_b=None,
gamma=1e-6, learning_rate=1.0, minibatch_size=None, multiscale_level=1, n_epoch_final_pass=None,
initial_guess=None, n_batch_per_update=1, reweighted_l1=False, interpolation='bilinear',
# ___________________________
# |Finite support constraint|___________________________________________
finite_support_mask_path=None, shrink_cycle=None, shrink_threshold=1e-9,
# ___________________
# |Object contraints|
object_type='normal',
# _______________
# |Forward model|_______________________________________________________
forward_algorithm='fresnel', binning=1, fresnel_approx=False, pure_projection=False, two_d_mode=False,
probe_type='gaussian', probe_initial=None,
# _____
# |I/O|_________________________________________________________________
save_path='.', output_folder=None, save_intermediate=False, full_intermediate=False, use_checkpoint=True,
save_stdout=False,
# _____________
# |Performance|_________________________________________________________
cpu_only=False, core_parallelization=True, shared_file_object=True, n_dp_batch=20,
# __________________________
# |Object optimizer options|____________________________________________
optimizer='adam',
# _________________________
# |Other optimizer options|_____________________________________________
probe_learning_rate=1e-3,
optimize_probe_defocusing=False, probe_defocusing_learning_rate=1e-5,
optimize_probe_pos_offset=False,
# ________________
# |Other settings|______________________________________________________
dynamic_rate=True, pupil_function=None, probe_circ_mask=0.9, dynamic_dropping=False, dropping_threshold=8e-5,
**kwargs,):
# ______________________________________________________________________
"""
Notes:
1. Input data are assumed to be contained in an HDF5 under 'exchange/data', as a 4D dataset of
shape [n_theta, n_spots, detector_size_y, detector_size_x].
2. Full-field reconstruction is treated as ptychography. If the image is not divided, the programs
runs as if it is dealing with ptychography with only 1 spot per angle.
3. Full-field reconstruction with minibatch_size > 1 but without image dividing is not supported.
In this case, minibatch_size will be forced to be 1, so that each rank process only one
rotation angle's image at a time. To perform large fullfield reconstruction efficiently,
divide the data into sub-chunks.
4. Full-field reconstruction using shared_file_mode but without image dividing is not recommended
even if minibatch_size is 1. In shared_file_mode, all ranks process data from the same rotation
angle in each synchronized batch. Doing this will cause all ranks to process the same data.
To perform large fullfield reconstruction efficiently, divide the data into sub-chunks.
"""
def calculate_loss(obj_delta, obj_beta, probe_real, probe_imag, probe_defocus_mm, probe_pos_offset, this_i_theta, this_pos_batch, this_prj_batch):
if optimize_probe_defocusing:
h_probe = get_kernel(probe_defocus_mm * 1e6, lmbda_nm, voxel_nm, probe_size, fresnel_approx=fresnel_approx)
probe_complex = probe_real + 1j * probe_imag
probe_complex = np.fft.ifft2(np.fft.ifftshift(np.fft.fftshift(np.fft.fft2(probe_complex)) * h_probe))
probe_real = np.real(probe_complex)
probe_imag = np.imag(probe_complex)
if optimize_probe_pos_offset:
this_pos_batch = this_pos_batch + probe_pos_offset[this_i_theta]
if not shared_file_object:
obj_stack = np.stack([obj_delta, obj_beta], axis=3)
if not two_d_mode:
obj_rot = apply_rotation(obj_stack, coord_ls[this_i_theta])
# obj_rot = sp_rotate(obj_stack, theta, axes=(1, 2), reshape=False)
else:
obj_rot = obj_stack
probe_pos_batch_ls = []
exiting_ls = []
i_dp = 0
while i_dp < minibatch_size:
probe_pos_batch_ls.append(this_pos_batch[i_dp:min([i_dp + n_dp_batch, minibatch_size])])
i_dp += n_dp_batch
# Pad if needed
obj_rot, pad_arr = pad_object(obj_rot, this_obj_size, probe_pos, probe_size)
for k, pos_batch in enumerate(probe_pos_batch_ls):
subobj_ls = []
for j in range(len(pos_batch)):
pos = pos_batch[j]
pos = [int(x) for x in pos]
pos[0] = pos[0] + pad_arr[0, 0]
pos[1] = pos[1] + pad_arr[1, 0]
subobj = obj_rot[pos[0]:pos[0] + probe_size[0], pos[1]:pos[1] + probe_size[1], :, :]
subobj_ls.append(subobj)
subobj_ls = np.stack(subobj_ls)
exiting = multislice_propagate_batch_numpy(subobj_ls[:, :, :, :, 0], subobj_ls[:, :, :, :, 1], probe_real,
probe_imag, energy_ev, psize_cm * ds_level, kernel=h, free_prop_cm=free_prop_cm,
obj_batch_shape=[len(pos_batch), *probe_size, this_obj_size[-1]],
fresnel_approx=fresnel_approx, pure_projection=pure_projection)
exiting_ls.append(exiting)
exiting_ls = np.concatenate(exiting_ls, 0)
loss = np.mean((np.abs(exiting_ls) - np.abs(this_prj_batch)) ** 2)
else:
probe_pos_batch_ls = []
exiting_ls = []
i_dp = 0
while i_dp < minibatch_size:
probe_pos_batch_ls.append(this_pos_batch[i_dp:min([i_dp + n_dp_batch, minibatch_size])])
i_dp += n_dp_batch
pos_ind = 0
for k, pos_batch in enumerate(probe_pos_batch_ls):
subobj_ls_delta = obj_delta[pos_ind:pos_ind + len(pos_batch), :, :, :]
subobj_ls_beta = obj_beta[pos_ind:pos_ind + len(pos_batch), :, :, :]
exiting = multislice_propagate_batch_numpy(subobj_ls_delta, subobj_ls_beta, probe_real,
probe_imag, energy_ev, psize_cm * ds_level, kernel=h,
free_prop_cm=free_prop_cm,
obj_batch_shape=[len(pos_batch), *probe_size,
this_obj_size[-1]],
fresnel_approx=fresnel_approx,
pure_projection=pure_projection)
exiting_ls.append(exiting)
pos_ind += len(pos_batch)
exiting_ls = np.concatenate(exiting_ls, 0)
loss = np.mean((np.abs(exiting_ls) - np.abs(this_prj_batch)) ** 2)
# dxchange.write_tiff(abs(exiting_ls._value[0]), output_folder + '/det/det', dtype='float32', overwrite=True)
# raise
# Regularization
if reweighted_l1:
if alpha_d not in [None, 0]:
loss = loss + alpha_d * np.mean(weight_l1 * np.abs(obj_delta))
if alpha_b not in [None, 0]:
loss = loss + alpha_b * np.mean(weight_l1 * np.abs(obj_beta))
else:
if alpha_d not in [None, 0]:
loss = loss + alpha_d * np.mean(np.abs(obj_delta))
if alpha_b not in [None, 0]:
loss = loss + alpha_b * np.mean(np.abs(obj_beta))
if gamma not in [None, 0]:
if shared_file_object:
loss = loss + gamma * total_variation_3d(obj_delta, axis_offset=1)
else:
loss = loss + gamma * total_variation_3d(obj_delta, axis_offset=0)
# Write convergence data
global current_loss
current_loss = loss._value
f_conv.write('{},{},{},'.format(i_epoch, i_batch, current_loss))
f_conv.flush()
return loss
comm = MPI.COMM_WORLD
n_ranks = comm.Get_size()
rank = comm.Get_rank()
t_zero = time.time()
timestr = str(datetime.datetime.today())
timestr = timestr[:timestr.find('.')]
for i in [':', '-', ' ']:
if i == ' ':
timestr = timestr.replace(i, '_')
else:
timestr = timestr.replace(i, '')
# ================================================================================
# Create pointer for raw data.
# ================================================================================
t0 = time.time()
print_flush('Reading data...', 0, rank)
f = h5py.File(os.path.join(save_path, fname), 'r')
prj = f['exchange/data']
if n_theta is None:
n_theta = prj.shape[0]
if two_d_mode:
n_theta = 1
prj_theta_ind = np.arange(n_theta, dtype=int)
theta = -np.linspace(theta_st, theta_end, n_theta, dtype='float32')
if theta_downsample is not None:
theta = theta[::theta_downsample]
prj_theta_ind = prj_theta_ind[::theta_downsample]
n_theta = len(theta)
original_shape = [n_theta, *prj.shape[1:]]
print_flush('Data reading: {} s'.format(time.time() - t0), 0, rank)
print_flush('Data shape: {}'.format(original_shape), 0, rank)
comm.Barrier()
not_first_level = False
stdout_options = {'save_stdout': save_stdout, 'output_folder': output_folder,
'timestamp': timestr}
n_pos = len(probe_pos)
probe_pos = np.array(probe_pos)
# ================================================================================
# Batching check.
# ================================================================================
if minibatch_size > 1 and n_pos == 1:
warnings.warn('It seems that you are processing undivided fullfield data with'
'minibatch > 1. A rank can only process data from the same rotation'
'angle at a time. I am setting minibatch_size to 1.')
minibatch_size = 1
if shared_file_object and n_pos == 1:
warnings.warn('It seems that you are processing undivided fullfield data with'
'shared_file_object=True. In shared-file mode, all ranks must'
'process data from the same rotation angle in each synchronized'
'batch.')
# ================================================================================
# Set output folder name if not specified.
# ================================================================================
if output_folder is None:
output_folder = 'recon_{}'.format(timestr)
if abs(PI - theta_end) < 1e-3:
output_folder += '_180'
print_flush('Output folder is {}'.format(output_folder), 0, rank)
if save_path != '.':
output_folder = os.path.join(save_path, output_folder)
for ds_level in range(multiscale_level - 1, -1, -1):
# ================================================================================
# Set metadata.
# ================================================================================
ds_level = 2 ** ds_level
print_flush('Multiscale downsampling level: {}'.format(ds_level), 0, rank, **stdout_options)
comm.Barrier()
prj_shape = original_shape
if ds_level > 1:
this_obj_size = [int(x / ds_level) for x in obj_size]
else:
this_obj_size = obj_size
dim_y, dim_x = prj_shape[-2:]
if minibatch_size is None:
minibatch_size = n_pos
comm.Barrier()
# ================================================================================
# Create output directory.
# ================================================================================
if rank == 0:
try:
os.makedirs(os.path.join(output_folder))
except:
print('Target folder {} exists.'.format(output_folder))
comm.Barrier()
# ================================================================================
# Create object function optimizer.
# ================================================================================
if optimizer == 'adam':
opt = AdamOptimizer([*this_obj_size, 2], output_folder=output_folder)
optimizer_options_obj = {'step_size': learning_rate,
'shared_file_object': shared_file_object}
elif optimizer == 'gd':
opt = GDOptimizer([*this_obj_size, 2], output_folder=output_folder)
optimizer_options_obj = {'step_size': learning_rate,
'dynamic_rate': True,
'first_downrate_iteration': 20 * max([ceil(n_pos / (minibatch_size * n_ranks)), 1])}
if shared_file_object:
opt.create_file_objects(use_checkpoint=use_checkpoint)
else:
if use_checkpoint:
try:
opt.restore_param_arrays_from_checkpoint()
except:
opt.create_param_arrays()
else:
opt.create_param_arrays()
# ================================================================================
# Read rotation data.
# ================================================================================
try:
coord_ls = read_all_origin_coords('arrsize_{}_{}_{}_ntheta_{}'.format(*this_obj_size, n_theta),
n_theta)
except:
if rank == 0:
print_flush('Saving rotation coordinates...', 0, rank, **stdout_options)
save_rotation_lookup(this_obj_size, n_theta)
comm.Barrier()
coord_ls = read_all_origin_coords('arrsize_{}_{}_{}_ntheta_{}'.format(*this_obj_size, n_theta),
n_theta)
# ================================================================================
# Unify random seed for all threads.
# ================================================================================
comm.Barrier()
seed = int(time.time() / 60)
np.random.seed(seed)
comm.Barrier()
# ================================================================================
# Get checkpointed parameters.
# ================================================================================
starting_epoch, starting_batch = (0, 0)
needs_initialize = False if use_checkpoint else True
if use_checkpoint and shared_file_object:
try:
starting_epoch, starting_batch = restore_checkpoint(output_folder, shared_file_object)
except:
needs_initialize = True
elif use_checkpoint and (not shared_file_object):
try:
starting_epoch, starting_batch, obj_delta, obj_beta = restore_checkpoint(output_folder, shared_file_object, opt)
except:
needs_initialize = True
# ================================================================================
# Create object class.
# ================================================================================
obj = ObjectFunction([*this_obj_size, 2], shared_file_object=shared_file_object,
output_folder=output_folder, ds_level=ds_level, object_type=object_type)
if shared_file_object:
obj.create_file_object(use_checkpoint)
obj.create_temporary_file_object()
if needs_initialize:
obj.initialize_file_object(save_stdout=save_stdout, timestr=timestr,
not_first_level=not_first_level, initial_guess=initial_guess)
else:
if needs_initialize:
obj.initialize_array(save_stdout=save_stdout, timestr=timestr,
not_first_level=not_first_level, initial_guess=initial_guess)
else:
obj.delta = obj_delta
obj.beta = obj_beta
# ================================================================================
# Create gradient class.
# ================================================================================
gradient = Gradient(obj)
if shared_file_object:
gradient.create_file_object()
gradient.initialize_gradient_file()
else:
gradient.initialize_array_with_values(np.zeros(this_obj_size), np.zeros(this_obj_size))
# ================================================================================
# If a finite support mask path is specified (common for full-field imaging),
# create an instance of monochannel mask class. While finite_support_mask_path
# has to point to a 3D tiff file, the mask will be written as an HDF5 if
# share_file_mode is True.
# ================================================================================
mask = None
if finite_support_mask_path is not None:
mask = Mask(this_obj_size, finite_support_mask_path, shared_file_object=shared_file_object,
output_folder=output_folder, ds_level=ds_level)
if shared_file_object:
mask.create_file_object(use_checkpoint=use_checkpoint)
mask.initialize_file_object()
else:
mask_arr = dxchange.read_tiff(finite_support_mask_path)
mask.initialize_array_with_values(mask_arr)
# ================================================================================
# Initialize probe functions.
# ================================================================================
print_flush('Initialzing probe...', 0, rank, **stdout_options)
probe_real, probe_imag = initialize_probe(probe_size, probe_type, pupil_function=pupil_function, probe_initial=probe_initial,
save_stdout=save_stdout, output_folder=output_folder, timestr=timestr,
save_path=save_path, fname=fname, **kwargs)
# ================================================================================
# generate Fresnel kernel.
# ================================================================================
voxel_nm = np.array([psize_cm] * 3) * 1.e7 * ds_level
lmbda_nm = 1240. / energy_ev
delta_nm = voxel_nm[-1]
h = get_kernel(delta_nm * binning, lmbda_nm, voxel_nm, probe_size, fresnel_approx=fresnel_approx)
# ================================================================================
# Create other optimizers (probe, probe defocus, probe positions, etc.).
# ================================================================================
opt_arg_ls = [0, 1]
if probe_type == 'optimizable':
opt_probe = GDOptimizer([*probe_size, 2], output_folder=output_folder)
optimizer_options_probe = {'step_size': probe_learning_rate,
'dynamic_rate': True,
'first_downrate_iteration': 4 * max([ceil(n_pos / (minibatch_size * n_ranks)), 1])}
opt_arg_ls = opt_arg_ls + [2, 3]
opt_probe.set_index_in_grad_return(len(opt_arg_ls))
probe_defocus_mm = np.array(0.0)
if optimize_probe_defocusing:
opt_probe_defocus = GDOptimizer([1], output_folder=output_folder)
optimizer_options_probe_defocus = {'step_size': probe_defocusing_learning_rate,
'dynamic_rate': True,
'first_downrate_iteration': 4 * max([ceil(n_pos / (minibatch_size * n_ranks)), 1])}
opt_arg_ls.append(4)
opt_probe_defocus.set_index_in_grad_return(len(opt_arg_ls))
probe_pos_offset = np.zeros([n_theta, 2])
if optimize_probe_pos_offset:
opt_probe_pos_offset = GDOptimizer(probe_pos_offset.shape, output_folder=output_folder)
optimizer_options_probe_pos_offset = {'step_size': 0.5,
'dynamic_rate': False}
opt_arg_ls.append(5)
opt_probe_pos_offset.set_index_in_grad_return(len(opt_arg_ls))
# ================================================================================
# Get gradient of loss function w.r.t. optimizable variables.
# ================================================================================
loss_grad = grad(calculate_loss, opt_arg_ls)
# ================================================================================
# Save convergence data.
# ================================================================================
if rank == 0:
try:
os.makedirs(os.path.join(output_folder, 'convergence'))
except:
pass
comm.Barrier()
f_conv = open(os.path.join(output_folder, 'convergence', 'loss_rank_{}.txt'.format(rank)), 'w')
f_conv.write('i_epoch,i_batch,loss,time\n')
# ================================================================================
# Create parameter summary file.
# ================================================================================
print_flush('Optimizer started.', 0, rank, **stdout_options)
if rank == 0:
create_summary(output_folder, locals(), preset='ptycho')
# ================================================================================
# Start outer (epoch) loop.
# ================================================================================
cont = True
i_epoch = starting_epoch
m_p, v_p, m_pd, v_pd = (None, None, None, None)
while cont:
n_pos = len(probe_pos)
n_spots = n_theta * n_pos
n_tot_per_batch = minibatch_size * n_ranks
n_batch = int(np.ceil(float(n_spots) / n_tot_per_batch))
t0 = time.time()
spots_ls = range(n_spots)
ind_list_rand = []
t00 = time.time()
print_flush('Allocating jobs over threads...', 0, rank, **stdout_options)
# Make a list of all thetas and spot positions'
np.random.seed(i_epoch)
comm.Barrier()
if not two_d_mode:
theta_ls = np.arange(n_theta)
np.random.shuffle(theta_ls)
else:
theta_ls = np.linspace(0, 2 * PI, prj.shape[0])
theta_ls = abs(theta_ls - theta_st) < 1e-5
i_theta = np.nonzero(theta_ls)[0][0]
theta_ls = np.array([i_theta])
# ================================================================================
# Put diffraction spots from all angles together, and divide into minibatches.
# ================================================================================
for i, i_theta in enumerate(theta_ls):
spots_ls = range(n_pos)
# ================================================================================
# Append randomly selected diffraction spots if necessary, so that a rank won't be given
# spots from different angles in one batch.
# When using shared file object, we must also ensure that all ranks deal with data at the
# same angle at a time.
# ================================================================================
if not shared_file_object and n_pos % minibatch_size != 0:
spots_ls = np.append(spots_ls, np.random.choice(spots_ls,
minibatch_size - (n_pos % minibatch_size),
replace=False))
elif shared_file_object and n_pos % n_tot_per_batch != 0:
spots_ls = np.append(spots_ls, np.random.choice(spots_ls,
n_tot_per_batch - (n_pos % n_tot_per_batch),
replace=False))
# ================================================================================
# Create task list for the current angle.
# ind_list_rand is in the format of [((5, 0), (5, 1), ...), ((17, 0), (17, 1), ..., (...))]
# |___________________| |_____|
# a batch for all ranks _| |_ (i_theta, i_spot)
# (minibatch_size * n_ranks)
# ================================================================================
if i == 0:
ind_list_rand = np.vstack([np.array([i_theta] * len(spots_ls)), spots_ls]).transpose()
else:
ind_list_rand = np.concatenate(
[ind_list_rand, np.vstack([np.array([i_theta] * len(spots_ls)), spots_ls]).transpose()], axis=0)
ind_list_rand = split_tasks(ind_list_rand, n_tot_per_batch)
print_flush('Allocation done in {} s.'.format(time.time() - t00), 0, rank, **stdout_options)
current_i_theta = 0
for i_batch in range(starting_batch, n_batch):
# ================================================================================
# Initialize.
# ================================================================================
print_flush('Epoch {}, batch {} of {} started.'.format(i_epoch, i_batch, n_batch), 0, rank, **stdout_options)
opt.i_batch = 0
# ================================================================================
# Save checkpoint.
# ================================================================================
if shared_file_object:
save_checkpoint(i_epoch, i_batch, output_folder, shared_file_object=True,
obj_array=None, optimizer=opt)
obj.f.flush()
else:
save_checkpoint(i_epoch, i_batch, output_folder, shared_file_object=False,
obj_array=np.stack([obj.delta, obj.beta], axis=-1), optimizer=opt)
# ================================================================================
# Get scan position, rotation angle indices, and raw data for current batch.
# ================================================================================
t00 = time.time()
if len(ind_list_rand[i_batch]) < n_tot_per_batch:
n_supp = n_tot_per_batch - len(ind_list_rand[i_batch])
ind_list_rand[i_batch] = np.concatenate([ind_list_rand[i_batch], ind_list_rand[0][:n_supp]])
this_ind_batch = ind_list_rand[i_batch]
this_i_theta = this_ind_batch[rank * minibatch_size, 0]
this_ind_rank = np.sort(this_ind_batch[rank * minibatch_size:(rank + 1) * minibatch_size, 1])
this_pos_batch = probe_pos[this_ind_rank]
print_flush('Current rank is processing angle ID {}.'.format(this_i_theta), 0, rank, **stdout_options)
t_prj_0 = time.time()
this_prj_batch = prj[this_i_theta, this_ind_rank]
print_flush(' Raw data reading done in {} s.'.format(time.time() - t_prj_0), 0, rank, **stdout_options)
# ================================================================================
# In shared file mode, if moving to a new angle, rotate the HDF5 object and saved
# the rotated object into the temporary file object.
# ================================================================================
if shared_file_object and this_i_theta != current_i_theta:
current_i_theta = this_i_theta
print_flush(' Rotating dataset...', 0, rank, **stdout_options)
t_rot_0 = time.time()
obj.rotate_data_in_file(coord_ls[this_i_theta], interpolation=interpolation, dset_2=obj.dset_rot)
# opt.rotate_files(coord_ls[this_i_theta], interpolation=interpolation)
# if mask is not None: mask.rotate_data_in_file(coord_ls[this_i_theta], interpolation=interpolation)
comm.Barrier()
print_flush(' Dataset rotation done in {} s.'.format(time.time() - t_rot_0), 0, rank, **stdout_options)
if ds_level > 1:
this_prj_batch = this_prj_batch[:, :, ::ds_level, ::ds_level]
comm.Barrier()
if shared_file_object:
# ================================================================================
# Get values for local chunks of object_delta and beta; interpolate and read directly from HDF5
# ================================================================================
t_read_0 = time.time()
obj_rot = obj.read_chunks_from_file(this_pos_batch, probe_size, dset_2=obj.dset_rot)
print_flush(' Chunk reading done in {} s.'.format(time.time() - t_read_0), 0, rank, **stdout_options)
obj_delta = np.array(obj_rot[:, :, :, :, 0])
obj_beta = np.array(obj_rot[:, :, :, :, 1])
opt.get_params_from_file(this_pos_batch, probe_size)
else:
obj_delta = obj.delta
obj_beta = obj.beta
# Update weight for reweighted L1
if shared_file_object:
weight_l1 = np.max(obj_delta) / (abs(obj_delta) + 1e-8)
else:
if i_batch % 10 == 0: weight_l1 = np.max(obj_delta) / (abs(obj_delta) + 1e-8)
# ================================================================================
# Calculate object gradients.
# ================================================================================
t_grad_0 = time.time()
grads = loss_grad(obj_delta, obj_beta, probe_real, probe_imag, probe_defocus_mm, probe_pos_offset, this_i_theta, this_pos_batch, this_prj_batch)
print_flush(' Gradient calculation done in {} s.'.format(time.time() - t_grad_0), 0, rank, **stdout_options)
grads = list(grads)
# ================================================================================
# Reshape object gradient to [y, x, z, c] or [n, y, x, z, c] and average over
# ranks.
# ================================================================================
if shared_file_object:
obj_grads = np.stack(grads[:2], axis=-1)
else:
this_obj_grads = np.stack(grads[:2], axis=-1)
obj_grads = np.zeros_like(this_obj_grads)
comm.Barrier()
comm.Allreduce(this_obj_grads, obj_grads)
obj_grads = obj_grads / n_ranks
# ================================================================================
# Update object function with optimizer if not shared_file_object; otherwise,
# just save the gradient chunk into the gradient file.
# ================================================================================
if not shared_file_object:
effective_iter = i_batch // max([ceil(n_pos / (minibatch_size * n_ranks)), 1])
obj_temp = opt.apply_gradient(np.stack([obj_delta, obj_beta], axis=-1), obj_grads, effective_iter,
**optimizer_options_obj)
obj_delta = np.take(obj_temp, 0, axis=-1)
obj_beta = np.take(obj_temp, 1, axis=-1)
else:
t_grad_write_0 = time.time()
gradient.write_chunks_to_file(this_pos_batch, np.take(obj_grads, 0, axis=-1),
np.take(obj_grads, 1, axis=-1), probe_size,
write_difference=False)
print_flush(' Gradient writing done in {} s.'.format(time.time() - t_grad_write_0), 0, rank, **stdout_options)
# ================================================================================
# Nonnegativity and phase/absorption-only constraints for non-shared-file-mode,
# and update arrays in instance.
# ================================================================================
if not shared_file_object:
obj_delta = np.clip(obj_delta, 0, None)
obj_beta = np.clip(obj_beta, 0, None)
if object_type == 'absorption_only': obj_delta[...] = 0
if object_type == 'phase_only': obj_beta[...] = 0
obj.delta = obj_delta
obj.beta = obj_beta
# ================================================================================
# Optimize probe and other parameters if necessary.
# ================================================================================
if probe_type == 'optimizable':
this_probe_grads = np.stack(grads[2:4], axis=-1)
probe_grads = np.zeros_like(this_probe_grads)
comm.Allreduce(this_probe_grads, probe_grads)
probe_grads = probe_grads / n_ranks
probe_temp = opt_probe.apply_gradient(np.stack([probe_real, probe_imag], axis=-1), probe_grads, **optimizer_options_probe)
probe_real = np.take(probe_temp, 0, axis=-1)
probe_imag = np.take(probe_temp, 1, axis=-1)
if optimize_probe_defocusing:
this_pd_grad = np.array(grads[opt_probe_defocus.index_in_grad_returns])
pd_grads = np.array(0.0)
comm.Allreduce(this_pd_grad, pd_grads)
pd_grads = pd_grads / n_ranks
probe_defocus_mm = opt_probe_defocus.apply_gradient(probe_defocus_mm, pd_grads,
**optimizer_options_probe_defocus)
print_flush(' Probe defocus is {} mm.'.format(probe_defocus_mm), 0, rank,
**stdout_options)
if optimize_probe_pos_offset:
this_pos_offset_grad = np.array(grads[optimize_probe_pos_offset.index_in_grad_returns])
pos_offset_grads = np.zeros_like(probe_pos_offset)
comm.Allreduce(this_pos_offset_grad, pos_offset_grads)
pos_offset_grads = pos_offset_grads / n_ranks
probe_pos_offset = opt_probe_pos_offset.apply_gradient(probe_pos_offset, pos_offset_grads,
**optimizer_options_probe_pos_offset)
# ================================================================================
# For shared-file-mode, if finishing or above to move to a different angle,
# rotate the gradient back, and use it to update the object at 0 deg. Then
# update the object using gradient at 0 deg.
# ================================================================================
if shared_file_object and (i_batch == n_batch - 1 or ind_list_rand[i_batch + 1][0, 0] != current_i_theta):
coord_new = read_origin_coords('arrsize_{}_{}_{}_ntheta_{}'.format(*this_obj_size, n_theta),
this_i_theta, reverse=True)
print_flush(' Rotating gradient dataset back...', 0, rank, **stdout_options)
t_rot_0 = time.time()
# dxchange.write_tiff(gradient.dset[:, :, :, 0], 'adhesin/test_shared_file/grad_prerot', dtype='float32')
# gradient.reverse_rotate_data_in_file(coord_ls[this_i_theta], interpolation=interpolation)
gradient.rotate_data_in_file(coord_new, interpolation=interpolation)
# dxchange.write_tiff(gradient.dset[:, :, :, 0], 'adhesin/test_shared_file/grad_postrot', dtype='float32')
# comm.Barrier()
print_flush(' Gradient rotation done in {} s.'.format(time.time() - t_rot_0), 0, rank, **stdout_options)
t_apply_grad_0 = time.time()
opt.apply_gradient_to_file(obj, gradient, **optimizer_options_obj)
print_flush(' Object update done in {} s.'.format(time.time() - t_apply_grad_0), 0, rank, **stdout_options)
gradient.initialize_gradient_file()
# ================================================================================
# Apply finite support mask if specified.
# ================================================================================
if mask is not None:
if not shared_file_object:
obj.apply_finite_support_mask_to_array(mask)
else:
obj.apply_finite_support_mask_to_file(mask)
print_flush(' Mask applied.', 0, rank, **stdout_options)
# ================================================================================
# Update finite support mask if necessary.
# ================================================================================
if mask is not None and shrink_cycle is not None:
if i_batch % shrink_cycle == 0 and i_batch > 0:
if shared_file_object:
mask.update_mask_file(obj, shrink_threshold)
else:
mask.update_mask_array(obj, shrink_threshold)
print_flush(' Mask updated.', 0, rank, **stdout_options)
# ================================================================================
# Save intermediate object.
# ================================================================================
if rank == 0 and save_intermediate:
if shared_file_object:
dxchange.write_tiff(obj.dset[:, :, :, 0],
fname=os.path.join(output_folder, 'intermediate', 'current'.format(ds_level)),
dtype='float32', overwrite=True)
else:
dxchange.write_tiff(obj.delta,
fname=os.path.join(output_folder, 'intermediate', 'current'.format(ds_level)),
dtype='float32', overwrite=True)
comm.Barrier()
print_flush('Minibatch done in {} s; loss (rank 0) is {}.'.format(time.time() - t00, current_loss), 0, rank, **stdout_options)
f_conv.write('{}\n'.format(time.time() - t_zero))
f_conv.flush()
if n_epochs == 'auto':
pass
else:
if i_epoch == n_epochs - 1: cont = False
i_epoch = i_epoch + 1
average_loss = 0
print_flush(
'Epoch {} (rank {}); Delta-t = {} s; current time = {} s,'.format(i_epoch, rank,
time.time() - t0, time.time() - t_zero), **stdout_options)
if rank == 0 and save_intermediate:
if shared_file_object:
dxchange.write_tiff(obj.dset[:, :, :, 0],
fname=os.path.join(output_folder, 'delta_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
dxchange.write_tiff(obj.dset[:, :, :, 1],
fname=os.path.join(output_folder, 'beta_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
dxchange.write_tiff(np.sqrt(probe_real ** 2 + probe_imag ** 2),
fname=os.path.join(output_folder, 'probe_mag_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
dxchange.write_tiff(np.arctan2(probe_imag, probe_real),
fname=os.path.join(output_folder, 'probe_phase_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
else:
dxchange.write_tiff(obj.delta,
fname=os.path.join(output_folder, 'delta_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
dxchange.write_tiff(obj.beta,
fname=os.path.join(output_folder, 'beta_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
dxchange.write_tiff(np.sqrt(probe_real ** 2 + probe_imag ** 2),
fname=os.path.join(output_folder, 'probe_mag_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
dxchange.write_tiff(np.arctan2(probe_imag, probe_real),
fname=os.path.join(output_folder, 'probe_phase_ds_{}'.format(ds_level)),
dtype='float32', overwrite=True)
print_flush('Current iteration finished.', 0, rank, **stdout_options)
comm.Barrier()
w1_new = w1 - alpha * w1_delta
b1_new = b1 - alpha * b1_delta
w2_new = w2 - alpha * w2_delta
b2_new = b2 - alpha * b2_delta
new_theta = (w1_new, b1_new, w2_new, b2_new)
return new_theta
# Compute Gradient
grad_objective = grad(objective)
# Train the Neural Network
epochs = 50
Y_pred = np.argmax(neural_network(D[0], theta), axis=1)
print("Accuracy score before training:",
accuracy_score(np.nonzero(D[1])[1], Y_pred))
accuScore = []
for i in range(0, epochs):
print('Epoch: %d' % (i + 1))
for j in range(0, examples):
delta = grad_objective(theta, j)
theta = update_theta(theta, delta, 0.01)
Y_pred = np.argmax(neural_network(D[0], theta), axis=1)
accuScore.append(accuracy_score(np.nonzero(D[1])[1], Y_pred))
print("Accuracy score after training:",
accuracy_score(np.nonzero(D[1])[1], Y_pred))
print(confusion_matrix(np.nonzero(D[1])[1], Y_pred))
print(classification_report(np.nonzero(D[1])[1], Y_pred))
pylab.plot(accuScore)
pylab.show()
def cal_splitvalueI(rating_matrix, user_vectors, current_vector, indices_like,
indices_dislike, indices_unknown, K):
like = rating_matrix[:, indices_like]
dislike = rating_matrix[:, indices_dislike]
unknown = rating_matrix[:, indices_unknown]
like_vector = np.zeros(K)
dislike_vector = np.zeros(K)
unknown_vector = np.zeros(K)
value = 0
if len(indices_like) > 0:
# print(indices_like)
like_vector = cf_item(rating_matrix, user_vectors, current_vector,
indices_like, K)
like_vector = np.array([like_vector for i in range(len(indices_like))])
pre_like = np.dot(user_vectors, like_vector.T)
Err_like = pre_like[np.nonzero(like)] - like[np.nonzero(like)]
value = value + np.dot(Err_like, Err_like)
# print(value)
if len(indices_dislike) > 0:
# print(indices_dislike)
dislike_vector = cf_item(rating_matrix, user_vectors, current_vector,
indices_dislike, K)
dislike_vector = np.array(
[dislike_vector for i in range(len(indices_dislike))])
pre_dislike = np.dot(user_vectors, dislike_vector.T)
Err_dislike = pre_dislike[np.nonzero(dislike)] - dislike[np.nonzero(
dislike)]
value = value + np.dot(Err_dislike, Err_dislike)
# print(value)
if len(indices_unknown) > 0:
# print(indices_unknown)
unknown_vector = cf_item(rating_matrix, user_vectors, current_vector,
indices_unknown, K)
unknown_vector = np.array(
[unknown_vector for i in range(len(indices_unknown))])
pre_unknown = np.dot(user_vectors, unknown_vector.T)
Err_unknown = pre_unknown[np.nonzero(unknown)] - unknown[np.nonzero(
unknown)]
value = value + np.dot(Err_unknown, Err_unknown)
# print(value)
lkv_l = like_vector[np.nonzero(like_vector)]
dlkv_l = dislike_vector[np.nonzero(dislike_vector)]
unkv_l = unknown_vector[np.nonzero(unknown_vector)]
value = value + lmd_v * (np.dot(lkv_l, lkv_l) + np.dot(dlkv_l, dlkv_l) +
np.dot(unkv_l, unkv_l))
user_l = user_vectors[np.nonzero(user_vectors)]
value = value + lmd_u * np.dot(user_l, user_l)
np.random.seed(0)
num_pair = 20
num_user, num_item = like.shape
if num_user * num_item != 0:
for i in range(num_pair):
c1, c2 = np.random.randint(0, num_item * num_user, 2)
u1, i1 = c1 // num_item, c1 % num_item
u2, i2 = c2 // num_item, c2 % num_item
if like[u1][i1] > like[u2][i2]:
diff = np.dot(user_vectors[u1, :].T,
like_vector[i1, :]) - np.dot(
user_vectors[u2, :].T, like_vector[i2, :])
diff = -diff
value = value + lmd_BPR * np.log(1 + np.exp(diff))
num_user, num_item = dislike.shape
if num_user * num_item != 0:
for i in range(num_pair):
c1, c2 = np.random.randint(0, num_item * num_user, 2)
u1, i1 = c1 // num_item, c1 % num_item
u2, i2 = c2 // num_item, c2 % num_item
if dislike[u1][i1] > dislike[u2][i2]:
diff = np.dot(user_vectors[u1, :].T,
dislike_vector[i1, :]) - np.dot(
user_vectors[u2, :].T, dislike_vector[i2, :])
diff = -diff
value = value + lmd_BPR * np.log(1 + np.exp(diff))
num_user, num_item = unknown.shape
if num_user * num_item != 0:
for i in range(num_pair):
c1, c2 = np.random.randint(0, num_item * num_user, 2)
u1, i1 = c1 // num_item, c1 % num_item
u2, i2 = c2 // num_item, c2 % num_item
if unknown[u1][i1] > unknown[u2][i2]:
diff = np.dot(user_vectors[u1, :].T,
unknown_vector[i1, :]) - np.dot(
user_vectors[u2, :].T, unknown_vector[i2, :])
diff = -diff
value = value + lmd_BPR * np.log(1 + np.exp(diff))
print(value)
return value
def get_order(adj_mtx, coords, ix_list, closest_ix, verts):
"""
Given a list of vertices (at a certain depth away from the center), calculates traversal order
:param adj_mtx: adjacency matrix of the mesh
:param coords: list of coordinates for each vertex
:param ix_list: list of vertices
:param closest_ix: the starting vertex
:return: ordered list of vertices
"""
arr = []
seen = set(verts)
arr.append(closest_ix)
seen.add(closest_ix)
v = closest_ix
# find the neighbor
neigh_list = []
list_of_lists = []
if sparse.issparse(adj_mtx):
nz = adj_mtx.tolil().rows
for i in ix_list:
neighs = nz[i]
list_of_lists.append(neighs)
else:
for i in ix_list:
try:
neighs = np.nonzero(adj_mtx[i])
except:
print("boo")
neighs = neighs[0]
list_of_lists.append(neighs)
ct = 0
for i in list_of_lists:
if closest_ix in i:
if ix_list[ct] not in seen:
neigh_list.append(ix_list[ct])
ct += 1
if len(arr) == len(ix_list):
return arr
while len(arr) != len(ix_list):
if len(neigh_list) >= 2:
v1 = neigh_list[0]
v2 = neigh_list[1]
x1 = coords[v1]
x2 = coords[v2]
if x1[0] <= x2[0]:
v = v1
arr.append(v)
seen.add(v)
neigh_list = []
ct = 0
for i in list_of_lists:
if v in i and ix_list[ct] not in seen:
neigh_list.append(ix_list[ct])
seen.add(ix_list[ct])
ct += 1
else:
v = v2
arr.append(v)
seen.add(v)
neigh_list = []
ct = 0
for i in list_of_lists:
if v in i and ix_list[ct] not in seen:
neigh_list.append(ix_list[ct])
seen.add(ix_list[ct])
ct += 1
if len(neigh_list) == 1:
v = neigh_list[0]
arr.append(v)
seen.add(v)
neigh_list = []
ct = 0
for i in list_of_lists:
if v in i and ix_list[ct] not in seen:
neigh_list.append(ix_list[ct])
seen.add(ix_list[ct])
ct += 1
if len(neigh_list) == 0:
return arr
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 get_neighs_sq2(adj_mtx, i):
new_row = adj_mtx[i]
new_row = np.nonzero(new_row)
verts = new_row[0]
return verts
def traverse_mesh(coords,
faces,
center,
stride=1,
verbose=False,
is_sparse=True):
"""
Calculates the traversal list of all vertices in the mesh
:param coords: coordinates of the vertices
:param faces: triplets of vertices for each triangle
:param center: center vertex
:param stride: the stride to be covered
:param verbose: whether to print time after each iteration
:param is_sparse: whether a sparse implementation is desired
:return: list of all vertices in the mesh, starting from the center and in order of traversal
"""
adj_mtx, coords, faces = create_adj_mtx(coords, faces, is_sparse)
verbose_ctr = 1
start = time.time()
if stride == 1:
vertex = center
verts = list()
# level_0
verts.append(vertex)
v = vertex
# find closest point in level 1
dists = []
if sparse.issparse(adj_mtx):
nz = adj_mtx.tolil().rows
ix_list = nz[v]
else:
row = adj_mtx[v]
ix_list = np.nonzero(row)
ix_list = ix_list[0]
for j in ix_list:
d = get_dist(coords, v, j)
dists.append(d)
ix_min = ix_list[dists.index(min(dists))]
closest_ix = ix_min
# levels_>=1
if sparse.issparse(adj_mtx):
l = adj_mtx.shape[0]
else:
l = len(adj_mtx[0])
# until all vertices are seen
while len(verts) <= 0.95 * l:
# this is the closest vertex of the new level
# find the ordering of the level
if verbose:
print("Iteration {}: {}".format(verbose_ctr,
time.time() - start))
verbose_ctr = verbose_ctr + 1
arr = get_order(adj_mtx, coords, ix_list, closest_ix, verts)
for i in arr:
if i not in verts:
verts.append(i)
# get next level: for each in ix_list, get neighbors that are not in <verts>, then add them to the new list
next_list = []
for j in ix_list:
if sparse.issparse(adj_mtx):
new_row = nz[j]
else:
new_row = adj_mtx[j]
new_row = np.nonzero(new_row)
new_row = new_row[0]
for k in new_row:
if k not in verts:
next_list.append(k)
next_list = list(set(next_list))
if len(next_list) == 0:
continue
# find starting point of next level using line eq
c1 = coords[vertex]
c2 = coords[closest_ix]
line_dists = []
for j in next_list:
c3 = coords[j]
line_dist = LA.norm(np.cross(c2 - c1, c1 - c3)) / LA.norm(
c2 - c1) # not exactly sure of this
line_dists.append(line_dist)
ix_list = next_list
closest_ix = next_list[line_dists.index(min(line_dists))]
return verts
else: # multiple stride case
vertex = center
verts = list()
# level_0
verts.append(vertex)
v = vertex
seen = list()
seen.append(v)
if sparse.issparse(adj_mtx):
nz = adj_mtx.tolil().rows
ix_list = nz[v]
else:
row = adj_mtx[v]
ix_list = np.nonzero(row)
ix_list = ix_list[0]
dists = []
for j in ix_list:
d = get_dist(coords, v, j)
dists.append(d)
ix_min = ix_list[dists.index(min(dists))]
closest_ix = ix_min
add_to_verts = False
ctr = 1
# levels_>=1
if sparse.issparse(adj_mtx):
l = adj_mtx.shape[0]
else:
l = len(adj_mtx[0])
while len(seen) != l: # until all vertices are seen
# this is the closest vertex of the new level
# find the ordering of the level
arr = get_order(adj_mtx, coords, ix_list, closest_ix, seen)
seen = seen + arr
if add_to_verts: # add only every other level to the traversal list
temp_arr = arr[::stride]
verts = verts + temp_arr
# get next level: for each in ix_list, get neighbors that are not in <verts>, then add them to the new list
ctr = ctr + 1
if ctr % stride == 0:
add_to_verts = True
else:
add_to_verts = False
next_list = []
for j in ix_list:
if sparse.issparse(adj_mtx):
nz = adj_mtx.tolil().rows
new_row = nz[j]
else:
new_row = adj_mtx[j]
new_row = np.nonzero(new_row)
new_row = new_row[0]
for k in new_row:
if k not in seen:
next_list.append(k)
next_list = list(set(next_list))
if len(next_list) == 0:
continue
# find starting point of next level using line eq
c1 = coords[vertex]
c2 = coords[closest_ix]
line_dists = []
for j in next_list:
c3 = coords[j]
line_dist = LA.norm(np.cross(c2 - c1, c1 - c3)) / LA.norm(
c2 - c1) # not exactly sure of this
line_dists.append(line_dist)
ix_list = next_list
closest_ix = next_list[line_dists.index(min(line_dists))]
return verts
w1_new = w1 - alpha * w1_delta
b1_new = b1 - alpha * b1_delta
w2_new = w2 - alpha * w2_delta
b2_new = b2 - alpha * b2_delta
new_theta = (w1_new, b1_new, w2_new, b2_new)
return new_theta
# Compute Gradient
grad_objective = grad(objective)
# Train the Neural Network
epochs = 50
Y_pred = np.argmax(neural_network(D[0], theta), axis=1)
print("Accuracy score before training:",
sklearn.metrics.accuracy_score(np.nonzero(D[1])[1], Y_pred))
accuScore = []
for i in range(0, epochs):
print('Epoch: %d' % (i + 1))
for j in range(0, examples):
delta = grad_objective(theta, j)
theta = update_theta(theta, delta, 0.3)
Y_pred = np.argmax(neural_network(D[0], theta), axis=1)
accuScore.append(
sklearn.metrics.accuracy_score(np.nonzero(D[1])[1], Y_pred))
print("Accuracy score after training:",
sklearn.metrics.accuracy_score(np.nonzero(D[1])[1], Y_pred))
print(sklearn.metrics.confusion_matrix(np.nonzero(D[1])[1], Y_pred))
print(sklearn.metrics.classification_report(np.nonzero(D[1])[1], Y_pred))
pylab.plot(accuScore)
pylab.show()
