def Pattern_Generate(self):
while True:
file_Name_List = list(self.attribute_Dict.keys());
random.shuffle(file_Name_List);
index = 0;
while index < len(self.attribute_Dict):
if len(self.pattern_Queue) >= self.max_Queue:
time.sleep(0.1)
continue;
image_Pattern_List = [resize(imread(os.path.join(self.image_Files_Dir,file_Name).replace("\\", "/")), (self.image_Size, self.image_Size), mode='constant') * 2 - 1 for file_Name in file_Name_List[index:index+self.batch_Size]];
image_Pattern_List = [np.flip(image, axis=1) if random.random() > 0.5 else image for image in image_Pattern_List];
attribute_Pattern_List = [self.attribute_Dict[file_Name] for file_Name in file_Name_List[index:index+self.batch_Size]];
fake_Attribute_Pattern_List = np.copy(attribute_Pattern_List);
random.shuffle(fake_Attribute_Pattern_List)
image_Pattern = np.stack(image_Pattern_List, axis=0).astype(np.float32);
original_Attribute_Pattern = np.stack(attribute_Pattern_List, axis=0).astype(np.float32);
fake_Attribute_Pattern = np.stack(fake_Attribute_Pattern_List, axis=0).astype(np.float32);
new_Feed_Dict = {
self.placeholder_Dict["Image"]: image_Pattern,
self.placeholder_Dict["Original_Attribute"]: original_Attribute_Pattern,
self.placeholder_Dict["Fake_Attribute"]: fake_Attribute_Pattern
}
self.pattern_Queue.append(new_Feed_Dict);
index += self.batch_Size;
def _run_mst_decoding(batch_energy: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
heads = []
head_tags = []
for energy, length in zip(batch_energy.detach().cpu(), lengths):
scores, tag_ids = energy.max(dim=0)
# Although we need to include the root node so that the MST includes it,
# we do not want any word to be the parent of the root node.
# Here, we enforce this by setting the scores for all word -> ROOT edges
# edges to be 0.
scores[0, :] = 0
# Decode the heads. Because we modify the scores to prevent
# adding in word -> ROOT edges, we need to find the labels ourselves.
instance_heads, _ = decode_mst(scores.numpy(), length, has_labels=False)
# Find the labels which correspond to the edges in the max spanning tree.
instance_head_tags = []
for child, parent in enumerate(instance_heads):
instance_head_tags.append(tag_ids[parent, child].item())
# We don't care what the head or tag is for the root token, but by default it's
# not necesarily the same in the batched vs unbatched case, which is annoying.
# Here we'll just set them to zero.
instance_heads[0] = 0
instance_head_tags[0] = 0
heads.append(instance_heads)
head_tags.append(instance_head_tags)
return torch.from_numpy(numpy.stack(heads)), torch.from_numpy(numpy.stack(head_tags))
def testImplicitLargeDiag(self):
mu = np.array([[1., 2, 3],
[11, 22, 33]]) # shape: [b, k] = [2, 3]
u = np.array([[[1., 2],
[3, 4],
[5, 6]],
[[0.5, 0.75],
[1, 0.25],
[1.5, 1.25]]]) # shape: [b, k, r] = [2, 3, 2]
m = np.array([[0.1, 0.2],
[0.4, 0.5]]) # shape: [b, r] = [2, 2]
scale = np.stack([
np.eye(3) + np.matmul(np.matmul(u[0], np.diag(m[0])),
np.transpose(u[0])),
np.eye(3) + np.matmul(np.matmul(u[1], np.diag(m[1])),
np.transpose(u[1])),
])
cov = np.stack([np.matmul(scale[0], scale[0].T),
np.matmul(scale[1], scale[1].T)])
logging.vlog(2, "expected_cov:\n{}".format(cov))
with self.test_session():
mvn = ds.MultivariateNormalDiagPlusLowRank(
loc=mu,
scale_perturb_factor=u,
scale_perturb_diag=m)
self.assertAllClose(cov, mvn.covariance().eval(), atol=0., rtol=1e-6)
def arrow3d(base, r1, r2, ort, l, h, m = 13, pivot = 'tail'):
x = np.array([1., 0., 0.])
y = np.array([0., 1., 0.])
th = np.linspace(0, np.pi*2, m).reshape(-1,1)
ort = norm_vec(ort)
if np.sum(ort * x) == 0:
d1 = norm_vec(np.cross(ort, y))
else:
d1 = norm_vec(np.cross(ort, x))
if pivot == 'tip':
base = base - (l+h)*ort
elif pivot == 'mid':
base = base - (l+h)*ort/2.
else:
pass
d2 = np.cross(ort, d1)
p = base + l*r1* (d1*np.cos(th) + d2*np.sin(th))
q = p + l*ort
p2 = base + l*r2* (d1*np.cos(th) + d2*np.sin(th)) + l*ort
p3 = base + (l+h)*ort
p3 = np.array([p3]*m).reshape(-1, 3)
t1 = np.stack((p[:-1], q[:-1], p[1:]), axis=1)
t2 = np.stack((p[1:], q[:-1], q[1:]), axis=1)
t3 = np.stack((p2[:-1], p3[:-1], p2[1:]), axis=1)
#t2 = np.dstack((p[1:], q[:-1], q[1:]))
t1 = np.vstack((t1, t2, t3))
return t1
def step(self, action):
"""Forward a batch of actions to the wrapped environments.
Args:
action: Batched action to apply to the environment.
Raises:
ValueError: Invalid actions.
Returns:
Batch of observations, rewards, and done flags.
"""
actions = action
for index, (env, action) in enumerate(zip(self._envs, actions)):
if not env.action_space.contains(action):
message = 'Invalid action at index {}: {}'
raise ValueError(message.format(index, action))
if self._blocking:
transitions = [
env.step(action)
for env, action in zip(self._envs, actions)]
else:
transitions = [
env.step(action, blocking=False)
for env, action in zip(self._envs, actions)]
transitions = [transition() for transition in transitions]
observs, rewards, dones, infos = zip(*transitions)
observ = np.stack(observs)
reward = np.stack(rewards)
done = np.stack(dones)
info = tuple(infos)
return observ, reward, done, info
def reset(self):
for remote in self.remotes:
remote.send(('reset', None))
results = [remote.recv() for remote in self.remotes]
obs, infos = zip(*results)
best_actions, action_masks = [np.stack(x) for x in get_best_actions_from_infos(infos)]
return np.stack(obs), best_actions, action_masks
def check_rnn_forward(layer, inputs, deterministic=True):
if isinstance(inputs, mx.nd.NDArray):
inputs.attach_grad()
else:
for x in inputs:
x.attach_grad()
layer.collect_params().initialize()
with mx.autograd.record():
out = layer.unroll(3, inputs, merge_outputs=False)[0]
mx.autograd.backward(out)
out = layer.unroll(3, inputs, merge_outputs=True)[0]
out.backward()
np_out = out.asnumpy()
if isinstance(inputs, mx.nd.NDArray):
np_dx = inputs.grad.asnumpy()
else:
np_dx = np.stack([x.grad.asnumpy() for x in inputs], axis=1)
layer.hybridize()
with mx.autograd.record():
out = layer.unroll(3, inputs, merge_outputs=False)[0]
mx.autograd.backward(out)
out = layer.unroll(3, inputs, merge_outputs=True)[0]
out.backward()
if isinstance(inputs, mx.nd.NDArray):
input_grads = inputs.grad.asnumpy()
else:
input_grads = np.stack([x.grad.asnumpy() for x in inputs], axis=1)
if deterministic:
mx.test_utils.assert_almost_equal(np_out, out.asnumpy(), rtol=1e-3, atol=1e-5)
mx.test_utils.assert_almost_equal(np_dx, input_grads, rtol=1e-3, atol=1e-5)
def filters_bank(M, N, J, L=8):
filters = {}
filters['psi'] = []
offset_unpad = 0
for j in range(J):
for theta in range(L):
psi = {}
psi['j'] = j
psi['theta'] = theta
psi_signal = morlet_2d(M, N, 0.8 * 2**j, (int(L - L / 2 - 1) - theta) * np.pi / L, 3.0 / 4.0 * np.pi / 2**j,offset=offset_unpad) # The 5 is here just to match the LUA implementation :)
psi_signal_fourier = fft.fft2(psi_signal)
for res in range(j + 1):
psi_signal_fourier_res = crop_freq(psi_signal_fourier, res)
psi[res] = torch.FloatTensor(np.stack((np.real(psi_signal_fourier_res), np.imag(psi_signal_fourier_res)), axis=2))
# Normalization to avoid doing it with the FFT!
psi[res].div_(M * N // 2**(2 * j))
filters['psi'].append(psi)
filters['phi'] = {}
phi_signal = gabor_2d(M, N, 0.8 * 2**(J - 1), 0, 0, offset=offset_unpad)
phi_signal_fourier = fft.fft2(phi_signal)
filters['phi']['j'] = J
for res in range(J):
phi_signal_fourier_res = crop_freq(phi_signal_fourier, res)
filters['phi'][res] = torch.FloatTensor(np.stack((np.real(phi_signal_fourier_res), np.imag(phi_signal_fourier_res)), axis=2))
filters['phi'][res].div_(M * N // 2 ** (2 * J))
return filters
def load_mask_labels():
'''Load both target and style masks.
A mask image (nr x nc) with m labels/colors will be loaded
as a 4D boolean tensor: (1, m, nr, nc) for 'th' or (1, nr, nc, m) for 'tf'
'''
target_mask_img = load_img(target_mask_path,
target_size=(img_nrows, img_ncols))
target_mask_img = img_to_array(target_mask_img)
style_mask_img = load_img(style_mask_path,
target_size=(img_nrows, img_ncols))
style_mask_img = img_to_array(style_mask_img)
if K.image_dim_ordering() == 'th':
mask_vecs = np.vstack([style_mask_img.reshape((3, -1)).T,
target_mask_img.reshape((3, -1)).T])
else:
mask_vecs = np.vstack([style_mask_img.reshape((-1, 3)),
target_mask_img.reshape((-1, 3))])
labels = kmeans(mask_vecs, nb_labels)
style_mask_label = labels[:img_nrows *
img_ncols].reshape((img_nrows, img_ncols))
target_mask_label = labels[img_nrows *
img_ncols:].reshape((img_nrows, img_ncols))
stack_axis = 0 if K.image_dim_ordering() == 'th' else -1
style_mask = np.stack([style_mask_label == r for r in xrange(nb_labels)],
axis=stack_axis)
target_mask = np.stack([target_mask_label == r for r in xrange(nb_labels)],
axis=stack_axis)
return (np.expand_dims(style_mask, axis=0),
np.expand_dims(target_mask, axis=0))
def _feed_dict(self, train_batch, is_training=True):
pred_polys = train_batch['raw_polys'] * np.expand_dims(train_batch['masks'], axis=2) # (seq,batch,2)
pred_polys = np.transpose(pred_polys, [1, 0, 2]) # (batch,seq,2)
pred_mask = np.transpose(train_batch['masks'], [1, 0]) # (batch_size,seq_len)
cnn_feats = train_batch['cnn_feats'] # (batch_size, 28, 28, 128)
cells_1 = np.stack([np.split(train_batch['hiddens_list'][-1][0], 2, axis=3)[0]], axis=1)
cells_2 = np.stack([np.split(train_batch['hiddens_list'][-1][1], 2, axis=3)[0]], axis=1)
pred_mask_imgs = self.draw_mask(28, 28, pred_polys, pred_mask)
if is_training:
raise NotImplementedError()
r = {
self._ph.cells_1: cells_1,
self._ph.cells_2: cells_2,
self._ph.pred_mask_imgs: pred_mask_imgs,
self._ph.cnn_feats: cnn_feats,
self._ph.predicted_mask: pred_mask,
self._ph.pred_polys: pred_polys,
self._ph.ious: self._zero_batch
}
return r
def split_data(chars, batch_size, num_steps, split_frac=0.9):
"""
Split character data into training and validation sets, inputs and targets for each set.
Arguments
---------
chars: character array
batch_size: Size of examples in each of batch
num_steps: Number of sequence steps to keep in the input and pass to the network
split_frac: Fraction of batches to keep in the training set
Returns train_x, train_y, val_x, val_y
"""
slice_size = batch_size * num_steps
n_batches = int(len(chars) / slice_size)
# Drop the last few characters to make only full batches
x = chars[: n_batches * slice_size]
y = chars[1: n_batches * slice_size + 1]
# Split the data into batch_size slices, then stack them into a 2D matrix
x = np.stack(np.split(x, batch_size))
y = np.stack(np.split(y, batch_size))
# Now x and y are arrays with dimensions batch_size x n_batches*num_steps
# Split into training and validation sets, keep the first split_frac batches for training
split_idx = int(n_batches * split_frac)
train_x, train_y = x[:, :split_idx * num_steps], y[:, :split_idx * num_steps]
val_x, val_y = x[:, split_idx * num_steps:], y[:, split_idx * num_steps:]
return train_x, train_y, val_x, val_y
def test_arrayize_vectorized_indexer(self):
for i, j, k in itertools.product(self.indexers, repeat=3):
vindex = indexing.VectorizedIndexer((i, j, k))
vindex_array = indexing._arrayize_vectorized_indexer(
vindex, self.data.shape)
np.testing.assert_array_equal(
self.data[vindex], self.data[vindex_array],)
actual = indexing._arrayize_vectorized_indexer(
indexing.VectorizedIndexer((slice(None),)), shape=(5,))
np.testing.assert_array_equal(actual.tuple, [np.arange(5)])
actual = indexing._arrayize_vectorized_indexer(
indexing.VectorizedIndexer((np.arange(5),) * 3), shape=(8, 10, 12))
expected = np.stack([np.arange(5)] * 3)
np.testing.assert_array_equal(np.stack(actual.tuple), expected)
actual = indexing._arrayize_vectorized_indexer(
indexing.VectorizedIndexer((np.arange(5), slice(None))),
shape=(8, 10))
a, b = actual.tuple
np.testing.assert_array_equal(a, np.arange(5)[:, np.newaxis])
np.testing.assert_array_equal(b, np.arange(10)[np.newaxis, :])
actual = indexing._arrayize_vectorized_indexer(
indexing.VectorizedIndexer((slice(None), np.arange(5))),
shape=(8, 10))
a, b = actual.tuple
np.testing.assert_array_equal(a, np.arange(8)[np.newaxis, :])
np.testing.assert_array_equal(b, np.arange(5)[:, np.newaxis])
def converter(batch, device, max_caption_length=None):
"""Optional preprocessing of the batch before forward pass."""
pad = max_caption_length is not None
imgs = []
captions = []
for img, caption in batch:
# Preproess the caption by either fixing the length by padding (LSTM)
# or by simply wrapping each caption in an ndarray (NStepLSTM)
if pad:
arr = np.full(max_caption_length, _ignore, dtype=np.int32)
# Clip to max length if necessary
arr[:len(caption)] = caption[:max_caption_length]
caption = arr
else:
caption = to_device(device, np.asarray(caption, dtype=np.int32))
imgs.append(img)
captions.append(caption)
if pad:
captions = to_device(device, np.stack(captions))
imgs = to_device(device, np.stack(imgs))
return imgs, captions
def corrcoef_raftscope(raftsfits, ROIrows, ROIcols, norm=True):
"""
Correlation over one or more CCDs, calculating correlation along lines at each time index in ROIcols,
then averaging.
:param raftsfits: file list
:param ROIrows: must be in the format: slice(start, stop)
:param ROIcols: must be in the format: slice(start, stop)
:param norm: if True, computes correlation coefficients; if not, returns covariances
:return:
"""
stackh = []
for fl in raftsfits:
h = pyfits.open(fl)
for i in range(1, 17):
stackh.append(h[i].data[ROIrows, ROIcols])
h.close()
del h
stackh = np.stack(stackh)
print stackh.shape
a = []
for numcol in range(ROIcols.stop - ROIcols.start):
if norm:
a.append(np.corrcoef(stackh[:, :, numcol]))
else:
a.append(np.cov(stackh[:, :, numcol]))
a = np.stack(a)
print a.shape
return a.mean(axis=0)
def formatPeaksArbitraryPSF(peaks, peaks_type):
"""
Input peaks array formatter for arbitrary PSFs.
Based on peaks_type, create a properly formatted ndarray to pass
to the C library. This is primarily for internal use by newPeaks().
"""
# These come from the finder, or the unit test code, create peaks
# as (N,3) with columns x, y, z.
#
if (peaks_type == "testing") or (peaks_type == "finder"):
c_peaks = numpy.stack((peaks["x"],
peaks["y"],
peaks["z"]), axis = 1)
# These come from pre-specified peak fitting locations, create peaks
# as (N,5) with columns x, y, z, background, height.
#
elif (peaks_type == "text") or (peaks_type == "hdf5"):
c_peaks = numpy.stack((peaks["x"],
peaks["y"],
peaks["z"],
peaks["background"],
peaks["height"]), axis = 1)
else:
raise MultiFitterException("Unknown peaks type '" + peaks_type + "'")
return numpy.ascontiguousarray(c_peaks, dtype = numpy.float64)
def compute_null_stats(self, elec_pair_phase_diff, recalled, elec_pair_stats):
res = Parallel(n_jobs=12, verbose=5)(delayed(calc_circ_stats)(elec_pair_phase_diff, recalled, True)
for _ in range(self.n_perms))
# for the rayleigh z and the resultant vector length, compute the actual difference between good and bad
# memory at each timepoint. Then compute a null distribution from shuffled data. Then compute the rank of the
# real data compared to the shuffled at each timepoint. Convert rank to z-score and return
null_elec_pair_zs_rec = np.stack([x['elec_pair_z_rec'] for x in res], 0)
null_elec_pair_zs_nrec = np.stack([x['elec_pair_z_nrec'] for x in res], 0)
null_delta_mem_zs = null_elec_pair_zs_rec - null_elec_pair_zs_nrec
real_delta_mem_zs = elec_pair_stats['elec_pair_z_rec'] - elec_pair_stats['elec_pair_z_nrec']
delta_mem_zs_rank = np.mean(real_delta_mem_zs > null_delta_mem_zs, axis=0)
delta_mem_zs_rank[delta_mem_zs_rank == 0] += 1/self.n_perms
delta_mem_zs_rank[delta_mem_zs_rank == 1] -= 1 / self.n_perms
null_elec_pair_rvls_rec = np.stack([x['elec_pair_rvl_rec'] for x in res], 0)
null_elec_pair_rvls_nrec = np.stack([x['elec_pair_rvl_nrec'] for x in res], 0)
null_delta_mem_rvls = null_elec_pair_rvls_rec - null_elec_pair_rvls_nrec
real_delta_mem_rvls = elec_pair_stats['elec_pair_rvl_rec'] - elec_pair_stats['elec_pair_rvl_nrec']
delta_mem_rvls_rank = np.mean(real_delta_mem_rvls > null_delta_mem_rvls, axis=0)
delta_mem_rvls_rank[delta_mem_rvls_rank == 0] += 1/self.n_perms
delta_mem_rvls_rank[delta_mem_rvls_rank == 1] -= 1 / self.n_perms
return norm.ppf(delta_mem_zs_rank), norm.ppf(delta_mem_rvls_rank)
def calc_score(self):
cardtype_names = np.array(
['highcard', 'pair', 'twopair', 'threeofakind', 'straight', 'flush', 'fullhouse', 'fourofakind',
'straightflush'])
self.cardtype_multiplier = np.array(
[self.highcard_multiplier, self.pair_multiplier, self.twopair_multiplier, self.threeofakind_multiplier,
self.straight_multiplier, self.flush_multiplier, self.fullhouse_multiplier, self.fourofakind_multiplier,
self.straighflush_multiplier])
self.detected_types = np.stack((self.highcard, self.pair, self.twopair, self.threeofakind,
self.straight, self.flush, self.fullhouse, self.fourofakind,
self.straightflush), axis=0)
self.hand_vals = np.stack((self.highCardsVal, self.pairScore, self.twoPairScore, self.threeScore,self.straightScore,
self.flushScore,self.fullhouseScore,self.fourofakindScore,self.straightflush_score),axis = 0)
detected_types = self.detected_types * 1
self.active_multiplier = self.cardtype_multiplier[:,None,None] * detected_types * self.hand_vals
self.ordered_multiplier = np.sort(self.active_multiplier,axis = 0)[::-1,:,:]
highestVals = np.argmax(self.ordered_multiplier[0,:,:], axis=1)
Winners = (self.ordered_multiplier[0, ::] == np.amax(self.ordered_multiplier[0, :, :], axis=1)[:, None])
MyWinnerMask = np.zeros(self.player_amount, dtype=int)
MyWinnerMask[0] = 1
MyWinnArray = (Winners == MyWinnerMask).all(1)
MyWins = np.sum(MyWinnArray,axis = 0)
# print('cardtype_multiplier \n {}'.format(self.cardtype_multiplier))
# print('detected_types \n {}'.format(detected_types))
# print('hand_vals \n {}'.format(self.hand_vals))
# print('active_multiplier \n {}'.format(self.active_multiplier))
# print('ordered_multiplier \n {}'.format(self.ordered_multiplier))
# print('highest vals \n {}'.format(highestVals))
# print('My Wins \n {}'.format(MyWins))
return MyWins / self.iterations
def __init__(self,stripeindex=None):
if stripeindex == None:
BCfile = MISTFILE_default
else:
BCfile = '/n/regal/conroy_lab/pac/MISTFILES/MIST_full_{0}.h5'.format(stripeindex)
# read in MIST hdf5 table
MISTh5 = h5py.File(BCfile,'r')
# determine the BC datasets
BCTableList = [x for x in MISTh5.keys() if x[:3] == 'BC_']
# read in each BC dataset and pull the photometric information
for BCT in BCTableList:
BCTABLE = Table(np.array(MISTh5[BCT]))
if BCT == BCTableList[0]:
BC = BCTABLE.copy()
else:
BCTABLE.remove_columns(['Teff', 'logg', '[Fe/H]', 'Av', 'Rv'])
BC = hstack([BC,BCTABLE])
BC_AV0 = BC[BC['Av'] == 0.0]
self.bands = BC.keys()
[self.bands.remove(x) for x in ['Teff', 'logg', '[Fe/H]', 'Av', 'Rv']]
self.redintr = LinearNDInterpolator(
(BC['Teff'],BC['logg'],BC['[Fe/H]'],BC['Av']),
np.stack([BC[bb] for bb in self.bands],axis=1),
rescale=True
)
self.redintr_0 = LinearNDInterpolator(
(BC_AV0['Teff'],BC_AV0['logg'],BC_AV0['[Fe/H]']),
np.stack([BC_AV0[bb] for bb in self.bands],axis=1),
rescale=True
)
def test_gaussian_filter_2d_variable_sigma(astronaut):
astronaut = astronaut[::2, ::2]
astronaut_stacked = np.stack([astronaut, astronaut.T])
astronaut_stacked = np.stack([astronaut,
astronaut[:, ::-1],
astronaut[::-1, :],
astronaut[::-1, ::-1]])
bs = len(astronaut_stacked)
img = theano.shared(astronaut_stacked[:, np.newaxis])
sigmas = np.array([3, 1, 2, 0.5], dtype=np.float32)
sigmas_shared = theano.shared(sigmas)
theano_blur = gaussian_filter_2d_variable_sigma(img, sigmas_shared,
border_mode='zero')
blur = theano_blur.eval()
assert blur.shape == (bs, 1, 64, 64)
blur = blur.reshape(bs, 64, 64)
r, c = 4, 2
for i, (sigma, astro) in enumerate(zip(sigmas, astronaut_stacked)):
expected = skimage.filters.gaussian_filter(astro,
float(sigma), mode='constant')
np.testing.assert_allclose(blur[i], expected, rtol=0.01, atol=0.02)
plt.subplot(r, c, 2*i+1)
plt.imshow(blur[0], cmap='gray')
plt.subplot(r, c, 2*(i+1))
plt.imshow(expected, cmap='gray')
plt_save_and_maybe_show("test_gaussian_blur_2d_variable_sigmas.png")
def interpolate_using_griddata(trainingPointsU,trainingPointsV,valuesX,valuesY,valuesZ,unknownPointsU,unknownPointsV,taxels,centersAndNormals,taxel_offset):
ret = interpolation_result();
trainingPoints = np.stack([np.array(trainingPointsU),np.array(trainingPointsV)],1);
unknownPoints = np.stack([np.array(unknownPointsU),np.array(unknownPointsV)],1);
ret.unknownX = scipy.interpolate.griddata(np.array(trainingPoints), np.array(valuesX), np.array(unknownPoints), method="cubic");
ret.unknownY = scipy.interpolate.griddata(np.array(trainingPoints), np.array(valuesY), np.array(unknownPoints), method="cubic");
ret.unknownZ = scipy.interpolate.griddata(np.array(trainingPoints), np.array(valuesZ), np.array(unknownPoints), method="cubic");
ret.normX = np.zeros(ret.unknownX.shape);
ret.normY = np.zeros(ret.unknownY.shape);
ret.normZ = np.zeros(ret.unknownZ.shape);
# the taxel outside the 2D convex hull of the triangle center, use the triangle center
# TODO use an interpolation method
for taxelIndex in taxels:
taxel = taxels[taxelIndex]
if( np.isnan(ret.unknownX[taxelIndex-taxel_offset]) and not(taxel["type"] is "dummy") ):
ret.unknownX[taxelIndex-taxel_offset] = centersAndNormals['centers'][taxel["triangleNumber"]][0]
ret.unknownY[taxelIndex-taxel_offset] = centersAndNormals['centers'][taxel["triangleNumber"]][1]
ret.unknownZ[taxelIndex-taxel_offset] = centersAndNormals['centers'][taxel["triangleNumber"]][2]
# normals TODO compute normals, for now just put the normal of the center of the triangle
if( not(taxel["type"] is "dummy") ):
ret.normX[taxelIndex-taxel_offset] = centersAndNormals['normals'][taxel["triangleNumber"]][0]
ret.normY[taxelIndex-taxel_offset] = centersAndNormals['normals'][taxel["triangleNumber"]][1]
ret.normZ[taxelIndex-taxel_offset] = centersAndNormals['normals'][taxel["triangleNumber"]][2]
return ret;
def ex_descriptor(omega, f, xia, n_lowest, c_ao, s, tdm, tqm, nocc, nvirt, mol, config):
"""
ADD DOCUMENTATION
"""
# Reshape xia
xia_I = xia.reshape(nocc, nvirt, nocc*nvirt)
# Transform the transition density matrix into AO basis
d0I_ao = np.stack(
np.linalg.multi_dot(
[c_ao[:, :nocc], xia_I[:, :, i], c_ao[:, nocc:].T]) for i in range(n_lowest))
# Compute omega in excition analysis for the lowest n excitations
om = get_omega(d0I_ao, s, n_lowest)
# Compute the distribution of positions for the hole and electron
xh, yh, zh = get_exciton_positions(d0I_ao, s, tdm, n_lowest, 'hole')
xe, ye, ze = get_exciton_positions(d0I_ao, s, tdm, n_lowest, 'electron')
# Compute the distribution of the square of position for the hole and electron
x2h, y2h, z2h = get_exciton_positions(d0I_ao, s, tqm, n_lowest, 'hole')
x2e, y2e, z2e = get_exciton_positions(d0I_ao, s, tqm, n_lowest, 'electron')
# Compute the distribution of both hole and electron positions
xhxe, yhye, zhze = get_exciton_positions(d0I_ao, s, tdm, n_lowest, 'both')
# Compute Descriptors
# Compute exciton size:
d_exc = np.sqrt(
((x2h - 2 * xhxe + x2e) + (y2h - 2 * yhye + y2e) + (z2h - 2 * zhze + z2e)) / om)
# Compute centroid electron_hole distance
d_he = np.abs(((xe - xh) + (ye - yh) + (ze - zh)) / om)
# Compute hole and electron size
sigma_h = np.sqrt(
(x2h / om - (xh / om) ** 2) + (y2h / om - (yh / om) ** 2) + (z2h / om - (zh / om) ** 2))
sigma_e = np.sqrt(
(x2e / om - (xe / om) ** 2) + (y2e / om - (ye / om) ** 2) + (z2e / om - (ze / om) ** 2))
# Compute Pearson coefficients
cov = (xhxe - xh * xe) + (yhye - yh * ye) + (zhze - zh * ze)
r_eh = cov / (sigma_h * sigma_e)
# Compute approximate d_exc and binding energy
omega_ab = get_omega_ab(d0I_ao, s, n_lowest, mol, config)
r_ab = get_r_ab(mol)
d_exc_apprx = np.stack(
np.sqrt(np.sum(omega_ab[i, :, :] * (r_ab ** 2)) / om[i]) for i in range(n_lowest))
# binding energy approximated
xs = np.stack((omega_ab[i, :, :] / r_ab) for i in range(n_lowest))
xs[np.isinf(xs)] = 0
binding_en_apprx = np.stack((np.sum(xs[i, :, :]) / om[i]) for i in range(n_lowest))
descriptors = write_output_descriptors(
d_exc, d_exc_apprx, d_he, sigma_h, sigma_e, r_eh, binding_en_apprx, n_lowest, omega, f)
return descriptors
def add_polygons(self, polygons, y_offset, x_offset, dimensions):
'''Creates a label image representation of segmented objects based
on global map coordinates of object contours.
Parameters
----------
polygons: List[List[Tuple[Union[int, shapely.geometry.polygon.Polygon]]]]
label and polygon geometry for segmented objects at each z-plane
and time point
y_offset: int
global vertical offset that needs to be subtracted from
y-coordinates
x_offset: int
global horizontal offset that needs to be subtracted from
x-coordinates
dimensions: Tuple[int]
*y*, *x* dimensions of image pixel planes
Returns
-------
numpy.ndarray[numpy.int32]
label image
'''
zstacks = list()
for poly in polygons:
zplanes = list()
for p in poly:
image = SegmentationImage.create_from_polygons(
p, y_offset, x_offset, dimensions
)
zplanes.append(image.array)
array = np.stack(zplanes, axis=-1)
zstacks.append(array)
self.value = np.stack(zstacks, axis=-1)
return self.value
def get_filters(R, filter_size, P=None, n_rings=None):
"""Perform single-frequency DFT on each ring of a polar-resampled patch"""
k = filter_size
filters = {}
N = n_samples(k)
from scipy.linalg import dft
for m, r in R.iteritems():
rsh = r.shape
# Get the basis matrices
weights = get_interpolation_weights(k, m, n_rings=n_rings)
DFT = dft(N)[m,:]
LPF = np.dot(DFT, weights).T
cosine = np.real(LPF).astype(np.float32)
sine = np.imag(LPF).astype(np.float32)
# Project taps on to rotational basis
r = np.reshape(r, np.stack([rsh[0],rsh[1]*rsh[2]]))
ucos = np.reshape(np.dot(cosine, r), np.stack([k, k, rsh[1], rsh[2]]))
usin = np.reshape(np.dot(sine, r), np.stack([k, k, rsh[1], rsh[2]]))
if P is not None:
# Rotate basis matrices
ucos_ = np.cos(P[m])*ucos + np.sin(P[m])*usin
usin = -np.sin(P[m])*ucos + np.cos(P[m])*usin
ucos = ucos_
filters[m] = (ucos, usin)
return filters
def translist_to_traj(tlist):
obs_T_Do = np.stack([trans[0] for trans in tlist]); assert obs_T_Do.shape == (len(tlist), self.obs_space.storage_size)
obsfeat_T_Df = np.stack([trans[1] for trans in tlist]); assert obsfeat_T_Df.shape[0] == len(tlist)
adist_T_Pa = np.stack([trans[2] for trans in tlist]); assert adist_T_Pa.ndim == 2 and adist_T_Pa.shape[0] == len(tlist)
a_T_Da = np.stack([trans[3] for trans in tlist]); assert a_T_Da.shape == (len(tlist), self.action_space.storage_size)
r_T = np.stack([trans[4] for trans in tlist]); assert r_T.shape == (len(tlist),)
return Trajectory(obs_T_Do, obsfeat_T_Df, adist_T_Pa, a_T_Da, r_T)
def get_non_missing(ids, x, y, real_codes):
"""
Takes lists of the data and removes missing data!
:param ids:
:param x:
:param y:
:param real_codes:
:return:
"""
dataset = zip(ids, x, y, real_codes)
dataset = np.array(dataset, dtype=object)
non_miss = dataset[~(dataset[:,3] == '""')]
id_clean = non_miss[:,0].tolist() ##Takes first column of non_missing matrix to writes it to a list
text_clean = non_miss[:,1]
code_clean = non_miss[:,2]
real_codes_clean = non_miss[:,3].tolist()
real_codes_clean = [float(i) for i in real_codes_clean] ##Turns real_codes into floats for memory efficiency
real_codes_clean = np.array(real_codes_clean)
text_clean = np.stack(text_clean, axis=0) ## Makes everything a 2D array instead of array of arrays...
code_clean = np.stack(code_clean, axis=0)
return [id_clean, text_clean, code_clean, real_codes_clean]
def step(self, action):
# x = np.argmax(action[:image_width])
# r = (np.argmax(action[image_width:]) - 1)
# pic = self.canvas[:, :, 0]
# if (r != -1):
# r = 2 ** r
# for i in range(image_width):
# if(np.sum(pic[i, x : x + r + 1])):
# self.draw(x, i, r)
# break
x = (action[:image_width] + 1) / 2.
y = (action[image_width:] + 1) / 2.
grey = x * y.reshape(image_width, 1)
grey = grey.reshape((image_width, image_width, 1))
grey = (grey * (255, 255, 255) / 4).astype('uint8')
grey = np.minimum(grey, self.canvas)
self.canvas -= grey
diff = self.diff()
reward = (self.lastdiff - diff) / self.rewardscale # reward is positive if diff increased
self.lastdiff = diff
self.stepnum += 1
ob = self.observation()
self.canvas = np.stack(np.rot90(self.canvas))
self.target = np.stack(np.rot90(self.target))
self.time += 1. / max_step
return ob, reward, (self.stepnum >= max_step), None # o,r,d,i
def read(self, input_path):
'''
Reads in the data from input files
'''
self.lr_inputs = None
self.sr_outputs = None
print(input_path)
filenames = glob.glob(input_path + '*')
#TODO: remove assertion
assert len(filenames) > 0
random.shuffle(filenames)
filenames = filenames[0:150]
print('Length: ' + str(len(filenames)))
filenames.sort()
outputs = []
inputs = []
for filename in filenames:
output_img = cv2.imread(filename)
# Asserts the image is read correctly and not empty
assert output_img.shape[0] > 0
assert output_img.shape[1] > 0
#TODO: read in actual depth
output_depth = np.random.random((output_img.shape[0], output_img.shape[1], 1))
#print(type(output_img))
output_img = np.concatenate((output_img, output_depth), 2)
#print(type(output_img))
outputs.append(output_img)
input_img = compute_lr_input(
output_img, downsampling_factor_x=2,
downsampling_factor_y=2, blur_sigma=1.6, noise_sigma=0.03)
inputs.append(input_img)
self.sr_outputs = np.stack(outputs, axis=0)
self.lr_inputs = np.stack(inputs, axis=0)
def _read(self, key):
ifnone = lambda a, b: b if a is None else a
y = key[1]
x = key[2]
if isinstance(x, slice):
xstart = ifnone(x.start,0)
xstop = ifnone(x.stop,self.raster_size[0])
xstep = xstop - xstart
else:
raise TypeError("Loc style access elements must be slices, e.g., [:] or [10:100]")
if isinstance(y, slice):
ystart = ifnone(y.start, 0)
ystop = ifnone(y.stop, self.raster_size[1])
ystep = ystop - ystart
else:
raise TypeError("Loc style access elements must be slices, e.g., [:] or [10:100]")
pixels = (xstart, ystart, xstep, ystep)
if isinstance(key[0], (int, np.integer)):
return self.read_array(band=int(key[0]+1), pixels=pixels)
elif isinstance(key[0], slice):
# Given some slice iterate over the bands and get the bands and pixel space requested
arrs = []
for band in list(list(range(1, self.nbands + 1))[key[0]]):
arrs.append(self.read_array(band, pixels = pixels))
return np.stack(arrs)
else:
arrs = []
for b in key[0]:
arrs.append(self.read_array(band=int(b+1), pixels=pixels))
return np.stack(arrs)
def main(args):
# load the model
model = load_model(args.model_filename, custom_objects={
'SubPixelUpscaling': SubPixelUpscaling
})
print model.layers
# load the images and bucket them by shape
images_by_size = defaultdict(list)
for filename in glob.glob(args.image_glob):
img = Image.open(filename)
img = img.resize(map(lambda x: int(x * args.output_scale), img.size)) # scale up
images_by_size[img.size].append(img)
# apply the model to the images
for size, imgs in images_by_size.items():
images = map(img_to_array, imgs)
images = (np.stack(images) / 127.5) - 1.
# NOTE: :(
x = input_layer = Input(shape=images.shape[1:])
for layer in model.layers[1:]:
x = layer(x)
this_model = Model([input_layer], [x])
this_model.compile(optimizer='sgd', loss='mse')
# END :(
new_images = images
for _ in range(args.apply_n):
new_images = this_model.predict(new_images, verbose=False)
# save before/after images
for i in range(new_images.shape[0]):
new_image = new_images[i]
image = images[i]
samples = np.stack([image, new_image])
filename = '{}_{}.png'.format(size, i)
filename = os.path.join(args.output_path, filename)
print('saving sample', samples.shape, filename)
save_sample_grid(samples, filename)
def extract_features(ids, path, output_path, extractor, batch_size=64):
images_names = dict()
for p in listdir(path):
image_id = int(p.split('_')[-1].split('.')[0])
if image_id in ids:
images_names[image_id] = p
batch,names = [],[]
with open(output_path,'w') as output_file:
for idx,n in enumerate(images_names):
p = join(path, images_names[n])
batch.append(load_image(p))
names.append(n)
if len(batch)==batch_size:
batch = np.stack(batch)
feed_dict = {images: batch}
with tf.device('/gpu:0'):
features = sess.run(extractor, feed_dict=feed_dict)
for n,f in zip(names,features):
output_file.write("%s;%s\n" % (n, " ".join(str(x) for x in f)))
print("%d/%d" % (idx,len(images_names)))
batch, names = [],[]
output_file.flush()
if len(batch)>0:
batch = np.stack(batch)
feed_dict = {images: batch}
with tf.device('/gpu:0'):
features = sess.run(extractor, feed_dict=feed_dict)
for n,f in zip(names,features):
output_file.write("%s;%s\n" % (n, " ".join(str(x) for x in f)))
print("%d/%d" % (idx,len(images_names)))
output_file.flush()
# Given the weight of this classifier, cast votes to the corresponding class
pred = tree.get_predictions(X_train, y_train, X_test)
for i, y in enumerate(pred):
if y == 1:
current = votes_1[i]
votes_1[i] = current + tree_weight
else:
current = votes_2[i]
votes_2[i] = current + tree_weight
print("Tree no. {}: \n\t1: {} \n\t2: {}".format(j, votes_1, votes_2))
# print("Got votes from classifier {}.".format(j))
votes = np.stack((votes_1, votes_2), axis=1)/VOTE_SCALING_FACTOR
y_pred = list(np.argmax(votes, axis=1) + 1)
# y_pred = get_predictions(X_train, y_train, X_test)
# Arrange answer in two columns. First column (with header "Id") is an
# enumeration from 0 to n-1, where n is the number of test points. Second
# column (with header "EpiOrStroma" is the predictions.
test_header = "Id,EpiOrStroma"
n_points = X_test.shape[0]
y_pred_pp = np.ones((n_points, 2))
y_pred_pp[:, 0] = range(n_points)
y_pred_pp[:, 1] = y_pred
file_name = 'submissions/my_submission_ADA_{}_a.csv'.format(NO_OF_CLASSIFIERS)
def extract_2d_blocks_training(inputul, outputul, iteration, block_size_input,
block_size_output, dim_output):
## inputul -- shape (num_batch, width, height, num_imaging_modalities)
## outputul -- shape (num_batch, width, height, num_imaging_modalitie)
#### this will extract 4 training examples ####
lista = np.arange(inputul.shape[0])
np.random.seed(iteration)
np.random.shuffle(lista)
current_index = lista[:2]
semi_block_size_input = int(block_size_input // 2)
semi_block_size_input2 = block_size_input - semi_block_size_input
semi_block_size_output = int(block_size_output // 2)
semi_block_size_output2 = block_size_output - semi_block_size_output
list_blocks_input = []
list_blocks_segmentation = []
for _ in current_index:
##### iterating over 2D images #####
### pad current input and output scan to avoid problems ####
current_input = inputul[_, ...]
current_output = outputul[_, ...]
#### shape of current scan ####
current_shape = inputul[_, ...].shape
#################################################################################################################
#### random places being extracted -- most likely not containing any segmentation besides background class ######
#################################################################################################################
list_of_random_places1 = random.sample(
range(semi_block_size_output,
current_shape[0] - semi_block_size_output2), 2)
list_of_random_places2 = random.sample(
range(semi_block_size_output,
current_shape[1] - semi_block_size_output2), 2)
for __ in range(2):
#### iterate over the 2 locations of the 3D cubes #####
central_points = [
list_of_random_places1[__], list_of_random_places2[__]
]
current_input_padded, current_output_padded, central_points = check_and_add_zero_padding_2d_image(
current_input, current_output, central_points,
semi_block_size_input, semi_block_size_input2)
list_blocks_segmentation.append(
crop_2D_block(current_output_padded, central_points,
semi_block_size_output, semi_block_size_output2))
list_blocks_input.append(
crop_2D_block(current_input_padded, central_points,
semi_block_size_input, semi_block_size_input2))
###############################################################################################
##### specifically extract 2D patches with a non-background class #############################
###############################################################################################
#########################
##### Class number 1 ####
#########################
indices_tumor = np.where(current_output[..., 0] == 1.0)
indices_tumor_dim1 = indices_tumor[0]
indices_tumor_dim2 = indices_tumor[1]
if len(indices_tumor_dim1) == 0:
print('tumor not found')
else:
list_of_random_places = random.sample(
range(0, len(indices_tumor_dim1)), 2)
for __ in range(2):
central_points = [
indices_tumor_dim1[list_of_random_places[__]],
indices_tumor_dim2[list_of_random_places[__]]
]
current_input_padded, current_output_padded, central_points = check_and_add_zero_padding_2d_image(
current_input, current_output, central_points,
semi_block_size_input, semi_block_size_input2)
list_blocks_segmentation.append(
crop_2D_block(current_output_padded, central_points,
semi_block_size_output,
semi_block_size_output2))
list_blocks_input.append(
crop_2D_block(current_input_padded, central_points,
semi_block_size_input,
semi_block_size_input2))
list_blocks_input = np.stack(list_blocks_input)
list_blocks_segmentation = np.stack(list_blocks_segmentation)
shape_of_seg = list_blocks_segmentation.shape
list_blocks_segmentation = list_blocks_segmentation.reshape((-1, 1))
#list_blocks_segmentation = output_transformation(list_blocks_segmentation)
#enc = preprocessing.OneHotEncoder()
#enc.fit(list_blocks_segmentation)
#list_blocks_segmentation = enc.transform(list_blocks_segmentation).toarray()
#list_blocks_segmentation = list_blocks_segmentation.reshape((-1,1))
list_blocks_segmentation = OneHotEncoder(list_blocks_segmentation)
list_blocks_segmentation = list_blocks_segmentation.reshape(
(shape_of_seg[0], shape_of_seg[1], shape_of_seg[2], dim_output))
return list_blocks_input, list_blocks_segmentation
def xyz2uv(xyz):
c = np.sqrt((xyz[..., :2]**2).sum(-1))
u = np.arctan2(xyz[..., 1], xyz[..., 0])
v = np.arctan2(xyz[..., 2], c)
return np.stack([u, v], axis=-1)
def uv2xyz(uv):
sin_u = np.sin(uv[..., 0])
cos_u = np.cos(uv[..., 0])
sin_v = np.sin(uv[..., 1])
cos_v = np.cos(uv[..., 1])
return np.stack([cos_v * cos_u, cos_v * sin_u, sin_v], axis=-1)
def genuv(h, w):
u, v = np.meshgrid(np.arange(w), np.arange(h))
u = (u + 0.5) * 2 * np.pi / w - np.pi
v = (v + 0.5) * np.pi / h - np.pi / 2
return np.stack([u, v], axis=-1)
def main(_):
assert FLAGS.model_dirs_or_checkpoints
if not tf.gfile.Exists(FLAGS.output_dir):
tf.gfile.MakeDirs(FLAGS.output_dir)
if (FLAGS.operation == "average_last_n" and
len(FLAGS.model_dirs_or_checkpoints) > 1):
raise ValueError("Need only 1 directory for %s operation" % FLAGS.operation)
checkpoints = []
for path in FLAGS.model_dirs_or_checkpoints:
if tf.gfile.IsDirectory(path):
# Grab the latest checkpoint for all the provided model dirs
checkpoint_state = tf.train.get_checkpoint_state(path)
if FLAGS.operation == "average_last_n":
ckpt_paths = tf.io.gfile.glob(os.path.join(path, "model.ckpt*index"))
def sort_fn(ckpt):
return int(re.sub(".*ckpt-", "", ckpt))
ckpts = sorted([c.replace(".index", "") for c in ckpt_paths],
key=sort_fn)
checkpoints.extend(ckpts[-FLAGS.number_of_checkpoints:])
else:
checkpoints.append(checkpoint_state.all_model_checkpoint_paths[-1])
else:
if FLAGS.operation == "average_last_n":
raise ValueError("need a directory while running %s operation" %
FLAGS.operation)
checkpoints.append(path)
logging.info("Using checkpoints %s", checkpoints)
if FLAGS.operation in ["ensemble", "average", "average_last_n"]:
if len(checkpoints) == 1:
raise ValueError("no point in ensebling/averaging one checkpoint")
else:
if len(checkpoints) != 1:
raise ValueError(
"operation %s requires exactly one checkpoint" % FLAGS.operation)
var_values = {}
var_dtypes = {}
for i in range(0, len(checkpoints)):
checkpoint = checkpoints[i]
logging.info("loading checkpoint %s", checkpoint)
reader = tf.train.load_checkpoint(checkpoint)
var_list = tf.train.list_variables(checkpoint)
for (name, _) in var_list:
if i:
assert name in var_values
tensor = reader.get_tensor(name)
assert tensor.dtype == var_dtypes[name]
var_values[name].append(tensor)
else:
tensor = reader.get_tensor(name)
var_dtypes[name] = tensor.dtype
var_values[name] = [tensor]
if not FLAGS.global_step:
if name == "global_step":
FLAGS.global_step = tensor
logging.info("Read from checkpoint %s", checkpoint)
# stack the list of tensors along the 0th dimension.
for name, tensors in var_values.items():
tensor = tensors[0]
if name == "global_step":
new_val = np.int32(FLAGS.global_step)
elif FLAGS.operation == "ensemble":
new_val = np.stack(tensors)
elif FLAGS.operation == "autoensemble":
new_val = np.stack([tensor] * FLAGS.autoensemble_size)
elif FLAGS.operation == "average" or FLAGS.operation == "average_last_n":
new_val = average_tensors(tensors)
elif FLAGS.operation == "extract_first":
new_val = tensor[0]
else:
raise ValueError("unknown FLAGS.operation=%s" % FLAGS.operation)
var_values[name] = new_val
with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):
tf_vars = [
tf.get_variable(v, shape=var_values[v].shape, dtype=var_dtypes[v])
for v in var_values
]
placeholders = [tf.placeholder(v.dtype, shape=v.shape) for v in tf_vars]
assign_ops = [tf.assign(v, p) for (v, p) in zip(tf_vars, placeholders)]
saver = tf.train.Saver(tf.all_variables())
output_file = "model.ckpt-" + str(FLAGS.global_step)
output_path = os.path.join(FLAGS.output_dir, output_file)
# Build a model consisting only of variables, set them to the average values.
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for p, assign_op, (name, value) in zip(placeholders, assign_ops,
six.iteritems(var_values)):
sess.run(assign_op, {p: value})
# Use the built saver to save the averaged checkpoint.
saver.save(sess, output_path)
logging.info("Transformed checkpoints saved in %s", output_path)
def main():
if args.dataset=='robotic_instrument':
from datasets.robotic_instrument import get_testloader, RoboticInstrument
if args.task=='binary':
num_classes = 2
elif args.task=='parts':
num_classes = 5
elif args.task=='type':
num_classes = 8
dataset = RoboticInstrument(args.task, 'test')
test_loader = get_testloader(args.task, batch_size=args.batch_size)
net_param = {"class_num" : num_classes,
"in_chns" : 3,
"bilinear" : True,
"feature_chns": [16, 32, 64, 128, 256],
"dropout" : [0.0, 0.0, 0.3, 0.4, 0.5]}
elif args.dataset=='covid19_lesion':
from datasets.covid19_lesion import get_testloader, Covid19Dataset
dataset = Covid19Dataset(args.task, 'test')
test_loader = get_testloader(args.task, batch_size=args.batch_size)
num_classes = 2
net_param = {"class_num" : num_classes,
"in_chns" : 1,
"bilinear" : True,
"feature_chns": [16, 32, 64, 128, 256],
"dropout" : [0.0, 0.0, 0.3, 0.4, 0.5]}
else:
raise NotImplementedError('The dataset is not supported.')
net = COPLENet(net_param).cuda()
optimizer.load_weights(net, None, None, args.snapshot, False)
torch.cuda.empty_cache()
net.eval()
hist = 0
predictions = []
groundtruths = []
for test_idx, data in enumerate(test_loader):
inputs, gts = data
assert len(inputs.size()) == 4 and len(gts.size()) == 3
assert inputs.size()[2:] == gts.size()[1:]
inputs, gts = inputs.cuda(), gts.cuda()
with torch.no_grad():
output = net(inputs)
del inputs
assert output.size()[2:] == gts.size()[1:]
assert output.size()[1] == num_classes
prediction = output.data.max(1)[1].cpu()
predictions.append(output.data.cpu().numpy())
groundtruths.append(gts.cpu().numpy())
hist += fast_hist(prediction.numpy().flatten(), gts.cpu().numpy().flatten(),
num_classes)
del gts, output, test_idx, data
predictions = np.concatenate(predictions, axis=0)
groundtruths = np.concatenate(groundtruths, axis=0)
if args.dump_imgs:
assert len(dataset)==predictions.shape[0]
dump_dir = './dump_' + args.dataset + '_' + args.task + '_' + args.method
os.makedirs(dump_dir, exist_ok=True)
for i in range(len(dataset)):
img = skimage.io.imread(dataset.img_paths[i])
if len(img.shape)==2:
img = np.stack((img, img, img), axis=2)
img = skimage.transform.resize(img, (224,336))
cm = np.argmax(predictions[i,:,:,:], axis=0)
color_cm = add_color(cm)
color_cm = skimage.transform.resize(color_cm, (224,336))
gt = np.asarray(groundtruths[i,:,:], np.uint8)
color_gt = add_color(gt)
color_gt = skimage.transform.resize(color_gt, (224,336))
blend_pred = 0.5 * img + 0.5 * color_cm
blend_gt = 0.5 * img + 0.5 * color_gt
blend_pred = np.asarray(blend_pred*255, np.uint8)
blend_gt = np.asarray(blend_gt*255, np.uint8)
#skimage.io.imsave(os.path.join(dump_dir, 'img_{:03d}.png'.format(i)), img)
skimage.io.imsave(os.path.join(dump_dir, 'pred_{:03d}.png'.format(i)), blend_pred)
skimage.io.imsave(os.path.join(dump_dir, 'gt_{:03d}.png'.format(i)), blend_gt)
if i > 20:
break
acc = np.diag(hist).sum() / hist.sum()
acc_cls = np.diag(hist) / hist.sum(axis=1)
iou = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))
id2cat = {i: i for i in range(len(iou))}
iou_false_positive = hist.sum(axis=1) - np.diag(hist)
iou_false_negative = hist.sum(axis=0) - np.diag(hist)
iou_true_positive = np.diag(hist)
print('IoU:')
print('label_id label IoU Precision Recall TP FP FN Pixel Acc.')
for idx, i in enumerate(iou):
idx_string = "{:2d}".format(idx)
class_name = "{:>13}".format(id2cat[idx]) if idx in id2cat else ''
iou_string = '{:5.1f}'.format(i * 100)
total_pixels = hist.sum()
tp = '{:5.1f}'.format(100 * iou_true_positive[idx] / total_pixels)
fp = '{:5.1f}'.format(100 * iou_false_positive[idx] / total_pixels)
fn = '{:5.1f}'.format(100 * iou_false_negative[idx] / total_pixels)
precision = '{:5.1f}'.format(
iou_true_positive[idx] / (iou_true_positive[idx] + iou_false_positive[idx]))
recall = '{:5.1f}'.format(
iou_true_positive[idx] / (iou_true_positive[idx] + iou_false_negative[idx]))
pixel_acc = '{:5.1f}'.format(100*acc_cls[idx])
print('{} {} {} {} {} {} {} {} {}'.format(
idx_string, class_name, iou_string, precision, recall, tp, fp, fn, pixel_acc))
def main():
np.set_printoptions(formatter={'float_kind':lambda x: "%.2f" % x})
env = envstandalone.BlockArrange()
# Standard q-learning parameters
max_timesteps=800
exploration_fraction=0.3
exploration_final_eps=0.1
gamma=.90
num_cpu = 16
# Used by buffering and DQN
learning_starts=100
buffer_size=1000
batch_size=10
target_network_update_freq=1
train_freq=1
print_freq=1
lr=0.0003
# first two elts of deicticShape must be odd
actionShape = (3,3,3)
memoryShape = (3,3,3)
stateActionShape = (3,3,6) # includes place memory
num_states = 2 # either holding or not
num_patches = env.maxSide**2
num_actions_discrete = 3 # pick/place/look
num_actions = num_actions_discrete*num_patches
num_cascade = 3
# valueFunctionType = "TABULAR"
valueFunctionType = "DQN"
# actionSelectionStrategy = "UNIFORM_RANDOM" # actions are selected randomly from collection of all actions
actionSelectionStrategy = "RANDOM_UNIQUE" # each unique action descriptor has equal chance of being selected
DEBUG = False
# DEBUG = True
episode_rewards = [0.0]
# Create the schedule for exploration starting from 1.
exploration = LinearSchedule(schedule_timesteps=int(exploration_fraction * max_timesteps),
initial_p=1.0,
final_p=exploration_final_eps)
# prioritized_replay=True
prioritized_replay=False
# prioritized_replay_alpha=1.0
prioritized_replay_alpha=0.6
prioritized_replay_beta0=0.4
prioritized_replay_beta_iters=None
# prioritized_replay_beta_iters=20000
prioritized_replay_eps=1e-6
if prioritized_replay:
replay_buffer = PrioritizedReplayBuffer(buffer_size, alpha=prioritized_replay_alpha)
if prioritized_replay_beta_iters is None:
prioritized_replay_beta_iters = max_timesteps
beta_schedule = LinearSchedule(prioritized_replay_beta_iters,
initial_p=prioritized_replay_beta0,
final_p=1.0)
else:
replay_buffer = ReplayBuffer(buffer_size)
beta_schedule = None
beta = 1
q_func = models.cnn_to_mlp(
# q_func = models.cnn_to_mlp_2pathways(
# convs=[(16,3,1), (32,3,1)],
# hiddens=[48],
convs=[(32,3,1)],
hiddens=[48],
# convs=[(48,3,1)],
# hiddens=[48],
dueling=True
)
def make_obs_ph(name):
return U.BatchInput(env.observation_space.spaces[0].shape, name=name)
def make_deic_ph(name):
return U.BatchInput(stateActionShape, name=name)
def make_target_ph(name):
return U.BatchInput([1], name=name)
# return U.BatchInput([num_cascade], name=name)
def make_weight_ph(name):
return U.BatchInput([1], name=name)
# return U.BatchInput([num_cascade], name=name)
getMoveActionDescriptors = build_getMoveActionDescriptors(make_obs_ph=make_obs_ph,deicticShape=actionShape)
if valueFunctionType == 'DQN':
getqNotHolding1 = build_getq(make_deic_ph=make_deic_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,scope="deepq",qscope="q_func_notholding")
getqHolding1 = build_getq(make_deic_ph=make_deic_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,scope="deepq",qscope="q_func_holding")
targetTrainNotHolding1 = build_targetTrain(make_deic_ph=make_deic_ph,make_target_ph=make_target_ph,make_weight_ph=make_weight_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,optimizer=tf.train.AdamOptimizer(learning_rate=lr),scope="deepq", qscope="q_func_notholding",grad_norm_clipping=1.)
targetTrainHolding1 = build_targetTrain(make_deic_ph=make_deic_ph,make_target_ph=make_target_ph,make_weight_ph=make_weight_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,optimizer=tf.train.AdamOptimizer(learning_rate=lr),scope="deepq",qscope="q_func_holding",grad_norm_clipping=1.)
# getqNotHolding2 = build_getq(make_deic_ph=make_deic_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,scope="deepq2",qscope="q_func_notholding2")
# getqHolding2 = build_getq(make_deic_ph=make_deic_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,scope="deepq2",qscope="q_func_holding2")
# targetTrainNotHolding2 = build_targetTrain(make_deic_ph=make_deic_ph,make_target_ph=make_target_ph,make_weight_ph=make_weight_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,optimizer=tf.train.AdamOptimizer(learning_rate=lr),scope="deepq2", qscope="q_func_notholding2",grad_norm_clipping=1.)
# targetTrainHolding2 = build_targetTrain(make_deic_ph=make_deic_ph,make_target_ph=make_target_ph,make_weight_ph=make_weight_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,optimizer=tf.train.AdamOptimizer(learning_rate=lr),scope="deepq2",qscope="q_func_holding2",grad_norm_clipping=1.)
#
# getqNotHolding3 = build_getq(make_deic_ph=make_deic_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,scope="deepq3",qscope="q_func_notholding3")
# getqHolding3 = build_getq(make_deic_ph=make_deic_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,scope="deepq3",qscope="q_func_holding3")
# targetTrainNotHolding3 = build_targetTrain(make_deic_ph=make_deic_ph,make_target_ph=make_target_ph,make_weight_ph=make_weight_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,optimizer=tf.train.AdamOptimizer(learning_rate=lr),scope="deepq3", qscope="q_func_notholding3",grad_norm_clipping=1.)
# targetTrainHolding3 = build_targetTrain(make_deic_ph=make_deic_ph,make_target_ph=make_target_ph,make_weight_ph=make_weight_ph,q_func=q_func,num_states=num_states,num_cascade=num_cascade,optimizer=tf.train.AdamOptimizer(learning_rate=lr),scope="deepq3",qscope="q_func_holding3",grad_norm_clipping=1.)
sess = U.make_session(num_cpu)
sess.__enter__()
obs = copy.deepcopy(env.reset())
grid_t = obs[0]
# grid_t = np.int32(obs[0]>0)
stateHolding_t = np.int32(obs[1] > 0)
memory_t = np.zeros([1, memoryShape[0], memoryShape[1], memoryShape[2]]) # first col is pick, second is place, third is look
# memory_t[0,:,:,2] = (env.pickBlockGoal + 2) * np.ones([memoryShape[1], memoryShape[2]]) # DEBUG
episode_rewards = [0.0]
timerStart = time.time()
U.initialize()
if DEBUG:
saver = tf.train.Saver()
saver.restore(sess, "./temp")
for t in range(max_timesteps):
# Get state/action descriptors
moveDescriptors = getMoveActionDescriptors([grid_t])
moveDescriptors[moveDescriptors == 0] = -1
actionsPickDescriptors = np.stack([moveDescriptors, np.zeros(np.shape(moveDescriptors)), np.zeros(np.shape(moveDescriptors))],axis=3)
actionsPlaceDescriptors = np.stack([np.zeros(np.shape(moveDescriptors)),moveDescriptors, np.zeros(np.shape(moveDescriptors))],axis=3)
actionsLookDescriptors = np.stack([np.zeros(np.shape(moveDescriptors)), np.zeros(np.shape(moveDescriptors)), moveDescriptors],axis=3)
actionDescriptors = np.r_[actionsPickDescriptors,actionsPlaceDescriptors,actionsLookDescriptors]
memoryTiled = np.repeat(memory_t,num_patches*num_actions_discrete,axis=0)
stateActionDescriptors = np.concatenate([actionDescriptors, memoryTiled],axis=3)
# Get current values
qCurrNotHolding = getqNotHolding1(stateActionDescriptors)
qCurrHolding = getqHolding1(stateActionDescriptors)
# qCurrNotHolding = getqNotHolding3(stateActionDescriptors)
# qCurrHolding = getqHolding3(stateActionDescriptors)
qCurr = np.concatenate([qCurrNotHolding,qCurrHolding],axis=1)
# Select action
qCurrNoise = qCurr + np.random.random(np.shape(qCurr))*0.01 # add small amount of noise to break ties randomly
if actionSelectionStrategy == "UNIFORM_RANDOM":
action = np.argmax(qCurrNoise[:,stateHolding_t])
if np.random.rand() < exploration.value(t):
action = np.random.randint(num_actions)
elif actionSelectionStrategy == "RANDOM_UNIQUE":
_,idx,inv = np.unique(actionDescriptors,axis=0,return_index=True,return_inverse=True)
actionIdx = np.argmax(qCurrNoise[idx,stateHolding_t])
# if not DEBUG:
# if np.random.rand() < exploration.value(t):
actionIdx = np.random.randint(len(idx))
actionsSelected = np.nonzero(inv==actionIdx)[0]
action = actionsSelected[np.random.randint(len(actionsSelected))]
else:
print("Error...")
# Take action
new_obs, rew, done, _ = env.step(action)
# Update state and memory
grid_tp1 = new_obs[0]
# grid_tp1 = np.int32(new_obs[0]>0)
stateHolding_tp1= np.int32(new_obs[1] > 0)
memory_tp1 = np.copy(memory_t)
if (stateHolding_t == 0) and (stateHolding_tp1 != 0): # if a block has been picked
memory_tp1[:,:,:,0] = np.reshape(stateActionDescriptors[action][:,:,0],[1,stateActionShape[0],stateActionShape[1]])
if (stateHolding_t > 0) and (stateHolding_tp1 == 0): # if a block has just been placed
memory_tp1[:,:,:,1] = np.reshape(stateActionDescriptors[action][:,:,1],[1,stateActionShape[0],stateActionShape[1]])
if action > num_patches*2: # if this is a look action
# memory_tp1[:,:,:,2] = np.reshape(stateActionDescriptors[action][:,:,2],[1,stateActionShape[0],stateActionShape[1]])
# memory_tp1[0,:,:,2] = (env.pickBlockGoal + 2) * np.ones([memoryShape[1], memoryShape[2]]) # DEBUG
if (env.pickBlockGoal + 2) in stateActionDescriptors[action][:,:,2]:
memory_tp1[0,:,:,2] = (env.pickBlockGoal + 2) * np.ones([memoryShape[1], memoryShape[2]])
if DEBUG:
env.render()
print("memory: ")
print(str(memory_tp1))
print("action: " + str(action))
print("action descriptor:")
if action < num_patches:
print(stateActionDescriptors[action][:,:,0])
elif action < 2*num_patches:
print(stateActionDescriptors[action][:,:,1])
else:
print(stateActionDescriptors[action][:,:,2])
# memory_tp1[0,:,:,2] = (env.pickBlockGoal + 2) * np.ones([memoryShape[1], memoryShape[2]]) # DEBUG
# Add to replay buffer
replay_buffer.add(stateHolding_t, stateActionDescriptors[action,:], rew, stateHolding_tp1, grid_tp1, memory_tp1[0], done)
# handle end of episode
if done:
new_obs = env.reset()
grid_tp1 = new_obs[0]
stateHolding_tp1= np.int32(new_obs[1] > 0)
memory_tp1 = np.zeros([1, memoryShape[0], memoryShape[1], memoryShape[2]])
# memory_tp1[0,:,:,2] = (env.pickBlockGoal + 2) * np.ones([memoryShape[1], memoryShape[2]]) # DEBUG
# Set tp1 equal to t
stateHolding_t = stateHolding_tp1
grid_t = grid_tp1
memory_t = memory_tp1
if t > learning_starts and t % train_freq == 0:
# Minimize the error in Bellman's equation on a batch sampled from replay buffer.
if prioritized_replay:
beta=beta_schedule.value(t)
states_t, actionPatches, rewards, images_tp1, states_tp1, placeMemory_tp1, dones, weights, batch_idxes = replay_buffer.sample(batch_size, beta)
else:
statesDiscrete_t, stateActionsImage_t, rewards, statesDiscrete_tp1, grids_tp1, memories_tp1, dones = replay_buffer.sample(batch_size)
weights, batch_idxes = np.ones_like(rewards), None
moveDescriptorsNext = getMoveActionDescriptors(grids_tp1)
moveDescriptorsNext[moveDescriptorsNext == 0] = -1
actionsPickDescriptorsNext = np.stack([moveDescriptorsNext, np.zeros(np.shape(moveDescriptorsNext)), np.zeros(np.shape(moveDescriptorsNext))],axis=3)
actionsPlaceDescriptorsNext = np.stack([np.zeros(np.shape(moveDescriptorsNext)), moveDescriptorsNext, np.zeros(np.shape(moveDescriptorsNext))],axis=3)
actionsLookDescriptorsNext = np.stack([np.zeros(np.shape(moveDescriptorsNext)), np.zeros(np.shape(moveDescriptorsNext)), moveDescriptorsNext],axis=3)
actionDescriptorsNext = np.stack([actionsPickDescriptorsNext, actionsPlaceDescriptorsNext, actionsLookDescriptorsNext], axis=1) # I sometimes get this axis parameter wrong... pay attention!
actionDescriptorsNext = np.reshape(actionDescriptorsNext,[batch_size*num_patches*num_actions_discrete,actionShape[0],actionShape[1],actionShape[2]])
# Augment with state, i.e. place memory
placeMemory_tp1_expanded = np.repeat(memories_tp1,num_patches*num_actions_discrete,axis=0)
actionDescriptorsNext = np.concatenate([actionDescriptorsNext, placeMemory_tp1_expanded],axis=3)
qNextNotHolding = getqNotHolding1(actionDescriptorsNext)
qNextHolding = getqHolding1(actionDescriptorsNext)
qNextFlat = np.concatenate([qNextNotHolding,qNextHolding],axis=1)
qNext = np.reshape(qNextFlat,[batch_size,num_patches,num_actions_discrete,num_states])
qNextmax = np.max(np.max(qNext[range(batch_size),:,:,statesDiscrete_tp1],2),1)
targets = rewards + (1-dones) * gamma * qNextmax
if any(targets > 11):
targets
if t > 750:
qNext
# avg value
qCurrTargetNotHolding = getqNotHolding1(stateActionsImage_t)
qCurrTargetHolding = getqHolding1(stateActionsImage_t)
qCurrTarget = np.concatenate([qCurrTargetNotHolding,qCurrTargetHolding],axis=1)
qCurrTarget[range(batch_size),statesDiscrete_t] = targets
targetTrainNotHolding1(stateActionsImage_t, np.reshape(qCurrTarget[:,0],[batch_size,1]), np.reshape(weights,[batch_size,1]))
targetTrainHolding1(stateActionsImage_t, np.reshape(qCurrTarget[:,1],[batch_size,1]), np.reshape(weights,[batch_size,1]))
# # cascaded value
# qCurrTargetNotHolding1 = getqNotHolding1(stateActionsImage_t)
# qCurrTargetHolding1 = getqHolding1(stateActionsImage_t)
# qCurrTarget1 = np.concatenate([qCurrTargetNotHolding1,qCurrTargetHolding1],axis=1)
# qCurrTargetNotHolding2 = getqNotHolding2(stateActionsImage_t)
# qCurrTargetHolding2 = getqHolding2(stateActionsImage_t)
# qCurrTarget2 = np.concatenate([qCurrTargetNotHolding2,qCurrTargetHolding2],axis=1)
# qCurrTargetNotHolding3 = getqNotHolding3(stateActionsImage_t)
# qCurrTargetHolding3 = getqHolding3(stateActionsImage_t)
# qCurrTarget3 = np.concatenate([qCurrTargetNotHolding3,qCurrTargetHolding3],axis=1)
#
# mask2Idx = np.nonzero(targets < qCurrTarget1[range(batch_size),statesDiscrete_t])[0]
# mask3Idx = np.nonzero(targets < qCurrTarget2[range(batch_size),statesDiscrete_t])[0]
# qCurrTarget1[range(batch_size),statesDiscrete_t] = targets
# qCurrTarget2[mask2Idx,statesDiscrete_t[mask2Idx]] = targets[mask2Idx]
# qCurrTarget3[mask3Idx,statesDiscrete_t[mask3Idx]] = targets[mask3Idx]
#
# targetTrainNotHolding1(stateActionsImage_t, np.reshape(qCurrTarget1[:,0],[batch_size,1]), np.ones([batch_size,1]))
# targetTrainHolding1(stateActionsImage_t, np.reshape(qCurrTarget1[:,1],[batch_size,1]), np.ones([batch_size,1]))
# targetTrainNotHolding2(stateActionsImage_t, np.reshape(qCurrTarget2[:,0],[batch_size,1]), np.ones([batch_size,1]))
# targetTrainHolding2(stateActionsImage_t, np.reshape(qCurrTarget2[:,1],[batch_size,1]), np.ones([batch_size,1]))
# targetTrainNotHolding3(stateActionsImage_t, np.reshape(qCurrTarget3[:,0],[batch_size,1]), np.ones([batch_size,1]))
# targetTrainHolding3(stateActionsImage_t, np.reshape(qCurrTarget3[:,1],[batch_size,1]), np.ones([batch_size,1]))
if prioritized_replay:
new_priorities = np.abs(td_error) + prioritized_replay_eps
replay_buffer.update_priorities(batch_idxes, new_priorities)
# bookkeeping for storing episode rewards
episode_rewards[-1] += rew
if done:
# new_obs = env.reset()
episode_rewards.append(0.0)
mean_100ep_reward = round(np.mean(episode_rewards[-51:-1]), 1)
num_episodes = len(episode_rewards)
if done and print_freq is not None and len(episode_rewards) % print_freq == 0:
timerFinal = time.time()
print("steps: " + str(t) + ", episodes: " + str(num_episodes) + ", mean 100 episode reward: " + str(mean_100ep_reward) + ", % time spent exploring: " + str(int(100 * exploration.value(t))) + ", time elapsed: " + str(timerFinal - timerStart))
timerStart = timerFinal
obs = new_obs
saver = tf.train.Saver()
saver.save(sess, "./temp")
# display value function
obs = env.reset()
moveDescriptors = getMoveActionDescriptors([obs[0]])
moveDescriptors[moveDescriptors == 0] = -1
actionsPickDescriptorsOrig = np.stack([moveDescriptors, np.zeros(np.shape(moveDescriptors)), np.zeros(np.shape(moveDescriptors))],axis=3)
actionsLookDescriptorsOrig = np.stack([np.zeros(np.shape(moveDescriptors)), np.zeros(np.shape(moveDescriptors)), moveDescriptors],axis=3)
memoryZeros = np.zeros([1, memoryShape[0], memoryShape[1], memoryShape[2]])
memoryLooked3 = np.zeros([1, memoryShape[0], memoryShape[1], memoryShape[2]])
memoryLooked3[0,:,:,2] = 3*np.ones([stateActionShape[0], stateActionShape[1]])
memoryLooked4 = np.zeros([1, memoryShape[0], memoryShape[1], memoryShape[2]])
memoryLooked4[0,:,:,2] = 4*np.ones([stateActionShape[0], stateActionShape[1]])
print("\nGrid configuration:")
print(str(obs[0][:,:,0]))
for i in range(3):
if i == 0:
placeMemory = memoryZeros
print("\nMemory has zeros:")
elif i==1:
placeMemory = memoryLooked3
print("\nMemory encodes look=3:")
else:
placeMemory = memoryLooked4
print("\nMemory encodes look=4:")
placeMemoryTiled = np.repeat(placeMemory,num_patches,axis=0)
actionsPickDescriptors = np.concatenate([actionsPickDescriptorsOrig, placeMemoryTiled],axis=3)
actionsLookDescriptors = np.concatenate([actionsLookDescriptorsOrig, placeMemoryTiled],axis=3)
qPickNotHolding1 = getqNotHolding1(actionsPickDescriptors)
qLookNotHolding1 = getqNotHolding1(actionsLookDescriptors)
# qPickNotHolding2 = getqNotHolding2(actionsPickDescriptors)
# qLookNotHolding2 = getqNotHolding2(actionsLookDescriptors)
# qPickNotHolding3 = getqNotHolding3(actionsPickDescriptors)
# qLookNotHolding3 = getqNotHolding3(actionsLookDescriptors)
print("\nValue function for pick action in hold-nothing state:")
print(str(np.reshape(qPickNotHolding1,[8,8])))
# print("***")
# print(str(np.reshape(qPickNotHolding2,[8,8])))
# print("***")
# print(str(np.reshape(qPickNotHolding3,[8,8])))
print("\nValue function for look action in hold-nothing state:")
print(str(np.reshape(qLookNotHolding1,[8,8])))
def running_normalize(vid_path,
save_folder='./norm_images/',
order=3,
dark=None,
return_images=False):
#get first frame of background
vidObj = cv2.VideoCapture(vid_path)
success, img0 = vidObj.read()
if not success:
print('Video not found')
return
nframes = int(vidObj.get(cv2.CAP_PROP_FRAME_COUNT))
print(nframes, 'frames')
if dark is None:
print('Computing dark count')
#get dark count
samplecount = 100 #how many frames to sample (at random)
subtract = 5 #offset dark count
min_cand = []
positions = np.random.choice(
nframes, samplecount, replace=False) #get random frames to sample
for i in range(samplecount):
vidObj.set(cv2.CAP_PROP_POS_FRAMES, positions[i])
success, image = vidObj.read()
if success:
min_cand.append(image.min())
else:
print('Something went wrong')
dark = min(min_cand) - subtract
print('dark count:{}'.format(dark))
#make save folder if it doesn't exist
if not os.path.exists(save_folder):
os.makedirs(save_folder)
success, img0 = vidObj.read()
img0 = img0[:, :, 0]
if not success:
print('Video not found')
return
img_return = []
success = 1
count = 0
vidObj.set(cv2.CAP_PROP_POS_FRAMES, count)
frame = vidObj.get(cv2.CAP_PROP_POS_FRAMES)
#instantiate vmedian object
v = vmedian(order=order, shape=img0.shape)
v.add(img0)
while success:
success, image = vidObj.read()
if success:
image = image[:, :, 0]
if not v.initialized:
v.add(image)
continue
bg = v.get()
numer = image - dark
denom = np.clip((bg - dark), 1, 255)
testimg = np.divide(numer, denom) * 100.
testimg = np.clip(testimg, 0, 255)
filename = os.path.dirname(save_folder) + '/image' + str(
count).zfill(4) + '.png'
cv2.imwrite(filename, testimg)
testimg = np.stack((testimg, ) * 3, axis=-1)
if return_images:
img_return.append(testimg)
print(filename, end='\r')
v.add(image)
count += 1
return img_return
continue
stacked_original = [
np.concatenate((np.array(orig_flow), np.array(orig_result)), axis=-1)
for orig_flow, orig_result in zip(orig_flows_by_attack_number_item,
orig_results_by_attack_number_item)
]
stacked_modified = [
np.concatenate((np.array(modified_flow), np.array(modified_result)),
axis=-1) for modified_flow, modified_result in zip(
modified_flows_by_attack_number_item,
results_by_attack_number_item)
]
seqs = [
np.stack((orig, modified))
for orig, modified in zip(stacked_original, stacked_modified)
]
# Filter good seqs where the adversarial attack succeeded.
filtered_seqs = [
item for item in seqs
if int(np.round(np.mean(numpy_sigmoid(item[0, -1:, -1])))) == 1
and int(np.round(np.mean(numpy_sigmoid(item[1, -1:, -1])))) == 0
]
print("Original seqs", len(seqs), "filtered seqs", len(filtered_seqs))
seqs = filtered_seqs
if len(filtered_seqs) <= 0:
continue
input_image_le_c = np.concatenate(
[input_image_le, input_image_le_gamma], axis=2)
output_image = cv2.cvtColor(
cv2.imread(train_output_names_hdr[id], -1), cv2.COLOR_BGR2RGB)
input_image_le_batch.append(
np.expand_dims(input_image_le_c, axis=0))
input_image_me_batch.append(
np.expand_dims(input_image_me_c, axis=0))
input_image_he_batch.append(
np.expand_dims(input_image_he_c, axis=0))
output_image_batch.append(np.expand_dims(output_image, axis=0))
input_image_le_batch = np.squeeze(
np.stack(input_image_le_batch, axis=1))
input_image_me_batch = np.squeeze(
np.stack(input_image_me_batch, axis=1))
input_image_he_batch = np.squeeze(
np.stack(input_image_he_batch, axis=1))
output_image_batch = np.squeeze(np.stack(output_image_batch, axis=1))
train_writer.add_summary(
sess.run(le_image_summ,
feed_dict={le_image_pl: input_image_le_batch[..., :3]}),
i)
train_writer.add_summary(
sess.run(me_image_summ,
feed_dict={me_image_pl: input_image_me_batch[..., :3]}),
i)
train_writer.add_summary(
TracksAtECAL_dZSig = np.array(rhTree.ECAL_tracksDzSig_atECALfixIP).reshape(
280, 360)
TracksAtECAL_d0Sig = np.array(rhTree.ECAL_tracksD0Sig_atECALfixIP).reshape(
280, 360)
PixAtEcal_1 = np.array(rhTree.BPIX_layer1_ECAL_atPV).reshape(280, 360)
PixAtEcal_2 = np.array(rhTree.BPIX_layer2_ECAL_atPV).reshape(280, 360)
PixAtEcal_3 = np.array(rhTree.BPIX_layer3_ECAL_atPV).reshape(280, 360)
PixAtEcal_4 = np.array(rhTree.BPIX_layer4_ECAL_atPV).reshape(280, 360)
TibAtEcal_1 = np.array(rhTree.TIB_layer1_ECAL_atPV).reshape(280, 360)
TibAtEcal_2 = np.array(rhTree.TIB_layer2_ECAL_atPV).reshape(280, 360)
TobAtEcal_1 = np.array(rhTree.TOB_layer1_ECAL_atPV).reshape(280, 360)
TobAtEcal_2 = np.array(rhTree.TOB_layer2_ECAL_atPV).reshape(280, 360)
#X_CMSII = np.stack([TracksAtECAL_pt, TracksAtECAL_dZSig, TracksAtECAL_d0Sig, ECAL_energy, HBHE_energy], axis=0) # (5, 280, 360)
X_CMSII = np.stack([
TracksAtECAL_pt, TracksAtECAL_dZSig, TracksAtECAL_d0Sig, ECAL_energy,
HBHE_energy, PixAtEcal_1, PixAtEcal_2, PixAtEcal_3, PixAtEcal_4,
TibAtEcal_1, TibAtEcal_2, TobAtEcal_1, TobAtEcal_2
],
axis=0) # (13, 280, 360)
#data['X_CMSII'] = np.stack([TracksAtECAL_pt, ECAL_energy, HBHE_energy], axis=0) # (3, 280, 360)
#data['X_CMSII'] = np.stack([TracksAtECAL_pt, TracksAtECAL_dz, TracksAtECAL_d0, ECAL_energy], axis=0) # (4, 280, 360)
#data['X_CMSII'] = np.stack([TracksAtECAL_pt, TracksAtECAL_dz, TracksAtECAL_d0, ECAL_energy, HBHE_energy, PixAtEcal_1, PixAtEcal_2, PixAtEcal_3, PixAtEcal_4], axis=0) # (9, 280, 360)
# Jet attributes
ys = rhTree.jetIsDiEle
ams = rhTree.a_m
apts = rhTree.a_pt
#dRs = rhTree.jetadR
#pts = rhTree.jetPt
#m0s = rhTree.jetM
iphis = rhTree.jetSeed_iphi
ietas = rhTree.jetSeed_ieta
def standard_test(input, layer, unit_index, preferred_stimulus):
# Note: we put edge of square on centre of preferred-stimulus bar
# Zhou et al. determined significance of the effects of contrast and border ownership with
# a 3-factor ANOVA, significance .01. The factors were side-of-ownership, contrast polarity,
# and time. Having no time component we use a two-factor ANOVA.
# "In the standard test, sizes
# of 4 or 6° were used for cells of V1 and V2, and sizes between 4 and 17°
# were used for cells of V4, depending on response field size."
# I don't see where they mention the number of reps per condition, but there are 10 reps
# in Figure 4.
colours = Colours()
bg_colour_name = 'Light gray (background)'
bg_colour = colours.get_RGB(bg_colour_name, 0)
preferred_colour = preferred_stimulus['colour']
square_shape = (100, 100)
angle = preferred_stimulus['angle']
rotation = [[np.cos(angle), -np.sin(angle)],
[np.sin(angle), np.cos(angle)]]
position_1 = np.add(np.dot(rotation, np.array(
[-50, 0]).transpose()), [200, 200]).astype(np.int)
position_2 = np.add(np.dot(rotation, np.array([50, 0]).transpose()), [
200, 200]).astype(np.int)
# preferred_shape = (preferred_stimulus['width'], preferred_stimulus['length'])
# add_rectangle(stimulus, (200,200), preferred_shape, angle, preferred_colour)
# Stimuli as in panels A-D of Zhou et al. Figure 2
stimulus_A = get_image((400, 400, 3), preferred_colour)
add_rectangle(stimulus_A, position_1, square_shape, angle, bg_colour)
stimulus_B = get_image((400, 400, 3), bg_colour)
add_rectangle(stimulus_B, position_2, square_shape, angle, preferred_colour)
stimulus_C = get_image((400, 400, 3), bg_colour)
add_rectangle(stimulus_C, position_1, square_shape, angle, preferred_colour)
stimulus_D = get_image((400, 400, 3), preferred_colour)
add_rectangle(stimulus_D, position_2, square_shape, angle, bg_colour)
# Stimulus of different size
square_shape = (150, 150)
stimulus_A2 = get_image((400, 400, 3), preferred_colour)
add_rectangle(stimulus_A2, position_1, square_shape, angle, bg_colour)
stimulus_B2 = get_image((400, 400, 3), bg_colour)
add_rectangle(stimulus_B2, position_2, square_shape, angle, preferred_colour)
stimulus_C2 = get_image((400, 400, 3), bg_colour)
add_rectangle(stimulus_C2, position_1, square_shape, angle, preferred_colour)
stimulus_D2 = get_image((400, 400, 3), preferred_colour)
add_rectangle(stimulus_D2, position_2, square_shape, angle, bg_colour)
input_data = np.stack((stimulus_A, stimulus_B, stimulus_C, stimulus_D,
stimulus_A2, stimulus_B2, stimulus_C2, stimulus_D2))
# print(input_data.shape)
# plt.imshow(stimulus_D)
# plt.show()
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
model_tf = sess.graph.get_tensor_by_name(layer)
activities = sess.run(
model_tf, feed_dict={input: input_data})
centre = (int(activities.shape[1] / 2), int(activities.shape[2] / 2))
responses = activities[:, centre[0], centre[1], unit_index]
m = np.mean(responses[:4])
m2 = np.mean(responses[4:])
A, B, C, D, A2, B2, C2, D2 = responses
side = np.abs((A+C)/2 - (B+D)/2) / m * 100
side2 = np.abs((A2+C2)/2 - (B2+D2)/2) / m2 * 100
return {'responses': responses, 'side': side, 'side2': side2, 'mean': m, 'mean2': m2}
import numpy as np
from matplotlib import pyplot as plt
from csxdata.stats import manova
from csxdata.visual import Plotter2D
from csxdata.utilities.highlevel import transform
from SciProjects.sophie import pull_data, axtitles
X_C, Y_C, DHI, D13C, CCode = pull_data("03GEO_pure.csv")
ingoes = np.stack((DHI, D13C), axis=1)
tX = transform(ingoes, 1, False, "lda", CCode)
F, p = manova(tX, CCode)
ttl = (r"2 $\sigma$ (kb. 95%), országokra illesztett konfidencia ellipszisek",
"LDA + ANOVA: F = {:.2f}, p = {:.2f}, az eltérés {}szignifikáns".format(
F, p, ("nem " if p > 0.05 else "")))
axlb = (axtitles["DHI"], axtitles["D13C"])
plot = Plotter2D(plt.figure(),
ingoes,
CCode,
title="\n".join(ttl),
axlabels=axlb)
plot.split_scatter(center=True, sigma=2, alpha=0.5)
plt.show()
def make_adversarial_examples(cls, image, true_label, target_label, args,
attack_norm, model_to_fool):
'''
The attack process for generating adversarial examples with priors.
'''
# Initial setup
orig_images = image.clone()
prior_size = IMAGE_SIZE[
args.dataset][0] if not args.tiling else args.tile_size
assert args.tiling == (args.dataset == "ImageNet")
if args.tiling:
upsampler = Upsample(size=(IMAGE_SIZE[args.dataset][0],
IMAGE_SIZE[args.dataset][1]))
else:
upsampler = lambda x: x
total_queries = torch.zeros(args.batch_size).cuda()
prior = torch.zeros(args.batch_size, IN_CHANNELS[args.dataset],
prior_size, prior_size).cuda()
dim = prior.nelement(
) / args.batch_size # nelement() --> total number of elements
prior_step = BanditAttack.gd_prior_step if attack_norm == 'l2' else BanditAttack.eg_step
image_step = BanditAttack.l2_image_step if attack_norm == 'l2' else BanditAttack.linf_step
proj_maker = BanditAttack.l2_proj if attack_norm == 'l2' else BanditAttack.linf_proj # 调用proj_maker返回的是一个函数
proj_step = proj_maker(orig_images, args.epsilon)
# Loss function
criterion = BanditAttack.cw_loss if args.loss == "cw" else BanditAttack.xent_loss
# Original classifications
orig_classes = model_to_fool(image).argmax(1).cuda()
correct_classified_mask = (orig_classes == true_label).float()
not_dones_mask = correct_classified_mask.clone() # 分类分对的mask
log.info("correct ratio : {:.3f}".format(
correct_classified_mask.mean()))
normalized_q1 = deque(maxlen=100)
normalized_q2 = deque(maxlen=100)
images = deque(maxlen=100)
logits_q1_list = deque(maxlen=100)
logits_q2_list = deque(maxlen=100)
# 有选择的选择一个段落，比如说从中间开始截取一个段落
assert args.max_queries // 2 >= 100
slice_iteration_end = random.randint(100, args.max_queries // 2)
for i in range(slice_iteration_end):
if not args.nes:
## Updating the prior:
# Create noise for exporation, estimate the gradient, and take a PGD step
exp_noise = args.exploration * torch.randn_like(prior) / (
dim**0.5
) # parameterizes the exploration to be done around the prior
exp_noise = exp_noise.cuda()
# Query deltas for finite difference estimator
q1 = upsampler(
prior + exp_noise
) # 这就是Finite Difference算法， prior相当于论文里的v，这个prior也会更新，把梯度累积上去
q2 = upsampler(
prior -
exp_noise) # prior 相当于累积的更新量，用这个更新量，再去修改image，就会变得非常准
# Loss points for finite difference estimator
logits_q1 = model_to_fool(image + args.fd_eta * q1 /
BanditAttack.norm(q1))
logits_q2 = model_to_fool(image + args.fd_eta * q2 /
BanditAttack.norm(q2))
l1 = criterion(logits_q1, true_label, target_label)
l2 = criterion(logits_q2, true_label, target_label)
if i >= slice_iteration_end - 100:
images.append(image.detach().cpu().numpy())
normalized_q1.append(
(args.fd_eta * q1 /
BanditAttack.norm(q1)).detach().cpu().numpy())
normalized_q2.append(
(args.fd_eta * q2 /
BanditAttack.norm(q2)).detach().cpu().numpy())
logits_q1_list.append(logits_q1.detach().cpu().numpy())
logits_q2_list.append(logits_q2.detach().cpu().numpy())
# Finite differences estimate of directional derivative
est_deriv = (l1 - l2) / (args.fd_eta * args.exploration
) # 方向导数 , l1和l2是loss
# 2-query gradient estimate
est_grad = est_deriv.view(-1, 1, 1,
1) * exp_noise # B, C, H, W,
# Update the prior with the estimated gradient
prior = prior_step(
prior, est_grad,
args.online_lr) # 注意，修正的是prior,这就是bandit算法的精髓
else: # NES方法
prior = torch.zeros_like(image).cuda()
for grad_iter_t in range(args.gradient_iters):
exp_noise = torch.randn_like(image) / (dim**0.5)
logits_q1 = model_to_fool(image + args.fd_eta * exp_noise)
logits_q2 = model_to_fool(image - args.fd_eta * exp_noise)
l1 = criterion(logits_q1, true_label, target_label)
l2 = criterion(logits_q2, true_label, target_label)
est_deriv = (l1 - l2) / args.fd_eta
prior += est_deriv.view(-1, 1, 1, 1) * exp_noise
if i * args.gradient_iters + grad_iter_t >= slice_iteration_end - 100:
images.append(image.detach().cpu().numpy())
normalized_q1.append(
(args.fd_eta * exp_noise).detach().cpu().numpy())
normalized_q2.append(
(-args.fd_eta * exp_noise).detach().cpu().numpy())
logits_q1_list.append(logits_q1.detach().cpu().numpy())
logits_q2_list.append(logits_q2.detach().cpu().numpy())
# Preserve images that are already done,
# Unless we are specifically measuring gradient estimation
prior = prior * not_dones_mask.view(-1, 1, 1, 1).cuda()
## Update the image:
# take a pgd step using the prior
new_im = image_step(
image,
upsampler(prior * correct_classified_mask.view(-1, 1, 1, 1)),
args.image_lr) # prior放大后相当于累积的更新量，可以用来更新
image = proj_step(new_im)
image = torch.clamp(image, 0, 1)
## Continue query count
total_queries += 2 * args.gradient_iters * not_dones_mask # gradient_iters是一个int值
with torch.no_grad():
adv_pred = model_to_fool(image).argmax(1)
if args.targeted:
not_dones_mask = not_dones_mask * (
1 - adv_pred.eq(target_label).float()
).float() # not_done初始化为 correct, shape = (batch_size,)
else:
not_dones_mask = not_dones_mask * adv_pred.eq(
true_label).float() # 只要是跟原始label相等的，就还需要query，还没有成功
## Logging stuff
success_mask = (1 - not_dones_mask) * correct_classified_mask
num_success = success_mask.sum()
current_success_rate = (
num_success.detach().cpu() /
correct_classified_mask.detach().cpu().sum()).cpu().item()
if num_success == 0:
success_queries = 0
else:
success_queries = ((success_mask * total_queries).sum() /
num_success).cpu().item()
max_curr_queries = total_queries.max().cpu().item()
# log.info("%d-th: Queries: %d | Success rate: %f | Average queries: %f" % (i, max_curr_queries, current_success_rate, success_queries))
# if current_success_rate == 1.0:
# break
normalized_q1 = np.ascontiguousarray(
np.transpose(np.stack(list(normalized_q1)), axes=(1, 0, 2, 3, 4)))
normalized_q2 = np.ascontiguousarray(
np.transpose(np.stack(list(normalized_q2)), axes=(1, 0, 2, 3, 4)))
images = np.ascontiguousarray(
np.transpose(np.stack(list(images)), axes=(1, 0, 2, 3, 4)))
logits_q1_list = np.ascontiguousarray(
np.transpose(np.stack(list(logits_q1_list)),
axes=(1, 0, 2))) # B,T,#class
logits_q2_list = np.ascontiguousarray(
np.transpose(np.stack(list(logits_q2_list)),
axes=(1, 0, 2))) # B,T,#class
return {
'average_queries': success_queries,
'num_correctly_classified':
correct_classified_mask.sum().cpu().item(),
'success_rate': current_success_rate,
'images_orig': orig_images.cpu().numpy(),
'images_adv': image.cpu().numpy(),
'all_queries': total_queries.cpu().numpy(),
'correctly_classified': correct_classified_mask.cpu().numpy(),
'success': success_mask.cpu().numpy(),
"q1": normalized_q1,
"q2": normalized_q2,
"images": images,
"logits_q1": logits_q1_list,
"logits_q2": logits_q2_list
}
def _log_images(self, num_images=36):
validation_X = self.validation_data[0]
validation_y = self.validation_data[1]
validation_length = len(validation_X)
if validation_length > num_images:
# pick some data at random
indices = np.random.choice(validation_length,
num_images,
replace=False)
else:
indices = range(validation_length)
test_data = []
test_output = []
for i in indices:
test_example = validation_X[i]
test_data.append(test_example)
test_output.append(validation_y[i])
predictions = self.model.predict(np.stack(test_data))
if self.input_type == 'label':
if self.output_type in ('image', 'images', 'segmentation_mask'):
captions = self._logits_to_captions(test_data)
output_image_data = self._masks_to_pixels(
predictions
) if self.output_type == 'segmentation_mask' else predictions
reference_image_data = self._masks_to_pixels(
test_output
) if self.output_type == 'segmentation_mask' else test_output
output_images = [
wandb.Image(data, caption=captions[i], grouping=2)
for i, data in enumerate(output_image_data)
]
reference_images = [
wandb.Image(data, caption=captions[i])
for i, data in enumerate(reference_image_data)
]
return list(
chain.from_iterable(zip(output_images, reference_images)))
elif self.input_type in ('image', 'images', 'segmentation_mask'):
input_image_data = self._masks_to_pixels(
test_data
) if self.input_type == 'segmentation_mask' else test_data
if self.output_type == 'label':
# we just use the predicted label as the caption for now
captions = self._logits_to_captions(predictions)
return [
wandb.Image(data, caption=captions[i])
for i, data in enumerate(test_data)
]
elif self.output_type in ('image', 'images', 'segmentation_mask'):
output_image_data = self._masks_to_pixels(
predictions
) if self.output_type == 'segmentation_mask' else predictions
reference_image_data = self._masks_to_pixels(
test_output
) if self.output_type == 'segmentation_mask' else test_output
input_images = [
wandb.Image(data, grouping=3)
for i, data in enumerate(input_image_data)
]
output_images = [
wandb.Image(data)
for i, data in enumerate(output_image_data)
]
reference_images = [
wandb.Image(data)
for i, data in enumerate(reference_image_data)
]
return list(
chain.from_iterable(
zip(input_images, output_images, reference_images)))
else:
# unknown output, just log the input images
return [wandb.Image(img) for img in test_data]
elif self.output_type in ('image', 'images', 'segmentation_mask'):
# unknown input, just log the predicted and reference outputs without captions
output_image_data = self._masks_to_pixels(
predictions
) if self.output_type == 'segmentation_mask' else predictions
reference_image_data = self._masks_to_pixels(
test_output
) if self.output_type == 'segmentation_mask' else test_output
output_images = [
wandb.Image(data, grouping=2)
for i, data in enumerate(output_image_data)
]
reference_images = [
wandb.Image(data)
for i, data in enumerate(reference_image_data)
]
return list(
chain.from_iterable(zip(output_images, reference_images)))
'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
'hair drier', 'toothbrush']
word_embeddings = []
for c in classes:
inputs = tokenizer(c, return_tensors="pt")
outputs = model(**inputs)
last_hidden_states = outputs[0]
#import pdb
#pdb.set_trace()
word_embedding = last_hidden_states[0].detach().numpy()
#print(word_embedding.size())
word_embedding = np.mean(word_embedding, axis=0)
print('{} {}'.format(c, word_embedding.shape))
word_embeddings.append(word_embedding)
word_embeddings = np.stack(word_embeddings, axis=0)
print('{}'.format(word_embeddings.shape))
import pickle
with open('bert_coco.pkl', 'wb') as f:
pickle.dump(word_embeddings, f)
print("{}",format(type(word_embeddings)))
#print(word_embeddings.shape)
with open('data/coco_glove_word2vec.pkl', 'rb') as f:
d = pickle.load(f)
print("{} {}".format(d.shape, type(d)))
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# 2.2 Particle potential energy at γ
#
# particle_info = open(potential_path + '/Particle potential-' + str(frame) + '.dump', 'r')
# alllines = particle_info.readlines()
# lines = alllines[9:]
# particle_info.close()
# for i in range(len(lines)):
# if (lines[i] == '\n'): del lines[i]
# Par_id = np.array([int(line.strip().split(' ')[0]) for line in lines]) # 字段以逗号分隔，这里取得是第1列
# Par_type = np.array([int(line.strip().split(' ')[1]) for line in lines]) # 字段以逗号分隔，这里取得是第2列
# Par_potential = np.array([float(line.strip().split(' ')[6]) for line in lines]) # 字段以逗号分隔，这里取得是第7列
# frame_par_potential_t0 = Par_potential[Par_type == 1]
Par_metrics_t0 = np.stack((Par_nonaffine_um_t0, Par_temperature_t0, Par_D2min_t0, Par_shear_strain_t0), axis=1)
time_corr = [[] for i in range(len(frame_interval))]
for jdx, frame_shift in enumerate(frame_interval):
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# 2.1 Particle nonaffine measures at γ+δγ
#
particle_info = open(dynamics_path + '/Particle dynamics-' + str(frame + frame_shift) + '.dump', 'r')
alllines = particle_info.readlines()
lines = alllines[9:]
particle_info.close()
for i in range(len(lines)):
if (lines[i] == '\n'): del lines[i]
Par_id = np.array([int(line.strip().split(' ')[0]) for line in lines]) # 字段以逗号分隔，这里取得是第1列
Par_type = np.array([int(line.strip().split(' ')[1]) for line in lines]) # 字段以逗号分隔，这里取得是第2列
Par_radius = np.array([float(line.strip().split(' ')[2]) for line in lines]) # 字段以逗号分隔，这里取得是第3列
def main(_):
bert_config = modeling.BertConfig.from_json_file(config_dict[FLAGS.model_size])
if FLAGS.max_seq_length > bert_config.max_position_embeddings:
raise ValueError(
"Cannot use sequence length %d because the BERT model "
"was only trained up to sequence length %d" %
(FLAGS.max_seq_length, bert_config.max_position_embeddings))
tpu_cluster_resolver = None
if use_tpu:
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
FLAGS.tpu)
is_per_host = tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2
run_config = tf.contrib.tpu.RunConfig(
cluster=tpu_cluster_resolver,
keep_checkpoint_max=1,
model_dir=FLAGS.output_path,
tpu_config=tf.contrib.tpu.TPUConfig(
iterations_per_loop=iterations_per_loop,
num_shards=num_tpu_cores,
per_host_input_for_training=is_per_host))
model_fn = model_fn_builder(
bert_config=bert_config,
num_labels=2,
init_checkpoint=init_checkpoint,
use_tpu=use_tpu,
use_one_hot_embeddings=use_tpu)
# If TPU is not available, this will fall back to normal Estimator on CPU
# or GPU.
estimator = tf.contrib.tpu.TPUEstimator(
use_tpu=use_tpu,
model_fn=model_fn,
config=run_config,
train_batch_size=FLAGS.batch_size,
eval_batch_size=FLAGS.batch_size,
predict_batch_size=FLAGS.batch_size,
params={"qc_scores": "qc_scores"})
tf.logging.info("***** Running evaluation *****")
tf.logging.info(" Batch size = %d", FLAGS.batch_size)
for split in ["valid", "test"]:
maxp_run = load_run(os.path.join(FLAGS.first_model_path, "{}_{}_result.trec".format(FLAGS.dataset, split)))
query_docids_map = []
data_path = os.path.join(FLAGS.output_path, "rerank-{0}_kc-{1}".format(FLAGS.rerank_num, FLAGS.kc), "data")
result_path = os.path.join(FLAGS.output_path, "rerank-{0}_kc-{1}".format(FLAGS.rerank_num, FLAGS.kc), "result")
if not tf.gfile.Exists(result_path):
tf.gfile.MakeDirs(result_path)
with tf.gfile.Open(os.path.join(data_path, "chunk_passage_ids_{0}.txt".format(split))) as ref_file:
for line in ref_file:
query_docids_map.append(line.strip().split("\t"))
predict_input_fn = input_fn_builder(
dataset_path=os.path.join(data_path, "chunk_passage_{0}.tf".format(split)),
is_training=False,
seq_length=FLAGS.max_seq_length,
drop_remainder=False)
total_count = 0
result_file = tf.gfile.Open(os.path.join(result_path, "{0}_{1}_result.trec".format(FLAGS.dataset, split)), 'w')
ckpt = tf.train.latest_checkpoint(checkpoint_dir=FLAGS.third_model_path)
print("use latest ckpt: {0}".format(ckpt))
result = estimator.predict(input_fn=predict_input_fn,
yield_single_examples=True,
checkpoint_path=ckpt)
start_time = time.time()
results = []
result_dict = collections.OrderedDict()
for item in result:
results.append((item["qc_scores"], item["probs"]))
total_count += 1
if total_count == len(query_docids_map) or query_docids_map[total_count][0] != \
query_docids_map[total_count - 1][0]:
chunk_num = len(results) // FLAGS.rerank_num
assert chunk_num <= FLAGS.kc
qc_scores, probs = list(zip(*results))
qc_scores = np.stack(qc_scores)
cp_scores = np.stack(probs)[:, 1]
qc_scores = np.reshape(qc_scores, [FLAGS.rerank_num, chunk_num])
cp_scores = np.reshape(cp_scores, [FLAGS.rerank_num, chunk_num])
# softmax normalization
qc_scores = softmax(qc_scores, axis=-1)
scores = np.sum(np.multiply(qc_scores, cp_scores), axis=-1, keepdims=False)
start_idx = total_count - FLAGS.rerank_num * chunk_num
end_idx = total_count
query_ids, chunk_ids, passage_ids, labels, qc_scores = zip(*query_docids_map[start_idx:end_idx])
assert len(set(query_ids)) == 1, "Query ids must be all the same."
query_id = query_ids[0]
candidate_docs = list()
for pid in passage_ids:
doc_id = pid.split("_")[0]
if doc_id not in candidate_docs:
candidate_docs.append(doc_id)
result_dict[query_id] = dict()
for i, doc in enumerate(candidate_docs):
result_dict[query_id][doc] = scores[i]
rerank_list = sorted(result_dict[query_id].items(), key=lambda x: x[1], reverse=True)
last_score = rerank_list[-1][1]
for doc in maxp_run[query_id][FLAGS.rerank_num:]:
current_score = last_score - 0.01
result_dict[query_id][doc] = current_score
last_score = current_score
ranking_list = sorted(result_dict[query_id].items(), key=lambda x: x[1], reverse=True)
for rank, (doc_id, score) in enumerate(ranking_list):
result_file.write(
"\t".join([query_id, "Q0", doc_id, str(rank + 1), str(score), "chunk_passage_PRF"]) + "\n")
results = []
if total_count % 1000 == 0:
tf.logging.warn("Read {} examples in {} secs".format(
total_count, int(time.time() - start_time)))
result_file.close()
tf.logging.info("Done Evaluating!")
img_data = []
for img in users_df.index.values:
input_img = cv2.imread(data_path + '/' + str(img)+'.jpg')
input_img_resize = cv2.resize(input_img, (100, 100))
img_data.append(input_img_resize)
print('loaded photos')
img_data = np.array(img_data)
# users_df = users_df[np.isin(users_df.index.values, ids)]
# %%
# feature_vectors =
# feature_vectors = np.loadtxt('feature_vectors_400_samples.txt')
# print("feature_vectors_shape:", feature_vectors.shape)
# print("num of images:", feature_vectors.shape[0])
# print("size of individual feature vector:", feature_vectors.shape[1])
feature_vectors = np.stack(users_df['vgg_face'])
features = tf.Variable(feature_vectors, name='features')
# Taken from: https://github.com/tensorflow/tensorflow/issues/6322
def images_to_sprite(data):
"""Creates the sprite image along with any necessary padding
Args:
data: NxHxW[x3] tensor containing the images.
Returns:
data: Properly shaped HxWx3 image with any necessary padding.
"""
if len(data.shape) == 3:
data = np.tile(data[..., np.newaxis], (1, 1, 1, 3))
# data = data.astype(np.float32)
#filters out just one chanel of the 3, the others are not used
Chosen, garbagelevel, garbagelevel2 = cv2.split(img)
#converts the single channel image into a numpy array
CurrentImage = asarray(Chosen)
#appends the array to the list initated before loop
arraylist.append(CurrentImage)
#prints shape of array to ensure that all images are the same size as program is running
print(CurrentImage.shape)
#once loop is complete this function stacks all of the images within the list
DataSet = np.stack(arraylist,axis = 2)
#this prints the shape of the entire dataset to be saved
print(DataSet.shape)
#saves as a compressed .npz file
savez_compressed('P:/Python Projects/MIT/MasonIsAnImageSavingGenius.npz', DataSet)
'''
#this was a test to ensure that the saved images can be opened and all look good
#loads data from file that was just saved
loaddata =load('P:/Python Projects/MIT/MasonIsAnImageSavingGenius.npz')
#Because noname was given in the savez_compressed line this is the auto one to ensure propper data load
DataArray = loaddata['arr_0']
def evaluation_preproc(model_output, args={}):
graph_loader = args['graph_loader']
heat = args.get('heat', 100.)
edge_thresh = args.get('edge_thresh', None)
heat_thresh = args.get('heat_thresh', None)
heat_thresh_is_relative = args.get('heat_thresh_is_relative', True)
verbose_rate = args.get('verbose_rate', None)
verbose = args.get('verbose', False)
topk = args.get('top_k', 1)
match_zero = args.get('match_zero', True)
add_full_proposal = args.get('add_full_proposal', False)
num_proposals = args.get('num_proposals', None)
gt_entities = args.get('gt_entities', False)
freq_prior_mtx = args.get('freq_prior', None)
freq_prior_weight = args.get('freq_prior_weight', 0.0)
filter_nonoverlap = args.get('filter_nonoverlap', False)
self_confidence = args.get('self_confidence', False)
rank_triplet_confidence = args.get('rank_triplet_confidence', True)
assert (not match_zero)
noun_prior = args.get('noun_prior', [1.0])
verb_prior = args.get('verb_prior', [1.0])
# reading output graph
pred_conf = None
image_id = model_output['image_id']
ent_prob = [
item[:n] for item, n in zip(model_output['out_ent_prob'],
model_output['out_num_ent'])
]
pred_prob = [
item[:n] for item, n in zip(model_output['out_pred_prob'],
model_output['out_num_pred'])
]
if self_confidence:
pred_conf = [
item[:n] for item, n in zip(model_output['out_pred_conf'],
model_output['out_num_pred'])
]
pred_roles = [
item[:, :np, :ne] for item, np, ne in zip(
model_output['out_pred_roles'], model_output['out_num_pred'],
model_output['out_num_ent'])
]
# Sparsifying the graph
pred_roles_idx = []
for i in range(len(pred_roles)):
#pred_roles[i] = pred_roles[i] >= pred_roles[i].max(axis=-1, keepdims=True) if edge_thresh is None else edge_thresh
if edge_thresh is None:
max_idx = np.argmax(pred_roles[i], axis=-1)
pred_roles[i] = np.zeros(pred_roles[i].shape, dtype='bool')
pr_idx = np.zeros((pred_roles[i].shape[1], pred_roles[i].shape[0]),
dtype=np.int32)
for role in range(max_idx.shape[0]):
for j in range(max_idx.shape[1]):
pred_roles[i][role, j, max_idx[role, j]] = True
pr_idx[j, role] = max_idx[role, j]
pred_roles_idx.append(pr_idx)
else:
pred_roles[i] = pred_roles[i] >= edge_thresh
ent_box = []
for i in range(len(image_id)):
prop = np.copy(args['proposals'][image_id[i]])
ent_box.append(prop)
num_prop = max([prop.shape[0] for prop in ent_box])
box_array = np.zeros((len(image_id), num_prop, 4))
for i, box in enumerate(ent_box):
box_array[i, :box.shape[0]] = box
ent_box = list(box_array)
if verbose:
print('Classifying embeddings...')
# Fetching the ground truth graph
idx = np.asarray([graph_loader.imgid2idx[i] for i in image_id])
gt_graph = graph_loader.get_gt_batch(idx, pack=False)
# Classifying nodes
ent_lbl = []
pred_lbl = []
ent_score = []
pred_score = []
for i in range(len(image_id)):
if gt_entities:
nouns_label = np.copy(gt_graph['ent_lbl'][i]).reshape(
(gt_graph['ent_lbl'][i].shape[0], 1))
nouns_score = np.ones((gt_graph['ent_lbl'][i].shape[0], ))
else:
if topk > 1:
nouns_label = np.argsort(-ent_prob[i], axis=-1)[:, :topk]
else:
nouns_label = np.argmin(-ent_prob[i], axis=-1)[:, np.newaxis]
nouns_score = np.asarray(
[[ent_prob[i][j, nouns_label[j, k]] for k in range(topk)]
for j in range(nouns_label.shape[0])])
nouns_score = np.sum(nouns_score, axis=-1)
# Late-fusion with frequency prior
if freq_prior_weight > 0.0:
n = nouns_label.shape[0]
pred_dist = np.zeros((n * n, pred_prob[i].shape[1]))
pred_dist[pred_roles_idx[i][:, 0] * n +
pred_roles_idx[i][:, 1]] = (
1 - freq_prior_weight) * pred_prob[i]
temp = np.tile(np.arange(n)[:, np.newaxis], (1, n))
pred_roles_idx[i] = np.stack((temp, temp.T), axis=-1).reshape(
(n * n, 2))
pred_dist += freq_prior_weight * freq_prior_mtx[
nouns_label[pred_roles_idx[i][:, 0],
0], nouns_label[pred_roles_idx[i][:, 1], 0]]
pred_roles[i] = np.eye(n, dtype=np.bool)[pred_roles_idx[i].T, :]
else:
pred_dist = pred_prob[i]
if topk > 1:
preds_label = np.argsort(-pred_dist, axis=-1)[:, :topk]
else:
preds_label = np.argmin(-pred_dist, axis=-1)[:, np.newaxis]
if self_confidence:
nouns_score = np.ones((nouns_label.shape[0], ))
preds_score = np.copy(pred_conf[i])
else:
preds_score = np.asarray(
[[pred_dist[j, preds_label[j, k]] for k in range(topk)]
for j in range(preds_label.shape[0])])
preds_score = np.sum(preds_score, axis=-1)
if filter_nonoverlap:
overlap = (pw_iou(ent_box[i], ent_box[i]) > 0.0).astype(np.float32)
preds_score *= overlap[pred_roles_idx[i][:, 0],
pred_roles_idx[i][:, 1]]
ent_lbl.append(nouns_label)
pred_lbl.append(preds_label)
ent_score.append(nouns_score)
pred_score.append(preds_score)
# sorting ...
for i in range(len(image_id)):
ts = np.copy(pred_score[i])
if rank_triplet_confidence:
for r in range(pred_roles[i].shape[0]):
ts *= np.matmul(pred_roles[i][r], ent_score[i])
sort_idx_pred = np.argsort(-ts)
pred_lbl[i] = pred_lbl[i][sort_idx_pred]
pred_score[i] = pred_score[i][sort_idx_pred]
pred_roles[i] = pred_roles[i][:, sort_idx_pred, :]
# Here is the final detected graph
det_graph = {
'ent_lbl': ent_lbl,
'ent_score': ent_score,
'ent_box': ent_box,
'pred_lbl': pred_lbl,
'pred_score': pred_score,
'pred_roles': pred_roles,
}
return det_graph, gt_graph
def get_stacked_images(self):
return np.stack(self.images, axis = 2)
}
# KITTI use IOU threshold for gt matching, here the threshold level array is with shape [num_difficulties, num_Classes].
# KITTI uses three levels of difficulties by default.
KITTI_OVERLAP_MODERATE = np.array([[0.5, 0.7, 0.7, 0.5, 0.5, 0.7, 0.5], [0.5, 0.7, 0.7, 0.5, 0.5, 0.7, 0.5],
[0.5, 0.7, 0.7, 0.5, 0.5, 0.7, 0.5]])
KITTI_OVERLAP_EASY_2D = np.array([[0.5, 0.7, 0.7, 0.5, 0.5, 0.5, 0.5], [0.5, 0.7, 0.7, 0.5, 0.5, 0.5, 0.5],
[0.5, 0.7, 0.7, 0.5, 0.5, 0.5, 0.5]])
KITTI_OVERLAP_EASY_BEV = np.array([[0.25, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5], [0.25, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5],
[0.25, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5]])
KITTI_OVERLAP_EASY_3D = np.array([[0.25, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5], [0.25, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5],
[0.25, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5]])
# Create threshold array for two levels of threshold for each metric class. [2, 3, 7] -> [Thresholds, Difficulties,
# Classes]
KITTI_OVERLAPs_2D = np.stack([KITTI_OVERLAP_MODERATE, KITTI_OVERLAP_EASY_2D], axis=0)
KITTI_OVERLAPs_BEV = np.stack([KITTI_OVERLAP_MODERATE, KITTI_OVERLAP_EASY_BEV], axis=0)
KITTI_OVERLAPs_3D = np.stack([KITTI_OVERLAP_MODERATE, KITTI_OVERLAP_EASY_3D], axis=0)
# Create threshold array by combining subarrays for each metric. [4, 2, 3, 7] -> [Metric_types, Thresholds,
# Difficulties, Classes]
KITTI_OVERLAP_THRESHOLDS = np.stack([KITTI_OVERLAPs_2D, KITTI_OVERLAPs_BEV, KITTI_OVERLAPs_3D, KITTI_OVERLAPs_3D], axis=0)
# NuScenes use distance thresh for gt matching,
# here the threshold level array is with shape [num_difficulties, num_Classes] for each threshold level.
NU_OVERLAP_MODERATE = np.array([[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]])
NU_OVERLAP_EASY = np.array([[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]])
def compute_AFS_descriptors(configurations,
n_max,
l_max,
r_cut,
dimensions,
radial_function_type='g_function',
reg_eigenvalues=0.,
neighbors_in_r_cut=False,
radial_tensor_product=False):
"""Implementation of the formula given in section III.G (page 9).
The indices i and i' in the sum are interpreted as the neighbor indices of a central atom.
If neighbors_in_r_cut=True, we add the constraint that the neighbors i and i' must be at a distance <= r_cut
"""
assert radial_function_type in [
'g_function', 'gaussian'
], f'invalid radial function type {radial_function_type}'
l_values = np.arange(l_max + 1).reshape(1, 1, -1)
if radial_function_type == 'g_function':
W_matrix = compute_W_matrix(n_max, reg=reg_eigenvalues)
alphas = np.arange(1, n_max + 1).astype('float64').reshape((1, -1))
exponents = alphas + 2
normalizing_constants = np.sqrt(2 * alphas + 5) / np.power(
r_cut, alphas + 2.5)
elif radial_function_type == 'gaussian':
centers = np.linspace(0, r_cut, n_max, endpoint=False).reshape((1, -1))
sigma = 0.5 * centers[0, 1]
if radial_tensor_product:
AFS_descriptors = np.zeros(
(configurations.shape[0], configurations.shape[1], n_max**2,
l_max + 1))
else:
AFS_descriptors = np.zeros((configurations.shape[0],
configurations.shape[1], n_max, l_max + 1))
for i_config in tqdm(range(configurations.shape[0])):
configuration = configurations[i_config]
periodized_configuration, initial_atom_ids = periodize_configuration(
configuration, r_cut, dimensions)
point_tree = spatial.cKDTree(periodized_configuration)
for i_atom in range(configuration.shape[0]):
atom = configuration[i_atom:i_atom + 1]
neighbors_indices = [
n_id for n_id in point_tree.query_ball_point(
configuration[i_atom], r_cut)
if initial_atom_ids[n_id] != i_atom
]
neighbors = periodized_configuration[neighbors_indices]
r_vectors = neighbors - atom
r_norms = np.linalg.norm(r_vectors, axis=1, keepdims=True)
if radial_function_type == 'g_function':
phi_functions = normalizing_constants * (r_cut -
r_norms)**exponents
radial_functions = np.dot(phi_functions, W_matrix)
elif radial_function_type == 'gaussian':
radial_functions = gaussian(r_norms, centers, sigma)
r_normalized = r_vectors / r_norms
cos_angles = np.dot(r_normalized, r_normalized.transpose())
# triangular-upper mask corresponding to pairs (i,j) with i<j, i.e. pair of different atoms
n_neighbors = neighbors.shape[0]
triu_mask = np.arange(n_neighbors)[:,
None] < np.arange(n_neighbors)
if neighbors_in_r_cut:
neighbors_indices_pdist_matrix = spatial.distance.squareform(
spatial.distance.pdist(neighbors))
neighbors_in_r_cut_mask = neighbors_indices_pdist_matrix < r_cut
triu_mask *= neighbors_in_r_cut_mask
# triangular-upper indices correspond to pairs (i,j) with i<j, i.e. pair of different atoms
cos_angles = np.clip(cos_angles, -1, 1)
angles_triu = np.arccos(cos_angles[triu_mask]).reshape(-1, 1, 1)
cos_l_angles_triu = np.cos(l_values * angles_triu)
if radial_tensor_product:
radial_functions_product_triu = np.tensordot(
radial_functions.transpose(), radial_functions,
axes=0).transpose(1, 2, 0, 3)[triu_mask, :, :].reshape(
-1, n_max**2, 1)
else:
radial_functions_product_triu = np.stack([
np.dot(radial_functions[:, n:n + 1],
radial_functions[:, n:n + 1].transpose())[triu_mask]
for n in range(n_max)
],
axis=-1)[:, :,
np.newaxis]
AFS_descriptors[i_config,
i_atom] += (radial_functions_product_triu *
cos_l_angles_triu).sum(axis=0)
return AFS_descriptors
def _handler_rgb_l1(ir_path, vis_path, model_path, model_pre_path, ssim_weight, index, output_path=None):
# ir_img = get_train_images(ir_path, flag=False)
# vis_img = get_train_images(vis_path, flag=False)
ir_img = get_test_image_rgb(ir_path, flag=False)
vis_img = get_test_image_rgb(vis_path, flag=False)
dimension = ir_img.shape
ir_img = ir_img.reshape([1, dimension[0], dimension[1], dimension[2]])
vis_img = vis_img.reshape([1, dimension[0], dimension[1], dimension[2]])
#ir_img = np.transpose(ir_img, (0, 2, 1, 3))
#vis_img = np.transpose(vis_img, (0, 2, 1, 3))
ir_img1 = ir_img[:, :, :, 0]
ir_img1 = ir_img1.reshape([1, dimension[0], dimension[1], 1])
ir_img2 = ir_img[:, :, :, 1]
ir_img2 = ir_img2.reshape([1, dimension[0], dimension[1], 1])
ir_img3 = ir_img[:, :, :, 2]
ir_img3 = ir_img3.reshape([1, dimension[0], dimension[1], 1])
vis_img1 = vis_img[:, :, :, 0]
vis_img1 = vis_img1.reshape([1, dimension[0], dimension[1], 1])
vis_img2 = vis_img[:, :, :, 1]
vis_img2 = vis_img2.reshape([1, dimension[0], dimension[1], 1])
vis_img3 = vis_img[:, :, :, 2]
vis_img3 = vis_img3.reshape([1, dimension[0], dimension[1], 1])
print('img shape final:', ir_img1.shape)
with tf.Graph().as_default(), tf.Session() as sess:
infrared_field = tf.placeholder(
tf.float32, shape=ir_img1.shape, name='content')
visible_field = tf.placeholder(
tf.float32, shape=ir_img1.shape, name='style')
dfn = DenseFuseNet(model_pre_path)
enc_ir = dfn.transform_encoder(infrared_field)
enc_vis = dfn.transform_encoder(visible_field)
target = tf.placeholder(
tf.float32, shape=enc_ir.shape, name='target')
output_image = dfn.transform_decoder(target)
# restore the trained model and run the style transferring
saver = tf.train.Saver()
saver.restore(sess, model_path)
enc_ir_temp, enc_vis_temp = sess.run([enc_ir, enc_vis], feed_dict={infrared_field: ir_img1, visible_field: vis_img1})
feature = L1_norm(enc_ir_temp, enc_vis_temp)
output1 = sess.run(output_image, feed_dict={target: feature})
enc_ir_temp, enc_vis_temp = sess.run([enc_ir, enc_vis], feed_dict={infrared_field: ir_img2, visible_field: vis_img2})
feature = L1_norm(enc_ir_temp, enc_vis_temp)
output2 = sess.run(output_image, feed_dict={target: feature})
enc_ir_temp, enc_vis_temp = sess.run([enc_ir, enc_vis], feed_dict={infrared_field: ir_img3, visible_field: vis_img3})
feature = L1_norm(enc_ir_temp, enc_vis_temp)
output3 = sess.run(output_image, feed_dict={target: feature})
output1 = output1.reshape([1, dimension[0], dimension[1]])
output2 = output2.reshape([1, dimension[0], dimension[1]])
output3 = output3.reshape([1, dimension[0], dimension[1]])
output = np.stack((output1, output2, output3), axis=-1)
#output = np.transpose(output, (0, 2, 1, 3))
save_images(ir_path, output, output_path,
prefix='fused' + str(index), suffix='_densefuse_l1norm_'+str(ssim_weight))
nms_threshold_abs = 0.0
nms_threshold_rel = 0.25
loss_type = 'maxlikelihood'
model_type = 'clf+unet-simple'
n_ch_in = 1
n_classes = 2
#%%
model = EggLayingDetector(n_ch_in, n_classes)
model.eval()
#%%
#%%
root_dir = Path.home() / 'workspace/WormData/egg_laying/data/v1_0.5x/test'
gen = SnippetsFullFlow(root_dir)
#%%
batch = []
for _ in range(4):
snippet, is_egg_laying = gen[0]
batch.append((snippet, is_egg_laying))
#%%
snippet, is_egg_laying = zip(*batch)
X = torch.from_numpy(np.stack(snippet))
y = torch.from_numpy(np.stack(is_egg_laying))
#%%
xout = model(X)
def gauss_sample(data, decay_chain, r_name, sigma, sample_N, dat_order):
sigma_delta = 5
def gauss(delta_x):
return tf.exp(-(delta_x**2) / (2 * sigma**2))
angle = cal_helicity_angle(data["particle"],
decay_chain.standard_topology())
decay_chain.standard_topology()
tp_map = decay_chain.topology_map()
r_particle = tp_map[get_particle(r_name)]
for i in decay_chain.standard_topology():
if i.core == r_particle:
m_min = sum(data["particle"][j]["m"] for j in i.outs)
print(i.outs, r_particle)
if any(r_particle == j for j in i.outs):
m_max = (data["particle"][i.core]["m"] -
sum(data["particle"][j]["m"]
for j in i.outs) + data["particle"][r_particle]["m"])
print("min, max: ", m_min, m_max)
mass = {}
weights = []
for i in data["particle"]:
mi = data["particle"][i]["m"]
if i == r_particle:
delta_min = tf.where(
m_min - mi > -sigma_delta * sigma,
m_min - mi,
-sigma_delta * sigma,
)
delta_max = tf.where(
m_max - mi > sigma_delta * sigma,
sigma_delta * sigma,
m_max - mi,
)
delta_m = (delta_max - delta_min) / (sample_N + 1)
print("delta_min:", delta_min)
min_m = mi + delta_min + delta_m / 2
mi_s = []
for j in range(sample_N):
mi_s_i = min_m + delta_m * j
mi_s.append(mi_s_i)
weights.append(gauss(mi_s_i - mi))
mass[i] = tf.stack(mi_s)
else:
mass[i] = mi[None, :]
# print(mass[r_particle], np.mean(mass[r_particle]))
weights = tf.stack(weights)
weights = weights / tf.reduce_sum(weights, axis=0)
data_weights = data.get("weight", tf.ones_like(weights))
total_weights = weights * data_weights
print({k: v.shape for k, v in mass.items()})
mask = True
p4_all = {}
for i in decay_chain:
phi = angle[tp_map[i]][tp_map[i.outs[0]]]["ang"]["alpha"]
theta = angle[tp_map[i]][tp_map[i.outs[0]]]["ang"]["beta"]
m0 = mass[tp_map[i.core]]
m1 = mass[tp_map[i.outs[0]]]
m2 = mass[tp_map[i.outs[1]]]
p_square = get_relative_p2(m0, m1, m2)
print(m0.shape, m1.shape, m2.shape, p_square.shape)
p = tf.sqrt(tf.where(p_square > 0, p_square, 0))
pz = p * tf.cos(theta)
px = p * tf.sin(theta) * tf.cos(phi)
py = p * tf.sin(theta) * tf.sin(phi)
E1 = tf.sqrt(m1 * m1 + p * p)
E2 = tf.sqrt(m2 * m2 + p * p)
p1 = tf.stack([E1, px, py, pz], axis=-1)
p2 = tf.stack([E2, -px, -py, -pz], axis=-1)
p4_all[i.outs[0]] = p1
p4_all[i.outs[1]] = p2
print("p shape", {k: v.shape for k, v in p4_all.items()})
core_boost = {}
for i in decay_chain:
if i.core != decay_chain.top:
core_boost[i.outs[0]] = i.core
core_boost[i.outs[1]] = i.core
ret = {}
for i in decay_chain.outs:
tmp = i
ret[i] = p4_all[i]
while tmp in core_boost:
tmp = core_boost[tmp]
# print(i, tmp)
print(tmp)
ret[i] = lv.rest_vector(lv.neg(p4_all[tmp]), ret[i])
ret2 = {}
mask = tf.expand_dims(mask, -1)
for i in ret:
ret2[i] = tf.where(mask, ret[i], data["particle"][tp_map[i]]["p"])
print("ret2:", {k: v.shape for k, v in ret2.items()})
# print({i: data["particle"][tp_map[i]]["p"] for i in decay_chain.outs})
pi = np.stack([ret2[i] for i in dat_order], axis=-2)
pi = np.transpose(pi, (1, 0, 2, 3))
total_weights = np.transpose(total_weights.numpy(), (1, 0))
print(pi.shape)
return pi, total_weights
frame_stitch[y_start:y_end, x_start:x_end, :] = face_stitch
# Display the images
cv2.rectangle(frame, (face_x, face_y),
(face_x + face_w, face_y + face_h), (0, 255, 0), 2)
frame = cv2.resize(frame, (512, 512), interpolation=cv2.INTER_AREA)
frame_stitch = cv2.resize(frame_stitch, (512, 512),
interpolation=cv2.INTER_AREA)
face_patch_crop = cv2.resize(face_patch_crop, (512, 512),
interpolation=cv2.INTER_AREA)
frame_hat = cv2.resize(frame_hat, (512, 512),
interpolation=cv2.INTER_AREA)
else:
frame = cv2.resize(frame, (512, 512), interpolation=cv2.INTER_AREA)
frame_stitch = np.zeros((512, 512, 3))
face_patch_crop = np.zeros((512, 512, 3))
frame_hat = np.zeros((512, 512, 3))
figure1 = np.stack([frame, frame_stitch], axis=0)
figure2 = np.stack([face_patch_crop, frame_hat], axis=0)
figure = np.stack([figure1, figure2], axis=1)
figure = stack_images(figure)
cv2.imshow('frame', figure)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
print("[INFO] Loaded model '{}' from disk".format(model_name))
print("[INFO] Predicting and generating submission file")
testingDataset = glob(os.path.join(test_path,'*.tif'))
submissionDataframe = pd.DataFrame()
testingDatasetSize = len(testingDataset)
print("[INFO] Predicting on '{}' data".format(testingDatasetSize))
testing_batch_size = 32
for index in range(0, testingDatasetSize, testing_batch_size):
print("[INFO] Predicting on batch: %i - %i"%(index, index+testing_batch_size))
df = pd.DataFrame({'path': testingDataset[index:index+testing_batch_size]})
df['id'] = df.path.map(lambda x: os.path.basename(x).split(".")[0])
df['image'] = df['path'].map(imread)
stack = np.stack(df.image, axis=0)
predictions = [loaded_model.predict(np.expand_dims(item / 255.0, axis=0))[0][0] for item in stack]
df['label'] = predictions
submissionDataframe = pd.concat([submissionDataframe, df[['id', 'label']]])
print("[INFO] Generating submission file")
submissionFilePath = os.path.sep.join([submission_file_path, ("submission__" + strftime("%Y-%m-%d_%H-%M-%S", gmtime()) + ".csv")])
submissionDataframe.to_csv(submissionFilePath, index = False, header = True)
#clearing ram, make some free space
gc.collect()
print("[INFO] Done")
