def build_discriminator(image, reuse=False): with tf.variable_scope("discriminator") as scope: if reuse: tf.get_variable_scope().reuse_variables() # t = image t = conv2d(inputs=t, filters=64, kernel_size=[5, 5], strides=2, padding="same", activation=my_leaky_relu) t = batch_normalization(inputs=t) t = conv2d(inputs=t, filters=128, kernel_size=[5, 5], strides=2, padding="same", activation=my_leaky_relu) t = batch_normalization(inputs=t) t = dropout(inputs=t, rate=DROP_RATE) t = flatten(inputs=t) t = dense(inputs=t, units=1, activation=tf.sigmoid) decision = t #print("\nD output shape: {}".format(decision.shape)) return decision
def f_net_dqn(inputs_state, inputs_action, is_training): depth = inputs_state.get_shape()[1:].num_elements() inputs_state = tf.reshape(inputs_state, shape=[-1, depth]) inputs_state = layers.batch_normalization(inputs_state, axis=1, training=is_training) hidden1 = layers.dense( inputs=inputs_state, units=400, activation=None, kernel_regularizer=l2_regularizer(scale=1e-2), trainable=True, name='hidden1', ) # hidden1 = tf.nn.relu(hidden1) hidden1 = tf.nn.relu(layers.batch_normalization(hidden1, axis=1, training=is_training)) depth = inputs_action.get_shape()[1:].num_elements() inputs_action = tf.reshape(inputs_action, shape=[-1, depth]) hidden1 = tf.concat([hidden1, inputs_action], axis=1) hidden2 = layers.dense( inputs=hidden1, units=300, activation=None, kernel_regularizer=l2_regularizer(scale=1e-2), trainable=True, name='hidden2', ) hidden2 = tf.nn.relu(hidden2) # hidden2 = tf.nn.relu(layers.batch_normalization(hidden2, axis=1, training=is_training)) q = layers.dense( inputs=hidden2, units=1, activation=None, kernel_initializer=tf.random_uniform_initializer(minval=-3e-3, maxval=3e-3), kernel_regularizer=l2_regularizer(scale=1e-2), trainable=True, name='out', ) q = tf.squeeze(q, axis=1, name='out_sqz') return q
def __call__(self): """ Builds the network. """ x = conv2d(self.img_input, self.nb_filter, self.initial_kernel, kernel_initializer='he_normal', padding='same', strides=self.initial_strides, use_bias=False, **self.conv_kwargs) if self.subsample_initial_block: x = batch_normalization(x, **self.bn_kwargs) x = tf.nn.relu(x) x = max_pooling2d(x, (3, 3), data_format=self.data_format, strides=(2, 2), padding='same') # Add dense blocks nb_filter = self.nb_filter for block_idx in range(self.nb_dense_block - 1): with tf.variable_scope('denseblock_{}'.format(block_idx)): x, nb_filter = self._dense_block(x, self.nb_layers[block_idx], nb_filter) # add transition_block x = self._transition_block(x, nb_filter) nb_filter = int(nb_filter * self.compression) # The last dense_block does not have a transition_block x, nb_filter = self._dense_block(x, self.final_nb_layer, self.nb_filter) x = batch_normalization(x, **self.bn_kwargs) x = tf.nn.relu(x) x = GlobalAveragePooling2D(data_format=self.data_format)(x) if self.include_top: x = dense(x, self.nb_classes) return x
def forward(self, X, momentum=0.5): # 1th layer z = conv2d(X, self.W1, [1, 2, 2, 1], padding="SAME") #add bias z = tf.nn.bias_add(z, self.b1) #Activation Function z = tf.nn.leaky_relu(z) # 2nd layer z = conv2d(z, self.W2, [1, 1, 1, 1], padding="SAME") z = tf.nn.bias_add(z, self.b2) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) # 3th layer z = conv2d(z, self.W3, [1, 2, 2, 1], padding="SAME") z = tf.nn.bias_add(z, self.b3) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) # 4th layer z = conv2d(z, self.W4, [1, 1, 1, 1], padding="SAME") z = tf.nn.bias_add(z, self.b4) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) # Fully Connected Layer # Flatten Image z = Flatten()(z) z = Dense(1)(z) logits = tf.nn.bias_add(z, self.b5) return logits #Activation Function included in cost function
def forward(self, X, momentum=0.5): X = tf.reshape(X, [-1, self.img_rows, self.img_cols, self.channels]) z = conv2d(X, self.W1, [1, 2, 2, 1], padding="SAME") z = tf.nn.bias_add(z, self.b1) z = tf.nn.leaky_relu(z) z = conv2d(z, self.W2, [1, 1, 1, 1], padding="SAME") z = tf.nn.bias_add(z, self.b2) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) z = conv2d(z, self.W3, [1, 2, 2, 1], padding="SAME") z = tf.nn.bias_add(z, self.b3) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) z = conv2d(z, self.W4, [1, 1, 1, 1], padding="SAME") z = tf.nn.bias_add(z, self.b4) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) z = tf.reshape(z, [-1, 7 * 7 * 256]) logits = tf.matmul(z, self.W5) logits = tf.nn.bias_add(logits, self.b5) return logits
def generatorNet(name, inputs, is_training, use_batchNorm, reuse=None): idx = 0 f = inputs with tf.variable_scope(name, reuse=reuse): f = layers.dense(f, 1024, None, name="dense_%d" % idx) if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.relu(f, "relu_%d" % idx) idx += 1 f = layers.dense(f, 7 * 7 * 128, None, name="dense_%d" % idx) # 6272 if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.relu(f, "relu_%d" % idx) f = tf.reshape(f, [-1, 7, 7, 128], name="reshape_%d" % idx) idx += 1 f = layers.conv2d_transpose(f, 64, kernel_size=4, strides=2, padding="SAME", name="deconv_%d" % idx) if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.relu(f, "relu_%d" % idx) idx += 1 f = layers.conv2d_transpose(f, 1, kernel_size=4, strides=2, padding="SAME", name="deconv_%d" % idx) f = tf.nn.sigmoid(f, "sigmoid_%d" % idx) return f
def res_block_2d(x, kernel_size, training, batch_norm=True): assert len(x.shape) == 4, "Input tensor must be 4-dimensional." filters = int(x.shape[3]) y = ly.conv2d(inputs=x, filters=filters, kernel_size=kernel_size, strides=1, padding='same') if batch_norm: y = ly.batch_normalization(y, training=training) y = k.layers.PReLU()(y) y = ly.conv2d(inputs=y, filters=filters, kernel_size=kernel_size, strides=1, padding='same') if batch_norm: y = ly.batch_normalization(y, training=training) return tf.add(x, y)
def res_block_2d(x, kernel_size, activation, training, batch_norm=True): assert len(x.shape) == 4, "Input tensor must be 4-dimensional." activation = activation.lower() filters = int(x.shape[3]) y = ly.conv2d(inputs=x, filters=filters, kernel_size=kernel_size, strides=1, padding='same') if batch_norm: y = ly.batch_normalization(y, training=training) y = nonlinear[activation](y) y = ly.conv2d(inputs=y, filters=filters, kernel_size=kernel_size, strides=1, padding='same') if batch_norm: y = ly.batch_normalization(y, training=training) return tf.add(x, y)
def forward(self, X, Y, momentum=0.5): # print('X shape in G is ', X.shape) # print('Y shape in G is ', Y.shape) # print('X type in G is ', type(X)) # print('Y type in G is ', type(Y)) # print('X dtype in G is ', X.dtype) # print('Y dtype in G is ', Y.dtype) # print('W1 shape in G is ', self.W1.shape) z = tf.concat([X, Y], 1) # print('z shape in G after concat is ', z.shape) # print('z type in G is ', type(z)) # print('z dtype in G is ', z.dtype) z = tf.matmul(z, self.W1) z = tf.nn.relu(z) z = tf.reshape(z, [-1, 16, 16, 512]) z = UpSampling2D()(z) z = conv2d(z, self.W2, [1, 1, 1, 1], padding="SAME") z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) z = UpSampling2D()(z) z = conv2d(z, self.W3, [1, 1, 1, 1], padding="SAME") z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) z = conv2d(z, self.W4, [1, 1, 1, 1], padding="SAME") return tf.nn.tanh(z)
def generator_fn(input_image, mode): with tf.name_scope('generator'): #4*4 dense_1 = layers.dense(inputs=input_image, units=batch_size*16) batch_norm_1 = layers.batch_normalization(inputs=dense_1) reshape_1 = tf.reshape(batch_norm_1, shape=(batch_size, 4, 4, batch_size)) relu_1 = tf.nn.relu(reshape_1) # 8*8 conv_T_1 = layers.conv2d_transpose(inputs=relu_1, filters=64, kernel_size=(2, 2), strides=(2, 2), padding='same') batch_norm_2 = layers.batch_normalization(inputs=conv_T_1) relu_2 = tf.nn.relu(batch_norm_2) # 16*16 conv_T_2 = layers.conv2d_transpose(inputs=relu_2, filters=32, kernel_size=(2, 2), strides=(2, 2), padding='same') batch_norm_3 = layers.batch_normalization(inputs=conv_T_2) relu_3 = tf.nn.relu(batch_norm_3) # 32*32 conv_T_3 = layers.conv2d_transpose(inputs=relu_3, filters=16, kernel_size=(2, 2), strides=(2, 2), padding='same') batch_norm_4 = layers.batch_normalization(inputs=conv_T_3) relu_4 = tf.nn.relu(batch_norm_4) # 64*64 conv_T_4 = layers.conv2d_transpose( inputs=relu_4, filters=3, kernel_size=(2, 2), strides=(2, 2), padding='same') tanh_1 = tf.nn.tanh(conv_T_4) print(tanh_1) return tanh_1
def generator(z): with tf.variable_scope("generator", reuse=tf.AUTO_REUSE): with tf.variable_scope("linear"): linear = clayers.fully_connected(z, 1024 * 4 * 4) with tf.variable_scope("conv1_transp"): # Reshape as 4x4 images conv1 = tf.reshape(linear, (-1, 4, 4, 1024)) conv1 = default_conv2d_transpose(conv1, 512) conv1 = layers.batch_normalization(conv1) conv1 = nn.relu(conv1) with tf.variable_scope("conv2_transp"): conv2 = default_conv2d_transpose(conv1, 256) conv2 = layers.batch_normalization(conv2) conv2 = nn.relu(conv2) with tf.variable_scope("conv3_transp"): conv3 = default_conv2d_transpose(conv2, 128) conv3 = layers.batch_normalization(conv3) conv3 = nn.relu(conv3) with tf.variable_scope("conv4_transp"): conv4 = default_conv2d_transpose(conv3, 3) with tf.variable_scope("out"): out = tf.tanh(conv4) return out
def _bottleneck_brick(incoming, nb_filters, is_training, scope, trainable=True): """ Code brick: conv --> conv . """ with tf.variable_scope(scope): code1 = layers.conv2d(incoming, filters=nb_filters, kernel_size=1, strides=1, padding='same', kernel_initializer=he_init, bias_initializer=b_init) code1_bn = layers.batch_normalization(code1, training=is_training, trainable=trainable) code1_act = tf.nn.relu(code1_bn) code2 = layers.conv2d(code1_act, filters=nb_filters, kernel_size=1, strides=1, padding='same', kernel_initializer=he_init, bias_initializer=b_init) code2_bn = layers.batch_normalization(code2, training=is_training, trainable=trainable) code2_act = tf.nn.relu(code2_bn) return code2_act
def dense_block(x, iter, two_conv, one_conv, is_train=False, name='denseblock'): with tf.variable_scope(name): net = x for i in range(iter): x = tl.batch_normalization(net, trainable=is_train, name=name + '_bn1/' + str(i)) x = tf.nn.relu(x) x = tl.conv2d(x, one_conv, (1, 1), padding='same', name=name + '_conv1/' + str(i)) x = tl.batch_normalization(x, trainable=is_train, name=name + '_bn2/' + str(i)) x = tf.nn.relu(x) x = tl.conv2d(x, two_conv, (3, 3), (1, 1), padding='same', name=name + '_conv2/' + str(i)) net = tf.concat([x, net], -1) return net
def generator(noise, reuse=False, alpha=0.2, training=True): with tf.variable_scope('generator', reuse=reuse): x = dense(noise, 4 * 4 * 512) x = tf.reshape(x, (-1, 4, 4, 512)) x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d_transpose(x, 256, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d_transpose(x, 128, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d_transpose(x, 64, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) logits = conv2d_transpose(x, 3, 5, 2, padding='same') out = tf.tanh(logits) return out, logits
def generator(z, batch_size, z_dim, test_train, reuse1=None): with tf.variable_scope("generator",reuse=reuse1): init = tf.truncated_normal_initializer(stddev=0.1) layer1 = Dnn( z, 500,"1",is_training=test_train) layer2 = Dnn( layer1, 1000, "2",is_training=test_train) layer3 = Dnn( layer2, 10000, "3",is_training=test_train) g = tf.reshape( layer3, [-1,10,10,100]) # Generate 50 features g_w1 = tf.get_variable('g_cw1', [2, 2, 50, 100], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.5)) g_b1 = tf.get_variable('g_cb1', [50], initializer=init) g1 = tf.nn.conv2d_transpose(g, g_w1, [batch_size, 19, 19, 50], strides=[1, 2, 2, 1], padding='SAME') g1 = g1 + g_b1 g1 = tf.nn.relu(g1) g1 = batch_normalization(g1, name='bn1', training=test_train) # Generate 25 features g_w2 = tf.get_variable('g_cw2', [2, 2, 25, 50], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.5)) g_b2 = tf.get_variable('g_cb2', [25], initializer=init) g2 = tf.nn.conv2d_transpose(g1, g_w2, [batch_size, 38, 38, 25], strides=[1, 2, 2, 1], padding='VALID') g2 = g2 + g_b2 g2 = tf.nn.relu(g2) g2 = batch_normalization(g2, name='bn2', training = test_train) # final features g_w3 = tf.get_variable('g_cw3', [2, 2, 3, 25], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=1)) g_b3 = tf.get_variable('g_cb3', [3], initializer=init) g3 = tf.nn.conv2d_transpose(g2, g_w3, [batch_size, 76, 76, 3], strides=[1, 2, 2, 1], padding='VALID') g3 = g3 + g_b3 g3 = tf.sigmoid(g3) return g3
def forward(self, X, momentum=0.5): z = tf.matmul(X,self.W1) z = tf.nn.leaky_relu(z) #Reshape to 4d tensor z = tf.reshape(z,[-1,8,8,self.layer_sizes[0]]) #8,8 #Upsampling to increase image size z = UpSampling2D()(z) #keras z = conv2d(z,self.W2,[1,1,1,1],padding="SAME") z = batch_normalization(z,momentum=momentum) z = tf.nn.leaky_relu(z) #16,16 z = UpSampling2D()(z) #keras z = conv2d(z,self.W3,[1,1,1,1],padding="SAME") z = batch_normalization(z,momentum=momentum) z = tf.nn.leaky_relu(z) #32,32 z = UpSampling2D()(z) #keras z = conv2d(z,self.W4,[1,1,1,1],padding="SAME") z = batch_normalization(z,momentum=momentum) z = tf.nn.leaky_relu(z) #64,64 z = conv2d(z,self.W5,[1,1,1,1],padding="SAME") #64,64,3 return tf.nn.tanh(z)
def discriminator(x, reuse=False, alpha=0.2, training=True): """ Discriminator model, taking `x` as input. """ with tf.variable_scope('discriminator', reuse=reuse): x = conv2d(x, 32, 5, 2, padding='same') x = tf.maximum(alpha * x, x) x = conv2d(x, 64, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d(x, 128, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d(x, 256, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) flatten = tf.reshape(x, (-1, 4 * 4 * 256)) logits = dense(flatten, 1) out = tf.sigmoid(logits) return logits
def _x(ip): x = batch_normalization(ip, **self.bn_kwargs) x = tf.nn.relu(x) if self.bottleneck: inter_channel = nb_filter * 4 x = conv2d(x, inter_channel, (1, 1), kernel_initializer='he_normal', padding='same', use_bias=False, **self.conv_kwargs) x = batch_normalization(x, **self.bn_kwargs) x = tf.nn.relu(x) x = conv2d(x, nb_filter, (3, 3), kernel_initializer='he_normal', padding='same', use_bias=False, **self.conv_kwargs) if self.dropout_rate: x = dropout(x, self.dropout_rate, training=self.training) return x
def discriminatorNet(inputs, is_training, use_batchNorm): idx = 0 f = inputs f = layers.conv2d(f, 64, kernel_size=4, strides=2, padding="SAME", name="conv_%d" % idx) if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx) idx += 1 f = layers.conv2d(f, 128, kernel_size=4, strides=2, padding="SAME", name="conv_%d" % idx) if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx) idx += 1 f = layers.flatten(f) f = layers.dense(f, 1024, name="dense_%d" % idx) f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx) return f
def generator(noise, reuse=False, alpha=0.2, training=True): """ Generator model that takes `noise` as input. `alpha` is the Leaky-ReLU paramter for slope. """ with tf.variable_scope('generator', reuse=reuse): x = dense(noise, 4 * 4 * 512) x = tf.reshape(x, (-1, 4, 4, 512)) x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d_transpose(x, 256, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d_transpose(x, 128, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) x = conv2d_transpose(x, 64, 5, 2, padding='same') x = batch_normalization(x, training=training) x = tf.maximum(alpha * x, x) logits = conv2d_transpose(x, 3, 5, 2, padding='same') out = tf.tanh(logits) return out
def f_net_ddp(inputs, action_shape, is_training): depth_state = inputs.get_shape()[1:].num_elements() inputs = tf.reshape(inputs, shape=[-1, depth_state], name='inputs') inputs = layers.batch_normalization(inputs, axis=1, training=is_training) hidden1 = layers.dense( inputs=inputs, units=400, activation=None, kernel_regularizer=l2_regularizer(scale=1e-2), trainable=True, name='hidden1', ) # hidden1 = tf.nn.relu(hidden1) hidden1 = tf.nn.relu(layers.batch_normalization(hidden1, axis=1, training=is_training)) hidden2 = layers.dense( inputs=hidden1, units=300, activation=None, kernel_regularizer=l2_regularizer(scale=1e-2), trainable=True, name='hidden2', ) # hidden2 = tf.nn.relu(layers.batch_normalization(hidden2, axis=1, training=is_training)) hidden2 = tf.nn.relu(hidden2) depth_action = reduce(lambda x, y: x*y, action_shape, 1) action = layers.dense( inputs=hidden2, units=depth_action, activation=tf.nn.tanh, kernel_initializer=tf.random_uniform_initializer(minval=-3e-3, maxval=3e-3), kernel_regularizer=l2_regularizer(scale=1e-2), trainable=True, name='out' ) action = tf.reshape(2.0*action, shape=[-1]+list(action_shape), name='out') return action
def discriminator(x): with tf.variable_scope("discriminator", reuse=tf.AUTO_REUSE): with tf.variable_scope("conv1"): conv1 = default_conv2d(x, 128) conv1 = nn.leaky_relu(conv1, alpha=0.2) with tf.variable_scope("conv2"): conv2 = default_conv2d(conv1, 256) conv2 = layers.batch_normalization(conv2) conv2 = nn.leaky_relu(conv2, alpha=0.2) with tf.variable_scope("conv3"): conv3 = default_conv2d(conv2, 512) conv3 = layers.batch_normalization(conv3) conv3 = nn.leaky_relu(conv3, alpha=0.2) with tf.variable_scope("conv4"): conv4 = default_conv2d(conv3, 1024) conv4 = layers.batch_normalization(conv3) conv4 = nn.leaky_relu(conv3, alpha=0.2) with tf.variable_scope("linear"): linear = clayers.flatten(conv4) linear = clayers.fully_connected(linear, 1) with tf.variable_scope("out"): out = nn.sigmoid(linear) return out
def forward2(self, X, momentum=0.5): # 1th layer z = conv2d(X,self.W1,[1,2,2,1],padding="SAME") #Size 14,14,64 #add bias z = tf.nn.bias_add(z,self.b1) #Activation Function z = tf.nn.leaky_relu(z) # 2nd layer z = conv2d(z,self.W2,[1,1,1,1],padding="SAME") #Size 14,14,64 z = tf.nn.bias_add(z,self.b2) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) # 3th layer z = conv2d(z,self.W3,[1,2,2,1],padding="SAME") #Size 7,7,128 z = tf.nn.bias_add(z,self.b3) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) # 4th layer z = conv2d(z,self.W4,[1,1,1,1],padding="SAME") #Size 7,7,256 z = tf.nn.bias_add(z,self.b4) z = batch_normalization(z, momentum=momentum) z = tf.nn.leaky_relu(z) # Fully Connected Layer # Flatten Image z = tf.reshape(z,[-1, 7*7*256]) logits = tf.matmul(z, self.W5) logits = tf.nn.bias_add(logits, self.b5) return logits #Activation Function included in cost function
def res_block(self, x, num_filter, is_train, name): with tf.variable_scope(name, reuse=self.reuse): y = tf.pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]], "REFLECT") y = layer.conv2d(y, num_filter, 3, 1, name='_res1') y = layer.batch_normalization(y, center=True, scale=True, training=is_train, name='_b1') y = tf.pad(y, [[0, 0], [1, 1], [1, 1], [0, 0]], "REFLECT") y = layer.conv2d(y, num_filter, 3, 1, name='_res2') y = layer.batch_normalization(y, center=True, scale=True, training=is_train, name='_b2') return x + y
def _build_discriminator(input_data, reuse_variables=False, name='discriminator'): with tf.variable_scope(name, reuse=reuse_variables): net = layers.conv2d(input_data, 16, [3, 3], strides=[2, 2], activation=tf.nn.relu, padding='same', name='conv2d_1') net = layers.batch_normalization(net, momentum=0.9, training=True) net = layers.conv2d(net, 32, [3, 3], strides=[2, 2], activation=tf.nn.relu, padding='same', name='conv2d_2') net = layers.batch_normalization(net, momentum=0.9, training=True) net = layers.conv2d(net, 64, [3, 3], strides=[2, 2], activation=tf.nn.relu, padding='same', name='conv2d_3') net = layers.conv2d(net, 128, [3, 3], strides=[2, 2], activation=tf.nn.relu, padding='same', name='conv2d_4') net = contrib_layers.flatten(net) net = layers.dense(net, 1) return net
def create_resnet_block(x, filters, training, activation=tf.nn.elu, skip_connection=False): h = layers.conv2d(x, filters, kernel_size=3, activation=None, padding="SAME", kernel_initializer=xavier_initializer(), bias_initializer=None) h = layers.batch_normalization(h, momentum=0.9, scale=True, fused=True, training=training) h = activation(h) h = layers.conv2d(h, filters, kernel_size=3, activation=None, padding="SAME", kernel_initializer=xavier_initializer(), bias_initializer=None) if not skip_connection: h = h+x h = layers.batch_normalization(h, momentum=0.9, scale=True, fused=True, training=training) h = activation(h) return h
def generator_net(inputs, scope, reuse=None, rgb=False): output_channels = 3 if rgb else 1 with tf.variable_scope(scope, reuse=reuse): # branch 1 ( color reconstruction) cv1 = conv2d(inputs, filters=16, kernel_size=3, strides=1, padding='same', activation=None, name='conv9_i') cv1_r = leaky_relu(cv1) res1_c = conv2d(cv1_r, filters=16, kernel_size=5, strides=1, padding='same', activation=None, name='conv3a_1') res1_b = batch_normalization(res1_c) res1_r = leaky_relu(res1_b) res1_d = conv2d(res1_r, filters=16, kernel_size=3, strides=1, padding='same', activation=None, name='conv3b_1') res1 = batch_normalization(res1_d) sum1 = cv1 + res1 res2_c = conv2d(sum1, filters=16, kernel_size=3, strides=1, padding='same', activation=None, name='conv3a_2') res2_b = batch_normalization(res2_c) res2_r = leaky_relu(res2_b) res2_d = conv2d(res2_r, filters=16, kernel_size=3, strides=1, padding='same', activation=None, name='conv3b_2') res2 = batch_normalization(res2_d) br1 = sum1 + res2 # branch 2 (features extraction) br2 = conv2d(inputs, filters=16, kernel_size=5, strides=1, padding='same', activation=tf.nn.leaky_relu, name='conv_bf1') br2 = max_pooling2d(br2, pool_size=2, strides=2, name='maxpool1') br2 = conv2d(br2, filters=16, kernel_size=3, strides=1, padding='same', activation=tf.nn.leaky_relu, name='conv_bf2') br2 = max_pooling2d(br2, pool_size=2, strides=2, name='maxpool2a') br2 = conv2d(br2, filters=16, kernel_size=3, strides=1, padding='same', activation=tf.nn.leaky_relu, name='conv_bf3') br2 = max_pooling2d(br2, pool_size=2, strides=2, name='maxpool2') print(br2.shape) br2 = conv2d_transpose(br2, filters=16, kernel_size=3, padding='same', strides=2, activation=tf.nn.leaky_relu, name="deconv_1") print(br2.shape) br2 = conv2d_transpose(br2, filters=16, kernel_size=3, padding='same', strides=2, activation=tf.nn.leaky_relu, name="deconv_2") print(br2.shape) br2 = conv2d_transpose(br2, filters=16, kernel_size=3, padding='same', strides=2, activation=tf.nn.leaky_relu, name="deconv_3") print(br2.shape) # concatenate branches and reconstruct image sum3 = tf.concat((br1, br2), axis=3); model = conv2d(sum3, filters=output_channels, kernel_size=3, strides=1, padding='same', activation=None, name='conv9_f') return model
def misconception_fishing(inputs, filters_list, kernel_size, strides_list, objective_function, training, pre_filters=128, post_filters=128, post_layers=1, dropout_rate=0.5, internal_dropout_rate=0.5, other_objectives=(), feature_means=None, feature_stds=None): _, layers = misconception_model(inputs, filters_list, kernel_size, strides_list, training, other_objectives, sub_filters=post_filters, sub_layers=2, dropout_rate=internal_dropout_rate, feature_means=feature_means, feature_stds=feature_stds) expanded_layers = [] for i, lyr in enumerate(layers): lyr = ly.conv1d(lyr, pre_filters, 1, activation=None) lyr = ly.batch_normalization(lyr, training=training) lyr = tf.nn.relu(lyr) expanded_layers.append(repeat_tensor(lyr, 2**i)) embedding = tf.add_n(expanded_layers) for _ in range(post_layers - 1): embedding = ly.conv1d(embedding, post_filters, 1, activation=None, use_bias=False) embedding = ly.batch_normalization(embedding, training=training) embedding = tf.nn.relu(embedding) embedding = ly.conv1d(embedding, post_filters, 1, activation=tf.nn.relu) embedding = ly.dropout(embedding, training=training, rate=dropout_rate) fishing_outputs = ly.conv1d(embedding, 1, 1, activation=None) return objective_function.build(fishing_outputs)
def batch_norm_layer(self, x, train_phase, scope_bn): bn_train = batch_normalization(x, center=True, scale=True, training=True, name=scope_bn) bn_inference = batch_normalization(x, center=True, scale=True, training=False, reuse=True, name=scope_bn) bn = tf.cond(train_phase, lambda: bn_train, lambda: bn_inference) return bn
def _build_generator(input_data, name='generator'): with tf.variable_scope(name): net = layers.dense(input_data, 128) net = tf.nn.relu(net) net = tf.reshape(net, [-1, 4, 4, 8]) net = layers.conv2d_transpose(net, 128, [5, 5], activation=tf.nn.relu, strides=[2, 2], padding='same') # 8x8 net = layers.batch_normalization(net, momentum=0.9, training=True) net = layers.conv2d_transpose(net, 64, [5, 5], activation=tf.nn.relu, strides=[2, 2]) # 19x19 net = layers.batch_normalization(net, momentum=0.9, training=True) net = layers.conv2d_transpose(net, 32, [5, 5], activation=tf.nn.relu) # 23x23 net = layers.batch_normalization(net, momentum=0.9, training=True) net = layers.conv2d_transpose(net, 16, [5, 5], activation=tf.nn.relu) # 27x27 net = layers.batch_normalization(net, momentum=0.9, training=True) net = layers.conv2d_transpose(net, 1, [2, 2], activation=tf.nn.relu) # 28x28 return net