def create_tensor_graph(self, model_input_params, class_count, algorithm_params):
with tf.device(model_input_params.device_id):
with slim.arg_scope([slim.conv2d, slim.fully_connected],
weights_initializer=initializers.variance_scaling(scale=2.0),
weights_regularizer=slim.l2_regularizer(algorithm_params["l2regularizer_scale"])):
band_size = model_input_params.x.get_shape()[3].value
hs_lidar_groups = tf.split(axis=3, num_or_size_splits=[band_size - 1, 1],
value=model_input_params.x)
lrelu = lambda inp: slim.nn.leaky_relu(inp, alpha=algorithm_params["lrelu_alpha"])
bn_training_params = {'is_training': model_input_params.is_training, 'decay': 0.95}
hs_lidar_diff = algorithm_params["hs_lidar_diff"]
hs_net = self._create_hs_tensor_branch(algorithm_params, bn_training_params,
hs_lidar_groups[0][:, hs_lidar_diff:-hs_lidar_diff,
hs_lidar_diff:-hs_lidar_diff, :], lrelu,
model_input_params)
lidar_net = self._create_lidar_tensor_branch(bn_training_params, hs_lidar_groups[1], lrelu,
model_input_params)
# net = tf.concat(axis=3, values=[hs_net, lidar_net])
net = tf.concat(axis=1, values=[slim.flatten(hs_net), slim.flatten(lidar_net)])
net = self._create_fc_tensor_branch(algorithm_params, bn_training_params, class_count, lrelu,
model_input_params, net)
return ModelOutputTensors(y_conv=net, image_output=None, image_original=None, histogram_tensors=[])
def create_tensor_graph(self, model_input_params, class_count,
algorithm_params):
with tf.device(model_input_params.device_id):
with slim.arg_scope([slim.conv2d, slim.fully_connected]):
level1_filter_count = int(1200 / 10)
data_format = 'NHWC'
# net = tf.transpose(model_input_params.x, [0, 3, 1, 2]) # Convert to NCHW
net = slim.conv2d(
model_input_params.x,
level1_filter_count, [1, 1],
scope='conv1',
data_format=data_format,
activation_fn=lambda inp: slim.nn.leaky_relu(
inp, alpha=algorithm_params["lrelu_alpha"]))
level2_filter_count = int(level1_filter_count / 2)
net = slim.conv2d(
net,
level2_filter_count, [3, 3],
scope='conv2',
data_format=data_format,
activation_fn=lambda inp: slim.nn.leaky_relu(
inp, alpha=algorithm_params["lrelu_alpha"]))
level3_filter_count = int(level2_filter_count / 2)
net = slim.conv2d(
net,
level3_filter_count, [5, 5],
scope='conv3',
data_format=data_format,
activation_fn=lambda inp: slim.nn.leaky_relu(
inp, alpha=algorithm_params["lrelu_alpha"]))
net = slim.flatten(net)
net = slim.fully_connected(net,
class_count * 9,
activation_fn=None,
scope='fc1')
net = slim.dropout(net,
algorithm_params["drop_out_ratio"],
is_training=model_input_params.is_training)
net = slim.fully_connected(net,
class_count * 6,
activation_fn=None,
scope='fc2')
net = slim.dropout(net,
algorithm_params["drop_out_ratio"],
is_training=model_input_params.is_training)
net = slim.fully_connected(net,
class_count * 3,
activation_fn=None,
scope='fc3')
net = slim.dropout(net,
algorithm_params["drop_out_ratio"],
is_training=model_input_params.is_training)
net = slim.fully_connected(net,
class_count,
activation_fn=None,
scope='fc4')
return ModelOutputTensors(y_conv=net,
image_output=None,
image_original=None)
def create_tensor_graph(self, model_input_params, class_count,
algorithm_params):
iter_routing = algorithm_params["iter_routing"]
conv_layer_kernel_size = [
algorithm_params["conv_layer_kernel_size"],
algorithm_params["conv_layer_kernel_size"]
]
primary_caps_kernel_size = [
algorithm_params["primary_caps_kernel_size"],
algorithm_params["primary_caps_kernel_size"]
]
feature_count = algorithm_params["feature_count"]
primary_capsule_count = algorithm_params["primary_capsule_count"]
primary_capsule_output_space = algorithm_params[
"digit_capsule_output_space"]
digit_capsule_output_space = algorithm_params[
"digit_capsule_output_space"]
digit_capsule_count = class_count
batch_size = -1
enable_decoding = algorithm_params["enable_decoding"]
lrelu_func = lambda inp: slim.nn.leaky_relu(
inp, alpha=algorithm_params["lrelu_alpha"])
with tf.device(model_input_params.device_id):
with slim.arg_scope(
[slim.conv2d],
trainable=model_input_params.is_training
# weights_initializer=initializers.variance_scaling(scale=2.0),
# activation_fn=lrelu_func
# weights_regularizer=slim.l2_regularizer(0.00001),
# normalizer_fn=slim.batch_norm,
):
with tf.variable_scope('Conv1_layer') as scope:
image_output = slim.conv2d(
model_input_params.x,
num_outputs=feature_count,
kernel_size=conv_layer_kernel_size,
padding='VALID',
scope=scope,
normalizer_fn=slim.batch_norm)
with tf.variable_scope('PrimaryCaps_layer') as scope:
image_output = slim.conv2d(
image_output,
num_outputs=primary_capsule_count *
primary_capsule_output_space,
kernel_size=primary_caps_kernel_size,
stride=1,
padding='VALID',
scope=scope,
normalizer_fn=slim.batch_norm)
data_size = (image_output.get_shape()[1] *
image_output.get_shape()[2] *
image_output.get_shape()[3]
).value / primary_capsule_output_space
data_size = int(data_size)
image_output = tf.reshape(image_output, [
batch_size, data_size, 1, primary_capsule_output_space
])
with tf.variable_scope('DigitCaps_layer'):
u_hats = []
image_output_groups = tf.split(
axis=1,
num_or_size_splits=data_size,
value=image_output)
for i in range(data_size):
u_hat = slim.conv2d(image_output_groups[i],
num_outputs=digit_capsule_count *
digit_capsule_output_space,
kernel_size=[1, 1],
padding='VALID',
scope='DigitCaps_layer_w_' +
str(i),
activation_fn=None)
u_hat = tf.reshape(u_hat, [
batch_size, 1, digit_capsule_count,
digit_capsule_output_space
])
u_hats.append(u_hat)
image_output = tf.concat(u_hats, axis=1)
b_ijs = tf.constant(
numpy.zeros([data_size, digit_capsule_count],
dtype=numpy.float32))
v_js = []
for r_iter in range(iter_routing):
with tf.variable_scope('iter_' + str(r_iter)):
b_ij_groups = tf.split(
axis=1,
num_or_size_splits=digit_capsule_count,
value=b_ijs)
c_ijs = tf.nn.softmax(b_ijs, axis=1)
c_ij_groups = tf.split(
axis=1,
num_or_size_splits=digit_capsule_count,
value=c_ijs)
image_output_groups = tf.split(
axis=2,
num_or_size_splits=digit_capsule_count,
value=image_output)
for i in range(digit_capsule_count):
c_ij = tf.reshape(
tf.tile(c_ij_groups[i],
[1, digit_capsule_output_space]),
[
c_ij_groups[i].get_shape()[0], 1,
digit_capsule_output_space, 1
])
s_j = tf.nn.depthwise_conv2d(
image_output_groups[i],
c_ij,
strides=[1, 1, 1, 1],
padding='VALID')
# Squash function
s_j = tf.reshape(
s_j,
[batch_size, digit_capsule_output_space])
s_j_norm_square = tf.reduce_mean(
tf.square(s_j), axis=1, keepdims=True)
v_j = s_j_norm_square * s_j / (
(1 + s_j_norm_square) *
tf.sqrt(s_j_norm_square + 1e-9))
b_ij_groups[i] = b_ij_groups[
i] + tf.reduce_sum(tf.matmul(
tf.reshape(image_output_groups[i], [
batch_size,
image_output_groups[i].get_shape()
[1], digit_capsule_output_space
]),
tf.reshape(v_j, [
batch_size,
digit_capsule_output_space, 1
])),
axis=0)
if r_iter == iter_routing - 1:
v_js.append(
tf.reshape(v_j, [
batch_size, 1,
digit_capsule_output_space
]))
b_ijs = tf.concat(b_ij_groups, axis=1)
image_output = tf.concat(v_js, axis=1)
with tf.variable_scope('Masking'):
y_conv = tf.norm(image_output, axis=2)
decoder_image_output = None
if model_input_params.is_training and enable_decoding:
y_as_float = tf.cast(model_input_params.y,
dtype=tf.float32)
masked_v = tf.matmul(
image_output,
tf.reshape(y_as_float,
[batch_size, digit_capsule_count, 1]),
transpose_a=True)
masked_v = tf.reshape(
masked_v, [batch_size, digit_capsule_output_space])
with tf.variable_scope('Decoder'):
size = (model_input_params.x.get_shape()[1] *
model_input_params.x.get_shape()[2] *
model_input_params.x.get_shape()[3]).value
image_output = slim.fully_connected(
masked_v,
512,
scope='fc1',
activation_fn=lrelu_func,
trainable=model_input_params.is_training)
image_output = slim.fully_connected(
image_output,
1024,
scope='fc2',
activation_fn=lrelu_func,
trainable=model_input_params.is_training)
decoder_image_output = slim.fully_connected(
image_output,
size,
scope='fc3',
activation_fn=tf.sigmoid,
trainable=model_input_params.is_training)
return ModelOutputTensors(y_conv=y_conv,
image_output=decoder_image_output,
image_original=model_input_params.x,
histogram_tensors=[])
def create_tensor_graph(self, model_input_params, class_count,
algorithm_params):
with tf.device(model_input_params.device_id):
data_format = None # 'NHWC'
bn_training_params = {
'is_training': model_input_params.is_training,
'decay': algorithm_params["bn_decay"]
}
lrelu = lambda inp: slim.nn.leaky_relu(
inp, alpha=algorithm_params["lrelu_alpha"])
with slim.arg_scope(
[slim.conv2d, slim.fully_connected],
weights_initializer=initializers.variance_scaling(
scale=2.0),
weights_regularizer=slim.l2_regularizer(
algorithm_params["l2regularizer_scale"]),
normalizer_fn=slim.batch_norm,
normalizer_params=bn_training_params,
activation_fn=lrelu):
level_filter_count = algorithm_params["filter_count"]
if data_format == 'NCHW':
net0 = tf.transpose(model_input_params.x,
[0, 3, 1, 2]) # Convert input to NCHW
else:
net0 = model_input_params.x
spectral_hierarchy_level = algorithm_params[
"spectral_hierarchy_level"]
net1 = self.__create_spectral_nn_layers(
data_format, level_filter_count, net0,
spectral_hierarchy_level, True)
net1 = net1 + CNNModelv4.__scale_input_to_output(net0, net1)
net2 = self.__create_spectral_nn_layers(
data_format, level_filter_count, net1,
spectral_hierarchy_level, False)
net2 = net2 + CNNModelv4.__scale_input_to_output(net1, net2)
spatial_hierarchy_level = algorithm_params[
"spatial_hierarchy_level"]
net3 = self.__create_levels_as_blocks(
data_format, int(net2.get_shape()[3].value / 2), net2,
spatial_hierarchy_level)
net3 = net3 + CNNModelv4.__scale_input_to_output(net2, net3)
net4 = slim.flatten(net3)
degradation_coeff = algorithm_params["degradation_coeff"]
net5 = self.__create_fc_block(algorithm_params, class_count,
degradation_coeff,
model_input_params, net4)
net6 = slim.fully_connected(net5,
class_count,
weights_regularizer=None,
activation_fn=None,
scope='fc_final')
image_gen_net4 = None
if model_input_params.is_training:
image_gen_net1 = slim.fully_connected(
net6,
class_count * 3,
weights_regularizer=None,
scope='image_gen_net_1')
image_gen_net2 = slim.fully_connected(
image_gen_net1,
class_count * 9,
weights_regularizer=None,
scope='image_gen_net_2')
image_gen_net3 = slim.fully_connected(
image_gen_net2,
class_count * 27,
weights_regularizer=None,
scope='image_gen_net_3')
image_size = (net0.get_shape()[1] * net0.get_shape()[2] *
net0.get_shape()[3]).value
image_gen_net4 = slim.fully_connected(
image_gen_net3,
image_size,
weights_regularizer=None,
activation_fn=tf.sigmoid,
scope='image_gen_net_4')
return ModelOutputTensors(y_conv=net6,
image_output=image_gen_net4,
image_original=net0)
def create_tensor_graph(self, model_input_params, class_count,
algorithm_params):
with tf.device(model_input_params.device_id):
with slim.arg_scope([slim.conv2d, slim.fully_connected]):
level0_filter_count = algorithm_params["filter_count"]
data_format = None # 'NHWC'
if data_format == 'NCHW':
net0 = tf.transpose(model_input_params.x,
[0, 3, 1, 2]) # Convert input to NCHW
else:
net0 = model_input_params.x
net0_1x1 = slim.conv2d(net0,
level0_filter_count, [1, 1],
scope='conv0_1x1',
data_format=data_format)
net0_3x3 = slim.conv2d(net0,
level0_filter_count, [3, 3],
scope='conv0_3x3',
data_format=data_format)
net0_5x5 = slim.conv2d(net0,
level0_filter_count, [5, 5],
scope='conv0_5x5',
data_format=data_format)
net0_out = tf.concat(axis=3,
values=[net0_1x1, net0_3x3, net0_5x5])
net0_out = tf.nn.local_response_normalization(net0_out)
level1_filter_count = level0_filter_count * 3
net11 = slim.conv2d(net0_out,
level1_filter_count, [1, 1],
scope='conv11',
data_format=data_format)
net11 = tf.nn.local_response_normalization(net11)
net12 = slim.conv2d(net11,
level1_filter_count, [1, 1],
scope='conv12',
data_format=data_format)
net13 = slim.conv2d(net12,
level1_filter_count, [1, 1],
scope='conv13',
data_format=data_format)
net13 = net13 + net11
level2_filter_count = level1_filter_count
net21 = slim.conv2d(net13,
level2_filter_count, [1, 1],
scope='conv21',
data_format=data_format)
net22 = slim.conv2d(net21,
level2_filter_count, [1, 1],
scope='conv22',
data_format=data_format)
net22 = net22 + net13
level3_filter_count = level2_filter_count
net31 = slim.conv2d(net22,
level3_filter_count, [1, 1],
scope='conv31',
data_format=data_format)
net31 = slim.dropout(
net31,
algorithm_params["drop_out_ratio"],
is_training=model_input_params.is_training)
net32 = slim.conv2d(net31,
level3_filter_count, [1, 1],
scope='conv32',
data_format=data_format)
net32 = slim.dropout(
net32,
algorithm_params["drop_out_ratio"],
is_training=model_input_params.is_training)
net33 = slim.conv2d(net32,
level3_filter_count, [1, 1],
scope='conv33',
data_format=data_format)
net_33 = slim.flatten(net33)
net_fc = slim.fully_connected(net_33,
class_count,
activation_fn=None,
scope='fc')
return ModelOutputTensors(y_conv=net_fc,
image_output=None,
image_original=None,
histogram_tensors=[])