def get_model(point_cloud, is_training,Transform=False, bn_decay=None):
forloss = []
idx=None
if point_cloud.get_shape()[-1].value>2:
l0_xyz = point_cloud[:,:,0:2]
l0_points = point_cloud [:,:,2:]
else:
l0_xyz = point_cloud
l0_points = None
if Transform:
l0_xyz, tnet,l0_points= transform_moudule(l0_xyz,l0_points, is_training,idx, [64,128,1024],[[1, 1], [1, 1],[1, 1]], [512,256],num_channle=32, nsample=32, scope='Tnet1', bn_decay=bn_decay, bn=True, K=2)
#forloss=tnet
l0_points, plane_feature, _ = plane_module(l0_xyz, l0_points, idx, centralize=True, num_channle=32, npoint=512,
have_sample=False,
nsample=32, is_training=is_training, scope='plane', pool='avg',
use_xyz=True, bn=True, bn_decay=bn_decay, weight_decay=0.0)
new_points,_ = conv_module(l0_points,plane_feature,mlp=[64,128,128,1024], is_training=is_training, scope='conv', bn=True, bn_decay=bn_decay)
# Fully connected layers
net = util.fully_connected(new_points, 512, bn=True, is_training=is_training, scope='fc1', bn_decay=bn_decay)
net = util.dropout(net, keep_prob=0.5, is_training=is_training, scope='dp1')
net = util.fully_connected(net, 256, bn=True, is_training=is_training, scope='fc2', bn_decay=bn_decay)
net = util.dropout(net, keep_prob=0.5, is_training=is_training, scope='dp2')
net = util.fully_connected(net, 10, activation_fn=None, scope='fc3')
return net, forloss
def create(self):
self.X = tf.reshape(
self.X,
shape=[-1, self.IMAGE_SIZE, self.IMAGE_SIZE, self.CHANEELS])
conv1 = util.conv_layer(self.X,
ksize=[11, 11, self.CHANEELS, 96],
strides=[1, 4, 4, 1],
name='conv1')
pool1 = util.max_pool_layer(conv1,
ksize=[1, 3, 3, 1],
strides=[1, 2, 2, 1],
name='pool1')
conv2 = util.conv_layer(pool1,
ksize=[5, 5, 96, 256],
strides=[1, 1, 1, 1],
name='conv2',
padding='SAME',
group=2)
pool2 = util.max_pool_layer(conv2,
ksize=[1, 3, 3, 1],
strides=[1, 2, 2, 1],
name='pool2')
conv3 = util.conv_layer(pool2,
ksize=[3, 3, 256, 384],
strides=[1, 1, 1, 1],
name='conv3',
padding='SAME')
conv4 = util.conv_layer(conv3,
ksize=[3, 3, 384, 384],
strides=[1, 1, 1, 1],
name='conv4',
padding='SAME',
group=2)
conv5 = util.conv_layer(conv4,
ksize=[3, 3, 384, 256],
strides=[1, 1, 1, 1],
name='conv5',
padding='SAME',
group=2)
pool5 = util.max_pool_layer(conv5,
ksize=[1, 3, 3, 1],
strides=[1, 2, 2, 1],
name='pool5')
fc6 = util.full_connected_layer(pool5, 4096, name='fc6')
fc6_dropout = util.dropout(fc6, self.KEEP_PROB)
fc7 = util.full_connected_layer(fc6_dropout, 4096, name='fc7')
fc7_dropout = util.dropout(fc7, self.KEEP_PROB)
self.fc8 = util.full_connected_layer(fc7_dropout,
self.NUM_CLASSES,
name='fc8',
relu=False)
def build_char_states(self, char_embed, is_training, reuse, char_ids,
char_lengths):
"""Build char embedding network for the QA model."""
max_char_length = self.cfg.max_char_length
inputs = dropout(tf.nn.embedding_lookup(char_embed, char_ids),
self.cfg.dropout, is_training)
inputs = tf.reshape(
inputs, shape=[max_char_length, -1, self.cfg.char_embed_dim])
char_lengths = tf.reshape(char_lengths, shape=[-1])
with tf.variable_scope('char_encoding', reuse=reuse):
cell_fw = XGRUCell(hidden_dim=self.cfg.char_embed_dim)
cell_bw = XGRUCell(hidden_dim=self.cfg.char_embed_dim)
_, (left_right, right_left) = tf.nn.bidirectional_dynamic_rnn(
cell_fw=cell_fw,
cell_bw=cell_bw,
sequence_length=char_lengths,
inputs=inputs,
time_major=True,
dtype=tf.float32)
left_right = tf.reshape(left_right,
shape=[-1, self.cfg.char_embed_dim])
right_left = tf.reshape(right_left,
shape=[-1, self.cfg.char_embed_dim])
states = tf.concat([left_right, right_left], axis=1)
out_shape = tf.shape(char_ids)[1:3]
out_shape = tf.concat([
out_shape,
tf.constant(value=[self.cfg.char_embed_dim * 2], dtype=tf.int32)
],
axis=0)
return tf.reshape(states, shape=out_shape)
def model(X, w_L1, w_L2, w_L3, w_L4, p_drop_conv, p_drop_hidden):
crossnormalizer = crossnorm(alpha=1e-4, k=2, beta=0.75, n=9)
l1b = rectify(cuconv(X, w_L1, border_mode=(5, 5)))
l1 = cupool(l1b, (3, 3), stride=(2, 2))
l1 = crossnormalizer(l1)
l1 = dropout(l1, p_drop_conv)
l2b = rectify(cuconv(l1, w_L2, border_mode='full'))
l2 = cupool(l2b, (3, 3), stride=(2, 2))
l2 = crossnormalizer(l2)
l2 = dropout(l2, p_drop_conv)
l3b = rectify(cuconv(l2, w_L3, border_mode='full'))
l3 = cupool(l3b, (3, 3), stride=(2, 2))
l3 = crossnormalizer(l3)
l4 = T.flatten(l3, outdim=2)
pyx = dropout(l4, p_drop_hidden)
pyx = softmax(T.dot(pyx, w_L4))
return l1, l2, l3, pyx
def rnn(input_states, sequence_lengths, dropout_rate, is_training, num_units):
layer_cnt = 1
states = []
xs = tf.transpose(input_states, perm=[1, 0, 2])
for i in range(0, layer_cnt):
xs = dropout(xs, dropout_rate, is_training)
with tf.variable_scope('layer_' + str(i)):
cell_fw = XGRUCell(num_units)
cell_bw = XGRUCell(num_units)
outputs, _ = tf.nn.bidirectional_dynamic_rnn(
cell_fw=cell_fw,
cell_bw=cell_bw,
dtype=tf.float32,
sequence_length=sequence_lengths,
inputs=xs,
time_major=True)
y_lr, y_rl = outputs
xs = tf.concat([y_lr, y_rl], 2)
states.append(xs)
return tf.transpose(dropout(tf.concat(states, axis=2),
dropout_rate,
is_training), perm=[1, 0, 2])
def multihead_attention(queries,
keys,
scope="multihead_attention",
num_units=None,
num_heads=4,
dropout_rate=0,
is_training=True,
causality=False):
'''Applies multihead attention.
Args:
queries: A 3d tensor with shape of [N, T_q, C_q].
keys: A 3d tensor with shape of [N, T_k, C_k].
num_units: A cdscalar. Attention size.
dropout_rate: A floating point number.
is_training: Boolean. Controller of mechanism for dropout.
causality: Boolean. If true, units that reference the future are masked.
num_heads: An int. Number of heads.
scope: Optional scope for `variable_scope`.
reuse: Boolean, whether to reuse the weights of a previous layer
by the same name.
Returns
A 3d tensor with shape of (N, T_q, C)
'''
global look5
with tf.variable_scope(scope):
# Set the fall back option for num_units
if num_units is None:
num_units = queries.get_shape().as_list()[-1]
Q_ = []
K_ = []
V_ = []
for head_i in range(num_heads):
Q = tf.layers.dense(queries, num_units / num_heads,
activation=tf.nn.relu, name='Query' + str(head_i)) # (N, T_q, C)
K = tf.layers.dense(keys, num_units / num_heads,
activation=tf.nn.relu, name='Key' + str(head_i)) # (N, T_k, C)
V = tf.layers.dense(keys, num_units / num_heads,
activation=tf.nn.relu, name='Value' + str(head_i)) # (N, T_k, C)
Q_.append(Q)
K_.append(K)
V_.append(V)
# Split and concat
Q_ = tf.concat(Q_, axis=0) # (h*N, T_q, C/h)
K_ = tf.concat(K_, axis=0) # (h*N, T_k, C/h)
V_ = tf.concat(V_, axis=0) # (h*N, T_k, C/h)
# Multiplication
outputs = tf.matmul(Q_, tf.transpose(K_, [0, 2, 1])) # (h*N, T_q, T_k)
# Scale
outputs = outputs / (K_.get_shape().as_list()[-1] ** 0.5)
# Key Masking
key_masks = tf.sign(tf.abs(tf.reduce_sum(keys, axis=-1))) # (N, T_k)
key_masks = tf.tile(key_masks, [num_heads, 1]) # (h*N, T_k)
key_masks = tf.tile(tf.expand_dims(key_masks, 1),
[1, tf.shape(queries)[1], 1]) # (h*N, T_q, T_k)
paddings = tf.ones_like(outputs) * (-2 ** 32 + 1)
outputs = tf.where(tf.equal(key_masks, 0), paddings,
outputs) # (h*N, T_q, T_k)
# Causality = Future blinding
if causality:
diag_vals = tf.ones_like(outputs[0, :, :]) # (T_q, T_k)
tril = tf.contrib.linalg.LinearOperatorTriL(
diag_vals).to_dense() # (T_q, T_k)
masks = tf.tile(tf.expand_dims(tril, 0),
[tf.shape(outputs)[0], 1, 1]) # (h*N, T_q, T_k)
paddings = tf.ones_like(masks) * (-2 ** 32 + 1)
outputs = tf.where(tf.equal(masks, 0), paddings,
outputs) # (h*N, T_q, T_k)
# Activation
look5 = outputs
outputs = tf.nn.softmax(outputs) # (h*N, T_q, T_k)
# Query Masking
query_masks = tf.sign(
tf.abs(tf.reduce_sum(queries, axis=-1))) # (N, T_q)
query_masks = tf.tile(query_masks, [num_heads, 1]) # (h*N, T_q)
query_masks = tf.tile(tf.expand_dims(
query_masks, -1), [1, 1, tf.shape(keys)[1]]) # (h*N, T_q, T_k)
outputs *= query_masks # broadcasting. (N, T_q, C)
# Dropouts
outputs = dropout(outputs, dropout_rate, is_training)
# Weighted sum
outputs = tf.matmul(outputs, V_) # ( h*N, T_q, C/h)
# Restore shape
outputs = tf.concat(tf.split(outputs, num_heads,
axis=0), axis=2) # (N, T_q, C)
# Residual connection
if queries.get_shape().as_list()[-1] == num_units:
outputs += queries
# Normalize
outputs = normalize(outputs, scope=scope) # (N, T_q, C)
return outputs
def graph_to_network(input1,
input2,
input1_lengths,
input2_lengths,
p_graph,
dropout_rate,
is_training,
num_heads=1,
rnn_units=256):
topology = p_graph.is_topology()
layers = dict()
layers_sequence_lengths = dict()
num_units = input1.get_shape().as_list()[-1]
layers[0] = input1*tf.sqrt(tf.cast(num_units, tf.float32)) + \
positional_encoding(input1, scale=False, zero_pad=False)
layers[1] = input2*tf.sqrt(tf.cast(num_units, tf.float32))
layers[0] = dropout(layers[0], dropout_rate, is_training)
layers[1] = dropout(layers[1], dropout_rate, is_training)
layers_sequence_lengths[0] = input1_lengths
layers_sequence_lengths[1] = input2_lengths
for _, topo_i in enumerate(topology):
if topo_i == '|':
continue
# Note: here we use the `hash_id` of layer as scope name,
# so that we can automatically load sharable weights from previous trained models
with tf.variable_scope(p_graph.layers[topo_i].hash_id, reuse=tf.AUTO_REUSE):
if p_graph.layers[topo_i].graph_type == LayerType.input.value:
continue
elif p_graph.layers[topo_i].graph_type == LayerType.attention.value:
with tf.variable_scope('attention'):
layer = multihead_attention(layers[p_graph.layers[topo_i].input[0]],
layers[p_graph.layers[topo_i].input[1]],
scope="multihead_attention",
dropout_rate=dropout_rate,
is_training=is_training,
num_heads=num_heads,
num_units=rnn_units * 2)
layer = feedforward(layer, scope="feedforward",
num_units=[rnn_units * 2 * 4, rnn_units * 2])
layers[topo_i] = layer
layers_sequence_lengths[topo_i] = layers_sequence_lengths[
p_graph.layers[topo_i].input[0]]
elif p_graph.layers[topo_i].graph_type == LayerType.self_attention.value:
with tf.variable_scope('self-attention'):
layer = multihead_attention(layers[p_graph.layers[topo_i].input[0]],
layers[p_graph.layers[topo_i].input[0]],
scope="multihead_attention",
dropout_rate=dropout_rate,
is_training=is_training,
num_heads=num_heads,
num_units=rnn_units * 2)
layer = feedforward(layer, scope="feedforward",
num_units=[rnn_units * 2 * 4, rnn_units * 2])
layers[topo_i] = layer
layers_sequence_lengths[topo_i] = layers_sequence_lengths[
p_graph.layers[topo_i].input[0]]
elif p_graph.layers[topo_i].graph_type == LayerType.rnn.value:
with tf.variable_scope('rnn'):
layer = rnn(layers[p_graph.layers[topo_i].input[0]],
layers_sequence_lengths[p_graph.layers[topo_i].input[0]],
dropout_rate,
is_training,
rnn_units)
layers[topo_i] = layer
layers_sequence_lengths[topo_i] = layers_sequence_lengths[
p_graph.layers[topo_i].input[0]]
elif p_graph.layers[topo_i].graph_type == LayerType.output.value:
layers[topo_i] = layers[p_graph.layers[topo_i].input[0]]
if layers[topo_i].get_shape().as_list()[-1] != rnn_units * 1 * 2:
with tf.variable_scope('add_dense'):
layers[topo_i] = tf.layers.dense(
layers[topo_i], units=rnn_units*2)
return layers[2], layers[3]
def build_model(self, batch_size, spatial_size, points_xyz, points_features, is_training, num_class, batch_normalization_decay=None):
""" Build a Fully-Convolutional Point Network.
Args:
batch_size: int
spatial_size: np.array
points_xyz: tf.placeholder
points_features: tf.placeholder
is_training: tf.placeholder
num_class: int
batch_normalization_decay: float
Returns: tf.tensor
"""
self.min_xyz_ = np.array([0, 0, 0])
self.max_xyz_ = spatial_size
self.use_batch_normalization_ = self._config['training']['optimizer']['batch_normalization'] != False
pointnet_locations = util.get_uniformly_spaced_point_grid(self.min_xyz_, self.max_xyz_, self._config['model']['pointnet']['spacing'], batch_size)
top_level_centroid_locations = util.get_uniformly_spaced_point_grid(self.min_xyz_, self.max_xyz_, self.get_centroid_spacing(self._config['model']['pointnet']['spacing'], self._abstraction_levels), batch_size)
with tf.variable_scope("abstraction"):
with tf.variable_scope("points_to_15cm"):
with tf.variable_scope("simplified_pointnet"):
with tf.device('/gpu:' + str(self._config['training']['gpu']['id'])):
# Radius search and Grouping
grouped_points_xyz_and_features = self.radius_search_and_group(pointnet_locations, self.get_pointnet_radius(self._config['model']['pointnet']['spacing']), self._config['model']['pointnet']['neighbors'], points_xyz, points_features)
# 3x 1x1 Convolutions
features = util.conv2d(grouped_points_xyz_and_features, self._config['model']['filters']['abstraction']['points_to_15cm'][0], [1, 1], padding='VALID', stride=[1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1_conv_1', bn_decay=batch_normalization_decay)
features = util.conv2d(features, self._config['model']['filters']['abstraction']['points_to_15cm'][1], [1, 1], padding='VALID', stride=[1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1_conv_2', bn_decay=batch_normalization_decay)
# Max-pooling for permutation invariance
features = tf.reduce_max(features, axis=[2], keepdims=True)
features = tf.squeeze(features, [2])
num_dims = self.get_feature_volume_shape(spatial_size, self._config['model']['pointnet']['spacing'], 1)
features = tf.reshape(features, [batch_size, num_dims[0], num_dims[1], num_dims[2], features.get_shape().as_list()[-1]])
with tf.variable_scope("skip_15cm"):
skip_15cm = util.conv3d(features, self._config['model']['filters']['skip']['15cm'], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv', bn_decay=batch_normalization_decay)
with tf.variable_scope("skip_45cm"):
padded = tf.pad(features, [[0,0], [1,1], [1,1], [1,1], [0,0]], "SYMMETRIC")
skip_45cm = util.conv3d(padded, self._config['model']['filters']['skip']['45cm'], [3, 3, 3], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='3x3x3_conv', bn_decay=batch_normalization_decay)
with tf.variable_scope("15cm_to_30cm"):
with tf.variable_scope("3d_convolution"):
features = util.conv3d(features, self._config['model']['filters']['abstraction']['15cm_to_30cm'][0], [2, 2, 2], padding='VALID', stride=[2, 2, 2], bn=self.use_batch_normalization_, is_training=is_training, scope='2x2x2_conv', bn_decay=batch_normalization_decay)
features = util.conv3d(features, self._config['model']['filters']['abstraction']['15cm_to_30cm'][1], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1_conv_1', bn_decay=batch_normalization_decay)
with tf.variable_scope("skip_30cm"):
skip_30cm = util.conv3d(features, self._config['model']['filters']['skip']['30cm'], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv', bn_decay=batch_normalization_decay)
with tf.variable_scope("skip_90cm"):
padded = tf.pad(features, [[0,0], [1,1], [1,1], [1,1], [0,0]], "SYMMETRIC")
skip_90cm = util.conv3d(padded, self._config['model']['filters']['skip']['90cm'], [3, 3, 3], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='3x3x3_conv', bn_decay=batch_normalization_decay)
with tf.variable_scope("30cm_to_60cm"):
with tf.variable_scope("3d_convolution"):
features = util.conv3d(features, self._config['model']['filters']['abstraction']['30cm_to_60cm'][0], [2, 2, 2], padding='VALID', stride=[2, 2, 2], bn=self.use_batch_normalization_, is_training=is_training, scope='2x2x2_conv', bn_decay=batch_normalization_decay)
features = util.conv3d(features, self._config['model']['filters']['abstraction']['30cm_to_60cm'][1], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv_1', bn_decay=batch_normalization_decay)
with tf.variable_scope("skip_60cm"):
skip_60cm = util.conv3d(features, self._config['model']['filters']['skip']['60cm'], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv_1', bn_decay=batch_normalization_decay)
with tf.variable_scope("skip_180cm"):
padded = tf.pad(features, [[0,0], [1,1], [1,1], [1,1], [0,0]], "SYMMETRIC")
skip_180cm = util.conv3d(padded, self._config['model']['filters']['skip']['180cm'], [3, 3, 3], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='3x3x3_conv', bn_decay=batch_normalization_decay)
with tf.variable_scope("spatial_pool"):
num_cells_in_current_layer = self.get_feature_volume_shape(spatial_size, self._config['model']['pointnet']['spacing'], 3)
with tf.variable_scope("reshape_and_repeat"):
# Reshape and repeat feature volume to apply weighted spatial pooling
features = tf.reshape(features, [batch_size, top_level_centroid_locations.get_shape()[1].value, self._config['model']['filters']['abstraction']['30cm_to_60cm'][-1]])
features = tf.tile(tf.expand_dims(features, axis=1), [1, top_level_centroid_locations.get_shape()[1].value, 1, 1])
with tf.variable_scope("pool"):
spatial_pooling_weights = self.get_spatial_pool_weighting(self._config['model']['spatial_pool_radius'], top_level_centroid_locations)
skip_spatial_pool = features * spatial_pooling_weights
skip_spatial_pool = tf.reduce_sum(skip_spatial_pool, axis=2)
skip_spatial_pool = tf.reshape(skip_spatial_pool, [batch_size, num_cells_in_current_layer[0], num_cells_in_current_layer[1], num_cells_in_current_layer[2], self._config['model']['filters']['abstraction']['30cm_to_60cm'][-1]])
with tf.variable_scope("skip_spatial_pool"):
skip_spatial_pool = util.conv3d(skip_spatial_pool, self._config['model']['filters']['skip']['spatial_pool'], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv', bn_decay=batch_normalization_decay)
with tf.variable_scope("upsampling"):
with tf.variable_scope("60cm_to_30cm"):
features = tf.concat([skip_60cm, skip_180cm, skip_spatial_pool], axis=4)
features = util.conv3d_transpose(features, self._config['model']['filters']['upsampling']['60cm_to_30cm'][0], [2, 2, 2], padding='VALID', stride=[2, 2, 2], bn=self.use_batch_normalization_, is_training=is_training, scope='2x2x2_deconv', bn_decay=batch_normalization_decay)
features = util.conv3d(features, self._config['model']['filters']['upsampling']['60cm_to_30cm'][1], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv_1', bn_decay=batch_normalization_decay)
features = util.conv3d(features, self._config['model']['filters']['upsampling']['60cm_to_30cm'][2], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv_2', bn_decay=batch_normalization_decay)
with tf.variable_scope("30cm_to_15cm"):
features = tf.concat([features, skip_30cm, skip_90cm], axis=4)
features = util.conv3d_transpose(features, self._config['model']['filters']['upsampling']['30cm_to_15cm'][0], [2, 2, 2], padding='VALID', stride=[2, 2, 2], bn=self.use_batch_normalization_, is_training=is_training, scope='2x2x2_deconv', bn_decay=batch_normalization_decay)
features = util.conv3d(features, self._config['model']['filters']['upsampling']['30cm_to_15cm'][1], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv_1', bn_decay=batch_normalization_decay)
features = util.dropout(features, keep_prob=0.5, is_training=is_training, scope='dropout')
features = tf.concat([features, skip_45cm], axis=4)
features = util.conv3d(features, self._config['model']['filters']['upsampling']['30cm_to_15cm'][2], [1, 1, 1], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='1x1x1_conv_3', bn_decay=batch_normalization_decay)
with tf.variable_scope("15cm_to_5cm"):
features = tf.concat([features, skip_15cm], axis=4)
features = util.dropout(features, keep_prob=0.5, is_training=is_training, scope='dropout')
upsample_factor = int(math.ceil(self._config['model']['pointnet']['spacing'] / self._output_voxel_size))
features = util.conv3d_transpose(features, self._config['model']['filters']['upsampling']['15cm_to_5cm'][0], [upsample_factor, upsample_factor, upsample_factor], padding='VALID', stride=[upsample_factor, upsample_factor, upsample_factor], bn=self.use_batch_normalization_, is_training=is_training, scope='final_deconv', bn_decay=batch_normalization_decay)
features = tf.pad(features, [[0,0], [1,1], [1,1], [1,1], [0,0]], "SYMMETRIC")
output = util.conv3d(features, num_class, [3, 3, 3], padding='VALID', stride=[1, 1, 1], bn=self.use_batch_normalization_, is_training=is_training, scope='final_conv', bn_decay=batch_normalization_decay, activation_fn=None)
num_output_elements = np.prod(self.get_output_volume_shape(spatial_size, self._output_voxel_size))
output = tf.reshape(output, [batch_size, num_output_elements, num_class])
return output
def create(self):
self.p = []
self.X = tf.reshape(
self.X,
shape=[-1, self.IMAGE_SIZE, self.IMAGE_SIZE, self.CHANEELS])
conv1_1 = util.conv_layer(self.X,
kh=3,
kw=3,
n_out=64,
sh=1,
sw=1,
name='conv1_1',
p=self.p,
padding='SAME')
conv1_2 = util.conv_layer(conv1_1,
kh=3,
kw=3,
n_out=64,
sh=1,
sw=1,
name='conv1_2',
p=self.p,
padding='SAME')
pool1 = util.max_pool_layer(conv1_2,
kh=2,
kw=2,
sh=2,
sw=2,
name='pool1')
conv2_1 = util.conv_layer(pool1,
kh=3,
kw=3,
n_out=128,
sh=1,
sw=1,
name='conv2_1',
p=self.p,
padding='SAME')
conv2_2 = util.conv_layer(conv2_1,
kh=3,
kw=3,
n_out=128,
sh=1,
sw=1,
name='conv2_2',
p=self.p,
padding='SAME')
pool2 = util.max_pool_layer(conv2_2,
kh=2,
kw=2,
sh=2,
sw=2,
name='pool2')
conv3_1 = util.conv_layer(pool2,
kh=3,
kw=3,
n_out=256,
sh=1,
sw=1,
name='conv3_1',
p=self.p,
padding='SAME')
conv3_2 = util.conv_layer(conv3_1,
kh=3,
kw=3,
n_out=256,
sh=1,
sw=1,
name='conv3_2',
p=self.p,
padding='SAME')
conv3_3 = util.conv_layer(conv3_2,
kh=3,
kw=3,
n_out=256,
sh=1,
sw=1,
name='conv3_3',
p=self.p,
padding='SAME')
pool3 = util.max_pool_layer(conv3_3,
kh=2,
kw=2,
sh=2,
sw=2,
name='pool3')
conv4_1 = util.conv_layer(pool3,
kh=3,
kw=3,
n_out=512,
sh=1,
sw=1,
name='conv4_1',
p=self.p,
padding='SAME')
conv4_2 = util.conv_layer(conv4_1,
kh=3,
kw=3,
n_out=512,
sh=1,
sw=1,
name='conv4_2',
p=self.p,
padding='SAME')
conv4_3 = util.conv_layer(conv4_2,
kh=3,
kw=3,
n_out=512,
sh=1,
sw=1,
name='conv4_3',
p=self.p,
padding='SAME')
pool4 = util.max_pool_layer(conv4_3,
kh=2,
kw=2,
sh=2,
sw=2,
name='pool4')
conv5_1 = util.conv_layer(pool4,
kh=3,
kw=3,
n_out=512,
sh=1,
sw=1,
name='conv5_1',
p=self.p,
padding='SAME')
conv5_2 = util.conv_layer(conv5_1,
kh=3,
kw=3,
n_out=512,
sh=1,
sw=1,
name='conv5_2',
p=self.p,
padding='SAME')
conv5_3 = util.conv_layer(conv5_2,
kh=3,
kw=3,
n_out=512,
sh=1,
sw=1,
name='conv5_3',
p=self.p,
padding='SAME')
pool5 = util.max_pool_layer(conv5_3,
kh=2,
kw=2,
sh=2,
sw=2,
name='pool5')
fc6 = util.full_connected_layer(pool5,
n_out=4096,
name='fc6',
p=self.p)
fc6_dropout = util.dropout(fc6, self.KEEP_PROB, name='fc6_drop')
fc7 = util.full_connected_layer(fc6_dropout,
n_out=4096,
name='fc7',
p=self.p)
fc7_dropout = util.dropout(fc7, self.KEEP_PROB, name='fc7_drop')
self.fc8 = util.full_connected_layer(fc7_dropout,
self.NUM_CLASSES,
name='fc8',
p=self.p)
self.softmax = tf.nn.softmax(self.fc8)
self.predictions = tf.argmax(self.softmax, 1)