def __init__(self,
name,
inputs,
tower_setup,
n_features,
concat,
activation="relu",
filter_size=(3, 3),
batch_norm_decay=BATCH_NORM_DECAY_DEFAULT,
l2=L2_DEFAULT):
super(Upsampling, self).__init__()
filter_size = list(filter_size)
assert isinstance(concat, list)
assert len(concat) > 0
curr, n_features_inp = prepare_input(inputs)
concat_inp, n_features_concat = prepare_input(concat)
curr = tf.image.resize_nearest_neighbor(curr,
tf.shape(concat_inp)[1:3])
curr = tf.concat([curr, concat_inp], axis=3)
n_features_curr = n_features_inp + n_features_concat
with tf.variable_scope(name):
W = self.create_weight_variable(
"W", filter_size + [n_features_curr, n_features], l2,
tower_setup)
b = self.create_bias_variable("b", [n_features], tower_setup)
curr = conv2d(curr, W) + b
curr = get_activation(activation)(curr)
self.outputs = [curr]
def __init__(self, name, inputs, tower_setup):
super(DoNothingLayer, self).__init__()
curr, n_features_inp = prepare_input(inputs)
# old_shape = smart_shape(curr)
# batch_size = old_shape[0]
# out = tf.reshape(curr, [-1, n_features_inp * 2])
self.outputs = [curr]
def __init__(self, name, inputs, tower_setup):
super(SiameseConcat, self).__init__()
curr, n_features_inp = prepare_input(inputs)
# old_shape = smart_shape(curr)
# batch_size = old_shape[0]
out = tf.reshape(curr, [-1, n_features_inp * 2])
self.outputs = [out]
def __init__(self, name, inputs, targets, n_classes, tower_setup, global_average_pooling=False, dropout=0.0,
loss="ce", l2=L2_DEFAULT):
super(Softmax, self).__init__()
self.measures = {}
if global_average_pooling:
inp, n_features_inp = prepare_input(inputs)
inp = global_avg_pool(inp)
else:
inp, n_features_inp = prepare_collapsed_input_and_dropout(inputs, dropout)
with tf.variable_scope(name):
W = self.create_weight_variable("W", [n_features_inp, n_classes], l2, tower_setup)
b = self.create_bias_variable("b", [n_classes], tower_setup)
y_ref = tf.cast(targets, tf.int64)
y_pred = tf.matmul(inp, W) + b
self.outputs = [tf.nn.softmax(y_pred, -1, 'softmax')]
errors = tf.not_equal(tf.argmax(y_pred, 1), y_ref)
errors = tf.reduce_sum(tf.cast(errors, tower_setup.dtype))
self.measures['errors'] = errors
if loss == "ce":
cross_entropy_per_example = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=y_pred, labels=y_ref, name='cross_entropy_per_example')
self.loss = tf.reduce_sum(cross_entropy_per_example, name='cross_entropy_sum')
else:
assert False, "Unknown loss " + loss
self.add_scalar_summary(self.loss, "loss")
def __init__(self, name, inputs, tower_setup, activation="relu", batch_norm_decay=BATCH_NORM_DECAY_DEFAULT):
super(Collapse, self).__init__()
curr, n_features_inp = prepare_input(inputs)
with tf.variable_scope(name):
inp = self.create_and_apply_batch_norm(curr, n_features_inp, batch_norm_decay, tower_setup)
h_act = get_activation(activation)(inp)
out = global_avg_pool(h_act)
self.outputs = [out]
def __init__(self, name, inputs, tower_setup, n_convs=2, n_features=None, dilations=None, strides=None,
filter_size=None, activation="relu", batch_norm_decay=BATCH_NORM_DECAY_DEFAULT, l2=L2_DEFAULT):
super(ResidualUnit2, self).__init__()
# TODO: dropout
curr, n_features_inp = prepare_input(inputs)
res = curr
assert n_convs >= 1, n_convs
if dilations is not None:
assert strides is None
elif strides is None:
strides = [[1, 1]] * n_convs
if filter_size is None:
filter_size = [[3, 3]] * n_convs
if n_features is None:
n_features = n_features_inp
if not isinstance(n_features, list):
n_features = [n_features] * n_convs
with tf.variable_scope(name):
curr = self.create_and_apply_batch_norm(curr, n_features_inp, batch_norm_decay, tower_setup, "bn0")
curr = get_activation(activation)(curr)
if strides is None:
strides_res = [1, 1]
else:
strides_res = numpy.prod(strides, axis=0).tolist()
if (n_features[-1] != n_features_inp) or (strides_res != [1, 1]):
W0 = self.create_weight_variable("W0", [1, 1] + [n_features_inp, n_features[-1]], l2, tower_setup)
if dilations is None:
res = conv2d(curr, W0, strides_res)
else:
res = conv2d(curr, W0)
W1 = self.create_weight_variable("W1", filter_size[0] + [n_features_inp, n_features[0]], l2, tower_setup)
if dilations is None:
curr = conv2d(curr, W1, strides[0])
else:
curr = conv2d_dilated(curr, W1, dilations[0])
for idx in range(1, n_convs):
curr = self.create_and_apply_batch_norm(curr, n_features[idx - 1], batch_norm_decay,
tower_setup, "bn" + str(idx + 1))
curr = get_activation(activation)(curr)
Wi = self.create_weight_variable("W" + str(idx + 1),
filter_size[idx] + [n_features[idx - 1], n_features[idx]],
l2, tower_setup)
if dilations is None:
curr = conv2d(curr, Wi, strides[idx])
else:
curr = conv2d_dilated(curr, Wi, dilations[idx])
curr += res
self.outputs = [curr]
def __init__(self, name, inputs, targets, n_classes, void_label, tower_setup, filter_size=(1, 1),
input_activation=None, dilation=None, resize_targets=False, resize_logits=False, loss="ce",
fraction=None, l2=L2_DEFAULT, dropout=0.0):
super(SegmentationSoftmax, self).__init__()
assert targets.get_shape().ndims == 4, targets.get_shape()
assert not (resize_targets and resize_logits)
inp, n_features_inp = prepare_input(inputs)
filter_size = list(filter_size)
with tf.variable_scope(name):
if input_activation is not None:
inp = get_activation(input_activation)(inp)
inp = apply_dropout(inp, dropout)
self.W, self.b, self.W_adjustable, self.b_adjustable, self.n_classes_current, W, b = self.create_weights(
n_classes, filter_size, n_features_inp, l2, tower_setup)
self.adjustable_output_assign_data = self._create_adjustable_output_assign_data(tower_setup)
if self.n_classes_current is None:
self.n_classes_current = n_classes
if dilation is None:
y_pred = conv2d(inp, W) + b
else:
y_pred = conv2d_dilated(inp, W, dilation) + b
self.outputs = [tf.nn.softmax(y_pred, -1, 'softmax')]
if resize_targets:
targets = tf.image.resize_nearest_neighbor(targets, tf.shape(y_pred)[1:3])
if resize_logits:
y_pred = tf.image.resize_images(y_pred, tf.shape(targets)[1:3])
pred = tf.argmax(y_pred, axis=3)
targets = tf.cast(targets, tf.int64)
targets = tf.squeeze(targets, axis=3)
# TODO: Void label is not considered in the iou calculation.
if void_label is not None:
# avoid nan by replacing void label by 0
# note: the loss for these cases is multiplied by 0 below
void_label_mask = tf.equal(targets, void_label)
no_void_label_mask = tf.logical_not(void_label_mask)
targets = tf.where(void_label_mask, tf.zeros_like(targets), targets)
else:
no_void_label_mask = None
self.measures = self.create_measures(n_classes, pred, targets)
self.loss = self.create_loss(loss, fraction, no_void_label_mask, targets, tower_setup, void_label, y_pred)
self.add_scalar_summary(self.loss, "loss")
def __init__(self, name, inputs, n_features, tower_setup, old_order=False, filter_size=(3, 3),
strides=(1, 1), dilation=None, pool_size=(1, 1), pool_strides=None, activation="relu", dropout=0.0,
batch_norm=False, bias=False, batch_norm_decay=BATCH_NORM_DECAY_DEFAULT, l2=L2_DEFAULT):
super(Conv, self).__init__()
# mind the order of dropout, conv, activation and batchnorm!
# default: batchnorm -> activation -> dropout -> conv -> pool
# if old_order: dropout -> conv -> batchnorm -> activation -> pool
curr, n_features_inp = prepare_input(inputs)
filter_size = list(filter_size)
strides = list(strides)
pool_size = list(pool_size)
if pool_strides is None:
pool_strides = pool_size
with tf.variable_scope(name):
W = self.create_weight_variable("W", filter_size + [n_features_inp, n_features], l2, tower_setup)
b = None
if bias:
b = self.create_bias_variable("b", [n_features], tower_setup)
if old_order:
curr = apply_dropout(curr, dropout)
if dilation is None:
curr = conv2d(curr, W, strides)
else:
curr = conv2d_dilated(curr, W, dilation)
if bias:
curr += b
if batch_norm:
curr = self.create_and_apply_batch_norm(curr, n_features, batch_norm_decay, tower_setup)
curr = get_activation(activation)(curr)
else:
if batch_norm:
curr = self.create_and_apply_batch_norm(curr, n_features_inp, batch_norm_decay, tower_setup)
curr = get_activation(activation)(curr)
curr = apply_dropout(curr, dropout)
if dilation is None:
curr = conv2d(curr, W, strides)
else:
curr = conv2d_dilated(curr, W, dilation)
if bias:
curr += b
if pool_size != [1, 1]:
curr = max_pool(curr, pool_size, pool_strides)
self.outputs = [curr]
def __init__(self, name, inputs, targets, tower_setup):
super(ExpandedSiameseConcat, self).__init__()
curr, n_features_inp = prepare_input(inputs)
size = smart_shape(curr)[0]
def Expand(idx):
anchor = curr[idx, :]
anchor_class = targets[idx]
classes, _ = tf.unique(targets)
class_division = tf.cast(tf.equal(targets, anchor_class), tf.int32)
partitioned_output = tf.dynamic_partition(curr, class_division, 2)
partitioned_targets = tf.dynamic_partition(targets, class_division,
2)
# Positives
positives = partitioned_output[1]
size_positives = smart_shape(positives)[0]
anchor_positive_repmat = tf.reshape(
tf.tile(anchor, [size_positives]), [size_positives, -1])
positives_combined = tf.concat((anchor_positive_repmat, positives),
1)
new_targets_positive = tf.ones(
[smart_shape(positives_combined)[0]], dtype=tf.int32)
# Negatives
negative_size = smart_shape(classes)[0]
def Get_negatives(neg_idx):
curr_neg_class = classes[neg_idx]
neg_class_division = tf.cast(tf.equal(targets, curr_neg_class),
tf.int32)
neg_partitioned_output = tf.dynamic_partition(
curr, neg_class_division, 2)
negative_set = neg_partitioned_output[1]
size_negative_set = smart_shape(negative_set)[0]
random_negative_idx = tf.random_shuffle(
tf.range(1, size_negative_set))[0]
random_negative = negative_set[random_negative_idx, :]
return random_negative
looper = tf.range(0, anchor_class)
iter_val = tf.minimum(anchor_class + 1, negative_size)
looper = tf.concat([looper, tf.range(iter_val, negative_size)], 0)
negatives = tf.map_fn(Get_negatives, looper, dtype=tf.float32)
size_negatives = smart_shape(negatives)[0]
anchor_negative_repmat = tf.reshape(
tf.tile(anchor, [size_negatives]), [size_negatives, -1])
negatives_combined = tf.concat((anchor_negative_repmat, negatives),
1)
new_targets_negative = tf.zeros(
[smart_shape(negatives_combined)[0]], dtype=tf.int32)
all_combined = tf.concat((positives_combined, negatives_combined),
0)
new_targets_combined = tf.concat(
(new_targets_positive, new_targets_negative), 0)
return all_combined, new_targets_combined
expanded, new_targets = tf.map_fn(Expand,
tf.range(0, size),
dtype=(tf.float32, tf.int32))
expanded = tf.reshape(expanded, [-1, n_features_inp * 2])
new_targets = tf.reshape(new_targets, [-1])
# new_shape = smart_shape(expanded)
# tower_setup.is_training*860 + 100
new_shape = [tower_setup.is_training * 896 + 64, 1000]
new_targets.set_shape([new_shape[0]])
expanded.set_shape(new_shape)
# self.outputs = [expanded]
# self.out_labels = new_targets
def if_training():
return new_targets, expanded
def if_not_training():
ahah = tf.concat([curr, curr], 1)
ahah.set_shape([64, 1000])
return targets, ahah
self.out_labels, rar = tf.cond(
tf.cast(tower_setup.is_training, tf.bool), if_training,
if_not_training)
self.outputs = [rar]
