def _create_conv(self): self._create_input() arg_scope = tf.contrib.framework.arg_scope with arg_scope([conv3d], nl=tf.nn.relu, trainable=True, mode=self.mode, graph=self.graph): conv1 = conv3d(self.image, 3, 64, 'conv1', 'wc1', 'bc1') pool1 = max_pool3d(conv1, 'pool1', padding='SAME', filter_size=[1,2,2]) conv2 = conv3d(pool1, 3, 128, 'conv2', 'wc2', 'bc2') pool2 = max_pool3d(conv2, 'pool2', padding='SAME') conv3a = conv3d(pool2, 3, 256, 'conv3a', 'wc3a', 'bc3a') conv3b = conv3d(conv3a, 3, 256, 'conv3b', 'wc3b', 'bc3b') pool3 = max_pool3d(conv3b, 'pool3', padding='SAME') conv4a = conv3d(pool3, 3, 256, 'conv4a', 'wc4a', 'bc4a') conv4b = conv3d(conv4a, 3, 256, 'conv4b', 'wc4b', 'bc4b') pool4 = max_pool3d(conv4b, 'pool4', padding='SAME') conv5a = conv3d(pool4, 3, 256, 'conv5a', 'wc5a', 'bc5a') conv5b = conv3d(conv5a, 3, 256, 'conv5b', 'wc5b', 'bc5b') pool5 = max_pool3d(conv5b, 'pool5', padding='SAME') self.layer['conv1'] = conv1 self.layer['conv2'] = conv2 self.layer['conv3'] = conv3b self.layer['conv4'] = conv4b self.layer['pool5'] = pool5 self.layer['conv_out'] = self.layer['conv5'] = conv5b return pool5
def inference(self): print('input_shape:', self.X.shape.as_list()) conv1 = conv3d('conv1', x=self.X, w=None, num_filters=self.output_channels['conv1'], kernel_size=(3, 3, 3), stride=(1, 2, 2), l2_strength=L2_DECAY, bias=0.0, batchnorm_enabled=True, is_training=self.is_training, activation=tf.nn.relu, padding='SAME') print('conv1_shape:', conv1.shape.as_list()) max_pool = max_pool_3d(conv1, size=(3, 3, 3), stride=(2, 2, 2), name='max_pool') print('max3d_shape:', max_pool.shape.as_list()) stage2 = self.__stage(max_pool, stage=2, repeat=3) print('stag2_shape:', stage2.shape.as_list()) stage3 = self.__stage(stage2, stage=3, repeat=7) print('stag3_shape:', stage3.shape.as_list()) stage4 = self.__stage(stage3, stage=4, repeat=3) print('stag4_shape:', stage4.shape.as_list()) global_pool = avg_pool_3d(stage4, size=(1, 5, 5), stride=(1, 1, 1), name='global_pool', padding='VALID') print('avg3d_shape:', global_pool.shape.as_list()) drop_out = dropout(global_pool, is_training=self.is_training, keep_prob=0.5) logits_unflattened = conv3d('fc', drop_out, w=None, num_filters=NUM_CLASS, kernel_size=(1, 1, 1), l2_strength=L2_DECAY, bias=0.0, is_training=self.is_training) print('convn_shape:', logits_unflattened.shape.as_list()) logits = flatten(logits_unflattened) print('fc_re_shape:', logits.shape.as_list()) return logits
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_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 conv_sigmod(x, kernal, scope=None): with tf.name_scope(scope): W = weight_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 IPN(x, PLM_NUM=5, filter_size=[3, 3, 3], LAYER_NUM=3, NUM_OF_CLASS=2, pooling_size=[]): """ :param x: input tensor,shape[?,nx,ny,nz,channels] :param filter_size: size of the convolution filer :param PLM_NUM: number of PLM :param LAYER_NUM: number of conv layers in each PLM :return: """ #Initialize Variable #whether use pooling size by automatic or by yourself if not pooling_size: pooling_size = utils.cal_downsampling_size_combine(x.shape[1], PLM_NUM) else: PLM_NUM = len(pooling_size) W = [[0] * LAYER_NUM for i in range(PLM_NUM)] b = [[0] * LAYER_NUM for i in range(PLM_NUM)] conv = [[0] * LAYER_NUM for i in range(PLM_NUM)] pool = [[0] * LAYER_NUM for i in range(PLM_NUM)] variables = [] #features = utils.cal_channel_num(PLM_NUM) features = np.ones(PLM_NUM, dtype='int32') * 64 ##################### print model para ############# print('') print('----------------- model paras ------------------') resize = 1 print('PLM DS SIZE: ', end='') for index in pooling_size: resize *= index print('{}->{} = '.format(x.shape[1], resize), end='') for i, s in enumerate(pooling_size): if i == 0: print(str(s), end='') else: print('x' + str(s), end='') print('') print('conv channel nums : ', end='') for f in features: print(f, ',', end='') print('') print('--------------------- end ----------------------') print('') ###################################################### features_count = -1 stddev = 0.02 #Build Projection Learning Module for PLM in range(PLM_NUM): features_count += 1 if PLM == 0: input = x else: input = pool[PLM - 1] for LAYER in range(LAYER_NUM): b[PLM][LAYER] = bias_variable([features[features_count]], name="b{}".format(PLM + 1)) in_channels = input.get_shape().as_list()[-1] W[PLM][LAYER] = weight_variable( filter_size + [in_channels, features[features_count]], stddev, name="w{}_{}".format(PLM + 1, LAYER + 1)) variables.append(W[PLM][LAYER]) variables.append(b[PLM][LAYER]) conv[PLM][LAYER] = tf.nn.relu( conv3d(input, W[PLM][LAYER], b[PLM][LAYER])) if LAYER == LAYER_NUM - 1: pool[PLM] = Unidirectional_pool( conv[PLM][LAYER], pooling_size[PLM]) #Unidirectional_pool else: input = conv[PLM][LAYER] #Output MAP Wop = weight_variable(filter_size + [features[features_count], NUM_OF_CLASS], stddev, name="w_output") bop = bias_variable([NUM_OF_CLASS], name="b_output") output = tf.nn.relu( tf.nn.bias_add( tf.nn.conv3d(pool[PLM_NUM - 1], Wop, strides=[1, 1, 1, 1, 1], padding="SAME"), bop)) sf = tf.nn.softmax(output) pred = tf.argmax(sf, axis=-1, name="prediction") return output, pred, variables, sf