def gatingsignal2d(x, kernal, phase, height=None, width=None, scope=None): """this is simply 1x1x1 convolution, bn, activation,Gating Signal(Query) :param x: :param kernal:(1,1,1,inputfilters,outputfilters) :param phase: :param drop: :param image_z: :param height: :param width: :param scope: :return: """ with tf.name_scope(scope): W = weight_xavier_init(shape=kernal, n_inputs=kernal[0] * kernal[1] * kernal[2], n_outputs=kernal[-1], activefunction='relu', variable_name=scope + 'conv_W') B = bias_variable([kernal[-1]], variable_name=scope + 'conv_B') conv = conv2d(x, W) + B conv = normalizationlayer(conv, is_train=phase, height=height, width=width, norm_type='group', scope=scope) conv = tf.nn.relu(conv) return conv
def conv_sigmod(x, kernal, scope=None): with tf.name_scope(scope): W = weight_xavier_init(shape=kernal, n_inputs=kernal[0] * kernal[1] * kernal[2] * kernal[3], n_outputs=kernal[-1], activefunction='sigomd', variable_name=scope + 'W') B = bias_variable([kernal[-1]], variable_name=scope + 'B') conv = conv3d(x, W) + B conv = tf.nn.sigmoid(conv) return conv
def deconv_relu(x, kernal, samefeture=False, scope=None): with tf.name_scope(scope): W = weight_xavier_init(shape=kernal, n_inputs=kernal[0] * kernal[1] * kernal[2] * kernal[-1], n_outputs=kernal[-2], activefunction='relu', variable_name=scope + 'W') B = bias_variable([kernal[-2]], variable_name=scope + 'B') conv = deconv3d(x, W, samefeture, True) + B conv = tf.nn.relu(conv) return conv
def conv_bn_relu_drop(x, kernal, phase, drop, image_z=None, height=None, width=None, scope=None): with tf.name_scope(scope): W = weight_xavier_init(shape=kernal, n_inputs=kernal[0] * kernal[1] * kernal[2] * kernal[3], n_outputs=kernal[-1], activefunction='relu', variable_name=scope + 'conv_W') B = bias_variable([kernal[-1]], variable_name=scope + 'conv_B') conv = conv3d(x, W) + B conv = normalizationlayer(conv, is_train=phase, height=height, width=width, image_z=image_z, norm_type='group', scope=scope) conv = tf.nn.dropout(tf.nn.relu(conv), drop) return conv
def deconv_relu_drop(x, kernalshape, samefeture=False, scope=None): with tf.name_scope(scope): W = weight_xavier_init(shape=kernalshape, n_inputs=kernalshape[0] * kernalshape[1] * kernalshape[-1], n_outputs=kernalshape[-2], activefunction='relu', variable_name=str(scope) + 'W') B = bias_variable([kernalshape[-2]], variable_name=str(scope) + 'B') dconv = tf.nn.relu(deconv2d(x, W, samefeature=samefeture) + B) return dconv
def conv_relu(x, kernalshape, scope=None): with tf.name_scope(scope): W = weight_xavier_init(shape=kernalshape, n_inputs=kernalshape[0] * kernalshape[1] * kernalshape[2], n_outputs=kernalshape[-1], activefunction='relu', variable_name=str(scope) + 'W') B = bias_variable([kernalshape[-1]], variable_name=str(scope) + 'B') conv = conv2d(x, W) + B conv = tf.nn.relu(conv) return conv
def __init__(self, number_of_classes=2, training_factor=.3, width=32): self.width = width self.emb_in = tf.placeholder(tf.float32, [None, self.width], name="emb_in") self.category_in = tf.placeholder(tf.float32, [None, number_of_classes], name="category") self.dropout = tf.placeholder(tf.float32) with tf.variable_scope("layer0"): self.W0 = layer.weight_variable([self.width, self.width], name=("layer0_weight")) self.b0 = layer.bias_variable([self.width], name=("layer0_bias")) self.layer0 = tf.add(tf.matmul(self.emb_in, self.W0), self.b0) self.layer0 = tf.tanh(self.layer0) self.layer0 = tf.nn.dropout(self.layer0, self.dropout) with tf.variable_scope("layer1"): self.W1 = layer.weight_variable([self.width, number_of_classes], name=("layer1_weight")) self.b1 = layer.bias_variable([number_of_classes], name=("layer1_bias")) self.layer1 = tf.add(tf.matmul(self.layer0, self.W1), self.b1) self.category_out = tf.nn.softmax(self.layer1) self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=self.category_in, logits=self.layer1)) self.train = tf.train.AdamOptimizer(training_factor).minimize( self.loss) self.error = 1.0 - tf.reduce_mean( tf.cast(tf.equal(tf.argmax(self.category_in, 1), tf.argmax(self.layer1, 1)), dtype=tf.float32))
def conv_bn_relu_drop(x, kernalshape, phase, drop_conv, height=None, width=None, scope=None): with tf.name_scope(scope): W = weight_xavier_init(shape=kernalshape, n_inputs=kernalshape[0] * kernalshape[1] * kernalshape[2], n_outputs=kernalshape[-1], activefunction='relu', variable_name=str(scope) + 'W') B = bias_variable([kernalshape[-1]], variable_name=str(scope) + 'B') conv = conv2d(x, W) + B conv = normalizationlayer(conv, phase, height=height, width=width, norm_type='group', scope=scope) conv = tf.nn.dropout(tf.nn.relu(conv), drop_conv) return conv
def attngatingblock(x, g, inputfilters, outfilters, scale_factor, phase, height=None, width=None, scope=None): """ take g which is the spatially smaller signal, do a conv to get the same number of feature channels as x (bigger spatially) do a conv on x to also get same feature channels (theta_x) then, upsample g to be same size as x add x and g (concat_xg) relu, 1x1x1 conv, then sigmoid then upsample the final - this gives us attn coefficients :param x: :param g: :param inputfilters: :param outfilters: :param scale_factor:2 :param scope: :return: """ with tf.name_scope(scope): kernalx = (1, 1, inputfilters, outfilters) Wx = weight_xavier_init(shape=kernalx, n_inputs=kernalx[0] * kernalx[1] * kernalx[2], n_outputs=kernalx[-1], activefunction='relu', variable_name=scope + 'conv_Wx') Bx = bias_variable([kernalx[-1]], variable_name=scope + 'conv_Bx') theta_x = conv2d(x, Wx, scale_factor) + Bx kernalg = (1, 1, inputfilters, outfilters) Wg = weight_xavier_init(shape=kernalg, n_inputs=kernalg[0] * kernalg[1] * kernalg[2], n_outputs=kernalg[-1], activefunction='relu', variable_name=scope + 'conv_Wg') Bg = bias_variable([kernalg[-1]], variable_name=scope + 'conv_Bg') phi_g = conv2d(g, Wg) + Bg add_xg = resnet_Add(theta_x, phi_g) act_xg = tf.nn.relu(add_xg) kernalpsi = (1, 1, outfilters, 1) Wpsi = weight_xavier_init(shape=kernalpsi, n_inputs=kernalpsi[0] * kernalpsi[1] * kernalpsi[2], n_outputs=kernalpsi[-1], activefunction='relu', variable_name=scope + 'conv_Wpsi') Bpsi = bias_variable([kernalpsi[-1]], variable_name=scope + 'conv_Bpsi') psi = conv2d(act_xg, Wpsi) + Bpsi sigmoid_psi = tf.nn.sigmoid(psi) upsample_psi = upsample2d(sigmoid_psi, scale_factor=scale_factor, scope=scope + "resampler") # Attention: upsample_psi * x # upsample_psi = layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=4), # arguments={'repnum': outfilters})(upsample_psi) gat_x = tf.multiply(upsample_psi, x) kernal_gat_x = (1, 1, outfilters, outfilters) Wgatx = weight_xavier_init(shape=kernal_gat_x, n_inputs=kernal_gat_x[0] * kernal_gat_x[1] * kernal_gat_x[2], n_outputs=kernal_gat_x[-1], activefunction='relu', variable_name=scope + 'conv_Wgatx') Bgatx = bias_variable([kernalpsi[-1]], variable_name=scope + 'conv_Bgatx') gat_x_out = conv2d(gat_x, Wgatx) + Bgatx gat_x_out = normalizationlayer(gat_x_out, is_train=phase, height=height, width=width, norm_type='group', scope=scope) return gat_x_out
def create_conv_net(x, keep_prob, channels, layers, features_root=16, filter_size=3, pool_size=2, training=True): """ 주어진 파라미터를 이용해서 convolution u-net 그래프 생성 함 :param x: input tensor, shape [?,nx,ny,channels] :param keep_prob: dropout probability tensor :param channels: number of channels in the input image :param layers: number of layers in the net :param features_root: number of features in the first layer :param filter_size: size of the convolution filter :param pool_size: size of the max pooling operation :param summaries: Flag if summaries should be created """ logging.info( "Layers {layers}, features {features}, filter size {filter_size}x{filter_size}, pool size: {pool_size}x{pool_size}" .format(layers=layers, features=features_root, filter_size=filter_size, pool_size=pool_size)) # Placeholder for the input image with tf.name_scope("preprocessing"): nx = tf.shape(x)[1] ny = tf.shape(x)[2] x_image = tf.reshape(x, tf.stack([-1, nx, ny, channels])) in_node = x_image batch_size = tf.shape(x_image)[0] weights = [] biases = [] convs = [] pools = OrderedDict() deconv = OrderedDict() dw_h_convs = OrderedDict() up_h_convs = OrderedDict() in_size = 1000 size = in_size # down layers for layer in range(0, layers): with tf.name_scope("down_conv_{}".format(str(layer))): features = 2**layer * features_root stddev = np.sqrt(2 / (filter_size**2 * features)) if layer == 0: w1 = weight_variable( [filter_size, filter_size, channels, features], stddev, name="w1") else: w1 = weight_variable( [filter_size, filter_size, features // 2, features], stddev, name="w1") w2 = weight_variable( [filter_size, filter_size, features, features], stddev, name="w2") b1 = bias_variable([features], name="b1") b2 = bias_variable([features], name="b2") conv1 = conv2d(in_node, w1, b1, keep_prob) tmp_h_conv = tf.nn.relu( tf.layers.batch_normalization(conv1, training=training)) conv2 = conv2d(tmp_h_conv, w2, b2, keep_prob) dw_h_convs[layer] = tf.nn.relu( tf.layers.batch_normalization(conv2, training=training)) weights.append((w1, w2)) biases.append((b1, b2)) convs.append((conv1, conv2)) size -= 4 if layer < layers - 1: pools[layer] = max_pool(dw_h_convs[layer], pool_size) in_node = pools[layer] size /= 2 in_node = dw_h_convs[layers - 1] # up layers for layer in range(layers - 2, -1, -1): with tf.name_scope("up_conv_{}".format(str(layer))): features = 2**(layer + 1) * features_root stddev = np.sqrt(2 / (filter_size**2 * features)) wd = weight_variable_devonc( [pool_size, pool_size, features // 2, features], stddev, name="wd") bd = bias_variable([features // 2], name="bd") h_deconv = tf.nn.relu(deconv2d(in_node, wd, pool_size) + bd) h_deconv_concat = crop_and_concat(dw_h_convs[layer], h_deconv) deconv[layer] = h_deconv_concat w1 = weight_variable( [filter_size, filter_size, features, features // 2], stddev, name="w1") w2 = weight_variable( [filter_size, filter_size, features // 2, features // 2], stddev, name="w2") b1 = bias_variable([features // 2], name="b1") b2 = bias_variable([features // 2], name="b2") conv1 = conv2d(h_deconv_concat, w1, b1, keep_prob) h_conv = tf.nn.relu( tf.layers.batch_normalization(conv1, training=training)) conv2 = conv2d(h_conv, w2, b2, keep_prob) in_node = tf.nn.relu( tf.layers.batch_normalization(conv2, training=training)) up_h_convs[layer] = in_node weights.append((w1, w2)) biases.append((b1, b2)) convs.append((conv1, conv2)) size *= 2 size -= 4 # Output Map with tf.name_scope("output_map"): weight = weight_variable( [1, 1, features_root, 1], stddev) # 불량 CLASS의 MAP만 Loss함수에 들어가므로 channel은 "1"이 됨. bias = bias_variable([1], name="bias") conv = conv2d(in_node, weight, bias, tf.constant(1.0)) output_map = tf.squeeze(tf.nn.sigmoid(conv), axis=-1) up_h_convs["out"] = output_map variables = [] for w1, w2 in weights: variables.append(w1) variables.append(w2) for b1, b2 in biases: variables.append(b1) variables.append(b2) return output_map, variables, int(in_size - size)