def angular_symmetry(self, d_cutoff, d, atom_numbers, coordinates):
""" Angular Symmetry Function """
max_atoms = self.max_atoms
embedding = tf.eye(np.max(self.atom_cases) + 1)
atom_numbers_embedded = tf.nn.embedding_lookup(embedding, atom_numbers)
Rs = np.linspace(0., self.angular_cutoff, self.angular_length)
ita = 3 / (Rs[1] - Rs[0])**2
thetas = np.linspace(0., np.pi, self.angular_length)
zeta = float(self.angular_length**2)
ita, zeta, Rs, thetas = np.meshgrid(ita, zeta, Rs, thetas)
zeta = tf.cast(np.reshape(zeta, (1, 1, 1, 1, -1)), tf.float32)
ita = tf.cast(np.reshape(ita, (1, 1, 1, 1, -1)), tf.float32)
Rs = tf.cast(np.reshape(Rs, (1, 1, 1, 1, -1)), tf.float32)
thetas = tf.cast(np.reshape(thetas, (1, 1, 1, 1, -1)), tf.float32)
length = zeta.get_shape().as_list()[-1]
vector_distances = tf.stack([coordinates] * max_atoms, 1) - tf.stack(
[coordinates] * max_atoms, 2)
R_ij = tf.stack([d] * max_atoms, axis=3)
R_ik = tf.stack([d] * max_atoms, axis=2)
f_R_ij = tf.stack([d_cutoff] * max_atoms, axis=3)
f_R_ik = tf.stack([d_cutoff] * max_atoms, axis=2)
# Define angle theta = arccos(R_ij(Vector) dot R_ik(Vector)/R_ij(distance)/R_ik(distance))
vector_mul = tf.reduce_sum(tf.stack([vector_distances] * max_atoms, axis=3) * \
tf.stack([vector_distances] * max_atoms, axis=2), axis=4)
vector_mul = vector_mul * tf.sign(f_R_ij) * tf.sign(f_R_ik)
theta = tf.acos(tf.math.divide(vector_mul, R_ij * R_ik + 1e-5))
R_ij = tf.stack([R_ij] * length, axis=4)
R_ik = tf.stack([R_ik] * length, axis=4)
f_R_ij = tf.stack([f_R_ij] * length, axis=4)
f_R_ik = tf.stack([f_R_ik] * length, axis=4)
theta = tf.stack([theta] * length, axis=4)
out_tensor = tf.pow((1. + tf.cos(theta - thetas)) / 2., zeta) * \
tf.exp(-ita * tf.square((R_ij + R_ik) / 2. - Rs)) * f_R_ij * f_R_ik * 2
if self.atomic_number_differentiated:
out_tensors = []
for id_j, atom_type_j in enumerate(self.atom_cases):
for atom_type_k in self.atom_cases[id_j:]:
selected_atoms = tf.stack([atom_numbers_embedded[:, :, atom_type_j]] * max_atoms, axis=2) * \
tf.stack([atom_numbers_embedded[:, :, atom_type_k]] * max_atoms, axis=1)
selected_atoms = tf.expand_dims(
tf.expand_dims(selected_atoms, axis=1), axis=4)
out_tensors.append(
tf.reduce_sum(out_tensor * selected_atoms, axis=(2, 3)))
return tf.concat(out_tensors, axis=2)
else:
return tf.reduce_sum(out_tensor, axis=(2, 3))
def to_degrees(log_quaternion_loss):
"""Converts a log quaternion distance to an angle.
Args:
log_quaternion_loss: The log quaternion distance between two
unit quaternions (or a batch of pairs of quaternions).
Returns:
The angle in degrees of the implied angle-axis representation.
"""
return tf.acos(-(tf.exp(log_quaternion_loss) - 1)) * 2 * 180 / math.pi
def zero_mean_covariance(covariance, stability=0.0):
'''Output covariance of ReLU for zero-mean Gaussian input.
f(x) = max(x, 0).
Args:
covariance: Input covariance matrix (Size, Size).
stability: For accurate results this should be zero
if used in training, use a value like 1e-4 for stability.
Returns:
Output covariance of ReLU for zero-mean Gaussian input (Size, Size).
'''
S = outer(tf.sqrt(tf.matrix_diag_part(covariance)))
V = tf.clip_by_value(covariance / S, stability - 1.0, 1.0 - stability)
Q = tf.acos(-V) * V + tf.sqrt(1.0 - (V**2.0)) - 1.0
return S * Q * (1.0 / (2.0 * math.pi))
def compute_degree(g1, g2, eps=1e-7):
"""Compute the degree between two vectors using their usual inner product."""
def _dot(u, v):
return tf.reduce_sum(u * v)
g1_norm = tf.sqrt(_dot(g1, g1))
g2_norm = tf.sqrt(_dot(g2, g2))
if g1_norm.numpy() == 0 and g2_norm.numpy() == 0:
cosine = 1. - eps
else:
g1_norm = 1. if g1_norm.numpy() == 0 else g1_norm
g2_norm = 1. if g2_norm.numpy() == 0 else g2_norm
cosine = _dot(g1, g2) / g1_norm / g2_norm
# Restrict to arccos range
cosine = tf.minimum(tf.maximum(cosine, eps - 1.), 1. - eps)
degree = tf.acos(cosine) * 180. / 3.141592653589793
return degree
def K(self, X, X2=None, presliced=False):
if not presliced:
X, X2 = self._slice(X, X2)
X_denominator = tf.sqrt(self._weighted_product(X))
if X2 is None:
X2 = X
X2_denominator = X_denominator
else:
X2_denominator = tf.sqrt(self._weighted_product(X2))
numerator = self._weighted_product(X, X2)
cos_theta = numerator / X_denominator[:, None] / X2_denominator[None, :]
jitter = 1e-15
theta = tf.acos(jitter + (1 - 2 * jitter) * cos_theta)
return self.variance * (1. / np.pi) * self._J(theta) * \
X_denominator[:, None] ** self.order * \
X2_denominator[None, :] ** self.order
def combine_loss_val(embedding, labels, w_init, out_num, margin_a, margin_m, margin_b, s):
'''
This code is contributed by RogerLo. Thanks for you contribution.
:param embedding: the input embedding vectors
:param labels: the input labels, the shape should be eg: (batch_size, 1)
:param s: scalar value default is 64
:param out_num: output class num
:param m: the margin value, default is 0.5
:return: the final cacualted output, this output is send into the tf.nn.softmax directly
'''
weights = tf.get_variable(name='embedding_weights', shape=(embedding.get_shape().as_list()[-1], out_num),
initializer=w_init, dtype=tf.float32)
weights_unit = tf.nn.l2_normalize(weights, axis=0)
embedding_unit = tf.nn.l2_normalize(embedding, axis=1)
cos_t = tf.matmul(embedding_unit, weights_unit)
ordinal = tf.constant(list(range(0, embedding.get_shape().as_list()[0])), tf.int64)
ordinal_y = tf.stack([ordinal, labels], axis=1)
zy = cos_t * s
sel_cos_t = tf.gather_nd(zy, ordinal_y)
if margin_a != 1.0 or margin_m != 0.0 or margin_b != 0.0:
if margin_a == 1.0 and margin_m == 0.0:
s_m = s * margin_b
new_zy = sel_cos_t - s_m
else:
cos_value = sel_cos_t / s
t = tf.acos(cos_value)
if margin_a != 1.0:
t = t * margin_a
if margin_m > 0.0:
t = t + margin_m
body = tf.cos(t)
if margin_b > 0.0:
body = body - margin_b
new_zy = body * s
updated_logits = tf.add(zy, tf.scatter_nd(ordinal_y, tf.subtract(new_zy, sel_cos_t), zy.get_shape()))
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=updated_logits))
predict_cls = tf.argmax(updated_logits, 1)
accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.cast(predict_cls, tf.int64), tf.cast(labels, tf.int64)), 'float'))
predict_cls_s = tf.argmax(zy, 1)
accuracy_s = tf.reduce_mean(tf.cast(tf.equal(tf.cast(predict_cls_s, tf.int64), tf.cast(labels, tf.int64)), 'float'))
return zy, loss, accuracy, accuracy_s, predict_cls_s
def _arccosine(self, slist1, slist2, tf_embs):
"""
Uses an arccosine kernel of degree 0 to calculate
the similarity matrix between two vectors of embeddings.
This is just cosine similarity projected into the [0,1] interval.
"""
dot = self._dot(slist1, slist2, tf_embs)
# This calculation corresponds to an arc-cosine with
# degree 0. It can be interpreted as cosine
# similarity but projected into a [0,1] interval.
# TODO: arc-cosine with degree 1.
tf_pi = tf.constant(np.pi, dtype=tf.float64)
tf_norms = tf.constant(self.norms, dtype=tf.float64, name='norms')
normlist1 = tf.gather(tf_norms, slist1, name='normlist1')
normlist2 = tf.matrix_transpose(tf.gather(tf_norms, slist2, name='normlist2'))
norms = tf.batch_matmul(normlist1, normlist2)
cosine = tf.clip_by_value(tf.truediv(dot, norms), -1, 1)
angle = tf.acos(cosine)
angle = tf.select(tf.is_nan(angle), tf.ones_like(angle) * tf_pi, angle)
return 1 - (angle / tf_pi)
def K(self, X, X2=None, presliced=False):
if not presliced:
X, X2 = self._slice(X, X2)
X_denominator = tf.sqrt(self._weighted_product(X))
if X2 is None:
X2 = X
X2_denominator = X_denominator
else:
X2_denominator = tf.sqrt(self._weighted_product(X2))
numerator = self._weighted_product(X, X2)
X_denominator = tf.expand_dims(X_denominator, -1)
X2_denominator = tf.matrix_transpose(tf.expand_dims(X2_denominator, -1))
cos_theta = numerator / X_denominator / X2_denominator
jitter = 1e-15
theta = tf.acos(jitter + (1 - 2 * jitter) * cos_theta)
return self.variance * (1. / np.pi) * self._J(theta) * \
X_denominator ** self.order * \
X2_denominator ** self.order
def _arccosine(self, s1, s2, tf_embs):
"""
Uses an arccosine kernel of degree 0 to calculate
the similarity matrix between two vectors of embeddings.
This is just cosine similarity projected into the [0,1] interval.
"""
tf_pi = tf.constant(np.pi, dtype=tf.float64)
mat1 = tf.gather(tf_embs, s1)
mat2 = tf.gather(tf_embs, s2)
tf_norms = tf.constant(self.norms, dtype=tf.float64, name='norms')
norms1 = tf.gather(tf_norms, s1)
norms2 = tf.gather(tf_norms, s2)
dot = tf.matmul(mat1, tf.transpose(mat2))
norms = tf.matmul(norms1, tf.transpose(norms2))
# We clip values due to numerical errors
# which put some values outside the arccosine range.
cosine = tf.clip_by_value(dot / norms, -1, 1)
angle = tf.acos(cosine)
# The 0 vector has norm 0, which generates a NaN.
# We catch these NaNs and replace them with pi,
# which ends up returning 0 similarity.
angle = tf.select(tf.is_nan(angle), tf.ones_like(angle) * tf_pi, angle)
return 1 - (angle / tf_pi)
def slerp(initial, final, progress):
omega = tf.acos(dot_product(initial / l2_norm(initial), final / l2_norm(final)))
so = tf.sin(omega)
return tf.sin((1.0-progress)*omega) / so * initial + tf.sin(progress*omega)/so * final
def _conv_layer(self,
bottom,
ksize,
n_filt,
is_training,
name,
stride=1,
bn=False,
relu=True,
pad='SAME',
norm='none',
reg=False,
orth=False,
w_norm='none'):
with tf.variable_scope(name) as scope:
n_input = bottom.get_shape().as_list()[3]
shape = [ksize, ksize, n_input, n_filt]
print("shape of filter %s: %s" % (name, str(shape)))
filt = self.get_conv_filter(
shape,
reg,
stddev=tf.sqrt(2.0 / tf.to_float(ksize * ksize * n_input)))
conv = tf.nn.conv2d(bottom,
filt, [1, stride, stride, 1],
padding=pad)
xnorm = self._get_input_norm(bottom, ksize, pad)
wnorm = self._get_filter_norm(filt)
if w_norm == 'linear':
conv = conv / wnorm
conv = -0.63662 * tf.acos(conv) + 1
elif w_norm == 'cosine':
conv = conv / wnorm
elif w_norm == 'sigmoid':
k_value_w = 0.3
constant_coeff_w = (1 + numpy.exp(
-numpy.pi /
(2 * k_value_w))) / (1 - numpy.exp(-numpy.pi /
(2 * k_value_w)))
conv = conv / wnorm
conv = constant_coeff_w * (1 - tf.exp(
tf.acos(conv) / k_value_w - numpy.pi /
(2 * k_value_w))) / (1 + tf.exp(
tf.acos(conv) / k_value_w - numpy.pi /
(2 * k_value_w)))
elif w_norm == 'none':
pass
if norm == 'linear':
conv = conv / xnorm
conv = conv / wnorm
conv = -0.63662 * tf.acos(conv) + 1
elif norm == 'cosine':
conv = conv / xnorm
conv = conv / wnorm
elif norm == 'sigmoid':
k_value = 0.3
constant_coeff = (1 + numpy.exp(-numpy.pi / (2 * k_value))) / (
1 - numpy.exp(-numpy.pi / (2 * k_value)))
conv = conv / xnorm
conv = conv / wnorm
conv = constant_coeff * (
1 -
tf.exp(tf.acos(conv) / k_value - numpy.pi /
(2 * k_value))) / (1 + tf.exp(
tf.acos(conv) / k_value - numpy.pi /
(2 * k_value)))
elif norm == 'lr_sigmoid':
k_value_lr = tf.get_variable(
'k_value_lr',
n_filt,
initializer=tf.constant_initializer(0.7),
dtype=tf.float32)
k_value_lr = tf.abs(k_value_lr) + 0.05
constant_coeff = (1 + tf.exp(-numpy.pi / (2 * k_value_lr))) / (
1 - tf.exp(-numpy.pi / (2 * k_value_lr)))
conv = conv / xnorm
conv = conv / wnorm
conv = constant_coeff * (1 - tf.exp(
tf.acos(conv) / k_value_lr - numpy.pi /
(2 * k_value_lr))) / (1 + tf.exp(
tf.acos(conv) / k_value_lr - numpy.pi /
(2 * k_value_lr)))
elif norm == 'none':
pass
if orth:
self._add_orthogonal_constraint(filt, n_filt)
if bn:
conv = self.batch_norm(conv, n_filt, is_training)
if relu:
return tf.nn.relu(conv)
else:
return conv
def testRenames(self):
with self.test_session():
self.assertAllClose(1.04719755, tf.acos(0.5).eval())
self.assertAllClose(0.5, tf.rsqrt(4.0).eval())
def testRenames(self): self.assertAllClose(1.04719755, tf.acos(0.5)) self.assertAllClose(0.5, tf.rsqrt(4.0))
sts_input2 = tf.sparse_placeholder(tf.int64, shape=(None, None))
# For evaluation we use exactly normalized rather than
# approximately normalized.
sts_encode1 = tf.nn.l2_normalize(
embed(inputs=dict(values=sts_input1.values,
indices=sts_input1.indices,
dense_shape=sts_input1.dense_shape)),
axis=1)
sts_encode2 = tf.nn.l2_normalize(
embed(inputs=dict(values=sts_input2.values,
indices=sts_input2.indices,
dense_shape=sts_input2.dense_shape)),
axis=1)
sim_scores = -tf.acos(
tf.reduce_sum(tf.multiply(sts_encode1, sts_encode2), axis=1))
# In[17]:
#dataset = sts_test[11:16] #@param ["sts_dev", "sts_test"] {type:"raw"}
#dataset = pandas.DataFrame()
#dataset['sent_2'] = sts_test['sent_2'][11:16]
#dataset['sent_1'] = "A man is cutting an onion"
#dataset.reset_index(drop = True,inplace = True)
#dataset = dataset[['sent_1','sent_2']]
#dataset
QuestionBank = pd.read_excel(
"C:\Girish\GDSAutomationCentral\EYGDSAC_AnalyticsInitiatives\GDSAnalytics\Infosec_Questionnaire\Colated_Questionnaire.xlsx",
sheet_name="Q&A")
def __init__(
self,
n_visible,
n_hidden,
load=False,
save=False,
save_filename=None,
save_name=None,
learning_rate=0.01,
momentum=0.95,
xavier_const=1.0,
err_function='mse',
use_tqdm=False,
# DEPRECATED:
tqdm=None):
tf.reset_default_graph()
if not 0.0 <= momentum <= 1.0:
raise ValueError('momentum should be in range [0, 1]')
if err_function not in {'mse', 'cosine'}:
raise ValueError(
'err_function should be either \'mse\' or \'cosine\'')
self._use_tqdm = use_tqdm
self._tqdm = None
if use_tqdm or tqdm is not None:
from tqdm import tqdm
self._tqdm = tqdm
#加载或保存权值
self._save = save
self._save_filename = save_filename
self._save_name = save_name
self.n_visible = n_visible
self.n_hidden = n_hidden
self.learning_rate = learning_rate
self.momentum = momentum
self.x = tf.placeholder(tf.float32, [None, self.n_visible])
self.y = tf.placeholder(tf.float32, [None, self.n_hidden])
self.w = tf.Variable(tf_xavier_init(self.n_visible,
self.n_hidden,
const=xavier_const),
dtype=tf.float32)
self.visible_bias = tf.Variable(tf.zeros([self.n_visible]),
dtype=tf.float32)
self.hidden_bias = tf.Variable(tf.zeros([self.n_hidden]),
dtype=tf.float32)
self.delta_w = tf.Variable(tf.zeros([self.n_visible, self.n_hidden]),
dtype=tf.float32)
self.delta_visible_bias = tf.Variable(tf.zeros([self.n_visible]),
dtype=tf.float32)
self.delta_hidden_bias = tf.Variable(tf.zeros([self.n_hidden]),
dtype=tf.float32)
self.update_weights = None
self.update_deltas = None
self.compute_hidden = None
self.compute_visible = None
self.compute_visible_from_hidden = None
self._initialize_vars()
assert self.update_weights is not None
assert self.update_deltas is not None
assert self.compute_hidden is not None
assert self.compute_visible is not None
assert self.compute_visible_from_hidden is not None
if err_function == 'cosine':
x1_norm = tf.nn.l2_normalize(self.x, 1)
x2_norm = tf.nn.l2_normalize(self.compute_visible, 1)
cos_val = tf.reduce_mean(tf.reduce_sum(tf.mul(x1_norm, x2_norm),
1))
self.compute_err = tf.acos(cos_val) / tf.constant(np.pi)
else:
self.compute_err = tf.reduce_mean(
tf.square(self.x - self.compute_visible))
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
# 加载权值
if self._load:
self.load_weights(self._save_filename, self._name)
groundtruth = ((z[j, :, :, :] / 255.0) - 0.5) * 2
mask = y[j, :, :, 0]
bmask = tf.cast(mask, tf.bool)
total_pixels += tf.count_nonzero(y[j, :, :, 0])
#tf.assign(bmask,tf.not_equal(bmask,0))
a11 = tf.boolean_mask(tf.reduce_sum(prediction * prediction, axis=2),
bmask)
a22 = tf.boolean_mask(tf.reduce_sum(norm * norm, axis=2), bmask)
a12 = tf.boolean_mask(tf.reduce_sum(prediction * norm, axis=2), bmask)
cos_dist = a12 / tf.sqrt(a11 * a22)
#tf.assign(cos_dist[tf.is_nan(cos_dist)],-1) # missing this in the evalution
cos_dist = tf.clip_by_value(cos_dist, -1, 1)
angle_error = tf.acos(cos_dist)
mean_angle_error += tf.reduce_sum(angle_error)
cost = mean_angle_error / tf.cast(total_pixels, tf.float32)
cost = tf.divide(cost, batch_size)
opt = tf.train.AdamOptimizer(0.0001).minimize(cost)
# the driver
random.shuffle(data)
train, test = train_test_split(data, data_size // 20)
with tf.Session(graph=train_graph) as sess:
sess.run(tf.global_variables_initializer())
for e in range(1, epochs + 1):
num_batches = 0
def slerp(a, b, t):
omega = tf.acos(tf.reduce_sum(a / tf.norm(a, axis=1, keepdims=True) * b / tf.norm(b, axis=1, keepdims=True), axis=1))
omega = tf.expand_dims(omega, axis=1)
res = (tf.sin((1.0 - t) * omega) / tf.sin(omega)) * a + (tf.sin(t * omega) / tf.sin(omega)) * b
return res
def loss(pred_quater,
gt_quater,
pred_transl,
gt_transl,
pred_mask,
pred_traj,
gt_traj,
pred_score,
gt_score,
pred_r,
gt_r,
pred_flow,
gt_flow,
batch_size,
dim=3,
h=240,
w=320):
obj_mask_origin = tf.greater(gt_traj[:, :, :, 2],
tf.zeros_like(gt_traj[:, :, :, 2]))
obj_mask_origin = tf.cast(obj_mask_origin, tf.float32)
obj_mask_1 = tf.reshape(obj_mask_origin, [-1, h, w, 1])
obj_mask_6 = tf.tile(obj_mask_1, [1, 1, 1, 6])
obj_mask_3 = tf.tile(obj_mask_1, [1, 1, 1, 3])
obj_tmp = tf.zeros_like(obj_mask_3)
obj_final = tf.concat([obj_mask_3, obj_tmp], 3)
loss_mask = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.cast(
obj_mask_origin, dtype=tf.int32),
logits=pred_mask))
score_weight = obj_mask_origin + 0.00001
loss_score = tf.reduce_sum(
(score_weight) * tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=tf.cast(gt_score, dtype=tf.int32), logits=pred_score)) / (
tf.reduce_sum(score_weight) + 0.000001)
loss_elem3 = tf.reduce_sum(
tf.squared_difference(pred_traj[:, :, :, 0:3], gt_traj[:, :, :, 0:3]) *
obj_mask_3) / (tf.reduce_sum(obj_mask_1) + 0.000001)
loss_elem6 = tf.reduce_sum(
tf.squared_difference(pred_traj[:, :, :, 3:6], gt_traj[:, :, :, 3:6]) *
obj_mask_3) / (tf.reduce_sum(obj_mask_1) + 0.000001)
loss_boundary = tf.reduce_sum(
tf.squared_difference(gt_r, pred_r) *
obj_mask_1) / (tf.reduce_sum(obj_mask_1) + 0.000001)
loss_flow = tf.reduce_sum(
tf.squared_difference(pred_flow, gt_flow) *
obj_mask_3) / (tf.reduce_sum(obj_mask_1) + 0.000001)
loss_transl = tf.reduce_sum(
tf.squared_difference(pred_transl, gt_transl) *
obj_mask_3) / (tf.reduce_sum(obj_mask_1) + 0.000001)
gt_angle = tf.acos(gt_quater[:, :, :, 0:1]) * 2
gt_angle_axis = gt_quater[:, :, :, 1:4] / (tf.sin(gt_angle / 2) +
0.000001) * gt_angle
loss_quater = tf.reduce_sum(
tf.squared_difference(gt_angle_axis, pred_quater) *
obj_mask_3) / (tf.reduce_sum(obj_mask_1 + 0.000001))
loss_variance = 0.0
loss_violation = 0.0
for b_i in xrange(batch_size):
tmp = gt_traj[b_i, :, :, 2]
tmp = tf.reshape(tmp, (-1, ))
y, idx = tf.unique(tmp)
idx = tf.reshape(idx, (h, w, 1))
ins_tmp = tf.ones_like(idx)
ones = tf.ones_like(gt_traj[b_i, :, :, 2])
obj_mask = obj_mask_origin[b_i]
def instance_variance_loss(z):
idx_mask = tf.equal(gt_traj[b_i, :, :, 2], ones * z)
idx_mask = tf.reshape(idx_mask, [h, w, 1])
idx_mask = tf.cast(idx_mask, tf.float32)
idx_mask_6d = tf.tile(idx_mask, [1, 1, 6])
tmp_prd = idx_mask_6d * pred_traj[b_i]
tmp_prd = tf.reshape(tmp_prd, (-1, 6))
tmp_mean = tf.reduce_sum(
tmp_prd, axis=0) / (tf.reduce_sum(idx_mask) + 0.000001)
tmp_mean = tf.reshape(tmp_mean, (1, 1, 6))
tmp_mean_final = tf.tile(tmp_mean, [h, w, 1])
loss_variance_instance = tf.reduce_sum(
idx_mask_6d *
tf.squared_difference(tmp_mean_final, pred_traj[b_i])) / (
tf.reduce_sum(idx_mask) + 0.000001)
return loss_variance_instance
#loss_variance += tf.reduce_mean(tf.map_fn(instance_variance_loss,y))
def instance_violation_loss(z):
idx_mask = tf.equal(gt_traj[b_i, :, :, dim - 1], ones * z)
idx_mask = tf.logical_and(idx_mask, tf.cast(obj_mask, tf.bool))
idx_mask = tf.reshape(idx_mask, [h, w, 1])
idx_mask = tf.cast(idx_mask, tf.float32)
idx_mask_6d = tf.tile(idx_mask, [1, 1, 6])
tmp_prd = idx_mask_6d * pred_traj[b_i, :, :, 0:6]
tmp_prd = tf.reshape(tmp_prd, (-1, 6))
tmp_r = idx_mask_6d[:, :, 0:1] * pred_r[b_i]
tmp_r_mean = tf.reduce_sum(tmp_r) / (tf.reduce_sum(idx_mask) +
0.000001)
r = tmp_r_mean * 0.5
friend_mask = idx_mask_6d[:, :, 0]
l2_error = tf.reduce_sum(
tf.squared_difference(pred_traj[b_i], gt_traj[b_i]), 2)
dist = tf.sqrt(l2_error)
pull_mask = tf.less(r * ones, dist)
pull_mask = tf.cast(pull_mask, tf.float32)
pos = tf.reduce_sum(friend_mask * pull_mask * l2_error) / (
tf.reduce_sum(friend_mask * pull_mask) + 0.000001)
return pos
#loss_violation += tf.reduce_mean(tf.map_fn(instance_violation_loss,y))
def instance_sceneflow_loss(z):
idx_mask = tf.equal(gt_traj[b_i, :, :, dim - 1], ones * z)
idx_mask = tf.logical_and(idx_mask, tf.cast(obj_mask, tf.bool))
idx_mask = tf.reshape(idx_mask, [h, w, 1])
idx_mask = tf.cast(idx_mask, tf.float32)
idx_mask_3d = tf.tile(idx_mask, [1, 1, 3])
tmp_quater = idx_mask_3d * pred_quater[b_i, :, :, 0:3]
tmp_quater = tf.reshape(tmp_quater, (-1, 3))
tmp_quater = tf.reduce_sum(
tmp_quater, axis=0) / (tf.reduce_sum(idx_mask) + 0.000001)
tmp_transl = idx_mask_3d * pred_transl[b_i, :, :, 0:3]
tmp_transl = tf.reshape(tmp_transl, (-1, 3))
tmp_transl = tf.reduce_sum(
tmp_transl, axis=0) / (tf.reduce_sum(idx_mask) + 0.000001)
w1, x1, y1, z1 = tf.unstack(tmp_quater, axis=-1)
x2, y2, z2 = tf.unstack(frame2_input_xyz[b_i], axis=-1)
wm = -x1 * x2 - y1 * y2 - z1 * z2
xm = w1 * x2 + y1 * z2 - z1 * y2
ym = w1 * y2 + z1 * x2 - x1 * z2
zm = w1 * z2 + x1 * y2 - y1 * x2
x = -wm * x1 + xm * w1 - ym * z1 + zm * y1
y = -wm * y1 + ym * w1 - zm * x1 + xm * z1
z = -wm * z1 + zm * w1 - xm * y1 + ym * x1
tmp_flow = tf.stack((x, y, z), axis=-1)
tmp_flow = tmp_flow + tmp_transl - frame2_input_xyz[b_i]
tmp_loss = tf.reduce_sum(idx_mask_3d * tf.squared_difference(
tmp_flow, gt_flow[b_i])) / (tf.reduce_sum(idx_mask) + 0.000001)
return tmp_loss
return loss_quater, loss_transl, loss_boundary, loss_flow, loss_elem3, loss_elem6, loss_mask, loss_score
def __init__(self,
n_visible,
n_hidden,
learning_rate=0.01,
momentum=0.95,
xavier_const=1.0,
err_function='mse',
use_tqdm=False,
# DEPRECATED:
tqdm=None):
if not 0.0 <= momentum <= 1.0:
raise ValueError('momentum should be in range [0, 1]')
if err_function not in {'mse', 'cosine'}:
raise ValueError('err_function should be either \'mse\' or \'cosine\'')
self._use_tqdm = use_tqdm
self._tqdm = None
if use_tqdm or tqdm is not None:
from tqdm import tqdm
self._tqdm = tqdm
self.n_visible = n_visible
self.n_hidden = n_hidden
self.learning_rate = learning_rate
self.momentum = momentum
self.x = tf.placeholder(tf.float32, [None, self.n_visible])
self.y = tf.placeholder(tf.float32, [None, self.n_hidden])
self.w = tf.Variable(tf_xavier_init(self.n_visible, self.n_hidden, const=xavier_const), dtype=tf.float32)
self.visible_bias = tf.Variable(tf.zeros([self.n_visible]), dtype=tf.float32)
self.hidden_bias = tf.Variable(tf.zeros([self.n_hidden]), dtype=tf.float32)
self.delta_w = tf.Variable(tf.zeros([self.n_visible, self.n_hidden]), dtype=tf.float32)
self.delta_visible_bias = tf.Variable(tf.zeros([self.n_visible]), dtype=tf.float32)
self.delta_hidden_bias = tf.Variable(tf.zeros([self.n_hidden]), dtype=tf.float32)
self.update_weights = None
self.update_deltas = None
self.compute_hidden = None
self.compute_visible = None
self.compute_visible_from_hidden = None
self._initialize_vars()
assert self.update_weights is not None
assert self.update_deltas is not None
assert self.compute_hidden is not None
assert self.compute_visible is not None
assert self.compute_visible_from_hidden is not None
if err_function == 'cosine':
x1_norm = tf.nn.l2_normalize(self.x, 1)
x2_norm = tf.nn.l2_normalize(self.compute_visible, 1)
cos_val = tf.reduce_mean(tf.reduce_sum(tf.mul(x1_norm, x2_norm), 1))
self.compute_err = tf.acos(cos_val) / tf.constant(np.pi)
else:
self.compute_err = tf.reduce_mean(tf.square(self.x - self.compute_visible))
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
def Prepare(self):
"""
Build the required graph.
Also build evaluations.
"""
with tf.name_scope("Capsules"):
self.xyzs = tf.placeholder(dtype=tf.float64,
shape=(self.batch_size, self.MaxNAtom,
3))
self.frac_sphere = tf.placeholder(dtype=tf.float64)
thetas = tf.acos(
2.0 * tf.random_uniform([self.batch_size], dtype=tf.float64) -
1)
phis = tf.random_uniform([self.batch_size],
dtype=tf.float64) * 2 * Pi
psis = tf.random_uniform(
[self.batch_size],
dtype=tf.float64) * 2 * Pi * self.frac_sphere
ts_in = tf.stack([thetas, phis, psis], axis=-1)
ts_inv = tf.stack([thetas, phis, -1.0 * psis], axis=-1)
matrices = TF_RotationBatch(thetas, phis, psis)
self.xyzs -= self.xyzs[:, 0, :][:, tf.newaxis, :]
self.xyzs_t = tf.einsum('ijk,ikl->ijl', self.xyzs, matrices)
# Transform the XYZ's
# The transformation is only WRT the first atom
# both orig. and transformed system get embedded.
# Each atom in xyzs gets transformed by ts_in to make t_xyzs
dxyzs = tf.expand_dims(self.xyzs, axis=2) - tf.expand_dims(
self.xyzs, axis=1)
dxyzs_t = tf.expand_dims(self.xyzs_t, axis=2) - tf.expand_dims(
self.xyzs_t, axis=1)
dist_tensor = tf.norm(dxyzs + 1.e-36, axis=3)
dist_tensor_t = tf.norm(dxyzs_t + 1.e-36, axis=3)
self.Embedded = tf.reshape(
tf.reduce_sum(tf_spherical_harmonics(dxyzs, dist_tensor,
self.lmax),
axis=2)[:, 0, :],
[self.batch_size, (self.lmax + 1)**2])
self.Embedded_t = tf.reshape(
tf.reduce_sum(tf_spherical_harmonics(dxyzs_t, dist_tensor_t,
self.lmax),
axis=2)[:, 0, :],
[self.batch_size, (self.lmax + 1)**2])
self.EmbeddedShp = tf.shape(self.Embedded)[-1]
self.Latent, self.angleOutput, self.Output = self.Capsules(
self.Embedded, ts_in)
self.tLatent, self.tangleOutput, self.tOutput = self.Capsules(
self.Embedded_t, ts_inv)
self.dLdR = tf.norm(tf.gradients(self.tLatent, psis))
self.fwd_reconstruction = tf.losses.mean_squared_error(
self.Embedded_t, self.Output)
self.rev_reconstruction = tf.losses.mean_squared_error(
self.Embedded, self.tOutput)
self.invariance = tf.losses.mean_squared_error(
self.tLatent, self.Latent)
self.loss = self.fwd_reconstruction + self.rev_reconstruction + self.invariance
tf.add_to_collection('losses', self.loss)
with tf.name_scope("Adam_optimizer"):
self.global_step = tf.Variable(0, trainable=False)
optimizer = tf.train.AdamOptimizer(self.learning_rate)
tvars = tf.trainable_variables()
grads_and_vars = optimizer.compute_gradients(self.loss, tvars)
#clipped = [(tf.clip_by_value(grad, -5, 5), tvar) for grad, tvar in grads_and_vars]
self.train_op = optimizer.apply_gradients(
grads_and_vars,
global_step=self.global_step,
name="minimize_cost")
init = tf.global_variables_initializer()
self.saver = tf.train.Saver(max_to_keep=10000)
self.sess = tf.Session(config=tf.ConfigProto(
allow_soft_placement=True))
self.sess.run(init)
self.summary_writer = tf.summary.FileWriter("./networks/",
self.sess.graph)
return