def build_graph_deconv(xyz, xyz_unpool, radius, nn_uplimit):
# intra_idx, intra_cnt, intra_dst = neighbor_fn(xyz, xyz, radius=radius,
# nnsample=nn_uplimit)
# inter_idx, inter_cnt, inter_dst = neighbor_fn(xyz, xyz_unpool, radius=radius,
# nnsample=nn_uplimit)
intra_idx, intra_cnt, intra_dst = None, None, None
inter_idx, inter_cnt, inter_dst = build_nearest_neighbor(xyz, xyz_unpool)
return intra_idx, intra_cnt, intra_dst, inter_idx, inter_cnt, inter_dst
xyz = xyz - np.mean(xyz, axis=0)
scale = np.sqrt(np.amax(np.sum(np.square(xyz), axis=1)))
xyz /= scale
tmp1[i, ...] = xyz
xyz = tmp2[i, ...]
xyz = xyz - np.mean(xyz, axis=0)
scale = np.sqrt(np.amax(np.sum(np.square(xyz), axis=1)))
xyz /= scale
tmp2[i, ...] = xyz
maxIter = 100
with tf.device('/gpu:0'):
database = tf.constant(tmp1)
query = tf.constant(tmp2)
nn_index, nn_count, nn_dist = build_nearest_neighbor(database, query)
weight = dist2weight(nn_count, nn_dist)
with tf.Session(config=config) as sess:
now = time.time()
for _ in range(maxIter):
nnIndex, nnCount, nnDist, Weight = sess.run(
[nn_index, nn_count, nn_dist, weight])
cpp_gpu_time = (time.time() - now) / maxIter
print(cpp_gpu_time)
now = time.time()
check_weight = check_weight_inv(nnCount, nnDist)
cpu_time = time.time() - now
print(cpp_gpu_time, cpu_time)
T = np.sum(check_weight, axis=-1)
tmp0 = np.random.random((B, N, 3)).astype('float32')
tmp1 = tmp0[:, np.random.choice(N, M, False), :]
tmp2 = np.random.random((B, N, C)).astype('float32')
tmp3 = np.random.random((B, M, C)).astype('float32')
tmp4 = np.random.random((B, N, nnsample)).astype('float32')
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
config.log_device_placement = False
print(tmp0.shape, tmp1.shape)
with tf.device('/gpu:0'):
xyz0 = tf.constant(tmp0)
xyz1 = tf.constant(tmp1)
nn_index, nn_count, _ = build_nearest_neighbor(xyz1, xyz0)
with tf.Session(config=config) as sess:
unpoolIndex, unpoolCount = sess.run([nn_index, nn_count])
print(unpoolIndex.shape, unpoolCount.shape)
with tf.device('/gpu:0'):
featIn = tf.constant(tmp3)
weight = tf.constant(tmp4)
gradOut = tf.constant(tmp2)
feat_out = weighted_interpolate(featIn, weight, nn_index)
grad_in = tf.gradients(feat_out, featIn, gradOut)
with tf.Session(config=config) as sess:
now = time.time()
for _ in range(100):
# print(np.array_equal(nnIndex, check_nn_index), \
# np.allclose(nnDist, check_nn_dist))
cpp_gpu_time = timeit.timeit(lambda: build_sphere_neighbor(
database, query, nvDatabase, nvQuery, radius=radius, nnsample=nnsample
),
number=maxIter)
print(
colored('sphereNN elapsed time: {}\n'.format(cpp_gpu_time / maxIter),
'magenta'))
cpp_gpu_time = timeit.timeit(
lambda: build_cube_neighbor(database,
query,
nvDatabase,
nvQuery,
length=2 * radius,
nnsample=nnsample,
gridsize=gridSize),
number=maxIter)
print(
colored('cubeNN elapsed time: {}\n'.format(cpp_gpu_time / maxIter),
'magenta'))
cpp_gpu_time = timeit.timeit(
lambda: build_nearest_neighbor(database, query, nvDatabase, nvQuery),
number=maxIter)
print(
colored('NN3 elapsed time: {}\n'.format(cpp_gpu_time / maxIter),
'magenta'))