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]