def init():
offset = 2.0
#if optimum[0] < np.inf:
# xmin = min(results['ADAM'][0][0], optimum[0]) - offset
# xmax = max(results['ADAM'][0][0], optimum[0]) + offset
#else:
xmin = domain[0, 0]
xmax = domain[0, 1]
#if optimum[1] < np.inf:
# ymin = min(results['ADAM'][1][0], optimum[1]) - offset
# ymax = max(results['ADAM'][1][0], optimum[1]) + offset
#else:
ymin = domain[1, 0]
ymax = domain[1, 1]
x = np.arange(xmin, xmax, 0.01)
y = np.arange(ymin, ymax, 0.01)
X, Y = np.meshgrid(x, y)
Z = np.zeros(np.shape(Y))
for a, _ in np.ndenumerate(Y):
Z[a] = func(X[a], Y[a])
level = fdict['level']
if level is None:
level = np.linspace(Z.min(), Z.max(), 20)
else:
if level[0] == 'normal':
level = np.linspace(Z.min(), Z.max(), level[1])
if level[0] == 'log':
level = np.logspace(np.log(Z.min()), np.log(Z.max()), level[1])
CF = ax[0].contour(X,Y,Z, levels=level)
#plt.colorbar(CF, orientation='horizontal', format='%.2f')
ax[0].grid()
ax[0].plot(results['ADAM'][0][0], results['ADAM'][1][0],
'h', markersize=15, color = '0.75')
if optimum[0] < np.inf and optimum[1] < np.inf:
ax[0].plot(optimum[0], optimum[1], '*', markersize=40,
markeredgewidth = 2, alpha = 0.5, color = '0.75')
ax[0].legend(loc='upper center', ncol=3, bbox_to_anchor=(0.5, 1.15))
ax[1].plot(0, results['ADAM'][2][0], 'o')
ax[1].axis([0, T, -0.5, max_err + 0.5])
ax[1].set_xlabel('num. iteration')
ax[1].set_ylabel('loss')
line1.set_data([], [])
line2.set_data([], [])
line3.set_data([], [])
line4.set_data([], [])
line5.set_data([], [])
err1.set_data([], [])
err2.set_data([], [])
err3.set_data([], [])
err4.set_data([], [])
err5.set_data([], [])
return line1, line2, line3, line4, line5, \
err1, err2, err3, err4, err5,
def make_pixel_grid(self):
""" makes a stack of points corresponding to each point in a pixel grid
with input shape
"""
y_grid = np.arange(self.nelec.shape[0], dtype=np.float) + 1
x_grid = np.arange(self.nelec.shape[1], dtype=np.float) + 1
xx, yy = np.meshgrid(x_grid, y_grid, indexing='xy')
# whenever we flatten and reshape use C ordering...
return np.column_stack((xx.ravel(order='C'), yy.ravel(order='C')))
def plot_isocontours(ax, func, xlimits=[-2, 2], ylimits=[-4, 2], numticks=101):
x = np.linspace(*xlimits, num=numticks)
y = np.linspace(*ylimits, num=numticks)
X, Y = np.meshgrid(x, y)
zs = func(np.concatenate([np.atleast_2d(X.ravel()), np.atleast_2d(Y.ravel())]).T)
Z = zs.reshape(X.shape)
plt.contour(X, Y, Z)
ax.set_yticks([])
ax.set_xticks([])
def create_pixel_grid(image, loc):
v_s = image.equa2pixel(loc)
bound = image.R
minx_b, maxx_b = max(0, int(v_s[0] - bound)), min(int(v_s[0] + bound + 1), image.nelec.shape[1])
miny_b, maxy_b = max(0, int(v_s[1] - bound)), min(int(v_s[1] + bound + 1), image.nelec.shape[0])
y_grid = np.arange(miny_b, maxy_b, dtype=np.float)
x_grid = np.arange(minx_b, maxx_b, dtype=np.float)
xx, yy = np.meshgrid(x_grid, y_grid, indexing='xy')
pixel_grid = np.column_stack((xx.ravel(order='C'), yy.ravel(order='C')))
return xx.astype(int), yy.astype(int),pixel_grid
def PyLQR_TrajCtrl_GeneralTest():
#build RBF basis
rbf_basis = np.array([
[-1.0, -1.0],
[-1.0, 1.0],
[1.0, -1.0],
[1.0, 1.0]
])
gamma = 1
T = 100
R = 1e-5
# rbf_funcs = [lambda x, u, t, aux: np.exp(-gamma*np.linalg.norm(x[0:2]-basis)**2) + .01*np.linalg.norm(u)**2 for basis in rbf_basis]
rbf_funcs = [
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[0])**2) + R*np.linalg.norm(u)**2,
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[1])**2) + R*np.linalg.norm(u)**2,
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[2])**2) + R*np.linalg.norm(u)**2,
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[3])**2) + R*np.linalg.norm(u)**2
]
weights = np.array([.75, .5, .25, 1.])
weights = weights / (np.sum(weights) + 1e-6)
cost_func = lambda x, u, t, aux: np.sum(weights * np.array([basis_func(x, u, t, aux) for basis_func in rbf_funcs]))
lqr_traj_ctrl = PyLQR_TrajCtrl(use_autograd=True)
lqr_traj_ctrl.build_ilqr_general_solver(cost_func, n_dims=rbf_basis.shape[1], T=T)
n_eval_pnts = 50
coords = np.linspace(-2.5, 2.5, n_eval_pnts)
xv, yv = np.meshgrid(coords, coords)
z = [[cost_func(np.array([xv[i, j], yv[i, j]]), np.zeros(2), None, None) for j in range(yv.shape[1])] for i in range(len(xv))]
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hold(True)
ax.contour(xv, yv, z)
n_queries = 5
u_array = np.random.rand(2, T-1).T * 2 - 1
for i in range(n_queries):
#start from a perturbed point
x0 = np.random.rand(2) * 4 - 2
syn_traj = lqr_traj_ctrl.synthesize_trajectory(x0, u_array)
#plot it
ax.plot([x0[0]], [x0[1]], 'k*', markersize=12.0)
ax.plot(syn_traj[:, 0], syn_traj[:, 1], linewidth=3.5)
plt.show()
return
def plot_error_surface(loss_fun, params, ax=None):
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
w0s = np.linspace(-2*params[0], 2*params[0], 10)
w1s = np.linspace(-2*params[1], 2*params[1], 10)
w0_grid, w1_grid = np.meshgrid(w0s, w1s)
lossvec = np.vectorize(loss_fun)
z = lossvec(w0_grid, w1_grid)
cs = ax.contour(w0s, w1s, z)
ax.clabel(cs)
ax.plot(params[0], params[1], 'rx', markersize=14)
return ax
def plot_trace(ps, ttl):
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = rosen(np.vstack([X.ravel(), Y.ravel()])).reshape((100,100))
ps = np.array(ps)
plt.figure(figsize=(12,4))
plt.subplot(121)
plt.contour(X, Y, Z, np.arange(10)**5)
plt.plot(ps[:, 0], ps[:, 1], '-o')
plt.plot(1, 1, 'r*', markersize=12) # global minimum
plt.subplot(122)
plt.semilogy(range(len(ps)), rosen(ps.T))
plt.title(ttl)
def plot_error_surface(xtrain, ytrain, model, ax=None):
params = model.params
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
w0s = np.linspace(-2*params[0], 2*params[0], 10)
w1s = np.linspace(-2*params[1], 2*params[1], 10)
w0_grid, w1_grid = np.meshgrid(w0s, w1s)
def loss(w0, w1):
return model.objective([w0, w1], xtrain, ytrain)
lossvec = np.vectorize(loss)
z = lossvec(w0_grid, w1_grid)
cs = ax.contour(w0s, w1s, z)
ax.clabel(cs)
ax.plot(params[0], params[1], 'rx', markersize=14)
def plot_true_posterior():
true_posterior_contour_levels = [0.01, 0.2, 1.0, 10.0]
x = np.linspace(*xlimits, num=200)
y = np.linspace(*ylimits, num=200)
X, Y = np.meshgrid(x, y)
fig = plt.figure(0); fig.clf()
fig.set_size_inches((5,4))
ax = fig.add_subplot(111)
zs = np.array([nllfun(np.concatenate(([x],[y]))) for x,y in zip(np.ravel(X), np.ravel(Y))])
Z = zs.reshape(X.shape)
plt.contour(X, Y, np.exp(-Z), true_posterior_contour_levels, colors='k')
ax.set_yticks([])
ax.set_xticks([])
return ax
def advect(f, vx, vy):
"""Move field f according to x and y velocities (u and v)
using an implicit Euler integrator."""
rows, cols = f.shape
cell_ys, cell_xs = np.meshgrid(np.arange(rows), np.arange(cols))
center_xs = (cell_xs - vx).ravel()
center_ys = (cell_ys - vy).ravel()
# Compute indices of source cells.
left_ix = np.floor(center_xs).astype(np.int)
top_ix = np.floor(center_ys).astype(np.int)
rw = center_xs - left_ix # Relative weight of right-hand cells.
bw = center_ys - top_ix # Relative weight of bottom cells.
left_ix = np.mod(left_ix, rows) # Wrap around edges of simulation.
right_ix = np.mod(left_ix + 1, rows)
top_ix = np.mod(top_ix, cols)
bot_ix = np.mod(top_ix + 1, cols)
# A linearly-weighted sum of the 4 surrounding cells.
flat_f = (1 - rw) * ((1 - bw)*f[left_ix, top_ix] + bw*f[left_ix, bot_ix]) \
+ rw * ((1 - bw)*f[right_ix, top_ix] + bw*f[right_ix, bot_ix])
return np.reshape(flat_f, (rows, cols))
def resample_photons(self, srcs, verbose=False):
"""resample photons - store source-specific images"""
# first, clear out old sample images
for src in srcs:
src.clear_sample_images()
# generate per-source sample image patch for each fits image in
# this field. keep track of photons due to noise
noise_sums = {}
for band, img in self.img_dict.iteritems():
if verbose:
print " ... resampling band %s " % band
samp_imgs, noise_sum = \
cel_mcmc.sample_source_photons_single_image_cython(
img, [s.params for s in srcs]
)
# tell each source to keep track of it's source-specific sampled
# images (and the image it was stripped out of)
for src, samp_img in zip(srcs, samp_imgs):
if samp_img is not None:
# cache pixel grid for each sample image
y_grid = np.arange(samp_img.y0, samp_img.y1, dtype=np.float)
x_grid = np.arange(samp_img.x0, samp_img.x1, dtype=np.float)
xx, yy = np.meshgrid(x_grid, y_grid, indexing='xy')
pixel_grid = np.column_stack((xx.ravel(order='C'), yy.ravel(order='C')))
src.sample_image_list.append((samp_img, img, pixel_grid))
# keep track of noise sums
noise_sums[band] = noise_sum
# resample noise parameter in each fits image
for band, img in self.img_dict.iteritems():
a_n = self.a_0 + noise_sums[band]
b_n = self.b_0 + img.nelec.size
eps_tmp = img.epsilon
img.epsilon = np.random.gamma(a_n, 1./b_n)
# Get maximum error.
maxError = 0
for xp in points:
y_a = phi_a(xp)
y_t = phi_t(xp, optimizedParams)
error = np.abs(y_a - y_t)
if error > maxError:
maxError = error
print("Max error:", maxError)
# Plot solutions.
# Make data.
X = np.linspace(MinVal, MaxVal, 100)
Y = np.linspace(MinVal, MaxVal, 100)
X, Y = np.meshgrid(X, Y)
Z_a = np.zeros(X.shape) # Analytic solution.
Z_t = np.zeros(X.shape) # Trial solution with neural network.
Z_e = np.zeros(X.shape) # Error surface.
d2Z_a_x12 = np.zeros(X.shape) # Second derivatives of analytic solution.
d2Z_a_x22 = np.zeros(X.shape)
d2Z_t_x12 = np.zeros(X.shape) # Second derivatives of trial solution.
d2Z_t_x22 = np.zeros(X.shape)
d2Z_e_x12 = np.zeros(
X.shape) # Error surface for second derivatives with respect to x_1.
d2Z_e_x22 = np.zeros(
X.shape) # Error surface for second derivatives with respect to x_2.
for ii in range(X.shape[0]):
for jj in range(X.shape[1]):
v = np.array([X[ii][jj], Y[ii][jj]]) # Input values.
Z_a[ii][jj] = phi_a(v) # Evalutating solutions.
def __init__(self, NSIDE, npix, clv=True):
"""
Args:
NSIDE (int) : the healpix NSIDE parameter, must be a power of 2, less than 2**30
npix (int) : number of pixel in the X and Y axis of the final projected map
rot_velocity (float) : rotation velocity of the star in the equator in km/s
Returns:
None
"""
self.NSIDE = int(NSIDE)
self.npix = int(npix)
self.hp_npix = hp.nside2npix(NSIDE)
# self.rot_velocity = rot_velocity
self.clv = clv
# Generate the indices of all healpix pixels
self.indices = np.arange(hp.nside2npix(NSIDE), dtype='int')
self.n_healpix_pxl = len(self.indices)
# Define the orthographic projector that generates the maps of the star on the plane of the sky
self.projector = hp.projector.OrthographicProj(xsize=int(self.npix))
# This function returns the pixel associated with a vector (x,y,z). This is needed by the projector
self.f_vec2pix = lambda x, y, z: hp.pixelfunc.vec2pix(int(self.NSIDE), x, y, z)
# Generate a mesh grid of X and Y points in the plane of the sky that covers only the observed hemisphere of the star
x = np.linspace(-2.0,0.0,int(self.npix/2))
y = np.linspace(-1.0,1.0,int(self.npix/2))
X, Y = np.meshgrid(x,y)
# Rotational velocity vector (pointing in the z direction and unit vector)
omega = np.array([0,0,1])
# Compute the radial vector at each position in the map and the projected velocity on the plane of the sky
radial_vector = np.array(self.projector.xy2vec(X.flatten(), Y.flatten())).reshape((3,int(self.npix/2),int(self.npix/2)))
self.vel_projection = np.cross(omega[:,None,None], radial_vector, axisa=0, axisb=0)[:,:,0]
# Compute the mu angle (astrocentric angle)
self.mu_angle = radial_vector[0,:,:]
# Read all Kurucz models from the database. Hardwired temperature and mu angles
print("Reading Kurucz spectra...")
self.T = 3500 + 250 * np.arange(27)
self.mus = np.array([1.0,0.9,0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0.05,0.02])[::-1]
for i in tqdm(range(27)):
f = 'kurucz_models/RESULTS/T_{0:d}_logg4.0_feh0.0.spec'.format(self.T[i])
vel, _, spec = _read_kurucz_spec(f)
if (i == 0):
self.nlambda, self.nmus = spec.shape
self.velocity = np.zeros((self.nlambda))
self.spectrum = np.zeros((27,self.nmus,self.nlambda))
self.velocity = vel
self.spectrum[i,:,:] = spec[:,::-1].T
# Generate a fake temperature map in the star using spherical harmonics
# self.temperature_map = 5000 * np.ones(self.npix)
# self.temperature_map = 5000 + 250 * hp.sphtfunc.alm2map(np.ones(10,dtype='complex'),self.NSIDE) #np.random.rand(self.n_healpix_pxl) * 2000 + 5000 #
self.temperature_map = 5000 * np.ones(self.hp_npix)
self.coeffs = hp.sphtfunc.map2alm(self.temperature_map)
self.velocity_per_pxl = self.velocity[1] - self.velocity[0]
self.freq_grid = np.fft.fftfreq(self.nlambda)
self.gradient = value_and_grad(self.loss)
def static_N2_simple(self, w_best, runner, **kwargs):
cost = runner.cost
predict = runner.model
full_predict = runner.full_model
feat = runner.feature_transforms
normalizer = runner.normalizer
inverse_nornalizer = runner.inverse_normalizer
x_train = inverse_nornalizer(runner.x_train).T
y_train = runner.y_train
x_test = inverse_nornalizer(runner.x_test).T
y_test = runner.y_test
# or just take last weights
self.w = w_best
# construct figure
fig, axs = plt.subplots(1, 1, figsize=(9, 4))
# create subplot with 2 panels
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax2 = plt.subplot(gs[0], aspect='equal')
ax3 = plt.subplot(gs[1])
ax3.axis('off')
### create boundary data ###
xmin1 = np.min(self.x[:, 0])
xmax1 = np.max(self.x[:, 0])
xgap1 = (xmax1 - xmin1) * 0.05
xmin1 -= xgap1
xmax1 += xgap1
xmin2 = np.min(self.x[:, 1])
xmax2 = np.max(self.x[:, 1])
xgap2 = (xmax2 - xmin2) * 0.05
xmin2 -= xgap2
xmax2 += xgap2
# plot boundary for 2d plot
r1 = np.linspace(xmin1, xmax1, 300)
r2 = np.linspace(xmin2, xmax2, 300)
s, t = np.meshgrid(r1, r2)
s = np.reshape(s, (np.size(s), 1))
t = np.reshape(t, (np.size(t), 1))
h = np.concatenate((s, t), axis=1)
# compute model on train data
z1 = predict(normalizer(h.T), self.w)
z1 = np.sign(z1)
# reshape it
s.shape = (np.size(r1), np.size(r2))
t.shape = (np.size(r1), np.size(r2))
z1.shape = (np.size(r1), np.size(r2))
### loop over two panels plotting each ###
for ax in [ax2]:
# plot training points
ind0 = np.argwhere(y_train == +1)
ind0 = [v[1] for v in ind0]
ax.scatter(x_train[ind0, 0],
x_train[ind0, 1],
s=55,
color=self.colors[0],
edgecolor='k',
linewidth=2.5,
zorder=3)
ind1 = np.argwhere(y_train == -1)
ind1 = [v[1] for v in ind1]
ax.scatter(x_train[ind1, 0],
x_train[ind1, 1],
s=55,
color=self.colors[1],
edgecolor='k',
linewidth=2.5,
zorder=3)
# plot testing points
ind0 = np.argwhere(y_test == +1)
ind0 = [v[1] for v in ind0]
ax.scatter(x_test[ind0, 0],
x_test[ind0, 1],
s=55,
color=self.colors[0],
edgecolor=[1, 0.8, 0.5],
linewidth=2.5,
zorder=3)
ind1 = np.argwhere(y_test == -1)
ind1 = [v[1] for v in ind1]
ax.scatter(x_test[ind1, 0],
x_test[ind1, 1],
s=55,
color=self.colors[1],
edgecolor=[1, 0.8, 0.5],
linewidth=2.5,
zorder=3)
#### plot contour, color regions ####
ax.contour(s,
t,
z1,
colors='k',
linewidths=2.5,
levels=[0],
zorder=2)
ax.contourf(s,
t,
z1,
colors=[self.colors[1], self.colors[0]],
alpha=0.15,
levels=range(-1, 2))
# cleanup panel
ax.set_xlabel(r'$x_1$', fontsize=15)
ax.set_ylabel(r'$x_2$', fontsize=15, rotation=0, labelpad=20)
ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
def secant(func, anchor, tracer, ax):
# evaluate function at anchor and tracer
g_anchor = func(anchor)
g_tracer = func(tracer)
anchor_orig = copy.deepcopy(anchor)
tracer_orig = copy.deepcopy(tracer)
# determine non-zero component of tracer, compute slope of secant line
anchor = anchor.flatten()
tracer = tracer.flatten()
ind = np.argwhere(tracer != 0)
anchor = anchor[ind]
tracer = tracer[ind]
# plot secant plane
color = 'lime'
if abs(anchor - tracer) > 10**-4:
# scatter tracer point
ax.scatter(tracer_orig[0],
tracer_orig[1],
g_tracer,
s=50,
c='b',
edgecolor='k',
linewidth=1)
# change color to red
color = 'r'
# plot visual guide for tracer
w = np.linspace(0, g_tracer, 100)
o = np.ones(100)
ax.plot(o * tracer_orig[0],
o * tracer_orig[1],
w,
linewidth=1.5,
alpha=1,
color='k',
linestyle='--')
w = np.linspace(0, g_anchor, 100)
o = np.ones(100)
ax.plot(o * anchor_orig[0],
o * anchor_orig[1],
w,
linewidth=1.5,
alpha=1,
color='k',
linestyle='--')
# compute slope of secant plane
slope = (g_anchor - g_tracer) / float(anchor - tracer)
# create function for hyperplane connecting anchor to tracer
w_tan = np.linspace(-2.5, 2.5, 200)
w1tan_vals, w2tan_vals = np.meshgrid(w_tan, w_tan)
w1tan_vals.shape = (len(w_tan)**2, 1)
w2tan_vals.shape = (len(w_tan)**2, 1)
wtan_vals = np.concatenate((w1tan_vals, w2tan_vals), axis=1).T
# create tangent hyperplane formula, evaluate
h = lambda w: g_anchor + slope * (w[ind] - anchor)
h_vals = h(wtan_vals)
# reshape everything and prep for plotting
w1tan_vals.shape = (len(w_tan), len(w_tan))
w2tan_vals.shape = (len(w_tan), len(w_tan))
h_vals.shape = (len(w_tan), len(w_tan))
# plot hyperplane and guides based on proximity of tracer to anchor
ax.plot_surface(w1tan_vals,
w2tan_vals,
h_vals,
alpha=0.2,
color=color,
zorder=3,
rstride=50,
cstride=50,
linewidth=0.5,
edgecolor='k')
def show_complete_coloring(self, w_hist, **kwargs):
'''
# determine best set of weights from history
cost_evals = []
for i in range(len(w_hist)):
W = w_hist[i]
cost = self.counting_cost(W)
cost_evals.append(cost)
ind = np.argmin(cost_evals)
'''
# or just take last weights
self.W = w_hist[-1]
# initialize figure
fig = plt.figure(figsize=(9, 4))
show_cost = False
if 'show_cost' in kwargs:
show_cost = kwargs['show_cost']
if show_cost == True:
gs = gridspec.GridSpec(1,
3,
width_ratios=[1, 1, 1],
height_ratios=[1])
# create third panel for cost values
ax3 = plt.subplot(gs[2], aspect='equal')
else:
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1])
# setup current axis
ax = plt.subplot(gs[0], aspect='equal')
ax2 = plt.subplot(gs[1], aspect='equal')
# generate input range for viewing range
minx = min(min(self.x[0, :]), min(self.x[1, :]))
maxx = max(max(self.x[0, :]), max(self.x[1, :]))
gapx = (maxx - minx) * 0.1
minx -= gapx
maxx += gapx
# plot panel with all data and separators
self.plot_data(ax)
self.plot_data(ax2)
self.plot_all_separators(ax)
### draw multiclass boundary on right panel
r = np.linspace(minx, maxx, 2000)
w1_vals, w2_vals = np.meshgrid(r, r)
w1_vals.shape = (len(r)**2, 1)
w2_vals.shape = (len(r)**2, 1)
o = np.ones((len(r)**2, 1))
h = np.concatenate([o, w1_vals, w2_vals], axis=1)
pts = np.dot(h, self.W)
g_vals = np.argmax(pts, axis=1)
# vals for cost surface
w1_vals.shape = (len(r), len(r))
w2_vals.shape = (len(r), len(r))
g_vals.shape = (len(r), len(r))
# plot contour
C = len(np.unique(self.y))
ax2.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=range(0, C + 1),
linewidths=2.75,
zorder=4)
ax2.contourf(w1_vals,
w2_vals,
g_vals + 1,
colors=self.colors[:],
alpha=0.2,
levels=range(0, C + 1))
ax.contourf(w1_vals,
w2_vals,
g_vals + 1,
colors=self.colors[:],
alpha=0.2,
levels=range(0, C + 1))
# dress panel
ax.set_xlim(minx, maxx)
ax.set_ylim(minx, maxx)
ax.set_xticks([])
ax.set_yticks([])
ax.set_yticklabels([])
ax.set_xticklabels([])
#ax.set_ylabel(r'$x_2$',rotation = 0,fontsize = 12,labelpad = 10)
#ax.set_xlabel(r'$x_1$',fontsize = 12)
ax2.set_xticks([])
ax2.set_yticks([])
ax2.set_yticklabels([])
ax2.set_xticklabels([])
ax2.set_xlim(minx, maxx)
ax2.set_ylim(minx, maxx)
#ax2.set_ylabel(r'$x_2$',rotation = 0,fontsize = 12,labelpad = 10)
#ax2.set_xlabel(r'$x_1$',fontsize = 12)
if show_cost == True:
# compute cost eval history
g = kwargs['cost']
cost_evals = []
for i in range(len(w_hist)):
W = w_hist[i]
cost = g(W)
cost_evals.append(cost)
# plot cost path - scale to fit inside same aspect as classification plots
num_iterations = len(w_hist)
s = np.linspace(minx + gapx, maxx - gapx, num_iterations)
scaled_costs = [
c / float(max(cost_evals)) * (maxx - gapx) - (minx + gapx)
for c in cost_evals
]
ax3.plot(s, scaled_costs, color='k', linewidth=1.5)
ax3.set_xlabel('iteration', fontsize=12)
ax3.set_title('cost function plot', fontsize=12)
# rescale number of iterations and cost function value to fit same aspect ratio as other two subplots
ax3.set_xlim(minx, maxx)
ax3.set_ylim(minx, maxx)
### set tickmarks for both axes - requries re-scaling
# x axis
marks = range(0, num_iterations, round(num_iterations / 5.0))
ax3.set_xticks(s[marks])
labels = [item.get_text() for item in ax3.get_xticklabels()]
ax3.set_xticklabels(marks)
### y axis
r = (max(scaled_costs) - min(scaled_costs)) / 5.0
marks = [min(scaled_costs) + m * r for m in range(6)]
ax3.set_yticks(marks)
labels = [item.get_text() for item in ax3.get_yticklabels()]
r = (max(cost_evals) - min(cost_evals)) / 5.0
marks = [int(min(cost_evals) + m * r) for m in range(6)]
ax3.set_yticklabels(marks)
def compare_2d3d(func1, func2, **kwargs):
# input arguments
view = [20, -65]
if 'view' in kwargs:
view = kwargs['view']
# define input space
w = np.linspace(-3, 3, 200) # input range for original function
if 'w' in kwargs:
w = kwargs['w']
# define pts
pt1 = 0
if 'pt1' in kwargs:
pt1 = kwargs['pt1']
pt2 = [0, 0]
if 'pt2' in kwargs:
pt2 = kwargs['pt2']
# construct figure
fig = plt.figure(figsize=(6, 3))
# remove whitespace from figure
fig.subplots_adjust(left=0, right=1, bottom=0, top=1) # remove whitespace
fig.subplots_adjust(wspace=0.01, hspace=0.01)
# create subplot with 3 panels, plot input function in center plot
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 2])
### draw 2d version ###
ax1 = plt.subplot(gs[0])
grad = compute_grad(func1)
# generate a range of values over which to plot input function, and derivatives
g_plot = func1(w)
g_range = max(g_plot) - min(g_plot) # used for cleaning up final plot
ggap = g_range * 0.2
# grab the next input/output tangency pair, the center of the next approximation(s)
pt1 = float(pt1)
g_val = func1(pt1)
# plot original function
ax1.plot(w, g_plot, color='k', zorder=1, linewidth=2)
# plot the input/output tangency point
ax1.scatter(pt1,
g_val,
s=60,
c='lime',
edgecolor='k',
linewidth=2,
zorder=3) # plot point of tangency
#### plot first order approximation ####
# plug input into the first derivative
g_grad_val = grad(pt1)
# compute first order approximation
w1 = pt1 - 3
w2 = pt1 + 3
wrange = np.linspace(w1, w2, 100)
h = g_val + g_grad_val * (wrange - pt1)
# plot the first order approximation
ax1.plot(wrange, h, color='lime', alpha=0.5, linewidth=3,
zorder=2) # plot approx
# make new x-axis
ax1.plot(w, g_plot * 0, linewidth=3, color='k')
#### clean up panel ####
# fix viewing limits on panel
ax1.set_xlim([min(w), max(w)])
ax1.set_ylim([min(min(g_plot) - ggap, -4), max(max(g_plot) + ggap, 0.5)])
# label axes
ax1.set_xlabel('$w$', fontsize=12, labelpad=-50)
ax1.set_ylabel('$g(w)$', fontsize=25, rotation=0, labelpad=50)
ax1.grid(False)
ax1.yaxis.set_visible(False)
ax1.spines['right'].set_visible(False)
ax1.spines['top'].set_visible(False)
ax1.spines['left'].set_visible(False)
### draw 3d version ###
ax2 = plt.subplot(gs[1], projection='3d')
grad = compute_grad(func2)
w_val = [float(0), float(0)]
# define input space
w1_vals, w2_vals = np.meshgrid(w, w)
w1_vals.shape = (len(w)**2, 1)
w2_vals.shape = (len(w)**2, 1)
w_vals = np.concatenate((w1_vals, w2_vals), axis=1).T
g_vals = func2(w_vals)
# evaluation points
w_val = np.array([float(pt2[0]), float(pt2[1])])
w_val.shape = (2, 1)
g_val = func2(w_val)
grad_val = grad(w_val)
grad_val.shape = (2, 1)
# create and evaluate tangent hyperplane
w1tan_vals, w2tan_vals = np.meshgrid(w, w)
w1tan_vals.shape = (len(w)**2, 1)
w2tan_vals.shape = (len(w)**2, 1)
wtan_vals = np.concatenate((w1tan_vals, w2tan_vals), axis=1).T
#h = lambda weh: g_val + np.dot( (weh - w_val).T,grad_val)
h = lambda weh: g_val + (weh[0] - w_val[0]) * grad_val[0] + (weh[
1] - w_val[1]) * grad_val[1]
h_vals = h(wtan_vals + w_val)
# vals for cost surface, reshape for plot_surface function
w1_vals.shape = (len(w), len(w))
w2_vals.shape = (len(w), len(w))
g_vals.shape = (len(w), len(w))
w1tan_vals += w_val[0]
w2tan_vals += w_val[1]
w1tan_vals.shape = (len(w), len(w))
w2tan_vals.shape = (len(w), len(w))
h_vals.shape = (len(w), len(w))
### plot function ###
ax2.plot_surface(w1_vals,
w2_vals,
g_vals,
alpha=0.5,
color='w',
rstride=25,
cstride=25,
linewidth=1,
edgecolor='k',
zorder=2)
### plot z=0 plane ###
ax2.plot_surface(w1_vals,
w2_vals,
g_vals * 0,
alpha=0.1,
color='w',
zorder=1,
rstride=25,
cstride=25,
linewidth=0.3,
edgecolor='k')
### plot tangent plane ###
ax2.plot_surface(w1tan_vals,
w2tan_vals,
h_vals,
alpha=0.4,
color='lime',
zorder=1,
rstride=50,
cstride=50,
linewidth=1,
edgecolor='k')
# scatter tangency
ax2.scatter(w_val[0],
w_val[1],
g_val,
s=70,
c='lime',
edgecolor='k',
linewidth=2)
### clean up plot ###
# plot x and y axes, and clean up
ax2.xaxis.pane.fill = False
ax2.yaxis.pane.fill = False
ax2.zaxis.pane.fill = False
#ax2.xaxis.pane.set_edgecolor('white')
ax2.yaxis.pane.set_edgecolor('white')
ax2.zaxis.pane.set_edgecolor('white')
# remove axes lines and tickmarks
ax2.w_zaxis.line.set_lw(0.)
ax2.set_zticks([])
ax2.w_xaxis.line.set_lw(0.)
ax2.set_xticks([])
ax2.w_yaxis.line.set_lw(0.)
ax2.set_yticks([])
# set viewing angle
ax2.view_init(view[0], view[1])
# set vewing limits
wgap = (max(w) - min(w)) * 0.4
y = max(w) + wgap
ax2.set_xlim([-y, y])
ax2.set_ylim([-y, y])
zmin = min(np.min(g_vals), -0.5)
zmax = max(np.max(g_vals), +0.5)
ax2.set_zlim([zmin, zmax])
# label plot
fontsize = 12
ax2.set_xlabel(r'$w_1$', fontsize=fontsize, labelpad=-30)
ax2.set_ylabel(r'$w_2$', fontsize=fontsize, rotation=0, labelpad=-30)
plt.show()
def show_individual_classifiers(self, run, w, **kwargs):
model = run.model
normalizer = run.normalizer
feat = run.feature_transforms
# grab args
view = [20, -70]
if 'view' in kwargs:
view = kwargs['view']
### plot all input data ###
# generate input range for functions
minx = min(min(self.x[:, 0]), min(self.x[:, 1]))
maxx = max(max(self.x[:, 0]), max(self.x[:, 1]))
gapx = (maxx - minx) * 0.1
minx -= gapx
maxx += gapx
r = np.linspace(minx, maxx, 600)
w1_vals, w2_vals = np.meshgrid(r, r)
w1_vals.shape = (len(r)**2, 1)
w2_vals.shape = (len(r)**2, 1)
h = np.concatenate([w1_vals, w2_vals], axis=1).T
g_vals = model(normalizer(h), w)
g_vals = np.asarray(g_vals)
g_new = copy.deepcopy(g_vals).T
g_vals = np.argmax(g_vals, axis=0)
# vals for cost surface
w1_vals.shape = (len(r), len(r))
w2_vals.shape = (len(r), len(r))
g_vals.shape = (len(r), len(r))
# count points
class_nums = np.unique(self.y)
C = int(len(class_nums))
fig = plt.figure(figsize=(10, 7))
gs = gridspec.GridSpec(2, C)
#### left plot - data and fit in original space ####
# setup current axis
ax1 = plt.subplot(gs[C], projection='3d')
ax2 = plt.subplot(gs[C + 1], aspect='equal')
fig.subplots_adjust(left=0, right=1, bottom=0,
top=1) # remove whitespace around 3d figure
##### plot top panels ####
for d in range(C):
# create panel
ax = plt.subplot(gs[d], aspect='equal')
for c in range(C):
# plot points
ind = np.argwhere(self.y == class_nums[c])
ind = [v[0] for v in ind]
ax.scatter(self.x[ind, 0],
self.x[ind, 1],
s=50,
color=self.colors[c],
edgecolor='k',
linewidth=2)
g_2 = np.sign(g_new[:, d])
g_2.shape = (len(r), len(r))
# plot separator curve
ax.contour(w1_vals,
w2_vals,
g_2 + 1,
colors='k',
levels=[-1, 1],
linewidths=4.5,
zorder=1,
linestyle='-')
ax.contour(w1_vals,
w2_vals,
g_2 + 1,
colors=self.colors[d],
levels=[-1, 1],
linewidths=2.5,
zorder=1,
linestyle='-')
ax.set_xlabel(r'$x_1$', fontsize=18, labelpad=10)
ax.set_ylabel(r'$x_2$', rotation=0, fontsize=18, labelpad=15)
##### plot bottom panels ###
# scatter points in both bottom panels
for c in range(C):
ind = np.argwhere(self.y == class_nums[c])
ind = [v[0] for v in ind]
ax1.scatter(self.x[ind, 0],
self.x[ind, 1],
self.y[ind],
s=50,
color=self.colors[c],
edgecolor='k',
linewidth=1.5)
ax2.scatter(self.x[ind, 0],
self.x[ind, 1],
s=50,
color=self.colors[c],
edgecolor='k',
linewidth=2)
ax1.plot_surface(w1_vals,
w2_vals,
g_vals,
alpha=0.1,
color='w',
rstride=45,
cstride=45,
linewidth=0.25,
edgecolor='k')
for c in range(C):
# plot separator curve in left plot z plane
ax1.contour(w1_vals,
w2_vals,
g_vals - c,
colors='k',
levels=[0],
linewidths=3,
zorder=1)
# color parts of plane with correct colors
ax1.contourf(w1_vals,
w2_vals,
g_vals - c + 0.5,
colors=self.colors[c],
alpha=0.4,
levels=[0, 1])
# plot separator in right plot
ax2.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=range(0, C + 1),
linewidths=3,
zorder=1)
# adjust height of regressor to plot filled contours
ax2.contourf(w1_vals,
w2_vals,
g_vals + 0.5,
colors=self.colors[:],
alpha=0.2,
levels=range(0, C + 1))
### clean up panels
# set viewing limits on vertical dimension for 3d plot
minz = 0
maxz = max(copy.deepcopy(self.y))
gapz = (maxz - minz) * 0.1
minz -= gapz
maxz += gapz
ax1.set_zlim([minz, maxz])
ax1.view_init(view[0], view[1])
# clean up panel
ax1.xaxis.pane.fill = False
ax1.yaxis.pane.fill = False
ax1.zaxis.pane.fill = False
ax1.xaxis.pane.set_edgecolor('white')
ax1.yaxis.pane.set_edgecolor('white')
ax1.zaxis.pane.set_edgecolor('white')
ax1.xaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax1.yaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax1.zaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
self.move_axis_left(ax1)
ax1.set_xlabel(r'$x_1$', fontsize=16, labelpad=5)
ax1.set_ylabel(r'$x_2$', rotation=0, fontsize=16, labelpad=5)
ax1.set_zlabel(r'$y$', rotation=0, fontsize=16, labelpad=5)
ax2.set_xlabel(r'$x_1$', fontsize=18, labelpad=10)
ax2.set_ylabel(r'$x_2$', rotation=0, fontsize=18, labelpad=15)
def static_N2_img(self,w_best,cost,predict,f1,f2,**kwargs):
# or just take last weights
self.w = w_best
zplane = 'on'
if 'zplane' in kwargs:
zplane = kwargs['zplane']
view1 = [20,45]
if 'view1' in kwargs:
view1 = kwargs['view1']
view2 = [20,30]
if 'view2' in kwargs:
view2 = kwargs['view2']
# initialize figure
fig = plt.figure(figsize = (10,9))
gs = gridspec.GridSpec(2, 2,width_ratios = [1,1])
#### left plot - data and fit in original space ####
# setup current axis
ax = plt.subplot(gs[0],aspect = 'equal');
ax2 = plt.subplot(gs[1],aspect = 'equal');
ax3 = plt.subplot(gs[2],projection = '3d');
ax4 = plt.subplot(gs[3],projection = '3d');
### cleanup left plots, create max view ranges ###
xmin1 = min(self.x[:,0])
xmax1 = max(self.x[:,0])
xgap1 = (xmax1 - xmin1)*0.05
xmin1 -= xgap1
xmax1 += xgap1
ax.set_xlim([xmin1,xmax1])
ax3.set_xlim([xmin1,xmax1])
xmin2 = min(self.x[:,1])
xmax2 = max(self.x[:,1])
xgap2 = (xmax2 - xmin2)*0.05
xmin2 -= xgap2
xmax2 += xgap2
ax.set_ylim([xmin2,xmax2])
ax3.set_ylim([xmin2,xmax2])
ymin = min(self.y)
ymax = max(self.y)
ygap = (ymax - ymin)*0.05
ymin -= ygap
ymax += ygap
ax3.set_zlim([ymin,ymax])
ax3.axis('off')
ax3.view_init(view1[0],view1[1])
ax.set_yticklabels([])
ax.set_xticklabels([])
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel(r'$x_1$',fontsize = 15)
ax.set_ylabel(r'$x_2$',fontsize = 15,rotation = 0,labelpad = 20)
#### plot left panels ####
# plot points in 2d and 3d
ind0 = np.argwhere(self.y == +1)
ax.scatter(self.x[ind0,0],self.x[ind0,1],s = 55, color = self.colors[0], edgecolor = 'k')
ax3.scatter(self.x[ind0,0],self.x[ind0,1],self.y[ind0],s = 55, color = self.colors[0], edgecolor = 'k')
ind1 = np.argwhere(self.y == -1)
ax.scatter(self.x[ind1,0],self.x[ind1,1],s = 55, color = self.colors[1], edgecolor = 'k')
ax3.scatter(self.x[ind1,0],self.x[ind1,1],self.y[ind1],s = 55, color = self.colors[1], edgecolor = 'k')
# plot boundary for 2d plot
r1 = np.linspace(xmin1,xmax1,100)
r2 = np.linspace(xmin2,xmax2,100)
s,t = np.meshgrid(r1,r2)
s = np.reshape(s,(np.size(s),1))
t = np.reshape(t,(np.size(t),1))
h = np.concatenate((s,t),axis = 1)
z = []
for j in range(len(h)):
a = predict(h[j,:],self.w)
z.append(a)
z = np.asarray(z)
z = np.tanh(z)
# reshape it
s.shape = (np.size(r1),np.size(r2))
t.shape = (np.size(r1),np.size(r2))
z.shape = (np.size(r1),np.size(r2))
#### plot contour, color regions ####
ax.contour(s,t,z,colors='k', linewidths=2.5,levels = [0],zorder = 2)
ax.contourf(s,t,z,colors = [self.colors[1],self.colors[0]],alpha = 0.15,levels = range(-1,2))
ax3.plot_surface(s,t,z,alpha = 0.1,color = 'w',rstride=10, cstride=10,linewidth=0.5,edgecolor = 'k')
# plot zplane = 0 in left 3d panel - showing intersection of regressor with z = 0 (i.e., its contour, the separator, in the 3d plot too)?
if zplane == 'on':
# plot zplane
ax3.plot_surface(s,t,z*0,alpha = 0.1,rstride=20, cstride=20,linewidth=0.15,color = 'w',edgecolor = 'k')
# plot separator curve in left plot
ax3.contour(s,t,z,colors = 'k',levels = [0],linewidths = 3,zorder = 1)
ax3.contourf(s,t,z,colors = self.colors[1],levels = [0,1],zorder = 1,alpha = 0.1)
ax3.contourf(s,t,z+1,colors = self.colors[0],levels = [0,1],zorder = 1,alpha = 0.1)
#### plot right panel scatter ####
# transform data
x1 = [f1(e) for e in self.x]
x2 = [f2(e) for e in self.x]
ind0 = [v[0] for v in ind0]
ind1 = [v[0] for v in ind1]
# plot points on desired panel
v1 = [x1[e] for e in ind0]
v2 = [x2[e] for e in ind0]
ax2.scatter(v1,v2,s = 55, color = self.colors[0], edgecolor = 'k')
ax4.scatter(v1,v2,self.y[ind0],s = 55, color = self.colors[0], edgecolor = 'k')
v1 = [x1[e] for e in ind1]
v2 = [x2[e] for e in ind1]
ax2.scatter(v1,v2,s = 55, color = self.colors[1], edgecolor = 'k')
ax4.scatter(v1,v2,self.y[ind1],s = 55, color = self.colors[1], edgecolor = 'k')
### cleanup right panels - making max viewing ranges ###
xmin1 = min(v1)
xmax1 = max(v1)
xgap1 = (xmax1 - xmin1)*0.1
xmin1 -= xgap1
xmax1 += xgap1
ax2.set_xlim([xmin1,xmax1])
ax4.set_xlim([xmin1,xmax1])
xmin2 = min(v2)
xmax2 = max(v2)
xgap2 = (xmax2 - xmin2)*0.1
xmin2 -= xgap2
xmax2 += xgap2
ax2.set_ylim([xmin2,xmax2])
ax4.set_ylim([xmin2,xmax2])
ymin = min(self.y)
ymax = max(self.y)
ygap = (ymax - ymin)*0.05
ymin -= ygap
ymax += ygap
ax4.set_zlim([ymin,ymax])
ax4.axis('off')
ax4.view_init(view2[0],view2[1])
ax2.set_yticklabels([])
ax2.set_xticklabels([])
ax2.set_xticks([])
ax2.set_yticks([])
ax2.set_xlabel(r'$f\,_1\left(x_1,x_2\right)$',fontsize = 15)
ax2.set_ylabel(r'$f\,_2\left(x_1,x_2\right)$',fontsize = 15)
### plot right panel 3d scatter ###
#### make right plot contour ####
r1 = np.linspace(xmin1,xmax1,100)
r2 = np.linspace(xmin2,xmax2,100)
s,t = np.meshgrid(r1,r2)
z = self.w[0] + self.w[1]*s + self.w[2]*t
z = np.tanh(np.asarray(z))
z.shape = (np.size(r1),np.size(r2))
ax2.contour(s,t,z,colors='k', linewidths=2.5,levels = [0],zorder = 2)
ax2.contourf(s,t,z,colors = [self.colors[1],self.colors[0]],alpha = 0.15,levels = range(-1,2))
#### plot right surface plot ####
# plot regression surface
ax4.plot_surface(s,t,z,alpha = 0.1,color = 'w',rstride=10, cstride=10,linewidth=0.5,edgecolor = 'k')
# plot zplane = 0 in left 3d panel - showing intersection of regressor with z = 0 (i.e., its contour, the separator, in the 3d plot too)?
if zplane == 'on':
# plot zplane
ax4.plot_surface(s,t,z*0,alpha = 0.1,rstride=20, cstride=20,linewidth=0.15,color = 'w',edgecolor = 'k')
# plot separator curve in left plot
ax4.contour(s,t,z,colors = 'k',levels = [0],linewidths = 3,zorder = 1)
ax4.contourf(s,t,z,colors = self.colors[0],levels = [0,1],zorder = 1,alpha = 0.1)
ax4.contourf(s,t,z+1,colors = self.colors[1],levels = [0,1],zorder = 1,alpha = 0.1)
plt.show()
def stop_condition(grad, eps):
return np.linalg.norm(grad) <= eps
if __name__ == "__main__":
n = 2
iteration = 0
epsilon = 0.1
verbose = 1
color = 'black'
H_f = jacobian(egrad(f))
if n == 2: # if dimension = 2 we could plot function
x_line = np.arange(-10, 10, 0.05)
y_line = np.arange(-10, 10, 0.05)
x_grid, y_grid = np.meshgrid(x_line, y_line, sparse=True)
function_values = f([x_grid, y_grid])
plt.pcolormesh(x_line,
y_line,
function_values,
cmap=cm.get_cmap('inferno_r'),
alpha=0.8)
x = np.array([-8, -8], dtype=np.float32)
if verbose == 1:
print('Starting...')
print('Starting point x_0:', x)
while True:
iteration += 1
def draw_panel(self,ax,title,**kwargs):
# set viewing limits on contour plot
xvals = [self.w_hist[s][0] for s in range(len(self.w_hist))]
xvals.append(self.w_init[0])
yvals = [self.w_hist[s][1] for s in range(len(self.w_hist))]
yvals.append(self.w_init[1])
xmax = max(xvals)
xmin = min(xvals)
xgap = (xmax - xmin)*0.1
ymax = max(yvals)
ymin = min(yvals)
ygap = (ymax - ymin)*0.1
xmin -= xgap
xmax += xgap
ymin -= ygap
ymax += ygap
if 'xmin' in kwargs:
xmin = kwargs['xmin']
if 'xmax' in kwargs:
xmax = kwargs['xmax']
if 'ymin' in kwargs:
ymin = kwargs['ymin']
if 'ymax' in kwargs:
ymax = kwargs['ymax']
axes = False
if 'axes' in kwargs:
axes = kwargs['ymax']
pts = False
if 'pts' in kwargs:
pts = kwargs['pts']
pts = False
if 'pts' in kwargs:
pts = kwargs['pts']
linewidth = 2.5
if 'linewidth' in kwargs:
linewidth = kwargs['linewidth']
#### define input space for function and evaluate ####
w1 = np.linspace(xmin,xmax,400)
w2 = np.linspace(ymin,ymax,400)
w1_vals, w2_vals = np.meshgrid(w1,w2)
w1_vals.shape = (len(w1)**2,1)
w2_vals.shape = (len(w2)**2,1)
h = np.concatenate((w1_vals,w2_vals),axis=1)
func_vals = np.asarray([self.g(s) for s in h])
w1_vals.shape = (len(w1),len(w1))
w2_vals.shape = (len(w2),len(w2))
func_vals.shape = (len(w1),len(w2))
### make contour right plot - as well as horizontal and vertical axes ###
# set level ridges
num_contours = kwargs['num_contours']
levelmin = min(func_vals.flatten())
levelmax = max(func_vals.flatten())
cutoff = 0.5
cutoff = (levelmax - levelmin)*cutoff
numper = 3
levels1 = np.linspace(cutoff,levelmax,numper)
num_contours -= numper
levels2 = np.linspace(levelmin,cutoff,min(num_contours,numper))
levels = np.unique(np.append(levels1,levels2))
num_contours -= numper
while num_contours > 0:
cutoff = levels[1]
levels2 = np.linspace(levelmin,cutoff,min(num_contours,numper))
levels = np.unique(np.append(levels2,levels))
num_contours -= numper
a = ax.contour(w1_vals, w2_vals, func_vals,levels = levels,colors = 'k')
ax.contourf(w1_vals, w2_vals, func_vals,levels = levels,cmap = 'Blues')
if axes == True:
ax.axhline(linestyle = '--', color = 'k',linewidth = 1)
ax.axvline(linestyle = '--', color = 'k',linewidth = 1)
# colors for points
s = np.linspace(0,1,len(self.w_hist[:round(len(self.w_hist)/2)]))
s.shape = (len(s),1)
t = np.ones(len(self.w_hist[round(len(self.w_hist)/2):]))
t.shape = (len(t),1)
s = np.vstack((s,t))
colorspec = []
colorspec = np.concatenate((s,np.flipud(s)),1)
colorspec = np.concatenate((colorspec,np.zeros((len(s),1))),1)
### plot function decrease plot in right panel
for j in range(len(self.w_hist)):
w_val = self.w_hist[j]
g_val = self.g(w_val)
# plot in left panel
if pts == 'True':
ax.scatter(w_val[0],w_val[1],s = 30,c = colorspec[j],edgecolor = 'k',linewidth = 1.5*math.sqrt((1/(float(j) + 1))),zorder = 3)
# plot connector between points for visualization purposes
if j > 0:
w_old = self.w_hist[j-1]
w_new = self.w_hist[j]
ax.plot([w_old[0],w_new[0]],[w_old[1],w_new[1]],color = colorspec[j],linewidth = linewidth,alpha = 1,zorder = 2) # plot approx
ax.plot([w_old[0],w_new[0]],[w_old[1],w_new[1]],color = 'k',linewidth = linewidth + 0.4,alpha = 1,zorder = 1) # plot approx
# clean panel
ax.set_title(title,fontsize = 12)
ax.set_xlabel('$w_1$',fontsize = 12)
ax.set_ylabel('$w_2$',fontsize = 12,rotation = 0)
ax.axhline(y=0, color='k',zorder = 0,linewidth = 0.5)
ax.axvline(x=0, color='k',zorder = 0,linewidth = 0.5)
ax.set_xlim([xmin,xmax])
ax.set_ylim([ymin,ymax])
ax.set_xticks(np.arange(round(xmin), round(xmax) + 1, 1.0))
ax.set_yticks(np.arange(round(ymin), round(ymax) + 1, 1.0))
def region_coloring(self, region, ax):
#### color first regions ####
# generate input range for functions
minx = min(min(self.x[:, 0]), min(self.x[:, 1]))
maxx = max(max(self.x[:, 0]), max(self.x[:, 1]))
gapx = (maxx - minx) * 0.1
minx -= gapx
maxx += gapx
# plot over range
r = np.linspace(minx, maxx, 200)
x1_vals, x2_vals = np.meshgrid(r, r)
x1_vals.shape = (len(r)**2, 1)
x2_vals.shape = (len(r)**2, 1)
o = np.ones((len(r)**2, 1))
x = np.concatenate([o, x1_vals, x2_vals], axis=1)
### for region 1, determine points that are uniquely positive for each classifier ###
ind_set = []
y = np.dot(self.W, x.T)
num_classes = np.size(np.unique(self.y))
if region == 1 or region == 'all':
for i in range(0, num_classes):
class_inds = np.arange(num_classes)
class_inds = np.delete(class_inds, (i), axis=0)
# loop over non-current classifier
ind = np.argwhere(y[class_inds[0]] < 0).tolist()
ind = [s[0] for s in ind]
for j in range(1, len(class_inds)):
c_ind = class_inds[j]
ind2 = np.argwhere(y[c_ind] < 0).tolist()
ind2 = [s[0] for s in ind2]
ind = [s for s in ind if s in ind2]
ind2 = np.argwhere(y[i] > 0).tolist()
ind2 = [s[0] for s in ind2]
ind = [s for s in ind if s in ind2]
# plot polygon over region defined by ind
x1_ins = np.asarray([x1_vals[s] for s in ind])
x1_ins.shape = (len(x1_ins), 1)
x2_ins = np.asarray([x2_vals[s] for s in ind])
x2_ins.shape = (len(x2_ins), 1)
h = np.concatenate((x1_ins, x2_ins), axis=1)
vertices = ConvexHull(h).vertices
poly = [h[v] for v in vertices]
polygon = Polygon(poly, True)
patches = []
patches.append(polygon)
p = PatchCollection(patches, alpha=0.2, color=self.colors[i])
ax.add_collection(p)
if region == 2 or region == 'all':
for i in range(0, num_classes):
class_inds = np.arange(num_classes)
class_inds = np.delete(class_inds, (i), axis=0)
# loop over non-current classifier
ind = np.argwhere(y[class_inds[0]] > 0).tolist()
ind = [s[0] for s in ind]
for j in range(1, len(class_inds)):
c_ind = class_inds[j]
ind2 = np.argwhere(y[c_ind] > 0).tolist()
ind2 = [s[0] for s in ind2]
ind = [s for s in ind if s in ind2]
ind2 = np.argwhere(y[i] < 0).tolist()
ind2 = [s[0] for s in ind2]
ind = [s for s in ind if s in ind2]
# plot polygon over region defined by ind
x1_ins = np.asarray([x1_vals[s] for s in ind])
x1_ins.shape = (len(x1_ins), 1)
x2_ins = np.asarray([x2_vals[s] for s in ind])
x2_ins.shape = (len(x2_ins), 1)
o = np.ones((len(x2_ins), 1))
h = np.concatenate((o, x1_ins, x2_ins), axis=1)
# determine regions dominated by one classifier or the other
vals = []
for c in class_inds:
w = self.W[int(c)]
nv = np.dot(w, h.T)
vals.append(nv)
vals = np.asarray(vals)
vals.shape = (len(class_inds), len(h))
ind = np.argmax(vals, axis=0)
for j in range(len(class_inds)):
# make polygon for each subregion
ind1 = np.argwhere(ind == j)
x1_ins2 = np.asarray([x1_ins[s] for s in ind1])
x1_ins2.shape = (len(x1_ins2), 1)
x2_ins2 = np.asarray([x2_ins[s] for s in ind1])
x2_ins2.shape = (len(x2_ins2), 1)
h = np.concatenate((x1_ins2, x2_ins2), axis=1)
# find convex hull of points
vertices = ConvexHull(h).vertices
poly = [h[v] for v in vertices]
polygon = Polygon(poly, True)
patches = []
patches.append(polygon)
c = class_inds[j]
p = PatchCollection(patches,
alpha=0.2,
color=self.colors[c])
ax.add_collection(p)
if region == 3 or region == 'all':
# find negative zone of all classifiers
ind = np.argwhere(y[0] < 0).tolist()
ind = [s[0] for s in ind]
for i in range(1, num_classes):
ind2 = np.argwhere(y[i] < 0).tolist()
ind2 = [s[0] for s in ind2]
ind = [s for s in ind if s in ind2]
# loop over negative zone, find max area of each classifier
x1_ins = np.asarray([x1_vals[s] for s in ind])
x1_ins.shape = (len(x1_ins), 1)
x2_ins = np.asarray([x2_vals[s] for s in ind])
x2_ins.shape = (len(x2_ins), 1)
o = np.ones((len(x2_ins), 1))
h = np.concatenate((o, x1_ins, x2_ins), axis=1)
# determine regions dominated by one classifier or the other
vals = []
for c in range(num_classes):
w = self.W[c]
nv = np.dot(w, h.T)
vals.append(nv)
vals = np.asarray(vals)
vals.shape = (num_classes, len(h))
ind = np.argmax(vals, axis=0)
# loop over each class, construct polygon region for each
for c in range(num_classes):
# make polygon for each subregion
ind1 = np.argwhere(ind == c)
x1_ins2 = np.asarray([x1_ins[s] for s in ind1])
x1_ins2.shape = (len(x1_ins2), 1)
x2_ins2 = np.asarray([x2_ins[s] for s in ind1])
x2_ins2.shape = (len(x2_ins2), 1)
h = np.concatenate((x1_ins2, x2_ins2), axis=1)
# find convex hull of points
vertices = ConvexHull(h).vertices
poly = [h[v] for v in vertices]
polygon = Polygon(poly, True)
patches = []
patches.append(polygon)
p = PatchCollection(patches, alpha=0.2, color=self.colors[c])
ax.add_collection(p)
def show_complete_coloring(self):
# generate input range for viewing range
minx = min(min(self.x[:, 0]), min(self.x[:, 1]))
maxx = max(max(self.x[:, 0]), max(self.x[:, 1]))
gapx = (maxx - minx) * 0.1
minx -= gapx
maxx += gapx
# initialize figure
fig = plt.figure(figsize=(8, 4))
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1])
# setup current axis
ax = plt.subplot(gs[0], aspect='equal')
ax2 = plt.subplot(gs[1], aspect='equal')
# plot panel with all data and separators
self.plot_data(ax)
self.plot_data(ax2)
self.plot_all_separators(ax)
### draw multiclass boundary on right panel
r = np.linspace(minx, maxx, 2000)
w1_vals, w2_vals = np.meshgrid(r, r)
w1_vals.shape = (len(r)**2, 1)
w2_vals.shape = (len(r)**2, 1)
o = np.ones((len(r)**2, 1))
h = np.concatenate([o, w1_vals, w2_vals], axis=1)
pts = np.dot(self.W, h.T)
g_vals = np.argmax(pts, axis=0)
# vals for cost surface
w1_vals.shape = (len(r), len(r))
w2_vals.shape = (len(r), len(r))
g_vals.shape = (len(r), len(r))
# plot contour
C = len(np.unique(self.y))
ax2.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=range(0, C + 1),
linewidths=2.75,
zorder=4)
ax2.contourf(w1_vals,
w2_vals,
g_vals + 1,
colors=self.colors[:],
alpha=0.2,
levels=range(0, C + 1))
ax.contourf(w1_vals,
w2_vals,
g_vals + 1,
colors=self.colors[:],
alpha=0.2,
levels=range(0, C + 1))
# dress panel
ax.set_xlim(minx, maxx)
ax.set_ylim(minx, maxx)
ax.axis('off')
ax2.set_xlim(minx, maxx)
ax2.set_ylim(minx, maxx)
ax2.axis('off')
def draw_surface(self, g, ax, **kwargs):
xmin = -3.1
xmax = 3.1
ymin = -3.1
ymax = 3.1
if 'xmin' in kwargs:
xmin = kwargs['xmin']
if 'xmax' in kwargs:
xmax = kwargs['xmax']
if 'ymin' in kwargs:
ymin = kwargs['ymin']
if 'ymax' in kwargs:
ymax = kwargs['ymax']
#### define input space for function and evaluate ####
w1 = np.linspace(xmin, xmax, 200)
w2 = np.linspace(ymin, ymax, 200)
w1_vals, w2_vals = np.meshgrid(w1, w2)
w1_vals.shape = (len(w1)**2, 1)
w2_vals.shape = (len(w2)**2, 1)
h = np.concatenate((w1_vals, w2_vals), axis=1)
func_vals = np.asarray([g(np.reshape(s, (2, 1))) for s in h])
### plot function as surface ###
w1_vals.shape = (len(w1), len(w2))
w2_vals.shape = (len(w1), len(w2))
func_vals.shape = (len(w1), len(w2))
ax.plot_surface(w1_vals,
w2_vals,
func_vals,
alpha=0.1,
color='w',
rstride=25,
cstride=25,
linewidth=1,
edgecolor='k',
zorder=2)
# plot z=0 plane
ax.plot_surface(w1_vals,
w2_vals,
func_vals * 0,
alpha=0.1,
color='w',
zorder=1,
rstride=25,
cstride=25,
linewidth=0.3,
edgecolor='k')
# clean up axis
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('white')
ax.yaxis.pane.set_edgecolor('white')
ax.zaxis.pane.set_edgecolor('white')
ax.xaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.yaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.zaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.set_xlabel('$w_0$', fontsize=14)
ax.set_ylabel('$w_1$', fontsize=14, rotation=0)
ax.set_title('$g(w_0,w_1)$', fontsize=14)
def plot_regressions(x, y, predictor, view1, view2):
# import all the requisite libs
# construct panels
fig = plt.figure(figsize=(9, 4))
ax0 = plt.subplot(121, projection='3d')
ax0.view_init(view1[0], view1[1])
ax0.axis('off')
ax1 = plt.subplot(122, projection='3d')
ax1.view_init(view2[0], view2[1])
ax1.axis('off')
# scatter plot data in each panel
ax0.scatter(x[0, :],
x[1, :],
y[0, :],
c='k',
edgecolor='w',
linewidth=1,
s=60)
ax1.scatter(x[0, :],
x[1, :],
y[1, :],
c='k',
edgecolor='w',
linewidth=1,
s=60)
# construct input for each model fit
a_ = np.linspace(0, 1, 15)
a, b = np.meshgrid(a_, a_)
a = a.flatten()[np.newaxis, :]
b = b.flatten()[np.newaxis, :]
c = np.vstack((a, b))
# evaluate model
p = predictor(c)
m1 = p[0, :]
m2 = p[1, :]
# plot each as surface
a.shape = (a_.size, a_.size)
b.shape = (a_.size, a_.size)
m1.shape = (a_.size, a_.size)
m2.shape = (a_.size, a_.size)
ax0.plot_surface(a,
b,
m1,
alpha=0.25,
color='lime',
cstride=2,
rstride=2,
linewidth=1,
edgecolor='k')
ax1.plot_surface(a,
b,
m2,
alpha=0.25,
color='lime',
cstride=2,
rstride=2,
linewidth=1,
edgecolor='k')
plt.show()
def static_N2_simple(self, w_best, runner, **kwargs):
cost = runner.cost
predict = runner.model
feat = runner.feature_transforms
normalizer = runner.normalizer
# count parameter layers of input to feature transform
sig = signature(feat)
sig = len(sig.parameters)
# or just take last weights
self.w = w_best
# construct figure
fig, axs = plt.subplots(1, 2, figsize=(9, 4))
# create subplot with 2 panels
gs = gridspec.GridSpec(1, 2)
ax2 = plt.subplot(gs[1], aspect='equal')
ax1 = plt.subplot(gs[0], projection='3d')
# scatter points
self.scatter_pts(ax1, self.x)
### from above
ax2.set_xlabel(r'$x_1$', fontsize=15)
ax2.set_ylabel(r'$x_2$', fontsize=15, rotation=0, labelpad=20)
ax2.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax2.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
# plot points in 2d and 3d
C = len(np.unique(self.y))
if C == 2:
ind0 = np.argwhere(self.y == +1)
ax2.scatter(self.x[ind0, 0],
self.x[ind0, 1],
s=55,
color=self.colors[0],
edgecolor='k')
ind1 = np.argwhere(self.y == -1)
ax2.scatter(self.x[ind1, 0],
self.x[ind1, 1],
s=55,
color=self.colors[1],
edgecolor='k')
else:
for c in range(C):
ind0 = np.argwhere(self.y == c)
ax2.scatter(self.x[ind0, 0],
self.x[ind0, 1],
s=55,
color=self.colors[c],
edgecolor='k')
self.move_axis_left(ax1)
ax1.set_xlabel(r'$x_1$', fontsize=12, labelpad=5)
ax1.set_ylabel(r'$x_2$', rotation=0, fontsize=12, labelpad=5)
ax1.set_zlabel(r'$y$', rotation=0, fontsize=12, labelpad=-3)
### create surface and boundary plot ###
xmin1 = np.min(self.x[:, 0])
xmax1 = np.max(self.x[:, 0])
xgap1 = (xmax1 - xmin1) * 0.05
xmin1 -= xgap1
xmax1 += xgap1
xmin2 = np.min(self.x[:, 1])
xmax2 = np.max(self.x[:, 1])
xgap2 = (xmax2 - xmin2) * 0.05
xmin2 -= xgap2
xmax2 += xgap2
if 'view' in kwargs:
view = kwargs['view']
ax1.view_init(view[0], view[1])
# plot boundary for 2d plot
r1 = np.linspace(xmin1, xmax1, 300)
r2 = np.linspace(xmin2, xmax2, 300)
s, t = np.meshgrid(r1, r2)
s = np.reshape(s, (np.size(s), 1))
t = np.reshape(t, (np.size(t), 1))
h = np.concatenate((s, t), axis=1)
z = predict(normalizer(h.T), self.w)
z = np.sign(z)
# reshape it
s.shape = (np.size(r1), np.size(r2))
t.shape = (np.size(r1), np.size(r2))
z.shape = (np.size(r1), np.size(r2))
#### plot contour, color regions ####
ax2.contour(s, t, z, colors='k', linewidths=2.5, levels=[0], zorder=2)
ax2.contourf(s,
t,
z,
colors=[self.colors[1], self.colors[0]],
alpha=0.15,
levels=range(-1, 2))
ax1.plot_surface(s,
t,
z,
alpha=0.1,
color='w',
rstride=30,
cstride=30,
linewidth=0.5,
edgecolor='k')
# Compute the gradient of the loss function
gradient_loss = grad(loss)
# Set the initial weights
weights = np.array([1.0, 1.0])
# Steepest Descent
loss_values = []
learning_rate = 0.001
for i in range(100):
loss_values.append(loss(weights))
step = gradient_loss(weights)
weights -= step * learning_rate
# Plot the decision boundary
x_min, x_max = train_X[:, 0].min() - 0.5, train_X[:, 0].max() + 0.5
y_min, y_max = train_X[:, 1].min() - 0.5, train_X[:, 1].max() + 0.5
x_mesh, y_mesh = np.meshgrid(np.arange(x_min, x_max, 0.01),
np.arange(y_min, y_max, 0.01))
Z = predict(weights, np.c_[x_mesh.ravel(), y_mesh.ravel()])
Z = Z.reshape(x_mesh.shape)
cs = pylab.contourf(x_mesh, y_mesh, Z, cmap=pylab.cm.Spectral)
pylab.scatter(train_X[:, 0], train_X[:, 1], c=train_y, cmap=pylab.cm.Spectral)
# pylab.colorbar(cs)
# Plot the loss over each step
pylab.figure()
# pylab.plot(loss_values)
pylab.xlabel("Steps")
pylab.ylabel("Loss")
pylab.show()
if np.all(abs(x_i - x_ip1) < 1e-6):
break
# Update x and p
p_i = p_ip1
x_i = x_ip1
# Save results
F = np.append(F, f(x_i))
X = np.append(X, np.reshape(x_i, (1, -1)), axis=0)
print("Plotting results")
xmin, xmax, xstep = -4.5, 4.5, .2
ymin, ymax, ystep = -4.5, 4.5, .2
x, y = np.meshgrid(np.arange(xmin, xmax + xstep, xstep),
np.arange(ymin, ymax + ystep, ystep))
z = f([x, y])
minima = np.array([0, 0])
minima_ = minima.reshape(-1, 1)
fig, ax = plt.subplots(figsize=(10, 10))
ax.contour(x,
y,
z,
levels=np.logspace(0, 5, 35),
norm=LogNorm(),
cmap=plt.cm.jet)
#ax.quiver(X.T[0,:-1], X.T[1,:-1], X.T[0,1:]-X.T[0,:-1], X.T[1,1:]-X.T[1,:-1], scale_units='xy', angles='xy', scale=1, color='k')
ax.scatter(X.T[0], X.T[1], s=5)
ax.plot(*minima_, 'r*', markersize=5)
def static_N1_img(self,w_best,cost,predict,**kwargs):
# or just take last weights
self.w = w_best
# initialize figure
fig = plt.figure(figsize = (9,4))
show_cost = False
if show_cost == True:
gs = gridspec.GridSpec(1, 3,width_ratios = [1,1,1],height_ratios = [1])
# create third panel for cost values
ax3 = plt.subplot(gs[2],aspect = 'equal')
else:
gs = gridspec.GridSpec(1, 2,width_ratios = [1,1])
#### left plot - data and fit in original space ####
# setup current axis
ax = plt.subplot(gs[0]);
ax2 = plt.subplot(gs[1],aspect = 'equal');
# scatter original points
self.scatter_pts(ax,self.x)
ax.set_xlabel(r'$x$', fontsize = 14,labelpad = 10)
ax.set_ylabel(r'$y$', rotation = 0,fontsize = 14,labelpad = 10)
# create fit
gapx = (max(self.x) - min(self.x))*0.1
s = np.linspace(min(self.x) - gapx,max(self.x) + gapx,100)
t = [np.tanh(predict(np.asarray([v]),self.w)) for v in s]
# plot fit
ax.plot(s,t,c = 'lime')
ax.axhline(linewidth=0.5, color='k',zorder = 1)
#### plot data in new space in middle panel (or right panel if cost function decrease plot shown ) #####
if 'f_x' in kwargs:
f_x = kwargs['f_x']
# scatter points
self.scatter_pts(ax2,f_x)
# create and plot fit
s = np.linspace(min(f_x) - 0.1,max(f_x) + 0.1,100)
t = np.tanh(self.w[0] + self.w[1]*s)
ax2.plot(s,t,c = 'lime')
ax2.set_xlabel(r'$f\,(x)$', fontsize = 14,labelpad = 10)
ax2.set_ylabel(r'$y$', rotation = 0,fontsize = 14,labelpad = 10)
if 'f2_x' in kwargs:
ax2 = plt.subplot(gs[1],projection = '3d');
view = kwargs['view']
# get input
f1_x = kwargs['f1_x']
f2_x = kwargs['f2_x']
# scatter points
f1_x = np.asarray(f1_x)
f1_x.shape = (len(f1_x),1)
f2_x = np.asarray(f2_x)
f2_x.shape = (len(f2_x),1)
xtran = np.concatenate((f1_x,f2_x),axis = 1)
self.scatter_pts(ax2,xtran)
# create and plot fit
s1 = np.linspace(min(f1_x) - 0.1,max(f1_x) + 0.1,100)
s2 = np.linspace(min(f2_x) - 0.1,max(f2_x) + 0.1,100)
t1,t2 = np.meshgrid(s1,s2)
# compute fitting hyperplane
t1.shape = (len(s1)**2,1)
t2.shape = (len(s2)**2,1)
r = np.tanh(self.w[0] + self.w[1]*t1 + self.w[2]*t2)
# reshape for plotting
t1.shape = (len(s1),len(s1))
t2.shape = (len(s2),len(s2))
r.shape = (len(s1),len(s2))
ax2.plot_surface(t1,t2,r,alpha = 0.1,color = 'lime',rstride=10, cstride=10,linewidth=0.5,edgecolor = 'k')
# label axes
self.move_axis_left(ax2)
ax2.set_xlabel(r'$f_1(x)$', fontsize = 12,labelpad = 5)
ax2.set_ylabel(r'$f_2(x)$', rotation = 0,fontsize = 12,labelpad = 5)
ax2.set_zlabel(r'$y$', rotation = 0,fontsize = 12,labelpad = -3)
ax2.view_init(view[0],view[1])
# plot cost function decrease
if show_cost == True:
# compute cost eval history
g = cost
cost_evals = []
for i in range(len(w_hist)):
W = w_hist[i]
cost = g(W)
cost_evals.append(cost)
# plot cost path - scale to fit inside same aspect as classification plots
num_iterations = len(w_hist)
minx = min(self.x)
maxx = max(self.x)
gapx = (maxx - minx)*0.1
minc = min(cost_evals)
maxc = max(cost_evals)
gapc = (maxc - minc)*0.1
minc -= gapc
maxc += gapc
s = np.linspace(minx + gapx,maxx - gapx,num_iterations)
scaled_costs = [c/float(max(cost_evals))*(maxx-gapx) - (minx+gapx) for c in cost_evals]
ax3.plot(s,scaled_costs,color = 'k',linewidth = 1.5)
ax3.set_xlabel('iteration',fontsize = 12)
ax3.set_title('cost function plot',fontsize = 12)
# rescale number of iterations and cost function value to fit same aspect ratio as other two subplots
ax3.set_xlim(minx,maxx)
#ax3.set_ylim(minc,maxc)
### set tickmarks for both axes - requries re-scaling
# x axis
marks = range(0,num_iterations,round(num_iterations/5.0))
ax3.set_xticks(s[marks])
labels = [item.get_text() for item in ax3.get_xticklabels()]
ax3.set_xticklabels(marks)
### y axis
r = (max(scaled_costs) - min(scaled_costs))/5.0
marks = [min(scaled_costs) + m*r for m in range(6)]
ax3.set_yticks(marks)
labels = [item.get_text() for item in ax3.get_yticklabels()]
r = (max(cost_evals) - min(cost_evals))/5.0
marks = [int(min(cost_evals) + m*r) for m in range(6)]
ax3.set_yticklabels(marks)
def multiclass_plot(self, ax1, ax2, run, w, view, **kwargs):
model = run.model
normalizer = run.normalizer
### plot all input data ###
# generate input range for functions
minx = min(min(self.x[:, 0]), min(self.x[:, 1]))
maxx = max(max(self.x[:, 0]), max(self.x[:, 1]))
gapx = (maxx - minx) * 0.1
minx -= gapx
maxx += gapx
r = np.linspace(minx, maxx, 600)
w1_vals, w2_vals = np.meshgrid(r, r)
w1_vals.shape = (len(r)**2, 1)
w2_vals.shape = (len(r)**2, 1)
h = np.concatenate([w1_vals, w2_vals], axis=1).T
g_vals = model(normalizer(h), w)
g_vals = np.asarray(g_vals)
g_vals = np.argmax(g_vals, axis=0)
# vals for cost surface
w1_vals.shape = (len(r), len(r))
w2_vals.shape = (len(r), len(r))
g_vals.shape = (len(r), len(r))
# scatter points in both panels
class_nums = np.unique(self.y)
C = len(class_nums)
for c in range(C):
ind = np.argwhere(self.y == class_nums[c])
ind = [v[0] for v in ind]
ax1.scatter(self.x[ind, 0],
self.x[ind, 1],
self.y[ind],
s=80,
color=self.colors[c],
edgecolor='k',
linewidth=1.5)
ax2.scatter(self.x[ind, 0],
self.x[ind, 1],
s=110,
color=self.colors[c],
edgecolor='k',
linewidth=2)
# switch for 2class / multiclass view
if C == 2:
# plot regression surface
ax1.plot_surface(w1_vals,
w2_vals,
g_vals,
alpha=0.1,
color='k',
rstride=20,
cstride=20,
linewidth=0,
edgecolor='k')
# plot zplane = 0 in left 3d panel - showing intersection of regressor with z = 0 (i.e., its contour, the separator, in the 3d plot too)?
ax1.plot_surface(w1_vals,
w2_vals,
g_vals * 0,
alpha=0.1,
rstride=20,
cstride=20,
linewidth=0.15,
color='k',
edgecolor='k')
# plot separator in left plot z plane
ax1.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=[0],
linewidths=3,
zorder=1)
# color parts of plane with correct colors
ax1.contourf(w1_vals,
w2_vals,
g_vals + 1,
colors=self.colors[:],
alpha=0.1,
levels=range(0, 2))
ax1.contourf(w1_vals,
w2_vals,
-g_vals + 1,
colors=self.colors[1:],
alpha=0.1,
levels=range(0, 2))
# plot separator in right plot
ax2.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=[0],
linewidths=3,
zorder=1)
# adjust height of regressor to plot filled contours
ax2.contourf(w1_vals,
w2_vals,
g_vals + 1,
colors=self.colors[:],
alpha=0.1,
levels=range(0, C + 1))
### clean up panels
# set viewing limits on vertical dimension for 3d plot
minz = min(copy.deepcopy(self.y))
maxz = max(copy.deepcopy(self.y))
gapz = (maxz - minz) * 0.1
minz -= gapz
maxz += gapz
# multiclass view
else:
ax1.plot_surface(w1_vals,
w2_vals,
g_vals,
alpha=0.2,
color='w',
rstride=45,
cstride=45,
linewidth=2,
edgecolor='k')
for c in range(C):
# plot separator curve in left plot z plane
ax1.contour(w1_vals,
w2_vals,
g_vals - c,
colors='k',
levels=[0],
linewidths=3,
zorder=1)
# color parts of plane with correct colors
ax1.contourf(w1_vals,
w2_vals,
g_vals - c + 0.5,
colors=self.colors[c],
alpha=0.4,
levels=[0, 1])
# plot separator in right plot
ax2.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=range(0, C + 1),
linewidths=3,
zorder=1)
# adjust height of regressor to plot filled contours
ax2.contourf(w1_vals,
w2_vals,
g_vals + 0.5,
colors=self.colors[:],
alpha=0.2,
levels=range(0, C + 1))
### clean up panels
# set viewing limits on vertical dimension for 3d plot
minz = 0
maxz = max(copy.deepcopy(self.y))
gapz = (maxz - minz) * 0.1
minz -= gapz
maxz += gapz
ax1.set_zlim([minz, maxz])
ax1.view_init(view[0], view[1])
# clean up panel
ax1.xaxis.pane.fill = False
ax1.yaxis.pane.fill = False
ax1.zaxis.pane.fill = False
ax1.xaxis.pane.set_edgecolor('white')
ax1.yaxis.pane.set_edgecolor('white')
ax1.zaxis.pane.set_edgecolor('white')
ax1.xaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax1.yaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax1.zaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax1.set_xlabel(r'$x_1$', fontsize=16, labelpad=5)
ax1.set_ylabel(r'$x_2$', rotation=0, fontsize=16, labelpad=5)
ax1.set_zlabel(r'$y$', rotation=0, fontsize=16, labelpad=5)
ax2.set_xlabel(r'$x_1$', fontsize=18, labelpad=10)
ax2.set_ylabel(r'$x_2$', rotation=0, fontsize=18, labelpad=15)
def show_surface_fit(self, w_hist, view, **kwargs):
'''
# determine best set of weights from history
cost_evals = []
for i in range(len(w_hist)):
W = w_hist[i]
cost = self.counting_cost(W)
cost_evals.append(cost)
ind = np.argmin(cost_evals)
'''
# or just take last weights
self.W = w_hist[-1]
# initialize figure
fig = plt.figure(figsize=(9, 4))
gs = gridspec.GridSpec(1, 2, width_ratios=[1.5, 1])
# setup current axis
ax = plt.subplot(gs[0], projection='3d')
ax2 = plt.subplot(gs[1], aspect='equal')
# load in args
zplane = 'on'
if 'zplane' in kwargs:
zplane = kwargs['zplane']
# generate input range for viewing range
minx = min(min(self.x[0, :]), min(self.x[1, :]))
maxx = max(max(self.x[0, :]), max(self.x[1, :]))
gapx = (maxx - minx) * 0.1
minx -= gapx
maxx += gapx
# plot panel with all data and separators
# scatter points in both panels
class_nums = np.unique(self.y)
C = len(class_nums)
# plot data in right panel from above
self.plot_data(ax2)
### draw multiclass boundary on right panel
r = np.linspace(minx, maxx, 1000)
w1_vals, w2_vals = np.meshgrid(r, r)
w1_vals.shape = (len(r)**2, 1)
w2_vals.shape = (len(r)**2, 1)
o = np.ones((len(r)**2, 1))
h = np.concatenate([o, w1_vals, w2_vals], axis=1)
pts = np.dot(h, self.W)
g_vals = np.argmax(pts, axis=1)
# vals for cost surface
w1_vals.shape = (len(r), len(r))
w2_vals.shape = (len(r), len(r))
g_vals.shape = (len(r), len(r))
# plot contour in right panel
C = len(np.unique(self.y))
ax2.contour(w1_vals,
w2_vals,
g_vals,
colors='k',
levels=range(-1, C),
linewidths=2.75,
zorder=4)
ax2.contourf(w1_vals,
w2_vals,
g_vals,
colors=self.colors[:],
alpha=0.2,
levels=range(-1, C))
# plot surface and z-plane contour in left panel
ax.plot_surface(w1_vals,
w2_vals,
g_vals,
alpha=0.3,
color='w',
rstride=50,
cstride=50,
linewidth=0.5,
edgecolor='k',
zorder=0)
# plot zplane = 0 in left 3d panel - showing intersection of regressor with z = 0 (i.e., its contour, the separator, in the 3d plot too)?
if zplane == 'on':
g_vals += 1
#ax.plot_surface(w1_vals,w2_vals,g_vals*0-1,alpha = 0.1)
# loop over each class and color in z-plane
for c in class_nums:
# plot separator curve in left plot z plane
ax.contour(w1_vals,
w2_vals,
g_vals - c,
colors='k',
levels=[0],
linewidths=3,
zorder=1)
# color parts of plane with correct colors
ax.contourf(w1_vals,
w2_vals,
g_vals - 0.5 - c,
colors=self.colors[(int(c)):],
alpha=0.1,
levels=range(0, 2))
# scatter points in 3d
for c in range(C):
ind = np.argwhere(self.y == class_nums[c])
ind = [v[0] for v in ind]
ax.scatter(self.x[0, ind],
self.x[1, ind],
self.y[ind],
s=80,
color=self.colors[c],
edgecolor='k',
linewidth=1.5,
zorder=3)
# dress panel
ax.view_init(view[0], view[1])
ax.axis('off')
ax.set_xlim(minx, maxx)
ax.set_ylim(minx, maxx)
ax.set_zlim(-0.5, C + 0.5)
ax2.set_xticks([])
ax2.set_yticks([])
ax2.set_yticklabels([])
ax2.set_xticklabels([])
ax2.set_xlim(minx, maxx)
ax2.set_ylim(minx, maxx)
lmb = 0.001
for i in range(100):
loss_grad = grad(loss_fun)(X, Y, w)
w[0] = w[0] - lmb * loss_grad[0]
w[1] = w[1] - lmb * loss_grad[1]
surface2 = np.zeros((nx, ny))
for i, x in enumerate(X):
for j, y in enumerate(Y):
surface2[i][j] = psy_trial(x, y, w)
fig = plt.figure()
ax = fig.gca(projection='3d')
x, y = np.meshgrid(X, Y)
surf = ax.plot_surface(x,
y,
surface,
rstride=1,
cstride=1,
cmap=cm.viridis,
linewidth=0,
antialiased=False)
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.set_zlim(0, 2)
ax.set_xlabel('$x$')
ax.set_ylabel('$y$')
return activation(np.dot(inputs, weights))
def loss(weights):
preds = predict(weights, train_X)
label_probabilities = preds * train_y + (1 - preds) * (1 - train_y)
return -np.sum(np.log(label_probabilities))
# Compute the gradient of the loss function
gradient_loss = grad(loss)
# Set the initial weights
weights = np.array([1.0, 1.0])
# Steepest Descent
loss_values = []
learning_rate = 0.001
for i in range(100):
loss_values.append(loss(weights))
step = gradient_loss(weights)
weights -= step * learning_rate
# Plot the decision boundary
x_min, x_max = train_X[:, 0].min() - 0.5, train_X[:, 0].max() + 0.5
y_min, y_max = train_X[:, 1].min() - 0.5, train_X[:, 1].max() + 0.5
x_mesh, y_mesh = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))
Z = predict(weights, np.c_[x_mesh.ravel(), y_mesh.ravel()])
Z = Z.reshape(x_mesh.shape)
cs = pylab.contourf(x_mesh, y_mesh, Z, cmap=pylab.cm.Spectral)
pylab.scatter(train_X[:, 0], train_X[:, 1], c=train_y, cmap=pylab.cm.Spectral)
pylab.colorbar(cs)
# Plot the loss over each step
pylab.figure()
pylab.plot(loss_values)
pylab.xlabel("Steps")
pylab.ylabel("Loss")
pylab.show()
def draw_2d(self, g, **kwargs):
self.g = g # input function
wmin = -5.1
wmax = 5.1
view = [50, 50]
num_contours = 100
if 'wmin' in kwargs:
wmin = kwargs['wmin']
if 'wmax' in kwargs:
wmax = kwargs['wmax']
if 'view' in kwargs:
view = kwargs['view']
if 'num_contours' in kwargs:
num_contours = kwargs['num_contours']
##### construct figure with panels #####
# construct figure
fig = plt.figure(figsize=(9, 3))
# remove whitespace from figure
fig.subplots_adjust(left=0, right=1, bottom=0,
top=1) # remove whitespace
# create subplot with 3 panels, plot input function in center plot
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 2])
ax = plt.subplot(gs[0], projection='3d')
ax2 = plt.subplot(gs[1], aspect='equal')
#### define input space for function and evaluate ####
w = np.linspace(-wmax, wmax, 200)
w1_vals, w2_vals = np.meshgrid(w, w)
w1_vals.shape = (len(w)**2, 1)
w2_vals.shape = (len(w)**2, 1)
h = np.concatenate((w1_vals, w2_vals), axis=1)
func_vals = np.asarray([g(s) for s in h])
w1_vals.shape = (len(w), len(w))
w2_vals.shape = (len(w), len(w))
func_vals.shape = (len(w), len(w))
### plot function as surface ###
ax.plot_surface(w1_vals,
w2_vals,
func_vals,
alpha=0.1,
color='w',
rstride=25,
cstride=25,
linewidth=1,
edgecolor='k',
zorder=2)
# plot z=0 plane
ax.plot_surface(w1_vals,
w2_vals,
func_vals * 0,
alpha=0.1,
color='w',
zorder=1,
rstride=25,
cstride=25,
linewidth=0.3,
edgecolor='k')
### plot function as contours ###
# set level ridges
levelmin = min(func_vals.flatten())
levelmax = max(func_vals.flatten())
cutoff = 0.5
cutoff = (levelmax - levelmin) * cutoff
numper = 3
levels1 = np.linspace(cutoff, levelmax, numper)
num_contours -= numper
levels2 = np.linspace(levelmin, cutoff, min(num_contours, numper))
levels = np.unique(np.append(levels1, levels2))
num_contours -= numper
while num_contours > 0:
cutoff = levels[1]
levels2 = np.linspace(levelmin, cutoff, min(num_contours, numper))
levels = np.unique(np.append(levels2, levels))
num_contours -= numper
ax2.contour(w1_vals, w2_vals, func_vals, levels=levels, colors='k')
ax2.contourf(w1_vals, w2_vals, func_vals, levels=levels, cmap='Blues')
### cleanup panels ###
ax.set_xlabel('$w_1$', fontsize=12)
ax.set_ylabel('$w_2$', fontsize=12, rotation=0)
ax.set_title('$g(w_1,w_2)$', fontsize=12)
ax.view_init(view[0], view[1])
ax2.set_xlabel('$w_1$', fontsize=12)
ax2.set_ylabel('$w_2$', fontsize=12, rotation=0)
ax2.axhline(y=0, color='k', zorder=0, linewidth=0.5)
ax2.axvline(x=0, color='k', zorder=0, linewidth=0.5)
ax2.set_xticks(np.arange(-round(wmax), round(wmax) + 1))
ax2.set_yticks(np.arange(-round(wmax), round(wmax) + 1))
# clean up axis
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('white')
ax.yaxis.pane.set_edgecolor('white')
ax.zaxis.pane.set_edgecolor('white')
ax.xaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.yaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.zaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
# plot
plt.show()
loss_grad = grad(loss_function)(W, x_space, y_space)
W[0] = W[0] - lmb * loss_grad[0]
W[1] = W[1] - lmb * loss_grad[1]
print(loss_function(W, x_space, y_space))
surface2 = np.zeros((ny, nx))
for i, x in enumerate(x_space):
for j, y in enumerate(y_space):
net_outt = neural_network(W, [x, y])[0]
surface2[i][j] = psy_trial([x, y], net_outt)
fig = plt.figure()
ax = fig.gca(projection='3d')
X, Y = np.meshgrid(x_space, y_space)
surf = ax.plot_surface(X,
Y,
surface2,
rstride=1,
cstride=1,
cmap=cm.viridis,
linewidth=0,
antialiased=False)
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.set_zlim(0, 1)
ax.set_xlabel('$x$')
ax.set_ylabel('$y$')
#number density of obj in 1d
sig_psf = 0.1 # psf width
sig_noise = 0.02 # noise level
#these are values for the power law function for sampling intensities
w_interval = (1, 2)
w_lin = np.linspace(1, 2, 100)
alpha_true = 2
w_norm = (50**(alpha_true + 1) -
w_interval[0]**(alpha_true + 1)) / (alpha_true + 1)
w_func = np.power(w_lin, alpha_true) / w_norm
w_true = w_norm * np.random.choice(w_func, Ndata)
mid = int(n_grid / 2)
x, y = np.meshgrid(pix_1d, pix_1d)
psf = np.exp(-((y - pix_1d[mid])**2 + (x - pix_1d[mid])**2) / 2 / sig_psf**2)
#keep in mind difference between x and y position and indices! Here, you are given indices, but meshgrid is in x-y coords
def psi(pos):
''' measurement model, which in our case is just a 1d gaussian of width
sigma (PSF) written out to a meshgrid created by pix1d
'''
x, y = np.meshgrid(pix_1d, pix_1d)
return np.exp(-((y - pix_1d[pos[0]])**2 + (x - pix_1d[pos[1]])**2) / 2 /
sig_psf**2)
#keep in mind difference between x and y position and indices! Here, you are given indices, but meshgrid is in x-y coords
def gaussian(x, loc=None, scale=None):
def static_N2_simple(self, ax, w_best, runner, train_valid):
cost = runner.cost
predict = runner.model
feat = runner.feature_transforms
normalizer = runner.normalizer
inverse_nornalizer = runner.inverse_normalizer
# or just take last weights
self.w = w_best
### create boundary data ###
xmin1 = np.min(self.x[:, 0])
xmax1 = np.max(self.x[:, 0])
xgap1 = (xmax1 - xmin1) * 0.05
xmin1 -= xgap1
xmax1 += xgap1
xmin2 = np.min(self.x[:, 1])
xmax2 = np.max(self.x[:, 1])
xgap2 = (xmax2 - xmin2) * 0.05
xmin2 -= xgap2
xmax2 += xgap2
# plot boundary for 2d plot
r1 = np.linspace(xmin1, xmax1, 300)
r2 = np.linspace(xmin2, xmax2, 300)
s, t = np.meshgrid(r1, r2)
s = np.reshape(s, (np.size(s), 1))
t = np.reshape(t, (np.size(t), 1))
h = np.concatenate((s, t), axis=1)
# compute model on train data
z1 = predict(normalizer(h.T), self.w)
z1 = np.sign(z1)
# reshape it
s.shape = (np.size(r1), np.size(r2))
t.shape = (np.size(r1), np.size(r2))
z1.shape = (np.size(r1), np.size(r2))
### loop over two panels plotting each ###
# plot training points
if train_valid == 'train':
# reverse normalize data
x_train = inverse_nornalizer(runner.x_train).T
y_train = runner.y_train
# plot data
ind0 = np.argwhere(y_train == +1)
ind0 = [v[1] for v in ind0]
ax.scatter(x_train[ind0, 0],
x_train[ind0, 1],
s=45,
color=self.colors[0],
edgecolor=[0, 0.7, 1],
linewidth=1,
zorder=3)
ind1 = np.argwhere(y_train == -1)
ind1 = [v[1] for v in ind1]
ax.scatter(x_train[ind1, 0],
x_train[ind1, 1],
s=45,
color=self.colors[1],
edgecolor=[0, 0.7, 1],
linewidth=1,
zorder=3)
ax.set_title('training data', fontsize=15)
if train_valid == 'validate':
# reverse normalize data
x_valid = inverse_nornalizer(runner.x_valid).T
y_valid = runner.y_valid
# plot testing points
ind0 = np.argwhere(y_valid == +1)
ind0 = [v[1] for v in ind0]
ax.scatter(x_valid[ind0, 0],
x_valid[ind0, 1],
s=45,
color=self.colors[0],
edgecolor=[1, 0.8, 0.5],
linewidth=1,
zorder=3)
ind1 = np.argwhere(y_valid == -1)
ind1 = [v[1] for v in ind1]
ax.scatter(x_valid[ind1, 0],
x_valid[ind1, 1],
s=45,
color=self.colors[1],
edgecolor=[1, 0.8, 0.5],
linewidth=1,
zorder=3)
ax.set_title('validation data', fontsize=15)
if train_valid == 'original':
# plot all points
ind0 = np.argwhere(self.y == +1)
ax.scatter(self.x[ind0, 0],
self.x[ind0, 1],
s=55,
color=self.colors[0],
edgecolor='k',
linewidth=1,
zorder=3)
ind1 = np.argwhere(self.y == -1)
ax.scatter(self.x[ind1, 0],
self.x[ind1, 1],
s=55,
color=self.colors[1],
edgecolor='k',
linewidth=1,
zorder=3)
ax.set_title('original data', fontsize=15)
#### plot contour, color regions ####
ax.contour(s, t, z1, colors='k', linewidths=2.5, levels=[0], zorder=2)
ax.contourf(s,
t,
z1,
colors=[self.colors[1], self.colors[0]],
alpha=0.15,
levels=range(-1, 2))
# cleanup panel
ax.set_xlabel(r'$x_1$', fontsize=15)
ax.set_ylabel(r'$x_2$', fontsize=15, rotation=0, labelpad=20)
ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
def reconstruct_fullfield(fname,
theta_st=0,
theta_end=PI,
n_epochs='auto',
crit_conv_rate=0.03,
max_nepochs=200,
alpha=1e-7,
alpha_d=None,
alpha_b=None,
gamma=1e-6,
learning_rate=1.0,
output_folder=None,
minibatch_size=None,
save_intermediate=False,
full_intermediate=False,
energy_ev=5000,
psize_cm=1e-7,
n_epochs_mask_release=None,
cpu_only=False,
save_path='.',
shrink_cycle=10,
core_parallelization=True,
free_prop_cm=None,
multiscale_level=1,
n_epoch_final_pass=None,
initial_guess=None,
n_batch_per_update=5,
dynamic_rate=True,
probe_type='plane',
probe_initial=None,
probe_learning_rate=1e-3,
pupil_function=None,
theta_downsample=None,
forward_algorithm='fresnel',
random_theta=True,
object_type='normal',
fresnel_approx=True,
shared_file_object=False,
reweighted_l1=False,
**kwargs):
"""
Reconstruct a beyond depth-of-focus object.
:param fname: Filename and path of raw data file. Must be in HDF5 format.
:param theta_st: Starting rotation angle.
:param theta_end: Ending rotation angle.
:param n_epochs: Number of epochs to be executed. If given 'auto', optimizer will stop
when reduction rate of loss function goes below crit_conv_rate.
:param crit_conv_rate: Reduction rate of loss function below which the optimizer should
stop.
:param max_nepochs: The maximum number of epochs to be executed if n_epochs is 'auto'.
:param alpha: Weighting coefficient for both delta and beta regularizer. Should be None
if alpha_d and alpha_b are specified.
:param alpha_d: Weighting coefficient for delta regularizer.
:param alpha_b: Weighting coefficient for beta regularizer.
:param gamma: Weighting coefficient for TV regularizer.
:param learning_rate: Learning rate of ADAM.
:param output_folder: Name of output folder. Put None for auto-generated pattern.
:param downsample: Downsampling (not implemented yet).
:param minibatch_size: Size of minibatch.
:param save_intermediate: Whether to save the object after each epoch.
:param energy_ev: Beam energy in eV.
:param psize_cm: Pixel size in cm.
:param n_epochs_mask_release: The number of epochs after which the finite support mask
is released. Put None to disable this feature.
:param cpu_only: Whether to disable GPU.
:param save_path: The location of finite support mask, the prefix of output_folder and
other metadata.
:param shrink_cycle: Shrink-wrap is executed per every this number of epochs.
:param core_parallelization: Whether to use Horovod for parallelized computation within
this function.
:param free_prop_cm: The distance to propagate the wavefront in free space after exiting
the sample, in cm.
:param multiscale_level: The level of multiscale processing. When this number is m and
m > 1, m - 1 low-resolution reconstructions will be performed
before reconstructing with the original resolution. The downsampling
factor for these coarse reconstructions will be [2^(m - 1),
2^(m - 2), ..., 2^1].
:param n_epoch_final_pass: specify a number of iterations for the final pass if multiscale
is activated. If None, it will be the same as n_epoch.
:param initial_guess: supply an initial guess. If None, object will be initialized with noises.
:param n_batch_per_update: number of minibatches during which gradients are accumulated, after
which obj is updated.
:param dynamic_rate: when n_batch_per_update > 1, adjust learning rate dynamically to allow it
to decrease with epoch number
:param probe_type: type of wavefront. Can be 'plane', ' fixed', or 'optimizable'. If 'optimizable',
the probe function will be optimized along with the object.
:param probe_initial: can be provided for 'optimizable' probe_type, and must be provided for
'fixed'.
"""
def calculate_loss(obj_delta, obj_beta, this_ind_batch, this_prj_batch):
if not shared_file_object:
obj_stack = np.stack([obj_delta, obj_beta], axis=3)
obj_rot_batch = []
for i in range(minibatch_size):
obj_rot_batch.append(
apply_rotation(
obj_stack, coord_ls[this_ind_batch[i]],
'arrsize_{}_{}_{}_ntheta_{}'.format(
dim_y, dim_x, dim_x, n_theta)))
obj_rot_batch = np.stack(obj_rot_batch)
exiting_batch = multislice_propagate_batch_numpy(
obj_rot_batch[:, :, :, :, 0],
obj_rot_batch[:, :, :, :, 1],
probe_real,
probe_imag,
energy_ev,
psize_cm * ds_level,
free_prop_cm=free_prop_cm,
obj_batch_shape=[minibatch_size, *this_obj_size],
kernel=h,
fresnel_approx=fresnel_approx)
loss = np.mean((np.abs(exiting_batch) - np.abs(this_prj_batch))**2)
else:
exiting_batch = multislice_propagate_batch_numpy(
obj_delta,
obj_beta,
probe_real,
probe_imag,
energy_ev,
psize_cm * ds_level,
free_prop_cm=free_prop_cm,
obj_batch_shape=obj_delta.shape,
kernel=h,
fresnel_approx=fresnel_approx)
exiting_batch = exiting_batch[:, safe_zone_width:exiting_batch.
shape[1] - safe_zone_width,
safe_zone_width:exiting_batch.
shape[2] - safe_zone_width]
loss = np.mean((np.abs(exiting_batch) - np.abs(this_prj_batch))**2)
dxchange.write_tiff(
np.squeeze(abs(exiting_batch._value)),
'cone_256_foam/test_shared_file_object/current/exit_{}'.format(
rank),
dtype='float32',
overwrite=True)
dxchange.write_tiff(
np.squeeze(abs(this_prj_batch)),
'cone_256_foam/test_shared_file_object/current/prj_{}'.format(
rank),
dtype='float32',
overwrite=True)
reg_term = 0
if reweighted_l1:
if alpha_d not in [None, 0]:
reg_term = reg_term + alpha_d * np.mean(
weight_l1 * np.abs(obj_delta))
loss = loss + reg_term
if alpha_b not in [None, 0]:
reg_term = reg_term + alpha_b * np.mean(
weight_l1 * np.abs(obj_beta))
loss = loss + reg_term
else:
if alpha_d not in [None, 0]:
reg_term = reg_term + alpha_d * np.mean(np.abs(obj_delta))
loss = loss + reg_term
if alpha_b not in [None, 0]:
reg_term = reg_term + alpha_b * np.mean(np.abs(obj_beta))
loss = loss + reg_term
if gamma not in [None, 0]:
if shared_file_object:
reg_term = reg_term + gamma * total_variation_3d(obj_delta,
axis_offset=1)
else:
reg_term = reg_term + gamma * total_variation_3d(obj_delta,
axis_offset=0)
loss = loss + reg_term
print('Loss:', loss._value, 'Regularization term:',
reg_term._value if reg_term != 0 else 0)
# if alpha_d is None:
# reg_term = alpha * (np.sum(np.abs(obj_delta)) + np.sum(np.abs(obj_delta))) + gamma * total_variation_3d(
# obj_delta)
# else:
# if gamma == 0:
# reg_term = alpha_d * np.sum(np.abs(obj_delta)) + alpha_b * np.sum(np.abs(obj_beta))
# else:
# reg_term = alpha_d * np.sum(np.abs(obj_delta)) + alpha_b * np.sum(
# np.abs(obj_beta)) + gamma * total_variation_3d(obj_delta)
# loss = loss + reg_term
# Write convergence data
f_conv.write('{},{},{},'.format(i_epoch, i_batch, loss._value))
f_conv.flush()
return loss
comm = MPI.COMM_WORLD
n_ranks = comm.Get_size()
rank = comm.Get_rank()
t_zero = time.time()
# read data
t0 = time.time()
print_flush('Reading data...', 0, rank)
f = h5py.File(os.path.join(save_path, fname), 'r')
prj_0 = f['exchange/data']
theta = -np.linspace(theta_st, theta_end, prj_0.shape[0], dtype='float32')
n_theta = len(theta)
prj_theta_ind = np.arange(n_theta, dtype=int)
if theta_downsample is not None:
prj_0 = prj_0[::theta_downsample]
theta = theta[::theta_downsample]
prj_theta_ind = prj_theta_ind[::theta_downsample]
n_theta = len(theta)
original_shape = prj_0.shape
comm.Barrier()
print_flush('Data reading: {} s'.format(time.time() - t0), 0, rank)
print_flush('Data shape: {}'.format(original_shape), 0, rank)
comm.Barrier()
if output_folder is None:
output_folder = 'recon_360_minibatch_{}_' \
'mskrls_{}_' \
'shrink_{}_' \
'iter_{}_' \
'alphad_{}_' \
'alphab_{}_' \
'gamma_{}_' \
'rate_{}_' \
'energy_{}_' \
'size_{}_' \
'ntheta_{}_' \
'prop_{}_' \
'ms_{}_' \
'cpu_{}' \
.format(minibatch_size, n_epochs_mask_release, shrink_cycle,
n_epochs, alpha_d, alpha_b,
gamma, learning_rate, energy_ev,
prj_0.shape[-1], prj_0.shape[0], free_prop_cm,
multiscale_level, cpu_only)
if abs(PI - theta_end) < 1e-3:
output_folder += '_180'
if save_path != '.':
output_folder = os.path.join(save_path, output_folder)
for ds_level in range(multiscale_level - 1, -1, -1):
initializer_flag = False if ds_level == range(multiscale_level -
1, -1, -1)[0] else True
ds_level = 2**ds_level
print_flush('Multiscale downsampling level: {}'.format(ds_level), 0,
rank)
comm.Barrier()
# Physical metadata
voxel_nm = np.array([psize_cm] * 3) * 1.e7 * ds_level
lmbda_nm = 1240. / energy_ev
delta_nm = voxel_nm[-1]
# downsample data
prj = prj_0
# prj = np.copy(prj_0)
# if ds_level > 1:
# prj = prj[:, ::ds_level, ::ds_level]
# prj = prj.astype('complex64')
# comm.Barrier()
dim_y, dim_x = prj.shape[-2] // ds_level, prj.shape[-1] // ds_level
this_obj_size = [dim_y, dim_x, dim_x]
comm.Barrier()
if shared_file_object:
# Create parallel npy
if rank == 0:
try:
os.makedirs(os.path.join(output_folder))
except:
print('Target folder {} exists.'.format(output_folder))
np.save(os.path.join(output_folder, 'intermediate_obj.npy'),
np.zeros([*this_obj_size, 2]))
np.save(os.path.join(output_folder, 'intermediate_m.npy'),
np.zeros([*this_obj_size, 2]))
np.save(os.path.join(output_folder, 'intermediate_v.npy'),
np.zeros([*this_obj_size, 2]))
comm.Barrier()
# Create memmap pointer on each rank
dset = np.load(os.path.join(output_folder, 'intermediate_obj.npy'),
mmap_mode='r+',
allow_pickle=True)
dset_m = np.load(os.path.join(output_folder, 'intermediate_m.npy'),
mmap_mode='r+',
allow_pickle=True)
dset_v = np.load(os.path.join(output_folder, 'intermediate_v.npy'),
mmap_mode='r+',
allow_pickle=True)
# Get block allocation
n_blocks_y, n_blocks_x, n_blocks, block_size = get_block_division(
this_obj_size, n_ranks)
print_flush('Number of blocks in y: {}'.format(n_blocks_y), 0,
rank)
print_flush('Number of blocks in x: {}'.format(n_blocks_x), 0,
rank)
print_flush('Block size: {}'.format(block_size), 0, rank)
probe_pos = []
# probe_pos is a list of tuples of (line_st, line_end, px_st, ps_end).
for i_pos in range(n_blocks):
probe_pos.append(
get_block_range(i_pos, n_blocks_x, block_size)[:4])
probe_pos = np.array(probe_pos)
if free_prop_cm not in [0, None]:
safe_zone_width = ceil(4.0 * np.sqrt(
(delta_nm * dim_x + free_prop_cm * 1e7) * lmbda_nm) /
(voxel_nm[0]))
else:
safe_zone_width = ceil(4.0 * np.sqrt(
(delta_nm * dim_x) * lmbda_nm) / (voxel_nm[0]))
print_flush('safe zone: {}'.format(safe_zone_width), 0, rank)
# read rotation data
try:
coord_ls = read_all_origin_coords(
'arrsize_{}_{}_{}_ntheta_{}'.format(dim_y, dim_x, dim_x,
n_theta), n_theta)
except:
save_rotation_lookup([dim_y, dim_x, dim_x], n_theta)
coord_ls = read_all_origin_coords(
'arrsize_{}_{}_{}_ntheta_{}'.format(dim_y, dim_x, dim_x,
n_theta), n_theta)
if minibatch_size is None:
minibatch_size = n_theta
if n_epochs_mask_release is None:
n_epochs_mask_release = np.inf
if (not shared_file_object) or (shared_file_object and rank == 0):
try:
mask = dxchange.read_tiff_stack(
os.path.join(save_path, 'fin_sup_mask', 'mask_00000.tiff'),
range(prj_0.shape[1]))
except:
try:
mask = dxchange.read_tiff(
os.path.join(save_path, 'fin_sup_mask', 'mask.tiff'))
except:
obj_pr = dxchange.read_tiff_stack(
os.path.join(save_path,
'paganin_obj/recon_00000.tiff'),
range(prj_0.shape[1]), 5)
obj_pr = gaussian_filter(np.abs(obj_pr),
sigma=3,
mode='constant')
mask = np.zeros_like(obj_pr)
mask[obj_pr > 1e-5] = 1
dxchange.write_tiff_stack(mask,
os.path.join(
save_path,
'fin_sup_mask/mask'),
dtype='float32',
overwrite=True)
if ds_level > 1:
mask = mask[::ds_level, ::ds_level, ::ds_level]
if shared_file_object:
np.save(os.path.join(output_folder, 'intermediate_mask.npy'),
mask)
comm.Barrier()
if shared_file_object:
dset_mask = np.load(os.path.join(output_folder,
'intermediate_mask.npy'),
mmap_mode='r+',
allow_pickle=True)
# unify random seed for all threads
comm.Barrier()
seed = int(time.time() / 60)
np.random.seed(seed)
comm.Barrier()
if rank == 0:
if initializer_flag == False:
if initial_guess is None:
print_flush('Initializing with Gaussian random.', 0, rank)
obj_delta = np.random.normal(size=[dim_y, dim_x, dim_x],
loc=8.7e-7,
scale=1e-7) * mask
obj_beta = np.random.normal(size=[dim_y, dim_x, dim_x],
loc=5.1e-8,
scale=1e-8) * mask
obj_delta[obj_delta < 0] = 0
obj_beta[obj_beta < 0] = 0
else:
print_flush('Using supplied initial guess.', 0, rank)
sys.stdout.flush()
obj_delta = initial_guess[0]
obj_beta = initial_guess[1]
else:
print_flush('Initializing previous pass outcomes.', 0, rank)
obj_delta = dxchange.read_tiff(
os.path.join(output_folder,
'delta_ds_{}.tiff'.format(ds_level * 2)))
obj_beta = dxchange.read_tiff(
os.path.join(output_folder,
'beta_ds_{}.tiff'.format(ds_level * 2)))
obj_delta = upsample_2x(obj_delta)
obj_beta = upsample_2x(obj_beta)
obj_delta += np.random.normal(
size=[dim_y, dim_x, dim_x], loc=8.7e-7, scale=1e-7) * mask
obj_beta += np.random.normal(
size=[dim_y, dim_x, dim_x], loc=5.1e-8, scale=1e-8) * mask
obj_delta[obj_delta < 0] = 0
obj_beta[obj_beta < 0] = 0
obj_size = obj_delta.shape
if object_type == 'phase_only':
obj_beta[...] = 0
elif object_type == 'absorption_only':
obj_delta[...] = 0
if not shared_file_object:
np.save('init_delta_temp.npy', obj_delta)
np.save('init_beta_temp.npy', obj_beta)
else:
dset[:, :, :, 0] = obj_delta
dset[:, :, :, 1] = obj_beta
dset_m[...] = 0
dset_v[...] = 0
comm.Barrier()
if not shared_file_object:
obj_delta = np.zeros(this_obj_size)
obj_beta = np.zeros(this_obj_size)
obj_delta[:, :, :] = np.load('init_delta_temp.npy',
allow_pickle=True)
obj_beta[:, :, :] = np.load('init_beta_temp.npy',
allow_pickle=True)
comm.Barrier()
if rank == 0:
os.remove('init_delta_temp.npy')
os.remove('init_beta_temp.npy')
comm.Barrier()
print_flush('Initialzing probe...', 0, rank)
if not shared_file_object:
if probe_type == 'plane':
probe_real = np.ones([dim_y, dim_x])
probe_imag = np.zeros([dim_y, dim_x])
elif probe_type == 'optimizable':
if probe_initial is not None:
probe_mag, probe_phase = probe_initial
probe_real, probe_imag = mag_phase_to_real_imag(
probe_mag, probe_phase)
else:
# probe_mag = np.ones([dim_y, dim_x])
# probe_phase = np.zeros([dim_y, dim_x])
back_prop_cm = (free_prop_cm + (psize_cm * obj_size[2])
) if free_prop_cm is not None else (
psize_cm * obj_size[2])
probe_init = create_probe_initial_guess(
os.path.join(save_path, fname), back_prop_cm * 1.e7,
energy_ev, psize_cm * 1.e7)
probe_real = probe_init.real
probe_imag = probe_init.imag
if pupil_function is not None:
probe_real = probe_real * pupil_function
probe_imag = probe_imag * pupil_function
elif probe_type == 'fixed':
probe_mag, probe_phase = probe_initial
probe_real, probe_imag = mag_phase_to_real_imag(
probe_mag, probe_phase)
elif probe_type == 'point':
# this should be in spherical coordinates
probe_real = np.ones([dim_y, dim_x])
probe_imag = np.zeros([dim_y, dim_x])
elif probe_type == 'gaussian':
probe_mag_sigma = kwargs['probe_mag_sigma']
probe_phase_sigma = kwargs['probe_phase_sigma']
probe_phase_max = kwargs['probe_phase_max']
py = np.arange(obj_size[0]) - (obj_size[0] - 1.) / 2
px = np.arange(obj_size[1]) - (obj_size[1] - 1.) / 2
pxx, pyy = np.meshgrid(px, py)
probe_mag = np.exp(-(pxx**2 + pyy**2) /
(2 * probe_mag_sigma**2))
probe_phase = probe_phase_max * np.exp(
-(pxx**2 + pyy**2) / (2 * probe_phase_sigma**2))
probe_real, probe_imag = mag_phase_to_real_imag(
probe_mag, probe_phase)
else:
raise ValueError(
'Invalid wavefront type. Choose from \'plane\', \'fixed\', \'optimizable\'.'
)
else:
if probe_type == 'plane':
probe_real = np.ones([block_size + 2 * safe_zone_width] * 2)
probe_imag = np.zeros([block_size + 2 * safe_zone_width] * 2)
else:
raise ValueError(
'probe_type other than plane is not yet supported with shared file object.'
)
# =============finite support===================
if not shared_file_object:
obj_delta = obj_delta * mask
obj_beta = obj_beta * mask
obj_delta = np.clip(obj_delta, 0, None)
obj_beta = np.clip(obj_beta, 0, None)
# ==============================================
# generate Fresnel kernel
if not shared_file_object:
h = get_kernel(delta_nm,
lmbda_nm,
voxel_nm, [dim_y, dim_y, dim_x],
fresnel_approx=fresnel_approx)
else:
h = get_kernel(delta_nm,
lmbda_nm,
voxel_nm, [
block_size + safe_zone_width * 2,
block_size + safe_zone_width * 2, dim_x
],
fresnel_approx=fresnel_approx)
loss_grad = grad(calculate_loss, [0, 1])
# Save convergence data
try:
os.makedirs(os.path.join(output_folder, 'convergence'))
except:
pass
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')
print_flush('Optimizer started.', 0, rank)
if rank == 0:
create_summary(output_folder, locals(), preset='fullfield')
cont = True
i_epoch = 0
while cont:
if shared_file_object:
# Do a ptychography-like allocation.
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))
spots_ls = range(n_spots)
ind_list_rand = []
theta_ls = np.arange(n_theta)
np.random.shuffle(theta_ls)
for i, i_theta in enumerate(theta_ls):
spots_ls = range(n_pos)
if n_pos % minibatch_size != 0:
# Append randomly selected diffraction spots if necessary, so that a rank won't be given
# spots from different angles in one batch.
spots_ls = np.append(
spots_ls,
np.random.choice(
spots_ls[:-(n_pos % minibatch_size)],
minibatch_size - (n_pos % minibatch_size),
replace=False))
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)
probe_size_half = block_size // 2 + safe_zone_width
else:
ind_list_rand = np.arange(n_theta)
np.random.shuffle(ind_list_rand)
n_tot_per_batch = n_ranks * minibatch_size
if n_theta % n_tot_per_batch > 0:
ind_list_rand = np.concatenate([
ind_list_rand, ind_list_rand[:n_tot_per_batch -
n_theta % n_tot_per_batch]
])
ind_list_rand = split_tasks(ind_list_rand, n_tot_per_batch)
ind_list_rand = [np.sort(x) for x in ind_list_rand]
m, v = (None, None)
t0 = time.time()
for i_batch in range(len(ind_list_rand)):
t00 = time.time()
if not shared_file_object:
this_ind_batch = ind_list_rand[i_batch][rank *
minibatch_size:
(rank + 1) *
minibatch_size]
this_prj_batch = prj[
this_ind_batch, ::ds_level, ::ds_level]
else:
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 = this_ind_batch[rank *
minibatch_size:(rank + 1) *
minibatch_size, 1]
this_prj_batch = []
for i_pos in this_ind_rank:
line_st, line_end, px_st, px_end = probe_pos[i_pos]
line_st_0 = max([0, line_st])
line_end_0 = min([dim_y, line_end])
px_st_0 = max([0, px_st])
px_end_0 = min([dim_x, px_end])
patch = prj[this_i_theta, ::ds_level, ::ds_level][
line_st_0:line_end_0, px_st_0:px_end_0]
if line_st < 0:
patch = np.pad(patch, [[-line_st, 0], [0, 0]],
mode='constant')
if line_end > dim_y:
patch = np.pad(patch,
[[0, line_end - dim_y], [0, 0]],
mode='constant')
if px_st < 0:
patch = np.pad(patch, [[0, 0], [-px_st, 0]],
mode='constant')
if px_end > dim_x:
patch = np.pad(patch,
[[0, 0], [0, px_end - dim_x]],
mode='constant')
this_prj_batch.append(patch)
this_prj_batch = np.array(this_prj_batch)
this_pos_batch = probe_pos[this_ind_rank]
this_pos_batch_safe = this_pos_batch + np.array([
-safe_zone_width, safe_zone_width, -safe_zone_width,
safe_zone_width
])
# if ds_level > 1:
# this_prj_batch = this_prj_batch[:, :, ::ds_level, ::ds_level]
comm.Barrier()
# Get values for local chunks of object_delta and beta; interpolate and read directly from HDF5
obj = get_rotated_subblocks(dset, this_pos_batch_safe,
coord_ls[this_i_theta], None)
obj_delta = np.array(obj[:, :, :, :, 0])
obj_beta = np.array(obj[:, :, :, :, 1])
m = get_rotated_subblocks(dset_m, this_pos_batch,
coord_ls[this_i_theta], None)
m = np.array([m[:, :, :, :, 0], m[:, :, :, :, 1]])
m_0 = np.copy(m)
v = get_rotated_subblocks(dset_v, this_pos_batch,
coord_ls[this_i_theta], None)
v = np.array([v[:, :, :, :, 0], v[:, :, :, :, 1]])
v_0 = np.copy(v)
mask = get_rotated_subblocks(dset_mask,
this_pos_batch,
coord_ls[this_i_theta],
None,
monochannel=True)
mask_0 = np.copy(mask)
# Update weight for reweighted L1
if i_batch % 10 == 0 and i_epoch >= 1:
weight_l1 = np.max(obj_delta) / (abs(obj_delta) + 1e-8)
else:
weight_l1 = np.ones_like(obj_delta)
grads = loss_grad(obj_delta, obj_beta, this_ind_batch,
this_prj_batch)
if not shared_file_object:
this_grads = np.array(grads)
grads = np.zeros_like(this_grads)
comm.Allreduce(this_grads, grads)
# grads = comm.allreduce(this_grads)
grads = np.array(grads)
grads = grads / n_ranks
if shared_file_object:
grads = grads[:, :,
safe_zone_width:safe_zone_width + block_size,
safe_zone_width:safe_zone_width +
block_size, :]
obj_delta = obj_delta[:,
safe_zone_width:obj_delta.shape[1] -
safe_zone_width,
safe_zone_width:obj_delta.shape[2] -
safe_zone_width, :]
obj_beta = obj_beta[:, safe_zone_width:obj_beta.shape[1] -
safe_zone_width,
safe_zone_width:obj_beta.shape[2] -
safe_zone_width, :]
(obj_delta, obj_beta), m, v = apply_gradient_adam(
np.array([obj_delta, obj_beta]),
grads,
i_batch,
m,
v,
step_size=learning_rate)
# finite support
obj_delta = obj_delta * mask
obj_beta = obj_beta * mask
obj_delta = np.clip(obj_delta, 0, None)
obj_beta = np.clip(obj_beta, 0, None)
# shrink wrap
if shrink_cycle is not None:
if i_batch % shrink_cycle == 0 and i_batch > 0:
boolean = obj_delta > 1e-12
boolean = boolean.astype('float')
if not shared_file_object:
mask = mask * boolean.astype('float')
if shared_file_object:
write_subblocks_to_file(dset_mask,
this_pos_batch,
boolean,
None,
coord_ls[this_i_theta],
probe_size_half,
mask=True)
if shared_file_object:
obj = obj[:,
safe_zone_width:obj.shape[1] - safe_zone_width,
safe_zone_width:obj.shape[2] -
safe_zone_width, :, :]
obj_delta = obj_delta - obj[:, :, :, :, 0]
obj_beta = obj_beta - obj[:, :, :, :, 1]
obj_delta = obj_delta / n_ranks
obj_beta = obj_beta / n_ranks
write_subblocks_to_file(dset, this_pos_batch, obj_delta,
obj_beta, coord_ls[this_i_theta],
probe_size_half)
m = m - m_0
m /= n_ranks
write_subblocks_to_file(dset_m, this_pos_batch, m[0], m[1],
coord_ls[this_i_theta],
probe_size_half)
v = v - v_0
v /= n_ranks
write_subblocks_to_file(dset_v, this_pos_batch, v[0], v[1],
coord_ls[this_i_theta],
probe_size_half)
if rank == 0:
if shared_file_object:
# dxchange.write_tiff(dset[:, :, :, 0],
# fname=os.path.join(output_folder, 'intermediate', 'current'.format(ds_level)),
# dtype='float32', overwrite=True)
dxchange.write_tiff(
dset[:, :, :, 0],
fname=os.path.join(
output_folder,
'current/delta_{}'.format(i_batch)),
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)
print_flush('Minibatch done in {} s (rank {})'.format(
time.time() - t00, rank))
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
# print_flush(
# 'Epoch {} (rank {}); loss = {}; Delta-t = {} s; current time = {}.'.format(i_epoch, rank,
# calculate_loss(obj_delta, obj_beta, this_ind_batch,
# this_prj_batch),
# time.time() - t0, time.time() - t_zero))
if rank == 0:
if shared_file_object:
dxchange.write_tiff(dset[:, :, :, 0],
fname=os.path.join(
output_folder,
'delta_ds_{}'.format(ds_level)),
dtype='float32',
overwrite=True)
dxchange.write_tiff(dset[:, :, :, 1],
fname=os.path.join(
output_folder,
'beta_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)
print_flush('Current iteration finished.', 0, rank)
def visualize3d(func,pt_history,eval_history,**kwargs):
### input arguments ###
wmax = 1
if 'wmax' in kwargs:
wmax = kwargs['wmax'] + 0.5
view = [20,-50]
if 'view' in kwargs:
view = kwargs['view']
axes = False
if 'axes' in kwargs:
axes = kwargs['axes']
plot_final = False
if 'plot_final' in kwargs:
plot_final = kwargs['plot_final']
num_contours = 10
if 'num_contours' in kwargs:
num_contours = kwargs['num_contours']
pt = [0,0]
if 'pt' in kwargs:
pt = kwargs['pt']
pt = np.asarray(pt)
pt.shape = (2,1)
max_steps = 10
if 'max_steps' in kwargs:
max_steps = kwargs['max_steps']
num_samples = 10
if 'num_samples' in kwargs:
num_samples = kwargs['num_samples']
steplength = 1
if 'steplength' in kwargs:
steplength = kwargs['steplength']
##### construct figure with panels #####
# construct figure
fig = plt.figure(figsize = (9,3))
# remove whitespace from figure
fig.subplots_adjust(left=0, right=1, bottom=0, top=1) # remove whitespace
# create subplot with 3 panels, plot input function in center plot
gs = gridspec.GridSpec(1, 2, width_ratios=[1,2])
ax = plt.subplot(gs[0],projection='3d');
ax2 = plt.subplot(gs[1],aspect='equal');
#### define input space for function and evaluate ####
w = np.linspace(-wmax,wmax,200)
w1_vals, w2_vals = np.meshgrid(w,w)
w1_vals.shape = (len(w)**2,1)
w2_vals.shape = (len(w)**2,1)
h = np.concatenate((w1_vals,w2_vals),axis=1)
func_vals = np.asarray([func(s) for s in h])
w1_vals.shape = (len(w),len(w))
w2_vals.shape = (len(w),len(w))
func_vals.shape = (len(w),len(w))
# plot function
ax.plot_surface(w1_vals, w2_vals, func_vals, alpha = 0.1,color = 'w',rstride=25, cstride=25,linewidth=1,edgecolor = 'k',zorder = 2)
# plot z=0 plane
ax.plot_surface(w1_vals, w2_vals, func_vals*0, alpha = 0.1,color = 'w',zorder = 1,rstride=25, cstride=25,linewidth=0.3,edgecolor = 'k')
### make contour right plot - as well as horizontal and vertical axes ###
ax2.contour(w1_vals, w2_vals, func_vals,num_contours,colors = 'k')
if axes == True:
ax2.axhline(linestyle = '--', color = 'k',linewidth = 1)
ax2.axvline(linestyle = '--', color = 'k',linewidth = 1)
### plot circle on which point lies, as well as step length circle - used only for simple quadratic
if plot_final == True:
# plot contour of quadratic on which final point was plotted
f = pt_history[-1]
val = np.linalg.norm(f)
theta = np.linspace(0,1,400)
x = val*np.cos(2*np.pi*theta)
y = val*np.sin(2*np.pi*theta)
ax2.plot(x,y,color = 'r',linestyle = '--',linewidth = 1)
# plot direction sampling circle centered at final point
x = steplength*np.cos(2*np.pi*theta) + f[0]
y = steplength*np.sin(2*np.pi*theta) + f[1]
ax2.plot(x,y,color = 'b',linewidth = 1)
# colors for points
s = np.linspace(0,1,len(eval_history[:round(len(eval_history)/2)]))
s.shape = (len(s),1)
t = np.ones(len(eval_history[round(len(eval_history)/2):]))
t.shape = (len(t),1)
s = np.vstack((s,t))
colorspec = []
colorspec = np.concatenate((s,np.flipud(s)),1)
colorspec = np.concatenate((colorspec,np.zeros((len(s),1))),1)
#### scatter path points ####
for k in range(len(eval_history)):
ax.scatter(pt_history[k][0],pt_history[k][1],0,s = 60,c = colorspec[k],edgecolor = 'k',linewidth = 0.5*math.sqrt((1/(float(k) + 1))),zorder = 3)
ax2.scatter(pt_history[k][0],pt_history[k][1],s = 60,c = colorspec[k],edgecolor = 'k',linewidth = 1.5*math.sqrt((1/(float(k) + 1))),zorder = 3)
#### connect points with arrows ####
for i in range(len(eval_history)-1):
pt1 = pt_history[i]
pt2 = pt_history[i+1]
if np.linalg.norm(pt1 - pt2) > 0.5:
# draw arrow in left plot
a = Arrow3D([pt1[0],pt2[0]], [pt1[1],pt2[1]], [0, 0], mutation_scale=10, lw=2, arrowstyle="-|>", color="k")
ax.add_artist(a)
# draw 2d arrow in right plot
ax2.arrow(pt1[0],pt1[1],(pt2[0] - pt1[0])*0.78,(pt2[1] - pt1[1])*0.78, head_width=0.1, head_length=0.1, fc='k', ec='k',linewidth=3,zorder = 2,length_includes_head=True)
### cleanup panels ###
ax.set_xlabel('$w_0$',fontsize = 12)
ax.set_ylabel('$w_1$',fontsize = 12,rotation = 0)
ax.set_title('$g(w_0,w_1)$',fontsize = 12)
ax.view_init(view[0],view[1])
ax2.set_xlabel('$w_0$',fontsize = 12)
ax2.set_ylabel('$w_1$',fontsize = 12,rotation = 0)
# clean up axis
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('white')
ax.yaxis.pane.set_edgecolor('white')
ax.zaxis.pane.set_edgecolor('white')
ax.xaxis._axinfo["grid"]['color'] = (1,1,1,0)
ax.yaxis._axinfo["grid"]['color'] = (1,1,1,0)
ax.zaxis._axinfo["grid"]['color'] = (1,1,1,0)
# plot
plt.show()
#create true values - assign to grid
#x_true = np.abs(np.random.rand(Ndata)) # location of sources
#y_true = np.abs(np.random.rand(Ndata));
x_true = [0.5]
y_true = [0.5]
w_true = np.ones(Ndata) * 5
print(x_true, y_true, w_true)
#true grid needs to be set up with noise
w_true_grid = np.zeros((n_grid, n_grid))
for x, y, w in zip(x_true, y_true, w_true):
w_true_grid[(np.abs(grid1d - x)).argmin(),
(np.abs(grid1d - y)).argmin()] = w
mid = int(n_grid / 2)
x, y = np.meshgrid(grid1d, grid1d)
psf = np.exp(-((y - grid1d[mid])**2 + (x - grid1d[mid])**2) / 2. / sig_psf**2)
xx = np.linspace(-0.5, 0.5, n_grid)
bump = np.exp(-0.5 * xx**2 / sig_psf**2)
#bump /= np.trapz(bump) # normalize the integral to 1
_psf = bump[:, np.newaxis] * bump[np.newaxis, :]
fig, ax = plt.subplots(1, 2)
ax[0].imshow(psf)
ax[0].set_title('psf')
ax[1].imshow(_psf)
ax[1].set_title('psf')
plt.savefig('test0.png')
data = np.real(fft.ifft2(fft.fft2(w_true_grid) * fft.fft2(_psf)))
def gen_point_source_psf_image(
u, # source location in equatorial coordinates
image, # FitsImage object
xlim = None, # compute model image only on patch defined
ylim = None, # by xlim ylimcompute only for this patch
check_overlap = True, # speedup to check overlap before computing
return_patch = True, # return the small patch as opposed to large patch (memory/speed purposes)
psf_grid = None, # cached PSF grid to be filled out
pixel_grid = None # Nx2 matrix of discrete pixel values to evaluate mog at
):
""" generates a PSF image (assigns density values to pixels) """
# compute pixel space location of source
# returns the X,Y = Width, Height pixel coordinate corresponding to u
# compute pixel space location, v_{n,s}
v_s = image.equa2pixel(u)
does_not_overlap = check_overlap and \
(v_s[0] < -50 or v_s[0] > 2*image.nelec.shape[0] or
v_s[1] < -50 or v_s[0] > 2*image.nelec.shape[1])
if does_not_overlap:
return None, None, None
# create sub-image - make sure it doesn't go outside of field pixels
if xlim is None and ylim is None:
bound = image.R
minx_b, maxx_b = max(0, int(v_s[0] - bound)), min(int(v_s[0] + bound + 1), image.nelec.shape[1])
miny_b, maxy_b = max(0, int(v_s[1] - bound)), min(int(v_s[1] + bound + 1), image.nelec.shape[0])
y_grid = np.arange(miny_b, maxy_b, dtype=np.float)
x_grid = np.arange(minx_b, maxx_b, dtype=np.float)
xx, yy = np.meshgrid(x_grid, y_grid, indexing='xy')
pixel_grid = np.column_stack((xx.ravel(order='C'), yy.ravel(order='C')))
else:
miny_b, maxy_b = ylim
minx_b, maxx_b = xlim
if pixel_grid is None:
y_grid = np.arange(miny_b, maxy_b, dtype=np.float)
x_grid = np.arange(minx_b, maxx_b, dtype=np.float)
xx, yy = np.meshgrid(x_grid, y_grid, indexing='xy')
pixel_grid = np.column_stack((xx.ravel(order='C'), yy.ravel(order='C')))
grid_shape = (maxy_b-miny_b, maxx_b-minx_b)
#psf_grid_small = gmm_like_2d(x = pixel_grid,
# ws = image.weights,
## mus = image.means + v_s,
# sigs = image.covars)
psf_grid_small = np.exp(mog_funs.mog_loglike(pixel_grid,
means = image.means+v_s,
icovs = image.invcovars,
dets = np.exp(image.logdets),
pis = image.weights))
# return the small patch and it's bounding box in the bigger fits_image
if return_patch:
return psf_grid_small.reshape(grid_shape, order='C'), \
(miny_b, maxy_b), (minx_b, maxx_b)
# instantiate a PSF grid
if psf_grid is None:
psf_grid = np.zeros(image.nelec.shape, dtype=np.float)
# create full field grid
psf_grid[miny_b:maxy_b, minx_b:maxx_b] = \
psf_grid_small.reshape(xx.shape, order='C')
return psf_grid, (0, psf_grid.shape[0]), (0, psf_grid.shape[1])
def surface_plot(self, g, ax, wmax, view):
##### Produce cost function surface #####
r = np.linspace(-wmax, wmax, 300)
# create grid from plotting range
w1_vals, w2_vals = np.meshgrid(r, r)
w1_vals.shape = (len(r)**2, 1)
w2_vals.shape = (len(r)**2, 1)
w_ = np.concatenate((w1_vals, w2_vals), axis=1)
g_vals = []
for i in range(len(r)**2):
g_vals.append(g(w_[i, :]))
g_vals = np.asarray(g_vals)
w1_vals.shape = (np.size(r), np.size(r))
w2_vals.shape = (np.size(r), np.size(r))
### is this a counting cost? if so re-calculate ###
levels = np.unique(g_vals)
if np.size(levels) < 30:
# plot each level of the counting cost
levels = np.unique(g_vals)
for u in levels:
# make copy of cost and nan out all non level entries
z = g_vals.copy()
ind = np.argwhere(z != u)
ind = [v[0] for v in ind]
z[ind] = np.nan
# plot the current level
z.shape = (len(r), len(r))
ax.plot_surface(w1_vals,
w2_vals,
z,
alpha=0.4,
color='#696969',
zorder=0,
shade=True,
linewidth=0)
else: # smooth cost function, plot usual
# reshape and plot the surface, as well as where the zero-plane is
g_vals.shape = (np.size(r), np.size(r))
# plot cost surface
ax.plot_surface(w1_vals,
w2_vals,
g_vals,
alpha=0.1,
color='w',
rstride=25,
cstride=25,
linewidth=1,
edgecolor='k',
zorder=2)
### clean up panel ###
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('white')
ax.yaxis.pane.set_edgecolor('white')
ax.zaxis.pane.set_edgecolor('white')
ax.xaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.yaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.zaxis._axinfo["grid"]['color'] = (1, 1, 1, 0)
ax.set_xlabel(r'$w_0$', fontsize=12)
ax.set_ylabel(r'$w_1$', fontsize=12, rotation=0)
ax.view_init(view[0], view[1])
# GD ALPHA
GD_alpha = 0.0001
# CGD ALPHA
CGD_alpha = 0.0001
# BFGS alpha - set to (1,1,max_iter) to force step size 1
#BFGS_alpha = alpha = np.linspace(0.1, 1.0, max_iter)
BFGS_alpha = alpha = np.linspace(1, 1, max_iter)
##############################################
# Design variables at mesh points
i1 = np.arange(xmin, xmax, step)
i2 = np.arange(ymin, ymax, step)
x1_mesh, x2_mesh = np.meshgrid(i1, i2)
# Create a contour plot
fig, ax = plt.subplots()
plt.ylim(ymin, ymax)
plt.xlim(xmin, xmax)
v_func = np.vectorize(f_sep)
ax.contour(x1_mesh, x2_mesh, v_func(x1_mesh, x2_mesh))
# Add some text to the plot
ax.set_title(title)
ax.set_xlabel('x1')
ax.set_ylabel('x2')
if __name__ == '__main__':
m = 4
n = 3
initial_path = '../initial_airfoil/naca0012.dat'
airfoil0_true = np.loadtxt(initial_path, skiprows=1)
x_min = np.min(airfoil0_true[:, 0])
x_max = np.max(airfoil0_true[:, 0])
z_min = np.min(airfoil0_true[:, 1])
z_max = np.max(airfoil0_true[:, 1])
Px = np.linspace(x_min, x_max, m, endpoint=True)
Py = np.linspace(z_min, z_max, n, endpoint=True)
x, y = np.meshgrid(Px, Py)
P0 = np.stack((x, y), axis=-1)
Px = P0[:, :, 0]
alpha0 = P0[:, :, 1].flatten()
airfoil0 = synthesize(alpha0, airfoil0_true, m, n, Px)
import matplotlib.pyplot as plt
plt.figure()
plt.plot(airfoil0[:, 0], airfoil0[:, 1], 'o-')
plt.plot(airfoil0_true[:, 0], airfoil0_true[:, 1], 'r-')
plt.plot(P0[:, :, 0].flatten(), P0[:, :, 1].flatten(), 'rs')
plt.axis('equal')
plt.show()
