def inception_block_3c(self, x, ct): self.inception_3c_double_3x3_reduce = Conv2D( kernel_size=1, filters=64, padding='valid', data_format=self.DATA_FORMAT, trainable=ct, name='inception_3c_double_3x3_reduce') self.inception_3c_double_3x3_reduce_bn = BatchNormalization( axis=1, trainable=ct, name='inception_3c_double_3x3_reduce_bn') self.inception_3c_double_3x3_1 = Conv2D( kernel_size=3, filters=96, padding='same', data_format=self.DATA_FORMAT, trainable=ct, name='inception_3c_double_3x3_1') self.inception_3c_double_3x3_1_bn = BatchNormalization( axis=1, trainable=ct, name='inception_3c_double_3x3_1_bn') x = self.inception_3c_double_3x3_reduce(x) x = self.inception_3c_double_3x3_reduce_bn(x) x = tf.nn.relu(x, name='inception_3c_relu_double_3x3_reduce_inp') x = self.inception_3c_double_3x3_1(x) x = self.inception_3c_double_3x3_1_bn(x) print(x) x = tf.nn.relu(x, name='inception_3c_relu_double_3x3_1_inp') x = tf.reshape(x, (-1, self.frm_num, 96, 28, 28), name='r2Dto3D') x = tf.transpose(x, [0, 2, 1, 3, 4]) return x
def g_block(x, filters, is_training, name): """Residual Block For a fast overview see Big GAN paper. Based on self-attention GAN code. """ with tf.variable_scope(name): x0 = x x = tf.nn.relu(batch_norm(x, is_training, 'bn0')) x = upsample(x, 2) x = Conv2D(filters=filters, kernel_size=3, padding='SAME', name='conv1')(x) x = tf.nn.relu(batch_norm(x, is_training, 'bn1')) x = Conv2D(filters=filters, kernel_size=3, padding='SAME', name='conv2')(x) x0 = upsample(x0, 2) x0 = Conv2D(filters=filters, kernel_size=1, padding='SAME', name='conv3')(x0) return x0 + x
def _build(self): self.s_input = tf.placeholder(tf.float32, [None] + list(self.state_shape), name='States') self.a_input = tf.placeholder(tf.float32, [None, self.n_actions], name='Actions') self.r_input = tf.placeholder(tf.float32, [None], name='Rewards') conv1 = Conv2D(32, 8, strides=(6, 6), activation=tf.nn.relu, kernel_initializer=tf.initializers.glorot_normal(), bias_initializer=tf.initializers.glorot_normal(), name='conv1')(self.s_input) conv2 = Conv2D(48, 6, strides=(3, 3), activation=tf.nn.relu, kernel_initializer=tf.initializers.glorot_normal(), bias_initializer=tf.initializers.glorot_normal(), name='conv2')(conv1) f = Flatten()(conv2) dense1 = Dense(512, activation=tf.nn.relu, kernel_initializer=tf.initializers.glorot_normal(), bias_initializer=tf.initializers.glorot_normal(), name='dense1')(f) dense_pi = Dense(128, activation=tf.nn.relu, kernel_initializer=tf.initializers.glorot_normal(), bias_initializer=tf.initializers.glorot_normal(), name='dense_pi')(dense1) self.pi = Dense(self.n_actions, activation=tf.nn.softmax, kernel_initializer=tf.initializers.glorot_normal(), bias_initializer=tf.initializers.glorot_normal(), name='Pi')(dense_pi) self.pi = tf.clip_by_value(self.pi, 1e-8, 1.) dense_v = Dense(32, activation=tf.nn.relu, kernel_initializer=tf.initializers.glorot_normal(), bias_initializer=tf.initializers.glorot_normal(), name='dense_v')(dense1) self.v = Dense(1, activation=None, kernel_initializer=tf.initializers.glorot_normal(), name='V')(dense_v) self.v = tf.squeeze(self.v, axis=1) log_policy = tf.log(tf.reduce_sum(self.pi * self.a_input, axis=1) + 1e-10) self.advantage = self.r_input - self.v loss_pi = -tf.multiply(log_policy, tf.stop_gradient(self.advantage)) loss_v = 0.5 * tf.square(self.advantage) entropy_pi = - 0.05 * tf.reduce_sum(self.pi * tf.log(self.pi), axis=1) self.loss = tf.reduce_mean(loss_pi + loss_v - entropy_pi) opt = tf.train.AdamOptimizer(self.lr) self.train_op = opt.minimize(self.loss)
def inception_part(self, input_x, ct): self.conv1_7x7_s2 = Conv2D(kernel_size=(7,7), filters=64, strides=2, padding='same', data_format=self.DATA_FORMAT, trainable=ct, name='conv1_7x7_s2') self.conv1_7x7_s2_bn = BatchNormalization(axis=1, trainable=ct, name='conv1_7x7_s2_bn') self.pool1_3x3_s2 = MaxPooling2D(pool_size=3, strides=2, padding='same', data_format=self.DATA_FORMAT, name='pool1_3x3_s2') self.conv2_3x3_reduce = Conv2D(kernel_size=1, filters=64, trainable=ct, data_format=self.DATA_FORMAT, name='conv2_3x3_reduce') self.conv2_3x3_reduce_bn = BatchNormalization(axis=1, trainable=ct, name='conv2_3x3_reduce_bn') self.conv2_3x3 = Conv2D(kernel_size=3, filters=192, padding='same', data_format=self.DATA_FORMAT, trainable=ct, name='conv2_3x3') self.conv2_3x3_bn = BatchNormalization(axis=1, trainable=ct, name='conv2_3x3_bn') self.pool2_3x3_s2 = MaxPooling2D(pool_size=3, strides=2, padding='same', data_format=self.DATA_FORMAT, name='pool2_3x3_s2') # x = tf.reshape(input_x, (-1, 3, 224, 224)) x = self.conv1_7x7_s2(input_x) x = self.conv1_7x7_s2_bn(x) x = tf.nn.relu(x, name='conv1_relu_7x7_inp') x = self.pool1_3x3_s2(x) x = self.conv2_3x3_reduce(x) x = self.conv2_3x3_reduce_bn(x) x = tf.nn.relu(x, name='conv2_relu_3x3_reduce_inp') x = self.conv2_3x3(x) x = self.conv2_3x3_bn(x) x = tf.nn.relu(x, name='conv2_relu_3x3_inp') x = self.pool2_3x3_s2(x) print(x) self.incep_3a = self.inception_block_3a(x, ct) print(self.incep_3a) self.incep_3b = self.inception_block_3b(self.incep_3a, ct) print(self.incep_3b) self.incep_3c = self.inception_block_3c(self.incep_3b, ct) print(self.incep_3c) return self.incep_3c
def conv_block_simple_2d(prevlayer, num_filters, prefix, kernel_size=(3, 3), initializer="he_normal", strides=(1, 1)): # conv = Conv2D(filters=num_filters, kernel_size=kernel_size, padding="same", kernel_initializer=initializer, strides=strides, name=prefix + "_conv", # data_format='channels_first')(prevlayer) # conv = Activation('relu', name=prefix + "_activation")(conv) # return conv conv = Conv2D(filters=num_filters, kernel_size=kernel_size, padding="same", kernel_initializer=initializer, strides=strides, name=prefix + "_conv", data_format='channels_first')(prevlayer) conv = BatchNormalization(name=prefix + "_bn", axis=1)(conv) # conv = Activation('relu', name=prefix + "_activation")(conv) conv = tf.nn.relu(conv, name=prefix + "_activation") return conv
def conv(inputs, out_filters, ksize=(3, 3), strides=(1, 1), dilation=(1, 1), use_bias=True): """ Convolution layer Parameters ---------- inputs: Input tensor out_filters: Number of output filters ksize: Kernel size. One integer of tuple of two integers strides: Strides for moving kernel. One integer of tuple of two integers dilation: Dilation of kernel. One integer of tuple of two integers use_bias: Whether to use bias """ return Conv2D( filters=out_filters, kernel_size=ksize, strides=strides, padding='same', dilation_rate=dilation, use_bias=use_bias, kernel_initializer=init_ops.glorot_uniform_initializer, )(inputs)
def shortcut(input, residual): """ shortcut连接. """ input_shape = input.shape residual_shape = residual.shape #通常卷积越深,特征是越小,所以如果shortcut前后的尺寸不一(通常要的),就需要加上一个卷积变换 #例如input_shape = (N, 40, 40, 64), residual_shape = (N, 20, 20, 128) #步长如下 #如何理解呢?因为我们需要缩放,那么要不就池化要不就卷积来有效的缩小,这里选择的是卷积,设置好合适的步长 stride_height = int(input_shape[1]/residual_shape[1]) stride_width = int(input_shape[2]/residual_shape[2]) equal_channels = (input_shape[3] == residual_shape[3]) identity = input if stride_height > 1 or stride_width > 1 or not equal_channels: identity = Conv2D( residual_shape[3], kernel_size = (1,1), strides = (stride_height, stride_width), padding = "VALID", kernel_regularizer = tf.contrib.layers.l1_regularizer(0.001))(input) #把两个维度大小相同的向量相加,矩阵加法 return identity + residual
def simple_cnn(input_shape): # NOTE: ThE INPUT_TENSOR IS THE SUBSAMPLED KSPACE # SO IT IS A COMPLEX128 TENSOR OF SHAPE # ( BATCH_DIM, CHANNELS_DIM, IMG_HEIGHT, IMG_WIDTH ) img_input = Input(input_shape) conv1 = conv_block_simple_2d(prevlayer=img_input, num_filters=16, prefix="conv1") conv2 = conv_block_simple_2d(prevlayer=conv1, num_filters=16, prefix="conv1_2") conv3 = conv_block_simple_2d(prevlayer=conv2, num_filters=16, prefix="conv1_3") prediction = Conv2D( filters=2, kernel_size=(1, 1), activation="sigmoid", name="prediction", data_format="channels_first", )(conv3) # prediction = Conv2D( # filters=1, # kernel_size=(1, 1), # activation="sigmoid", # name="prediction", # data_format="channels_first", # )(conv3) the_model = Model(inputs=img_input, outputs=prediction) return the_model
def d_block(x, filters, name): with tf.variable_scope(name): x0 = x x = tf.nn.relu(x) x = Conv2D(filters, kernel_size=3, padding='SAME', name='conv1')(x) x = tf.nn.relu(x) x = Conv2D(filters, kernel_size=3, padding='SAME', name='conv2')(x) x = AveragePooling2D(pool_size=2, strides=2, padding='VALID', name='avg1')(x) x0 = Conv2D(filters, kernel_size=3, padding='SAME', name='conv3')(x0) x0 = AveragePooling2D(pool_size=2, strides=2, padding='VALID', name='avg1')(x0) return x0 + x
def inception_block_3a(self, x, ct): self.inception_3a_1x1 = Conv2D(kernel_size=1, filters=64, data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_1x1') self.inception_3a_1x1_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_1x1_bn') self.inception_3a_3x3_reduce = Conv2D(kernel_size=1, filters=64, data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_3x3_reduce') self.inception_3a_3x3_reduce_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_3x3_reduce_bn') self.inception_3a_3x3 = Conv2D(kernel_size=3, filters=64, padding='same', data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_3x3') self.inception_3a_3x3_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_3x3_bn') self.inception_3a_double_3x3_reduce = Conv2D(kernel_size=1, filters=64, data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_double_3x3_reduce') self.inception_3a_double_3x3_reduce_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_double_3x3_reduce_bn') self.inception_3a_double_3x3_1 = Conv2D(kernel_size=3, filters=96, padding='same', data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_double_3x3_1') self.inception_3a_double_3x3_1_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_double_3x3_1_bn') self.inception_3a_double_3x3_2 = Conv2D(kernel_size=3, filters=96, padding='same', data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_double_3x3_2') self.inception_3a_double_3x3_2_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_double_3x3_2_bn') self.inception_3a_pool = MaxPooling2D(pool_size=3, strides=1, padding='same', data_format=self.DATA_FORMAT, name='inception_3a_pool') self.inception_3a_pool_proj = Conv2D(kernel_size=1, filters=32, data_format=self.DATA_FORMAT, trainable=ct, name='inception_3a_pool_proj') self.inception_3a_pool_proj_bn = BatchNormalization(axis=1, trainable=ct, name='inception_3a_pool_proj_bn') x1 = self.inception_3a_1x1(x) x1 = self.inception_3a_1x1_bn(x1) x1 = tf.nn.relu(x1) x2 = self.inception_3a_3x3_reduce(x) x2 = self.inception_3a_3x3_reduce_bn(x2) x2 = tf.nn.relu(x2) x2 = self.inception_3a_3x3(x2) x2 = self.inception_3a_3x3_bn(x2) x2 = tf.nn.relu(x2) x3 = self.inception_3a_double_3x3_reduce(x) x3 = self.inception_3a_double_3x3_reduce_bn(x3) x3 = tf.nn.relu(x3) x3 = self.inception_3a_double_3x3_1(x3) x3 = self.inception_3a_double_3x3_1_bn(x3) x3 = tf.nn.relu(x3) x3 = self.inception_3a_double_3x3_2(x3) x3 = self.inception_3a_double_3x3_2_bn(x3) x3 = tf.nn.relu(x3) x4 = self.inception_3a_pool(x) x4 = self.inception_3a_pool_proj(x4) x4 = self.inception_3a_pool_proj_bn(x4) x4 = tf.nn.relu(x4) x = tf.concat([x1, x2, x3, x4], axis=1, name='inception_3a_output') return x
def Network(features, labels, mode) : # input shape : 640 x 640 x 1 input_layer = tf.reshape(features["x"],[-1,640,640,1]) # encoder down1 = MaxPooling2D([2,2],2)(conv_res_conv(input_layer,64)) down2 = MaxPooling2D([2,2],2)(conv_res_conv(down1,128)) down3 = MaxPooling2D([2,2],2)(conv_res_conv(down2,256)) down4 = MaxPooling2D([2,2],2)(conv_res_conv(down3,512)) # bridge bridge = conv_res_conv(down4,1024) # decoder deconv4 = deconv2d_with_bn_and_act(bridge,down4.get_shape()) merge4 = skip_connection(deconv4,down4) upscale4 = conv_res_conv(merge4,512) deconv3 = deconv2d_with_bn_and_act(upscale4,down3.get_shape()) merge3 = skip_connection(deconv3,down3) upscale3 = conv_res_conv(merge3,256) deconv2 = deconv2d_with_bn_and_act(upscale3,down2.get_shape()) merge2 = skip_connection(deconv2,down2) upscale2 = conv_res_conv(merge2,128) deconv1 = deconv2d_with_bn_and_act(upscale2,down1.get_shape()) merge1 = skip_connection(deconv1,down1) upscale1 = conv_res_conv(merge1,64) output = Conv2D(1,kernel_size=[1,1],padding="same")(upscale1) predictions = { "outputs" : output } if mode == ModeKeys.PREDICT : return EstimatorSpec(mode=mode,predictions=predictions) loss = tf.losses.mean_pairwise_squared_error(labels,predictions) if mode == ModeKeys.TRAIN : optimizer = tf.train.AdamOptimizer() train_op = optimizer.minimize ( loss = loss, global_step = tf.train.get_global_step()) return EstimatorSpec(mode=mode,loss=loss,train_op=train_op) eval_metric_ops = { "acc" : tf.metrics.accuracy(labels=labels,predictions=predictions["outputs"]) } return EstimatorSpec(mode=mode,loss=loss,eval_metric_ops=eval_metric_ops)
def conv2d_bn(x, nb_filter, kernel_size, strides = (1, 1), padding = "SAME"): """ conv2d -> batch normalization -> relu. """ x = Conv2D( nb_filter, kernel_size, strides, padding, kernel_regularizer = tf.contrib.layers.l1_regularizer(0.001))(x) x = BatchNormalization()(x) x = relu(x) return x
def __init__(self): super(Encoder, self).__init__() arg = {'activation': tf.nn.relu, 'padding': 'same'} self.conv_11 = Conv2D(name='e_conv_11', filters=64, kernel_size=7, strides=(2, 2), **arg) self.conv_12 = Conv2D(name='e_conv_12', filters=64, kernel_size=7, strides=(2, 2), **arg) self.pool_1 = MaxPooling2D(name='e_pool_1', pool_size=4, strides=(2, 2), padding='same') self.compress_11 = AveragePooling2D(name='e_comp_11', pool_size=5, strides=(3, 3), padding='same') self.compress_12 = Flatten() self.compress_13 = Dense(name='e_comp_13', units=128, activation=None, use_bias=False) # activity_regularizer=tf.keras.regularizers.l2(l=0.01)) self.batch_norm_1 = BatchNormalization(name='e_bn_1') self.drop_1 = Dropout(name='e_drop_1', rate=0.5) self.conv_21 = Conv2D(name='e_conv_21', filters=128, kernel_size=5, strides=(1, 1), **arg) self.conv_22 = Conv2D(name='e_conv_22', filters=128, kernel_size=5, strides=(1, 1), **arg) self.pool_2 = MaxPooling2D(name='e_pool_2', pool_size=4, strides=(2, 2), padding='same') self.compress_21 = AveragePooling2D(name='e_comp_21', pool_size=5, strides=(3, 3), padding='same') self.compress_22 = Flatten() self.compress_23 = Dense(name='e_comp_23', units=128, activation=None, use_bias=False) # activity_regularizer=tf.keras.regularizers.l2(l=0.01)) self.batch_norm_2 = BatchNormalization(name='e_bn_2') self.drop_2 = Dropout(name='e_drop_2', rate=0.5) self.conv_31 = Conv2D(name='e_conv_31', filters=256, kernel_size=3, strides=(1, 1), **arg) self.conv_32 = Conv2D(name='e_conv_32', filters=256, kernel_size=3, strides=(1, 1), **arg) self.pool_3 = MaxPooling2D(name='e_pool_3', pool_size=2, strides=(2, 2), padding='same') self.compress_31 = AveragePooling2D(name='e_comp_31', pool_size=3, strides=(1, 1), padding='same') self.compress_32 = Flatten() self.compress_33 = Dense(name='e_comp_33', units=128, activation=None, use_bias=False) # activity_regularizer=tf.keras.regularizers.l2(l=0.01)) self.batch_norm_3 = BatchNormalization(name='e_bn_3') self.drop_3 = Dropout(name='e_drop_3', rate=0.5)
def unet_7_layers(input_tensor): # print('INPUT IMAGE SHAPE') # print(input_tensor.shape) mp_param = (2, 2) # (1,2,2) stride_param = (2, 2) d_format = "channels_first" pad = "same" us_param = (2, 2) kern = (3, 3) # filt=(32,64,128,256,512) filt = (32, 64, 128, 256) # filt=(64,128,256,512,1024) conv1 = conv_block_simple_2d(prevlayer=input_tensor, num_filters=filt[0], prefix="conv1", kernel_size=kern) conv1 = conv_block_simple_2d(prevlayer=conv1, num_filters=filt[0], prefix="conv1_1", kernel_size=kern) pool1 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool1")(conv1) conv2 = conv_block_simple_2d(prevlayer=pool1, num_filters=filt[1], prefix="conv2", kernel_size=kern) conv2 = conv_block_simple_2d(prevlayer=conv2, num_filters=filt[1], prefix="conv2_1", kernel_size=kern) pool2 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool2")(conv2) conv3 = conv_block_simple_2d(prevlayer=pool2, num_filters=filt[2], prefix="conv3", kernel_size=kern) conv3 = conv_block_simple_2d(prevlayer=conv3, num_filters=filt[2], prefix="conv3_1", kernel_size=kern) pool3 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool3")(conv3) conv4 = conv_block_simple_2d(prevlayer=pool3, num_filters=filt[3], prefix="conv_4", kernel_size=kern) conv4 = conv_block_simple_2d(prevlayer=conv4, num_filters=filt[3], prefix="conv_4_1", kernel_size=kern) conv4 = conv_block_simple_2d(prevlayer=conv4, num_filters=filt[3], prefix="conv_4_2", kernel_size=kern) up5 = Conv2DTranspose(filters=filt[2], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv4) up5 = concatenate([up5, conv3], axis=1) conv5 = conv_block_simple_2d(prevlayer=up5, num_filters=filt[2], prefix="conv5_1") conv5 = conv_block_simple_2d(prevlayer=conv5, num_filters=filt[2], prefix="conv5_2") up6 = Conv2DTranspose(filters=filt[1], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv5) up6 = concatenate([up6, conv2], axis=1) conv6 = conv_block_simple_2d(prevlayer=up6, num_filters=filt[1], prefix="conv6_1") conv6 = conv_block_simple_2d(prevlayer=conv6, num_filters=filt[1], prefix="conv6_2") up7 = Conv2DTranspose(filters=filt[0], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv6) up7 = concatenate([up7, conv1], axis=1) conv7 = conv_block_simple_2d(prevlayer=up7, num_filters=filt[0], prefix="conv7_1") conv7 = conv_block_simple_2d(prevlayer=conv7, num_filters=filt[0], prefix="conv7_2") # conv9 = SpatialDropout2D(0.2,data_format=d_format)(conv9) prediction = Conv2D(filters=1, kernel_size=(1, 1), activation="sigmoid", name="prediction", data_format=d_format)(conv7) # print('PREDICTION SHAPE') # print(prediction.shape) return prediction
def unet_9_layers(input_tensor, output_tensor_channels=1): mp_param = (2, 2) stride_param = (2, 2) d_format = "channels_first" pad = "same" kern = (3, 3) filt = (32, 64, 128, 256, 512) # filt=(64,128,256,512,1024) conv1 = conv_block_simple_2d(prevlayer=input_tensor, num_filters=filt[0], prefix="conv1") conv1 = conv_block_simple_2d(prevlayer=conv1, num_filters=filt[0], prefix="conv1_1") pool1 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool1")(conv1) conv2 = conv_block_simple_2d(prevlayer=pool1, num_filters=filt[1], prefix="conv2") conv2 = conv_block_simple_2d(prevlayer=conv2, num_filters=filt[1], prefix="conv2_1") pool2 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool2")(conv2) conv3 = conv_block_simple_2d(prevlayer=pool2, num_filters=filt[2], prefix="conv3") conv3 = conv_block_simple_2d(prevlayer=conv3, num_filters=filt[2], prefix="conv3_1") pool3 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool3")(conv3) conv4 = conv_block_simple_2d(prevlayer=pool3, num_filters=filt[3], prefix="conv4") conv4 = conv_block_simple_2d(prevlayer=conv4, num_filters=filt[3], prefix="conv4_1") pool4 = MaxPooling2D(pool_size=mp_param, strides=stride_param, padding="same", data_format="channels_first", name="pool4")(conv4) conv5 = conv_block_simple_2d(prevlayer=pool4, num_filters=filt[4], prefix="conv_5") conv5 = conv_block_simple_2d(prevlayer=conv5, num_filters=filt[3], prefix="conv_5_1") # conv5 = conv_block_simple_2d(prevlayer=conv5, num_filters=filt[4], prefix="conv_5_2") # 4 is 512, # 3 is 256 # 2 is 128 up6 = Conv2DTranspose(filters=filt[3], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv5) up6 = concatenate([up6, conv4], axis=1) conv6 = conv_block_simple_2d(prevlayer=up6, num_filters=filt[3], prefix="conv6_1") conv6 = conv_block_simple_2d(prevlayer=conv6, num_filters=filt[2], prefix="conv6_2") up7 = Conv2DTranspose(filters=filt[2], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv6) up7 = concatenate([up7, conv3], axis=1) conv7 = conv_block_simple_2d(prevlayer=up7, num_filters=filt[2], prefix="conv7_1") conv7 = conv_block_simple_2d(prevlayer=conv7, num_filters=filt[1], prefix="conv7_2") up8 = Conv2DTranspose(filters=filt[1], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv7) up8 = concatenate([up8, conv2], axis=1) conv8 = conv_block_simple_2d(prevlayer=up8, num_filters=filt[1], prefix="conv8_1") conv8 = conv_block_simple_2d(prevlayer=conv8, num_filters=filt[0], prefix="conv8_2") up9 = Conv2DTranspose(filters=filt[0], kernel_size=kern, strides=(2, 2), padding="same", data_format="channels_first")(conv8) up9 = concatenate([up9, conv1], axis=1) conv9 = conv_block_simple_2d(prevlayer=up9, num_filters=filt[0], prefix="conv9_1") conv9 = conv_block_simple_2d(prevlayer=conv9, num_filters=filt[0], prefix="conv9_2") # conv9 = SpatialDropout2D(0.2,data_format=d_format)(conv9) # prediction = Conv2D(filters=1, kernel_size=(1, 1), activation="sigmoid", name="prediction", data_format=d_format)(conv9) prediction = Conv2D(filters=output_tensor_channels, kernel_size=(1, 1), activation="sigmoid", use_bias=True, name="prediction", data_format=d_format)(conv9) # prediction = Conv2D(filters = output_tensor_channels, kernel_size = (1, 1), name="prediction",data_format=d_format)(conv9) return prediction
def __init__(self): super(Discriminator, self).__init__() arg = {'activation': tf.nn.relu, 'padding': 'same'} self.conv_11 = Conv2D(name='di_conv_11', filters=64, kernel_size=(5, 5), strides=(2, 2), **arg) self.conv_12 = Conv2D(name='di_conv_12', filters=64, kernel_size=(3, 3), strides=(1, 1), **arg) self.conv_13 = Conv2D(name='di_conv_13', filters=64, kernel_size=(3, 3), strides=(1, 1), **arg) self.pool_1 = MaxPooling2D(name='di_pool_1', pool_size=(5, 5), strides=(2, 2), padding='same') self.drop_1 = Dropout(0.5) self.conv_21 = Conv2D(name='di_conv_21', filters=128, kernel_size=(3, 3), strides=(1, 1), **arg) self.conv_22 = Conv2D(name='di_conv_22', filters=128, kernel_size=(3, 3), strides=(1, 1), **arg) self.conv_23 = Conv2D(name='di_conv_23', filters=128, kernel_size=(3, 3), strides=(1, 1), **arg) self.pool_2 = MaxPooling2D(name='di_pool_2', pool_size=(3, 3), strides=(2, 2), padding='same') self.drop_2 = Dropout(0.5) self.conv_31 = Conv2D(name='di_conv_31', filters=256, kernel_size=(3, 3), strides=(2, 2), **arg) self.conv_32 = Conv2D(name='di_conv_32', filters=256, kernel_size=(3, 3), strides=(1, 1), **arg) self.conv_33 = Conv2D(name='di_conv_33', filters=256, kernel_size=(3, 3), strides=(1, 1), **arg) self.pool_3 = MaxPooling2D(name='di_pool_3', pool_size=(3, 3), strides=(2, 2), padding='same') self.drop_3 = Dropout(0.5) self.flattener = Flatten() self.drop_4 = Dropout(0.5) self.classifier_1 = Dense(name='di_cls_1', units=512, activation=tf.nn.relu, use_bias=True) self.drop_5 = Dropout(0.5) self.classifier_2 = Dense(name='di_cls_2', units=256, activation=tf.nn.relu, use_bias=True) self.classifier_3 = Dense(name='di_cls_3', units=2, activation=None, use_bias=True)
def conv2d_with_bn_and_act(input_,filters,k_size=[3,3],strides=[1,1],padding="same") : return BatchNormalization()(Conv2D(filters,kernel_size=k_size,strides=strides,activation=tf.nn.relu)(input_))
'epochs': 5, 'batch_size': 64, 'num_channels': 64, }) """ NUM_CHANNELS = 64 BN1 = BatchNormalization() BN2 = BatchNormalization() BN3 = BatchNormalization() BN4 = BatchNormalization() BN5 = BatchNormalization() BN6 = BatchNormalization() CONV1 = Conv2D(NUM_CHANNELS, kernel_size=3, strides=1, padding='same') CONV2 = Conv2D(NUM_CHANNELS, kernel_size=3, strides=1, padding='same') CONV3 = Conv2D(NUM_CHANNELS, kernel_size=3, strides=1) CONV4 = Conv2D(NUM_CHANNELS, kernel_size=3, strides=1) FC1 = Dense(128) FC2 = Dense(64) FC3 = Dense(7) DROP1 = Dropout(0.3) DROP2 = Dropout(0.3) # 6x7 input # https://github.com/PaddlePaddle/PARL/blob/0915559a1dd1b9de74ddd2b261e2a4accd0cd96a/benchmark/torch/AlphaZero/submission_template.py#L496 def modified_cnn(inputs, **kwargs):
def __init__(self): self.pad0 = [[0, 0], [0, 0], [0, 1], [0, 0]] self.pad1 = [[0, 0], [0, 0], [1, 0], [0, 0]] self.CM_2 = Conv2D(filters=message_hidden_size, kernel_size=1, activation=tf.nn.relu, kernel_initializer=conv_initializer, name='CM_2') self.CM_1 = Conv2D(filters=message_hidden_size, kernel_size=1, activation=tf.nn.relu, kernel_initializer=conv_initializer, name='CM_1') self.CM_0 = Conv2D(filters=message_size * 2, kernel_size=1, activation=tf.nn.relu, kernel_initializer=conv_initializer, name='CM_0') # * 2 # Weights for input vectors of shape (message_size, hidden_size) self.Wr = Conv2D(filters=hidden_size, kernel_size=1, activation=None, kernel_initializer=conv_initializer, use_bias=True, name='C_Wr') self.Wz = Conv2D(filters=hidden_size, kernel_size=1, activation=None, kernel_initializer=conv_initializer, use_bias=True, name='C_Wz') self.Wh = Conv2D(filters=hidden_size, kernel_size=1, activation=None, kernel_initializer=conv_initializer, use_bias=True, name='C_Wh') # Weights for hidden vectors of shape (hidden_size, hidden_size) self.Ur = Conv2D(filters=hidden_size, kernel_size=1, activation=None, kernel_initializer=conv_initializer, use_bias=True, name='C_Ur') self.Uz = Conv2D(filters=hidden_size, kernel_size=1, activation=None, kernel_initializer=conv_initializer, use_bias=True, name='C_Uz') self.Uh = Conv2D(filters=hidden_size, kernel_size=1, activation=None, kernel_initializer=conv_initializer, use_bias=True, name='C_Uh') # Biases for hidden vectors of shape (hidden_size,) # self.br = tf.Variable(tf.truncated_normal(dtype=dtype, shape=(1, 1, hidden_size), mean=0, stddev=0.01), name='br') # self.bz = tf.Variable(tf.truncated_normal(dtype=dtype, shape=(1, 1, hidden_size), mean=0, stddev=0.01), name='bz') # self.bh = tf.Variable(tf.truncated_normal(dtype=dtype, shape=(1, 1, hidden_size), mean=0, stddev=0.01), name='bh') # self.Br = tf.tile(self.br, [input_dimensions, input_dimensions, 1], name='C_Br') # self.Bz = tf.tile(self.bz, [input_dimensions, input_dimensions, 1], name='C_Bz') # self.Bh = tf.tile(self.bh, [input_dimensions, input_dimensions, 1], name='C_Bh') self.X = tf.ones([time_step, 1]) self.H_0 = tf.tensordot(input_layer, tf.zeros(dtype=dtype, shape=(1, hidden_size)), axes=1, name='H_0') self.H_ts = tf.scan(self.forward_pass, self.X, initializer=self.H_0, name='H_ts') self.H_cur = tf.squeeze(tf.slice(self.H_ts, [time_step - 1, 0, 0, 0, 0], [1, -1, -1, -1, -1]), axis=0, name='H_cur')
NAME = "CATS_VS_DOGS_CNN" gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333) sess = tf.Sesseion(config=tf.ConfigProto(gpu_options=gpu_options)) pickle_in = open("X.pickle", "rb") X = pickle.load(pickle_in) pickle_in = open("y.pickle", "rb") y = pickle.load(pickle_in) X = X / 255.0 model = Sequential() model.add(Conv2D(64, (3, 3), input_shape=X.shape[1:])) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3), input_shape=X.shape[1:])) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors model.add(Dense(64)) model.add(Dense(1)) model.add(Activation("sigmoid")) tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))
def MobilenetV2(inputs, alpha=1.0, num_classes=1000, include_top=True): """Implementation of MobilenetV2""" with tf.variable_scope('MobilenetV2'): with tf.variable_scope('Conv'): first_block = _make_divisible(32 * alpha, 8) x = Conv2D(first_block, 3, strides=2, padding='same', use_bias=False, name='Conv2D')(inputs) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name='BatchNorm')(x) x = Activation(relu6)(x) x = inverted_residuals(x, 16, 3, stride=1, expansion=1, block_id=0, alpha=alpha, residual=False) x = inverted_residuals(x, 24, 3, stride=2, expansion=6, block_id=1, alpha=alpha, residual=False) x = inverted_residuals(x, 24, 3, stride=1, expansion=6, block_id=2, alpha=alpha) x = inverted_residuals(x, 32, 3, stride=2, expansion=6, block_id=3, alpha=alpha, residual=False) x = inverted_residuals(x, 32, 3, stride=1, expansion=6, block_id=4, alpha=alpha) x = inverted_residuals(x, 32, 3, stride=1, expansion=6, block_id=5, alpha=alpha) x = inverted_residuals(x, 64, 3, stride=2, expansion=6, block_id=6, alpha=alpha, residual=False) x = inverted_residuals(x, 64, 3, stride=1, expansion=6, block_id=7, alpha=alpha) x = inverted_residuals(x, 64, 3, stride=1, expansion=6, block_id=8, alpha=alpha) x = inverted_residuals(x, 64, 3, stride=1, expansion=6, block_id=9, alpha=alpha) x = inverted_residuals(x, 96, 3, stride=1, expansion=6, block_id=10, alpha=alpha, residual=False) x = inverted_residuals(x, 96, 3, stride=1, expansion=6, block_id=11, alpha=alpha) x = inverted_residuals(x, 96, 3, stride=1, expansion=6, block_id=12, alpha=alpha) x = inverted_residuals(x, 160, 3, stride=2, expansion=6, block_id=13, alpha=alpha, residual=False) x = inverted_residuals(x, 160, 3, stride=1, expansion=6, block_id=14, alpha=alpha) x = inverted_residuals(x, 160, 3, stride=1, expansion=6, block_id=15, alpha=alpha) x = inverted_residuals(x, 320, 3, stride=1, expansion=6, block_id=16, alpha=alpha, residual=False) x = Conv2D(_make_divisible(1280 * alpha, 8), 1, use_bias=False)(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999)(x) x = Activation(relu6)(x) if include_top: with tf.variable_scope('Predictions'): x = AvgPool2D((7, 7))(x) x = Conv2D(num_classes, 1, activation='softmax', use_bias=True)(x) x = Reshape((num_classes, ), name='Reshape_1')(x) return x
def inverted_residuals(inputs, filters, kernel, stride, expansion=1, alpha=1.0, atrous_rate=1, residual=True, block_id=None): """Define Inveterd Residuals Architecture. inputs --> 1x1 Conv --> Batch Norm --> Relu6 --> 3x3 DepthWise --> Batch Norm --> Relu6 --> 1x1 Conv --> Batch Norm --> Relu6 -- > Outputs Args: inputs - tf.float32 4D Tensor filters: number of expected output channels strides: """ scope = 'expanded_conv_' + str(block_id) if block_id else 'expanded_conv' with tf.variable_scope(scope): # ####################################################### # Expand and Pointwise # ####################################################### if block_id: with tf.variable_scope('expand'): in_channels = inputs.get_shape().as_list()[-1] x = Conv2D(filters=expansion * in_channels, kernel_size=1, padding='SAME', use_bias=False, activation=None)(inputs) x = BatchNormalization(epsilon=1e-3, momentum=0.999)(x) x = Activation(relu6)(x) else: x = inputs # ######################################################## # Depthwise # ######################################################## with tf.variable_scope('depthwise'): x = DepthwiseConv2D(kernel_size=kernel, strides=stride, activation=None, use_bias=False, dilation_rate=(atrous_rate, atrous_rate), padding='SAME')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999)(x) x = Activation(relu6)(x) # ######################################################## # Linear Projection # ######################################################## with tf.variable_scope('project'): pointwise_filters = int(filters * alpha) pointwise_filters = _make_divisible(pointwise_filters, 8) # Why 8??? x = Conv2D(filters=pointwise_filters, kernel_size=1, padding='SAME', use_bias=False, activation=None)(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999)(x) x = Activation(relu6)(x) if residual: x = Add()([inputs, x]) return x
import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.layers import Dense, Conv2D, Flattem, Dropout, MaxPooling2D model = Sequential( Conv2D(128, (4, 4), padding='same', activation='relu', input_shape=(6, 7, 1)), MaxPooling2D(pool_size=(2, 2)), Dense(64, activation='relu'), Dense(64, activation='relu'), Dense(1)) optimizer = tf.keras.optimizers.Adam() model.compile(loss='mean_squared_error', optimizer=optimizer, metrics=['accuracy'])
[-1, input_dimensions, input_dimensions_m1, size]) ver0 = tf.slice(edge, [0, input_dimensions, 0, 0], [-1, input_dimensions, input_dimensions_m1, size]) ver1 = tf.slice(edge, [0, input_dimensions, 0, size], [-1, input_dimensions, input_dimensions_m1, size]) hor_ = tf.pad(hor0, self.pad0) + tf.pad(hor1, self.pad1) ver_ = tf.pad(ver0, self.pad0) + tf.pad(ver1, self.pad1) return tf.add(hor_, tf.transpose(ver_, [0, 2, 1, 3]), name=name) main_layers = GNN_GRU() H_cur = main_layers.get_current_state() map_2 = Conv2D(filters=message_hidden_size, kernel_size=1, activation=tf.nn.relu, kernel_initializer=conv_initializer, name='CR_2')(H_cur) map_1 = Conv2D(filters=message_hidden_size, kernel_size=1, activation=tf.nn.relu, kernel_initializer=conv_initializer, name='CR_1')(map_2) map_0 = Conv2D(filters=label_size, kernel_size=1, activation=tf.nn.softmax, kernel_initializer=conv_initializer, name='CR_0')(map_1) output_layer = map_0 # tf.subtract(1., map_0, name='soft_output') # label_layer = tf.cast(tf.argmax(output_layer, axis=-1), dtype=tf.int32,
def Simple_VGG_19(inputs, num_classes): outputs = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(inputs) outputs = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) outputs = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(outputs) outputs = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) outputs = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) outputs = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(outputs) outputs = Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) outputs = Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) #outputs = Conv2D(filters = 256, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) #outputs = Conv2D(filters = 256, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) outputs = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(outputs) outputs = Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) outputs = Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), activation="relu", padding="SAME")(outputs) #outputs = Conv2D(filters = 512, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) #outputs = Conv2D(filters = 512, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) outputs = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(outputs) #outputs = Conv2D(filters = 512, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) #outputs = Conv2D(filters = 512, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) #outputs = Conv2D(filters = 512, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) #outputs = Conv2D(filters = 512, kernel_size = (3,3), strides = (1,1), activation = "relu", padding = "SAME")(outputs) #outputs = MaxPooling2D(pool_size = (2,2), strides = (2,2))(outputs) outputs = tf.layers.Flatten()(outputs) #outputs = tf.layers.Dense(4096, activation = "relu")(outputs) #outputs = tf.layers.Dense(4096, activation = "relu")(outputs) #outputs = tf.layers.Dense(1000, activation = "relu")(outputs) outputs = tf.layers.Dense(512, activation="relu")(outputs) outputs = tf.layers.Dense(512, activation="relu")(outputs) outputs = tf.layers.Dense(64, activation="relu")(outputs) outputs = tf.layers.Dense(num_classes, activation="relu")(outputs) return outputs
def __init__(self): super(Decoder, self).__init__() arg = {'activation': tf.nn.relu, 'padding': 'same'} self.deconv_11 = Conv2DTranspose(name='d_deconv_11', filters=512, kernel_size=(5, 5), strides=(2, 2), **arg) self.deconv_12 = Conv2DTranspose(name='d_deconv_12', filters=512, kernel_size=(5, 5), strides=(2, 2), **arg) self.deconv_13 = Conv2D(name='d_deconv_13', filters=256, kernel_size=(3, 3), strides=(1, 1), **arg) # self.batch_norm_1 = BatchNormalization(name='d_bn_1') # self.drop_1 = Dropout(name='d_drop_1', rate=0.5) self.deconv_21 = Conv2DTranspose(name='d_deconv_21', filters=256, kernel_size=(5, 5), strides=(2, 2), **arg) self.deconv_22 = Conv2DTranspose(name='d_deconv_22', filters=256, kernel_size=(5, 5), strides=(2, 2), **arg) self.deconv_23 = Conv2D(name='d_deconv_23', filters=128, kernel_size=(3, 3), strides=(1, 1), **arg) # self.batch_norm_2 = BatchNormalization(name='d_bn_2') # self.drop_2 = Dropout(name='d_drop_2', rate=0.5) self.deconv_31 = Conv2DTranspose(name='d_deconv_31', filters=128, kernel_size=(5, 5), strides=(2, 2), **arg) self.deconv_32 = Conv2D(name='d_deconv_32', filters=64, kernel_size=(3, 3), strides=(1, 1), **arg) self.deconv_33 = Conv2D(name='d_deconv_33', filters=64, kernel_size=(3, 3), strides=(1, 1), **arg) # self.batch_norm_3 = BatchNormalization(name='d_bn_3') # self.drop_3 = Dropout(name='d_drop_3', rate=0.5) self.deconv_4 = Conv2D(name='d_deconv_4', filters=3, kernel_size=(3, 3), strides=(1, 1), padding='same')