def _VerifyGradientsNew(self, src_z, src_q, src_t, des_z, des_q, des_t,
in_pos, n_src_cube, n_des_cube, batch_size):
with self.test_session():
sz = constant_op.constant(src_z, shape=[batch_size, 3*n_src_cube])
sq = constant_op.constant(src_q, shape=[batch_size, 4*n_src_cube])
st = constant_op.constant(src_t, shape=[batch_size, 3*n_src_cube])
dz = constant_op.constant(des_z, shape=[batch_size, 3*n_des_cube])
dq = constant_op.constant(des_q, shape=[batch_size, 4*n_des_cube])
dt = constant_op.constant(des_t, shape=[batch_size, 3*n_des_cube])
pos = constant_op.constant(in_pos)
points_index = primitive_group_points_v3(sz, sq, st, pos)
data_out = primitive_cube_coverage_loss_v3(dz, dq, dt, pos, points_index,
n_src_cube=n_src_cube)
ret = gradient_checker.compute_gradient(
[dz, dq, dt],
[[batch_size, 3*n_des_cube], [batch_size, 4*n_des_cube], [batch_size, 3*n_des_cube]],
data_out,
[1],
x_init_value=[np.asfarray(des_z).reshape([batch_size, 3*n_des_cube]),
np.asfarray(des_q).reshape([batch_size, 4*n_des_cube]),
np.asfarray(des_t).reshape([batch_size, 3*n_des_cube])]
)
# print(ret)
self.assertAllClose(ret[0][0], ret[0][1], atol=5e-5)
self.assertAllClose(ret[1][0], ret[1][1], atol=5e-5)
self.assertAllClose(ret[2][0], ret[2][1], atol=5e-5)
def _VerifyValuesNew(self, in_z, in_q, in_t, in_pos, expected):
with self.test_session() as sess:
z = constant_op.constant(in_z)
q = constant_op.constant(in_q)
t = constant_op.constant(in_t)
pos = constant_op.constant(in_pos)
data_out = primitive_group_points_v3(z, q, t, pos)
actual = sess.run(data_out)
self.assertAllEqual(expected, actual.flatten())
def cube_coverage_loss_v6(src_latent_code, des_latent_code, n_src_cube,
node_position):
with tf.name_scope('cube_coverage'):
points_index = primitive_group_points_v3(src_latent_code[0],
src_latent_code[1], src_latent_code[2], node_position)
_, relation = primitive_cube_coverage_loss_v4(des_latent_code[0],
des_latent_code[1], des_latent_code[2], node_position, points_index,
n_src_cube=n_src_cube)
return relation
def cube_coverage_loss_v5(src_cube_params, des_cube_params, n_src_cube,
node_position):
with tf.name_scope('cube_coverage'):
points_index = primitive_group_points_v3(src_cube_params[0],
src_cube_params[1], src_cube_params[2], node_position)
volume = primitive_cube_volume_v2(des_cube_params[0])
volume = tf.reduce_sum(volume)
distance = primitive_cube_coverage_loss_v3(des_cube_params[0],
des_cube_params[1], des_cube_params[2], node_position, points_index,
n_src_cube=n_src_cube)
distance = tf.reduce_sum(distance)
return distance, volume
def _VerifyValuesNew(self, src_z, src_q, src_t, des_z, des_q, des_t, in_pos,
n_src_cube, expected):
with self.test_session() as sess:
sz = constant_op.constant(src_z)
sq = constant_op.constant(src_q)
st = constant_op.constant(src_t)
dz = constant_op.constant(des_z)
dq = constant_op.constant(des_q)
dt = constant_op.constant(des_t)
pos = constant_op.constant(in_pos)
points_index = primitive_group_points_v3(sz, sq, st, pos)
data_out = primitive_cube_coverage_loss_v3(dz, dq, dt, pos, points_index,
n_src_cube=n_src_cube)
[actual, pi] = sess.run([data_out, points_index])
# print("points_index: ", pi)
self.assertAllClose(expected, actual.flatten(), atol=1e-8)