def convolve_with_basis(self, signal):
"""
Convolve each column of the event count matrix with this basis
:param S: signal: an array-like data, each series is (1, T) shape
:return: TxB of inputs convolved with bases
"""
(T,_) = signal.shape
(R,B) = self.basis.shape
# Initialize array for filtered stimulus
F = np.empty((T,B))
# Compute convolutions fo each basis vector, one at a time
for b in np.arange(B):
F[:,b] = sig.fftconvolve(signal,
np.reshape(self.basis[:,b],(R,1)),
'full')[:T,:]
# Check for positivity
if np.amin(self.basis) >= 0 and np.amin(signal) >= 0:
np.clip(F, 0, np.inf, out=F)
assert np.amin(F) >= 0, "convolution should be >= 0"
return F
def colorize(frames, cmap):
import matplotlib.pyplot as plt
cmap = plt.get_cmap(cmap) if isinstance(cmap, str) else cmap
frames = frames.copy()
frames -= np.nanmin(frames)
frames /= np.nanmax(frames)
return np.clip(cmap(frames)[...,:3]*255, 0, 255)
def next_t(path, t, dist):
p = path.point(t)
L = path.length()
# t += 1.0 / np.abs(path.derivative(t))
itr = 0
while itr < 20:
itr += 1
p1 = path.point(t)
err = np.abs(p1 - p) - dist
d1 = path.derivative(t)
if np.abs(err) < 1e-5:
return t, p1, d1 / np.abs(d1)
derr = np.abs(d1) * L
# do a step in Newton's method (clipped because some of the
# gradients in the curve are really small)
t -= np.clip(err / derr, -1e-2, 1e-2)
t = np.clip(t, 0, 1)
return t, p, d1 / np.abs(d1)
def simulator(theta,v):
a = n
c = 0
b = 1
d = 1
p=theta
mu = n*p
sig = np.sqrt(n*p*(1-p))
gaussian = mu+sig*v
gaussian = np.clip(gaussian,0,n)
return gaussian, sig
def simulator(theta,N):
a = n
c = 0
b = 1
d = 1
p=theta
mu = n*p
sig = np.sqrt(n*p*(1-p))
gaussian = mu+sig
gaussian = mu+sig*np.random.randn(N)
gaussian = np.clip(gaussian,0,n)
return gaussian,sig
def simulator(n,theta,v):
a = n
c = 0
b = 1
d = 1
p=theta
mu = n*p
sig2 = np.sqrt(n*p*(1-p))
gaussian = mu+sig2*v
#if gaussian<0:
# gaussian=0
# print "a 0"
gaussian = np.clip(gaussian,0,n)
return gaussian
def simulator(sim_variables,theta,u2):
'''
@summary: simulator
@sim_variables: simulator variables/settings that are fixed
@param theta: global parameter, drawn from variational distribution
@param u2: controls simulator randomness
'''
n = sim_variables[1]
p = theta
mu = n*p
sig2 = np.sqrt(n*p*(1-p))
gaussian = mu+sig2*u2
gaussian = np.clip(gaussian,0,n)
return gaussian
def update_weights(self, params, dparams):
"""
params: the parameters of the model as they currently exist.
dparams: the grad of the cost w.r.t. the parameters of the model.
We update params based on dparams.
"""
for k in params.keys():
p = params[k]
d = dparams[k]
d = np.clip(d,-10,10)
self.ns[k] = self.b * self.ns[k] + (1 - self.b) * (d*d)
self.gs[k] = self.b * self.gs[k] + (1 - self.b) * d
n = self.ns[k]
g = self.gs[k]
self.ms[k] = self.d * self.ms[k] - self.lr * (d / (np.sqrt(n - g*g + 1e-8)))
self.qs[k] = self.b * self.qs[k] + (1 - self.b) * (l2(self.ms[k]) / l2(p))
p += self.ms[k]
def gumbel_softmax(X, tau=1.0, eps=np.finfo(float).eps):
# element-wise gumbel softmax
# return np.exp(np.log(X+eps)/temp)/np.sum(np.exp(np.log(X+eps)/temp), axis=1)[:, np.newaxis]
X_temp = np.clip(X / tau, -32, 32)
return 1 / (1 + np.exp(X_temp))
def invert(self, data, input=None, mask=None, tag=None):
yhat = self.link(np.clip(data, .1, np.inf))
return self._invert(yhat, input=input, mask=mask, tag=tag)
def _log_hazard(self, params, T, X):
hz = self._hazard(params, T, X)
hz = np.clip(hz, 1e-20, np.inf)
return np.log(hz)
def l2_normalize(x):
# x / sqrt(max(sum(x**2), epsilon))
return x / np.sqrt(
np.clip(np.sum(x**2, axis=-1, keepdims=True), EPSILON, None))
def binary_crossentropy(actual, predicted):
"""二分类logloss
"""
predicted = np.clip(predicted, EPS, 1 - EPS)
return -np.mean(actual * np.log(predicted) +
(1 - actual) * np.log(1 - predicted))
def evaluate_gradient(
gradient,
objectPoints,
P,
image_pts_measured,
normalize=False,
):
x1, y1, x2, y2, x3, y3, x4, y4 = extract_objectpoints_vars(objectPoints)
gradient.dx1_eval_old = gradient.dx1_eval
gradient.dy1_eval_old = gradient.dy1_eval
gradient.dx2_eval_old = gradient.dx2_eval
gradient.dy2_eval_old = gradient.dy2_eval
gradient.dx3_eval_old = gradient.dx3_eval
gradient.dy3_eval_old = gradient.dy3_eval
gradient.dx4_eval_old = gradient.dx4_eval
gradient.dy4_eval_old = gradient.dy4_eval
gradient.dx1_eval = gradient.dx1(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_x1
gradient.dy1_eval = gradient.dy1(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_y1
gradient.dx2_eval = gradient.dx2(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_x2
gradient.dy2_eval = gradient.dy2(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_y2
gradient.dx3_eval = gradient.dx3(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_x3
gradient.dy3_eval = gradient.dy3(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_y3
gradient.dx4_eval = gradient.dx4(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_x4
gradient.dy4_eval = gradient.dy4(x1, y1, x2, y2, x3, y3, x4, y4, P,
image_pts_measured,
normalize) * gradient.n_y4
gradient.n_x1 = supersab(gradient.n_x1, gradient.dx1_eval,
gradient.dx1_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x2 = supersab(gradient.n_x2, gradient.dx2_eval,
gradient.dx2_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x3 = supersab(gradient.n_x3, gradient.dx3_eval,
gradient.dx3_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x4 = supersab(gradient.n_x4, gradient.dx4_eval,
gradient.dx4_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y1 = supersab(gradient.n_y1, gradient.dy1_eval,
gradient.dy1_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y2 = supersab(gradient.n_y2, gradient.dy2_eval,
gradient.dy2_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y3 = supersab(gradient.n_y3, gradient.dy3_eval,
gradient.dy3_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y4 = supersab(gradient.n_y4, gradient.dy4_eval,
gradient.dy4_eval_old, gradient.n_pos,
gradient.n_neg)
## Limit
limit = 0.05
gradient.dx1_eval = np.clip(gradient.dx1_eval, -limit, limit)
gradient.dy1_eval = np.clip(gradient.dy1_eval, -limit, limit)
gradient.dx2_eval = np.clip(gradient.dx2_eval, -limit, limit)
gradient.dy2_eval = np.clip(gradient.dy2_eval, -limit, limit)
gradient.dx3_eval = np.clip(gradient.dx3_eval, -limit, limit)
gradient.dy3_eval = np.clip(gradient.dy3_eval, -limit, limit)
gradient.dx4_eval = np.clip(gradient.dx4_eval, -limit, limit)
gradient.dy4_eval = np.clip(gradient.dy4_eval, -limit, limit)
return gradient
def binary_crossentropy(y_true, y_pred):
y_pred = np.clip(y_pred, EPSILON, 1 - EPSILON)
return -np.mean(
y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred), axis=-1)
def _cumulative_hazard(self, params, times):
lambda_, rho_ = params
return np.exp(
rho_ * (np.log(np.clip(times, 1e-25, np.inf)) - np.log(lambda_)))
def fun(x):
return np.clip(x, a_min=0.1, a_max=1.1)
def noise(self, x=None, u=None):
u = np.clip(u, -self._umax, self._umax)
x = np.clip(x, -self._xmax, self._xmax)
return self._sigma
def clip(x, c, axis=None):
return (x.T / (np.linalg.norm(x, axis=axis) + 1e-9) *
np.clip(np.linalg.norm(x, axis=axis), 0, c)).T
def binary_crossentropy(actual, predicted):
predicted = np.clip(predicted, EPS, 1 - EPS)
return np.mean(-np.sum(actual * np.log(predicted) +
(1 - actual) * np.log(1 - predicted)))
def logloss(actual, predicted):
predicted = np.clip(predicted, EPS, 1 - EPS)
loss = -np.sum(actual * np.log(predicted))
return loss / float(actual.shape[0])
def reconstruct_ptychography(fname,
probe_pos,
probe_size,
obj_size,
theta_st=0,
theta_end=PI,
theta_downsample=None,
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,
cpu_only=False,
save_path='.',
phantom_path='phantom',
core_parallelization=True,
free_prop_cm=None,
multiscale_level=1,
n_epoch_final_pass=None,
initial_guess=None,
n_batch_per_update=1,
dynamic_rate=True,
probe_type='gaussian',
probe_initial=None,
probe_learning_rate=1e-3,
pupil_function=None,
probe_circ_mask=0.9,
finite_support_mask=None,
forward_algorithm='fresnel',
dynamic_dropping=True,
dropping_threshold=8e-5,
n_dp_batch=20,
object_type='normal',
**kwargs):
def calculate_loss(obj_delta, obj_beta, this_i_theta, this_pos_batch,
this_prj_batch):
obj_stack = np.stack([obj_delta, obj_beta], axis=3)
obj_rot = apply_rotation(
obj_stack, coord_ls[this_i_theta],
'arrsize_{}_{}_{}_ntheta_{}'.format(*this_obj_size, n_theta))
probe_pos_batch_ls = []
exiting_ls = []
i_dp = 0
while i_dp < minibatch_size:
probe_pos_batch_ls.append(
this_pos_batch[i_dp:min([i_dp + n_dp_batch, minibatch_size])])
i_dp += n_dp_batch
# pad if needed
pad_arr = np.array([[0, 0], [0, 0]])
if probe_pos[:, 0].min() - probe_size_half[0] < 0:
pad_len = probe_size_half[0] - probe_pos[:, 0].min()
obj_rot = np.pad(obj_rot, ((pad_len, 0), (0, 0), (0, 0), (0, 0)),
mode='constant')
pad_arr[0, 0] = pad_len
if probe_pos[:, 0].max() + probe_size_half[0] > this_obj_size[0]:
pad_len = probe_pos[:, 0].max(
) + probe_size_half[0] - this_obj_size[0]
obj_rot = np.pad(obj_rot, ((0, pad_len), (0, 0), (0, 0), (0, 0)),
mode='constant')
pad_arr[0, 1] = pad_len
if probe_pos[:, 1].min() - probe_size_half[1] < 0:
pad_len = probe_size_half[1] - probe_pos[:, 1].min()
obj_rot = np.pad(obj_rot, ((0, 0), (pad_len, 0), (0, 0), (0, 0)),
mode='constant')
pad_arr[1, 0] = pad_len
if probe_pos[:, 1].max() + probe_size_half[1] > this_obj_size[1]:
pad_len = probe_pos[:, 1].max(
) + probe_size_half[0] - this_obj_size[1]
obj_rot = np.pad(obj_rot, ((0, 0), (0, pad_len), (0, 0), (0, 0)),
mode='constant')
pad_arr[1, 1] = pad_len
for k, pos_batch in enumerate(probe_pos_batch_ls):
subobj_ls = []
for j in range(len(pos_batch)):
pos = pos_batch[j]
pos = [int(x) for x in pos]
pos[0] = pos[0] + pad_arr[0, 0]
pos[1] = pos[1] + pad_arr[1, 0]
subobj = obj_rot[pos[0] - probe_size_half[0]:pos[0] -
probe_size_half[0] + probe_size[0],
pos[1] - probe_size_half[1]:pos[1] -
probe_size_half[1] + probe_size[1], :, :]
subobj_ls.append(subobj)
subobj_ls = np.stack(subobj_ls)
exiting = multislice_propagate_cnn(subobj_ls[:, :, :, :, 0],
subobj_ls[:, :, :, :, 1],
probe_real,
probe_imag,
energy_ev,
[psize_cm * ds_level] * 3,
free_prop_cm='inf')
exiting_ls.append(exiting)
exiting_ls = np.concatenate(exiting_ls, 0)
loss = np.mean((np.abs(exiting_ls) - np.abs(this_prj_batch))**2)
return loss
comm = MPI.COMM_WORLD
size = comm.Get_size()
rank = comm.Get_rank()
t_zero = time.time()
# read data
t0 = time.time()
print_flush('Reading data...', designate_rank=0, this_rank=rank)
f = h5py.File(os.path.join(save_path, fname), 'r')
prj = f['exchange/data']
n_theta = prj.shape[0]
prj_theta_ind = np.arange(n_theta, dtype=int)
theta = -np.linspace(theta_st, theta_end, n_theta, dtype='float32')
if theta_downsample is not None:
theta = theta[::theta_downsample]
prj_theta_ind = prj_theta_ind[::theta_downsample]
n_theta = len(theta)
original_shape = [n_theta, *prj.shape[1:]]
print_flush('Data reading: {} s'.format(time.time() - t0),
designate_rank=0,
this_rank=rank)
print_flush('Data shape: {}'.format(original_shape),
designate_rank=0,
this_rank=rank)
comm.Barrier()
not_first_level = False
if output_folder is None:
output_folder = 'recon_ptycho_minibatch_{}_' \
'iter_{}_' \
'alphad_{}_' \
'alphab_{}_' \
'rate_{}_' \
'energy_{}_' \
'size_{}_' \
'ntheta_{}_' \
'ms_{}_' \
'cpu_{}' \
.format(minibatch_size,
n_epochs, alpha_d, alpha_b,
learning_rate, energy_ev,
prj.shape[-1], prj.shape[0],
multiscale_level, cpu_only)
if abs(PI - theta_end) < 1e-3:
output_folder += '_180'
print_flush('Output folder is {}'.format(output_folder),
designate_rank=0,
this_rank=rank)
if save_path != '.':
output_folder = os.path.join(save_path, output_folder)
for ds_level in range(multiscale_level - 1, -1, -1):
ds_level = 2**ds_level
print_flush('Multiscale downsampling level: {}'.format(ds_level),
designate_rank=0,
this_rank=rank)
comm.Barrier()
n_pos = len(probe_pos)
probe_pos = np.array(probe_pos)
probe_size_half = (np.array(probe_size) / 2).astype('int')
prj_shape = original_shape
if ds_level > 1:
this_obj_size = [int(x / ds_level) for x in obj_size]
else:
this_obj_size = obj_size
dim_y, dim_x = prj_shape[-2:]
comm.Barrier()
# read rotation data
try:
coord_ls = read_all_origin_coords(
'arrsize_{}_{}_{}_ntheta_{}'.format(*this_obj_size, n_theta),
n_theta)
except:
if rank == 0:
print_flush('Saving rotation coordinates...',
designate_rank=0,
this_rank=rank)
save_rotation_lookup(this_obj_size, n_theta)
comm.Barrier()
coord_ls = read_all_origin_coords(
'arrsize_{}_{}_{}_ntheta_{}'.format(*this_obj_size, n_theta),
n_theta)
if minibatch_size is None:
minibatch_size = n_theta
# unify random seed for all threads
comm.Barrier()
seed = int(time.time() / 60)
np.random.seed(seed)
comm.Barrier()
if rank == 0:
if not_first_level == False:
if initial_guess is None:
print_flush('Initializing with Gaussian random.',
designate_rank=0,
this_rank=rank)
obj_delta = np.random.normal(size=this_obj_size,
loc=8.7e-7,
scale=1e-7)
obj_beta = np.random.normal(size=this_obj_size,
loc=5.1e-8,
scale=1e-8)
obj_delta[obj_delta < 0] = 0
obj_beta[obj_beta < 0] = 0
else:
print_flush('Using supplied initial guess.',
designate_rank=0,
this_rank=rank)
sys.stdout.flush()
obj_delta = initial_guess[0]
obj_beta = initial_guess[1]
else:
print_flush('Initializing with Gaussian random.',
designate_rank=0,
this_rank=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=this_obj_size,
loc=8.7e-7,
scale=1e-7)
obj_beta += np.random.normal(size=this_obj_size,
loc=5.1e-8,
scale=1e-8)
obj_delta[obj_delta < 0] = 0
obj_beta[obj_beta < 0] = 0
if object_type == 'phase_only':
obj_beta[...] = 0
elif object_type == 'absorption_only':
obj_delta[...] = 0
np.save('init_delta_temp.npy', obj_delta)
np.save('init_beta_temp.npy', obj_beta)
comm.Barrier()
if rank != 0:
obj_delta = np.zeros(this_obj_size)
obj_beta = np.zeros(this_obj_size)
obj_delta[:, :, :] = np.load('init_delta_temp.npy')
obj_beta[:, :, :] = np.load('init_beta_temp.npy')
comm.Barrier()
if rank == 0:
os.remove('init_delta_temp.npy')
os.remove('init_beta_temp.npy')
comm.Barrier()
print_flush('Initialzing probe...', designate_rank=0)
if 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(probe_size[0]) - (probe_size[0] - 1.) / 2
px = np.arange(probe_size[1]) - (probe_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)
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:
back_prop_cm = (free_prop_cm + (psize_cm * obj_delta.shape[2])
) if free_prop_cm is not None else (
psize_cm * obj_delta.shape[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)
else:
raise ValueError(
'Invalid wavefront type. Choose from \'plane\', \'fixed\', \'optimizable\'.'
)
# generate Fresnel kernel
voxel_nm = np.array([psize_cm] * 3) * 1.e7 * ds_level
lmbda_nm = 1240. / energy_ev
delta_nm = voxel_nm[-1]
h = get_kernel(delta_nm, lmbda_nm, voxel_nm, probe_size)
loss_grad = grad(calculate_loss, [0, 1])
print_flush('Optimizer started.', designate_rank=0, this_rank=rank)
if rank == 0:
create_summary(output_folder, locals(), preset='ptycho')
cont = True
i_epoch = 0
while cont:
n_pos = len(probe_pos)
n_spots = n_theta * n_pos
n_tot_per_batch = minibatch_size * size
n_batch = int(np.ceil(float(n_spots) / n_tot_per_batch))
m, v = (None, None)
t0 = time.time()
spots_ls = range(n_spots)
ind_list_rand = []
t00 = time.time()
print_flush('Allocating jobs over threads...',
designate_rank=0,
this_rank=rank)
# Make a list of all thetas and spot positions
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:
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)
print_flush('Allocation done in {} s.'.format(time.time() - t00),
designate_rank=0,
this_rank=rank)
for i_batch in range(n_batch):
t00 = time.time()
if len(ind_list_rand[i_batch]) < n_tot_per_batch:
n_supp = n_tot_per_batch - len(ind_list_rand[i_batch])
ind_list_rand[i_batch] = np.concatenate(
[ind_list_rand[i_batch], ind_list_rand[0][:n_supp]])
this_ind_batch = ind_list_rand[i_batch]
this_i_theta = this_ind_batch[rank * minibatch_size, 0]
this_ind_rank = np.sort(
this_ind_batch[rank * minibatch_size:(rank + 1) *
minibatch_size, 1])
this_prj_batch = prj[this_i_theta, this_ind_rank]
this_pos_batch = probe_pos[this_ind_rank]
if ds_level > 1:
this_prj_batch = this_prj_batch[:, :, ::ds_level, ::
ds_level]
comm.Barrier()
grads = loss_grad(obj_delta, obj_beta, this_i_theta,
this_pos_batch, this_prj_batch)
this_grads = np.array(grads)
grads = np.zeros_like(this_grads)
comm.Barrier()
comm.Allreduce(this_grads, grads)
grads = grads / size
(obj_delta, obj_beta), m, v = apply_gradient_adam(
np.array([obj_delta, obj_beta]),
grads,
i_batch,
m,
v,
step_size=learning_rate)
obj_delta = np.clip(obj_delta, 0, None)
obj_beta = np.clip(obj_beta, 0, None)
if rank == 0:
dxchange.write_tiff(obj_delta,
fname=os.path.join(
output_folder, 'intermediate',
'current'.format(ds_level)),
dtype='float32',
overwrite=True)
comm.Barrier()
print_flush('Minibatch done in {} s (rank {})'.format(
time.time() - t00, rank))
if n_epochs == 'auto':
pass
else:
if i_epoch == n_epochs - 1: cont = False
if dynamic_dropping:
print_flush('Dynamic dropping...', 0, rank)
this_loss_table = np.zeros(n_pos)
loss_table = np.zeros(n_pos)
fill_start = 0
ind_list = np.arange(n_pos)
if n_pos % size != 0:
ind_list = np.append(ind_list,
np.zeros(size - (n_pos % size)))
while fill_start < n_pos:
this_ind_rank = ind_list[fill_start + rank:fill_start +
rank + 1]
this_prj_batch = prj[0, this_ind_rank]
this_pos_batch = probe_pos[this_ind_rank]
this_loss = calculate_loss(obj_delta, obj_beta, 0,
this_pos_batch, this_prj_batch)
loss_table[fill_start + rank] = this_loss
fill_start += size
comm.Allreduce(this_loss_table, loss_table)
loss_table = loss_table[:n_pos]
drop_ls = np.where(loss_table < dropping_threshold)[0]
np.delete(probe_pos, drop_ls, axis=0)
print_flush('Dropped {} spot positions.'.format(len(drop_ls)),
0, rank)
i_epoch = i_epoch + 1
# if i_epoch == 1:
# dxchange.write_tiff(obj_delta, os.path.join(output_folder, 'debug', 'rank_{}'.format(rank)), dtype='float32')
this_loss = calculate_loss(obj_delta, obj_beta, this_i_theta,
this_pos_batch, this_prj_batch)
average_loss = 0
print_flush(
'Epoch {} (rank {}); loss = {}; Delta-t = {} s; current time = {} s,'
.format(i_epoch, rank, this_loss,
time.time() - t0,
time.time() - t_zero))
# print_flush(
# 'Average loss = {}.'.format(comm.Allreduce(this_loss, average_loss)))
if rank == 0:
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.',
designate_rank=0,
this_rank=rank)
comm.Barrier()
def categorical_crossentropy(y_true, y_pred):
y_pred = y_pred / np.sum(y_pred, axis=y_pred.ndim - 1, keepdims=True)
y_pred = np.clip(y_pred, EPSILON, 1 - EPSILON)
return -np.mean(y_true * np.log(y_pred), axis=y_pred.ndim - 1)
def noise(self, x=None, u=None):
_u = np.clip(u, -self.ulim, self.ulim)
_x = np.clip(x, -self.xlim, self.xlim)
return self.sigma
def kullback_leibler_divergence(y_true, y_pred):
y_true = np.clip(y_true, EPSILON, 1)
y_pred = np.clip(y_pred, EPSILON, 1)
return np.sum(y_true * np.log(y_true / y_pred), axis=-1)
def dynamics(self, x, u):
_u = np.clip(u, -self.ulim, self.ulim)
# import from: https://github.com/JoeMWatson/input-inference-for-control/
"""
http://www.lirmm.fr/~chemori/Temp/Wafa/double%20pendule%20inverse.pdf
"""
# x = [x, th1, th2, dx, dth1, dth2]
g = 9.81
Mc = 0.37
Mp1 = 0.127
Mp2 = 0.127
Mt = Mc + Mp1 + Mp2
L1 = 0.3365
L2 = 0.3365
l1 = L1 / 2.
l2 = L2 / 2.
J1 = Mp1 * L1 / 12.
J2 = Mp2 * L2 / 12.
def f(x, u):
q = x[0]
th1 = x[1]
th2 = x[2]
dq = x[3]
dth1 = x[4]
dth2 = x[5]
s1 = np.sin(th1)
c1 = np.cos(th1)
s2 = np.sin(th2)
c2 = np.cos(th2)
sdth = np.sin(th1 - th2)
cdth = np.cos(th1 - th2)
# helpers
l1_mp1_mp2 = Mp1 * l1 + Mp2 * L2
l1_mp1_mp2_c1 = l1_mp1_mp2 * c1
Mp2_l2 = Mp2 * l2
Mp2_l2_c2 = Mp2_l2 * c2
l1_l2_Mp2 = L1 * l2 * Mp2
l1_l2_Mp2_cdth = l1_l2_Mp2 * cdth
# inertia
M11 = Mt
M12 = l1_mp1_mp2_c1
M13 = Mp2_l2_c2
M21 = l1_mp1_mp2_c1
M22 = (l1**2) * Mp1 + (L1**2) * Mp2 + J1
M23 = l1_l2_Mp2_cdth
M31 = Mp2_l2_c2
M32 = l1_l2_Mp2_cdth
M33 = (l2**2) * Mp2 + J2
# coreolis
C11 = 0.
C12 = -l1_mp1_mp2 * dth1 * s1
C13 = -Mp2_l2 * dth2 * s2
C21 = 0.
C22 = 0.
C23 = l1_l2_Mp2 * dth2 * sdth
C31 = 0.
C32 = -l1_l2_Mp2 * dth1 * sdth
C33 = 0.
# gravity
G11 = 0.
G21 = -(Mp1 * l1 + Mp2 * L1) * g * s1
G31 = -Mp2 * l2 * g * s2
# make matrices
M = np.vstack((np.hstack(
(M11, M12, M13)), np.hstack(
(M21, M22, M23)), np.hstack((M31, M32, M33))))
C = np.vstack((np.hstack(
(C11, C12, C13)), np.hstack(
(C21, C22, C23)), np.hstack((C31, C32, C33))))
G = np.vstack((G11, G21, G31))
action = np.vstack((u, 0.0, 0.0))
M_inv = np.linalg.inv(M)
C_dx = np.dot(C, x[3:].reshape((-1, 1)))
ddx = np.dot(M_inv, action - C_dx - G).squeeze()
return np.hstack((dq, dth1, dth2, ddx))
k1 = f(x, _u)
k2 = f(x + 0.5 * self.dt * k1, _u)
k3 = f(x + 0.5 * self.dt * k2, _u)
k4 = f(x + self.dt * k3, _u)
xn = x + self.dt / 6. * (k1 + 2. * k2 + 2. * k3 + k4)
xn = np.clip(xn, -self.xlim, self.xlim)
return xn
def fun(x):
return to_scalar(np.clip(x, a_min=0.1, a_max=1.1))
def log_loss(y, pred):
this_pred = np.clip(pred, EPS, 1 - EPS)
# this_pred = tf.clip_by_value(tf.squeeze(pred), EPS, 1 - EPS)
# print(y.shape, this_pred.shape)
return -(y * np.log(this_pred) + (1 - y) * np.log(1 - this_pred))
def categorical_crossentropy(actual, predicted):
"""多分类logloss,要先OneHotEncoder
"""
predicted = np.clip(predicted, EPS, 1 - EPS)
loss = -np.sum(actual * np.log(predicted))
return loss / float(actual.shape[0])
#####################################################################
# fit star => galaxy proposal distributions
#
# re - [0, infty], transformation log
# ab - [0, 1], transformation log (ab / (1 - ab))
# phi - [0, 180], transformation log (phi / (180 - phi))
#
######################################################################
import CelestePy.util.data as du
from sklearn.linear_model import LinearRegression
coadd_df = du.load_celeste_dataframe("../../data/stripe_82_dataset/coadd_catalog_from_casjobs.fit")
# make star => radial extent proposal
star_res = coadd_df.gal_arcsec_scale[ coadd_df.is_star ].values
star_res = np.clip(star_res, 1e-8, np.inf)
star_res_proposal = fit_mog(np.log(star_res).reshape((-1,1)), max_comps = 20, mog_class = MixtureOfGaussians)
with open('star_res_proposal.pkl', 'wb') as f:
pickle.dump(star_res_proposal, f)
if False:
xgrid = np.linspace(np.min(np.log(star_res)), np.max(np.log(star_res)), 100)
lpdf = star_res_proposal.logpdf(xgrid.reshape((-1,1)))
plt.plot(xgrid, np.exp(lpdf))
plt.hist(np.log(star_res), 25, normed=True)
plt.hist(np.log(star_res), 25, normed=True, alpha=.24)
plt.hist(star_res_proposal.rvs(684).flatten(), 25, normed=True, alpha=.24)
# make star fluxes => gal fluxes for tars
colors = ['ug', 'gr', 'ri', 'iz']
star_mags = np.array([du.colors_to_mags(r, c)
def initialize(self, datas, inputs=None, masks=None, tags=None):
datas = [
interpolate_data(data, mask) for data, mask in zip(datas, masks)
]
yhats = [self.link(np.clip(d, .1, np.inf)) for d in datas]
self._initialize_with_pca(yhats, inputs=inputs, masks=masks, tags=tags)
def binary_crossentropy(actual, predicted):
predicted = np.clip(predicted, EPS, 1 - EPS)
return np.mean(-np.sum(actual * np.log(predicted) +
(1 - actual) * np.log(1 - predicted)))
env_sigma = env.unwrapped.sigma
state = np.zeros((dm_state, nb_steps + 1))
action = np.zeros((dm_act, nb_steps))
state[:, 0] = env.reset()
for t in range(nb_steps):
solver = MBGPS(env,
init_state=tuple([state[:, t], env_sigma]),
init_action_sigma=100.,
nb_steps=horizon,
kl_bound=5.)
trace = solver.run(nb_iter=10, verbose=False)
_act = solver.ctl.sample(state[:, t], 0, stoch=False)
action[:, t] = np.clip(_act, -env.ulim, env.ulim)
state[:, t + 1], _, _, _ = env.step(action[:, t])
print('Time Step:', t, 'Cost:', trace[-1])
plt.figure()
plt.subplot(3, 1, 1)
plt.plot(state[0, :], '-b')
plt.subplot(3, 1, 2)
plt.plot(state[1, :], '-b')
plt.subplot(3, 1, 3)
plt.plot(action[0, :], '-g')
plt.show()
def r_from_s(s, epsilon=1.e-6):
return np.clip((1. - s + epsilon) / (s + epsilon), epsilon, None)
def s_from_r(r):
return np.clip(1. / (1. + r), 0., 1.)
def mean_squared_logarithmic_error(y_true, y_pred):
first = np.log(np.clip(y_pred, EPSILON, None) + 1.)
second = np.log(np.clip(y_true, EPSILON, None) + 1.)
return np.mean((first - second)**2, axis=-1)
def _cumulative_hazard(self, params, times):
alpha_, beta_ = params
return np.logaddexp(beta_ * (np.log(np.clip(times, 1e-25, np.inf)) - np.log(alpha_)), 0)
def evaluate_gradient(gradient, objectPoints, P, normalize=False):
x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, x7, y7, x8, y8 = extract_objectpoints_vars(
objectPoints)
gradient.dx1_eval_old = gradient.dx1_eval
gradient.dy1_eval_old = gradient.dy1_eval
gradient.dx2_eval_old = gradient.dx2_eval
gradient.dy2_eval_old = gradient.dy2_eval
gradient.dx3_eval_old = gradient.dx3_eval
gradient.dy3_eval_old = gradient.dy3_eval
gradient.dx4_eval_old = gradient.dx4_eval
gradient.dy4_eval_old = gradient.dy4_eval
gradient.dx5_eval_old = gradient.dx5_eval
gradient.dy5_eval_old = gradient.dy5_eval
gradient.dx6_eval_old = gradient.dx6_eval
gradient.dy6_eval_old = gradient.dy6_eval
gradient.dx7_eval_old = gradient.dx7_eval
gradient.dy7_eval_old = gradient.dy7_eval
gradient.dx8_eval_old = gradient.dx8_eval
gradient.dy8_eval_old = gradient.dy8_eval
gradient.dx1_eval = gradient.dx1(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x1
gradient.dy1_eval = gradient.dy1(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y1
gradient.dx2_eval = gradient.dx2(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x2
gradient.dy2_eval = gradient.dy2(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y2
gradient.dx3_eval = gradient.dx3(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x3
gradient.dy3_eval = gradient.dy3(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y3
gradient.dx4_eval = gradient.dx4(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x4
gradient.dy4_eval = gradient.dy4(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y4
gradient.dx5_eval = gradient.dx5(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x5
gradient.dy5_eval = gradient.dy5(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y5
gradient.dx6_eval = gradient.dx6(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x6
gradient.dy6_eval = gradient.dy6(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y6
gradient.dx7_eval = gradient.dx7(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x7
gradient.dy7_eval = gradient.dy7(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y7
gradient.dx8_eval = gradient.dx8(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_x8
gradient.dy8_eval = gradient.dy8(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5,
x6, y6, x7, y7, x8, y8, P,
normalize) * gradient.n_y8
## Limit
limit = 0.01
gradient.dx1_eval = np.clip(gradient.dx1_eval, -limit, limit)
gradient.dy1_eval = np.clip(gradient.dy1_eval, -limit, limit)
gradient.dx2_eval = np.clip(gradient.dx2_eval, -limit, limit)
gradient.dy2_eval = np.clip(gradient.dy2_eval, -limit, limit)
gradient.dx3_eval = np.clip(gradient.dx3_eval, -limit, limit)
gradient.dy3_eval = np.clip(gradient.dy3_eval, -limit, limit)
gradient.dx4_eval = np.clip(gradient.dx4_eval, -limit, limit)
gradient.dy4_eval = np.clip(gradient.dy4_eval, -limit, limit)
gradient.dx5_eval = np.clip(gradient.dx5_eval, -limit, limit)
gradient.dy5_eval = np.clip(gradient.dy5_eval, -limit, limit)
gradient.dx6_eval = np.clip(gradient.dx6_eval, -limit, limit)
gradient.dy6_eval = np.clip(gradient.dy6_eval, -limit, limit)
gradient.dx7_eval = np.clip(gradient.dx7_eval, -limit, limit)
gradient.dy7_eval = np.clip(gradient.dy7_eval, -limit, limit)
gradient.dx8_eval = np.clip(gradient.dx8_eval, -limit, limit)
gradient.dy8_eval = np.clip(gradient.dy8_eval, -limit, limit)
gradient.n_x1 = supersab(gradient.n_x1, gradient.dx1_eval,
gradient.dx1_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x2 = supersab(gradient.n_x2, gradient.dx2_eval,
gradient.dx2_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x3 = supersab(gradient.n_x3, gradient.dx3_eval,
gradient.dx3_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x4 = supersab(gradient.n_x4, gradient.dx4_eval,
gradient.dx4_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x5 = supersab(gradient.n_x5, gradient.dx5_eval,
gradient.dx5_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x6 = supersab(gradient.n_x6, gradient.dx6_eval,
gradient.dx6_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x7 = supersab(gradient.n_x7, gradient.dx7_eval,
gradient.dx7_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_x8 = supersab(gradient.n_x8, gradient.dx8_eval,
gradient.dx8_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y1 = supersab(gradient.n_y1, gradient.dy1_eval,
gradient.dy1_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y2 = supersab(gradient.n_y2, gradient.dy2_eval,
gradient.dy2_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y3 = supersab(gradient.n_y3, gradient.dy3_eval,
gradient.dy3_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y4 = supersab(gradient.n_y4, gradient.dy4_eval,
gradient.dy4_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y5 = supersab(gradient.n_y5, gradient.dy5_eval,
gradient.dy5_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y6 = supersab(gradient.n_y6, gradient.dy6_eval,
gradient.dy6_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y7 = supersab(gradient.n_y7, gradient.dy7_eval,
gradient.dy7_eval_old, gradient.n_pos,
gradient.n_neg)
gradient.n_y8 = supersab(gradient.n_y8, gradient.dy8_eval,
gradient.dy8_eval_old, gradient.n_pos,
gradient.n_neg)
return gradient
def logloss(actual, predicted):
predicted = np.clip(predicted, EPS, 1 - EPS)
loss = -np.sum(actual * np.log(predicted))
return loss / float(actual.shape[0])
def fun(x): return to_scalar(np.clip(x, a_min=0.1, a_max=1.1)) d_fun = lambda x : to_scalar(grad(fun)(x))
def fun(x): return to_scalar(np.clip(x, a_min=0.1, a_max=1.1)) d_fun = lambda x : to_scalar(grad(fun)(x))
def mean_absolute_percentage_error(y_true, y_pred):
diff = np.abs((y_true - y_pred) / np.clip(y_true, EPSILON, None))
return 100. * np.mean(diff, axis=-1)