def __init__(self, n_filter, in_channels, strides=(1, 1), is_down_sample=False, data_format="channels_first"): super().__init__() self.data_format = data_format self.is_down_sample = is_down_sample self.main_block = LayerList([ Conv2d(n_filter=n_filter, in_channels=in_channels, filter_size=(3, 3), strides=strides, b_init=None, data_format=self.data_format), BatchNorm2d(decay=0.9, act=tf.nn.relu, is_train=True, num_features=n_filter, data_format=self.data_format), Conv2d(n_filter=n_filter, in_channels=n_filter, filter_size=(3, 3), strides=(1, 1), b_init=None, data_format=self.data_format), BatchNorm2d(decay=0.9, is_train=True, num_features=n_filter, data_format=self.data_format), ]) if (self.is_down_sample): self.down_sample = LayerList([ Conv2d(n_filter=n_filter, in_channels=in_channels, filter_size=(3, 3), strides=strides, b_init=None, data_format=self.data_format), BatchNorm2d(decay=0.9, is_train=True, num_features=n_filter, data_format=self.data_format) ])
def build_generator(image_size=128, gf_dim=64): s16 = image_size // 16 w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ni = Input([None, Z_DIM]) nn = Dense(n_units=(gf_dim * 8 * s16 * s16), W_init=w_init, b_init=None)(ni) nn = Reshape(shape=[-1, s16, s16, gf_dim*8])(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = DeConv2d(gf_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(gf_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(gf_dim, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(3, (5, 5), (2, 2), act=tf.nn.tanh, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn)
def get_discriminator(shape, df_dim=64): # Dimension of discrim filters in first conv layer. [64] # w_init = tf.glorot_normal_initializer() w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x : tf.nn.leaky_relu(x, 0.2) ni = Input(shape) nn = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(ni) nn = Conv2d(df_dim*2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(df_dim*4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(df_dim*8, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Flatten()(nn) nn = Dense(n_units=1, act=tf.identity, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn, name='discriminator')
def get_G(shape): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ni = Input(shape) nn = Dense(n_units=(1024), W_init=w_init, b_init=None)(ni) nn = Reshape(shape=[-1, 1024])(nn) nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = Dense(n_units=(8 * 8 * 256), W_init=w_init, b_init=None)(nn) nn = Reshape(shape=[-1, 8, 8, 256])(nn) # ??? nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = DeConv2d(n_filter=256, filter_size=(4, 4), strides=(1, 1), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(n_filter=256, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(n_filter=128, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(n_filter=64, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(n_filter=1, filter_size=(4, 4), strides=(1, 1), act=tf.nn.sigmoid, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn, name='G')
def get_G(input_shape): w_init = tf.random_normal_initializer(stddev=0.02) g_init = tf.random_normal_initializer(1., 0.02) nin = Input(input_shape) n = Conv2d(64, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=w_init)(nin) temp = n # B residual blocks for i in range(16): nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) nn = BatchNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn) nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(gamma_init=g_init)(nn) nn = Elementwise(tf.add)([n, nn]) n = nn n = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm(gamma_init=g_init)(n) n = Elementwise(tf.add)([n, temp]) # B residual blacks end n = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(n) n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n) n = Conv2d(256, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init)(n) n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n) nn = Conv2d(3, (1, 1), (1, 1), act=tf.nn.tanh, padding='SAME', W_init=w_init)(n) G = Model(inputs=nin, outputs=nn, name="generator") return G
def __init__(self, n_filter=512, in_channels=3, data_format="channels_first"): super().__init__() self.data_format = data_format self.out_channels = n_filter self.conv1 = Conv2d(n_filter=64, in_channels=in_channels, filter_size=(7, 7), strides=(2, 2), b_init=None, data_format=self.data_format) self.bn1 = BatchNorm2d(decay=0.9, act=tf.nn.relu, is_train=True, num_features=64, data_format=self.data_format) self.maxpool = MaxPool2d(filter_size=(3, 3), strides=(2, 2), data_format=self.data_format) self.res_block_2_1 = self.Res_block(n_filter=64, in_channels=64, strides=(1, 1), is_down_sample=False, data_format=self.data_format) self.res_block_2_2 = self.Res_block(n_filter=64, in_channels=64, strides=(1, 1), is_down_sample=False, data_format=self.data_format) self.res_block_3_1 = self.Res_block(n_filter=128, in_channels=64, strides=(2, 2), is_down_sample=True, data_format=self.data_format) self.res_block_3_2 = self.Res_block(n_filter=128, in_channels=128, strides=(1, 1), is_down_sample=False, data_format=self.data_format) self.res_block_4_1 = self.Res_block(n_filter=256, in_channels=128, strides=(2, 2), is_down_sample=True, data_format=self.data_format) self.res_block_4_2 = self.Res_block(n_filter=256, in_channels=256, strides=(1, 1), is_down_sample=False, data_format=self.data_format) self.res_block_5_1 = self.Res_block(n_filter=n_filter, in_channels=256, strides=(2, 2), is_down_sample=True, data_format=self.data_format)
def get_D(shape): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) def lrelu(x): return tf.nn.leaky_relu(x, flags.leaky_rate) ni = Input(shape) nn = Conv2d(n_filter=64, filter_size=(4, 4), strides=(2, 2), act=lrelu, W_init=w_init)(ni) nn = Conv2d(n_filter=128, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(n_filter=256, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(n_filter=256, filter_size=(4, 4), strides=(1, 1), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(n_filter=256, filter_size=(4, 4), strides=(1, 1), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Flatten()(nn) nn = Dense(n_units=1024, W_init=w_init)(nn) nn = BatchNorm(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) mid = nn d = Dense(n_units=1, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=[d, mid], name='D')
def get_generator( shape, gf_dim=64, o_size=32, o_channel=3): # Dimension of gen filters in first conv layer. [64] image_size = o_size s4 = image_size // 4 lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) ni = Input(shape) nn = Dense(n_units=(gf_dim * 4 * s4 * s4))(ni) nn = Reshape(shape=(-1, s4, s4, gf_dim * 4))(nn) nn = BatchNorm2d(decay=0.9, act=lrelu)(nn) nn = DeConv2d(gf_dim * 2, (5, 5), (1, 1))(nn) nn = BatchNorm2d(decay=0.9, act=lrelu)(nn) nn = DeConv2d(gf_dim, (5, 5), (2, 2))(nn) nn = BatchNorm2d(decay=0.9, act=lrelu)(nn) nn = DeConv2d(o_channel, (5, 5), (2, 2), act=tf.nn.tanh)(nn) return tl.models.Model(inputs=ni, outputs=nn, name='generator')
def get_generator(shape, gf_dim=64): # Dimension of gen filters in first conv layer. [64] image_size = 64 s16 = image_size // 16 # w_init = tf.glorot_normal_initializer() w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ni = Input(shape) nn = Dense(n_units=(gf_dim * 8 * s16 * s16), W_init=w_init, b_init=None)(ni) nn = Reshape(shape=[-1, s16, s16, gf_dim*8])(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = DeConv2d(gf_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d( decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(gf_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(gf_dim, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(3, (5, 5), (2, 2), act=tf.nn.tanh, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn, name='generator')
def get_E(shape): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) ni = Input(shape) # (1, 64, 64, 3) n = Conv2d(3, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(ni) # (1, 16, 16, 3) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(32, (5, 5), (1, 1), padding="VALID", act=None, W_init=w_init, b_init=None)(n) # (1, 12, 12, 32) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(64, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(n) # (1, 6, 6, 64) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Flatten(name='flatten')(n) nz = Dense(n_units=flags.z_dim, act=None, W_init=w_init)(n) return tl.models.Model(inputs=ni, outputs=nz, name='encoder')
def get_discriminator(shape=[None, flags.output_size, flags.output_size, flags.c_dim] \ , df_dim=64, name=None): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) ni = Input(shape) nn = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(ni) nn = Conv2d(df_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(df_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(df_dim * 8, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Flatten()(nn) nn = Dense(n_units=1, act=tf.identity, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn, name=name)
def get_G_cifar_10( shape_z): # Dimension of gen filters in first conv layer. [64] # input: (flags.z_dim,) w_init = tf.random_normal_initializer(stddev=0.02) ni = Input(shape_z) n = Dense(n_units=128 * 4 * 4, act=tf.nn.relu, W_init=w_init)(ni) # res blocks nn = Conv2d(128, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(n) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=g_init)(nn) nn = Conv2d(128, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=None, gamma_init=g_init)(nn) n = Elementwise(tf.add)([n, nn]) # res blocks nn = Conv2d(128, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(n) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=g_init)(nn) nn = Conv2d(128, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=None, gamma_init=g_init)(nn) n = Elementwise(tf.add)([n, nn]) # res blocks nn = Conv2d(128, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(n) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=g_init)(nn) nn = Conv2d(128, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=None, gamma_init=g_init)(nn) n = Elementwise(tf.add)([n, nn]) n = Conv2d(3, (3, 3), (1, 1), act=tf.nn.relu, W_init=w_init)(n) return tl.models.Model(inputs=nz, outputs=n, name='generator_CIFAR10')
def generator_I(shape, nc=3, ngf=64, nz=60): ni = Input(shape) nn = DeConv2d(in_channels=nz, n_filter=ngf * 8, filter_size=(6, 6), strides=(1, 1), padding='VALID', b_init=None)(ni) nn = BatchNorm2d(num_features=ngf * 8, act=tf.nn.relu)(nn) nn = DeConv2d(in_channels=ngf * 8, n_filter=ngf * 4, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None)(nn) nn = BatchNorm2d(num_features=ngf * 4, act=tf.nn.relu)(nn) nn = DeConv2d(in_channels=ngf * 4, n_filter=ngf * 2, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None)(nn) nn = BatchNorm2d(num_features=ngf * 2, act=tf.nn.relu)(nn) nn = DeConv2d(in_channels=ngf * 2, n_filter=ngf, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None)(nn) nn = BatchNorm2d(num_features=ngf, act=tf.nn.relu)(nn) out = DeConv2d(in_channels=ngf, n_filter=nc, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None, act=tf.nn.tanh)(nn) return Model(inputs=ni, outputs=out, name='generator_I')
def get_G_cmnist( shape_z): # Dimension of gen filters in first conv layer. [64] # input: (100,) w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) nz = Input(shape_z) n = Dense(n_units=3136, act=tf.nn.relu, W_init=w_init)(nz) n = Reshape(shape=[-1, 14, 14, 16])(n) n = DeConv2d(64, (5, 5), strides=(2, 2), W_init=w_init, b_init=None)(n) # (1, 28, 28, 64) n = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n) n = DeConv2d(32, (5, 5), strides=(1, 1), padding="VALID", W_init=w_init, b_init=None)(n) # (1, 32, 32, 32) n = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n) n = DeConv2d(flags.c_dim, (5, 5), strides=(2, 2), act=tf.nn.tanh, W_init=w_init)(n) # (1, 64, 64, 3) return tl.models.Model(inputs=nz, outputs=n, name='generator_CMNIST')
def get_G(shape_z, gf_dim=64): # Dimension of gen filters in first conv layer. [64] # # input: (100,) # w_init = tf.random_normal_initializer(stddev=0.02) # gamma_init = tf.random_normal_initializer(1., 0.02) # nz = Input(shape_z) # n = Dense(n_units=3136, act=tf.nn.relu, W_init=w_init)(nz) # n = Reshape(shape=[-1, 14, 14, 16])(n) # n = DeConv2d(64, (5, 5), strides=(2, 2), W_init=w_init, b_init=None)(n) # (1, 28, 28, 64) # n = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n) # n = DeConv2d(flags.c_dim, (5, 5), strides=(1, 1), padding="VALID", W_init=w_init, b_init=None)(n) # (1, 32, 32, 3) # return tl.models.Model(inputs=nz, outputs=n, name='generator') image_size = 32 s16 = image_size // 16 # w_init = tf.glorot_normal_initializer() w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ni = Input(shape_z) nn = Dense(n_units=(gf_dim * 8 * s16 * s16), W_init=w_init, b_init=None)(ni) nn = Reshape(shape=[-1, s16, s16, gf_dim * 8])( nn) # [-1, 2, 2, gf_dim * 8] nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = DeConv2d(gf_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) # [-1, 4, 4, gf_dim * 4] nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(gf_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) # [-1, 8, 8, gf_dim * 2] nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(gf_dim, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) # [-1, 16, 16, gf_dim *] nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(3, (5, 5), (2, 2), act=tf.nn.tanh, W_init=w_init)(nn) # [-1, 32, 32, 3] return tl.models.Model(inputs=ni, outputs=nn, name='generator')
def __init__(self, nc=3, ndf=64): super(discriminator_I, self).__init__() self.conv1 = Conv2d(in_channels=nc, n_filter=ndf, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None, act=tf.nn.leaky_relu) self.conv2 = Conv2d(in_channels=ndf, n_filter=ndf * 2, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None) self.batch1 = BatchNorm2d(num_features=ndf * 2, act=tf.nn.leaky_relu) self.conv3 = Conv2d(in_channels=ndf * 2, n_filter=ndf * 4, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None) self.batch2 = BatchNorm2d(num_features=ndf * 4, act=tf.nn.leaky_relu) self.conv4 = Conv2d(in_channels=ndf * 4, n_filter=ndf * 8, filter_size=(4, 4), strides=(2, 2), padding='SAME', b_init=None) self.batch3 = BatchNorm2d(num_features=ndf * 8, act=tf.nn.leaky_relu) self.conv5 = Conv2d(in_channels=ndf * 8, n_filter=1, filter_size=(6, 6), strides=(1, 1), padding='VALID', b_init=None, act=tf.nn.sigmoid)
def dw_conv_block(n_filter, in_channels, filter_size=(3, 3), strides=(1, 1), dilation_rate=(1, 1), W_init=initializer, b_init=initializer, data_format="channels_first"): layer_list = [] layer_list.append( DepthwiseConv2d(filter_size=filter_size, strides=strides, in_channels=in_channels, dilation_rate=dilation_rate, W_init=initializer, b_init=None, data_format=data_format)) layer_list.append( BatchNorm2d(decay=0.99, act=tf.nn.relu, num_features=in_channels, data_format=data_format, is_train=True)) layer_list.append( Conv2d(n_filter=n_filter, filter_size=(1, 1), strides=(1, 1), in_channels=in_channels, W_init=initializer, b_init=None, data_format=data_format)) layer_list.append( BatchNorm2d(decay=0.99, act=tf.nn.relu, num_features=n_filter, data_format=data_format, is_train=True)) return layers.LayerList(layer_list)
def __init__(self,parts=CocoPart,limbs=CocoLimb,colors=None,K_size=18,L_size=17,win=384,hin=384,wout=12,hout=12,wnei=9,hnei=9\ ,lmd_rsp=0.25,lmd_iou=1,lmd_coor=5,lmd_size=5,lmd_limb=0.5,backbone=None,data_format="channels_first"): super().__init__() #construct params self.parts=parts self.limbs=limbs self.colors=colors self.K=K_size self.L=L_size self.win=win self.hin=hin self.wout=wout self.hout=hout self.hnei=hnei self.wnei=wnei self.n_pos=K_size self.lmd_rsp=lmd_rsp self.lmd_iou=lmd_iou self.lmd_coor=lmd_coor self.lmd_size=lmd_size self.lmd_limb=lmd_limb self.data_format=data_format self.output_dim=6*self.K+self.hnei*self.wnei*self.L #construct networks if(backbone==None): self.backbone=self.Resnet_18(n_filter=512,in_channels=3,data_format=data_format) else: self.backbone=backbone(scale_size=32,data_format=self.data_format) self.add_layer_1=LayerList([ Conv2d(n_filter=512,in_channels=self.backbone.out_channels,filter_size=(3,3),strides=(1,1),data_format=self.data_format), BatchNorm2d(decay=0.9,act=lambda x:tl.act.leaky_relu(x,alpha=0.1),is_train=True,num_features=512,data_format=self.data_format) ]) self.add_layer_2=LayerList([ Conv2d(n_filter=512,in_channels=512,filter_size=(3,3),strides=(1,1),data_format=self.data_format), BatchNorm2d(decay=0.9,act=lambda x:tl.act.leaky_relu(x,alpha=0.1),is_train=True,num_features=512,data_format=self.data_format) ]) self.add_layer_3=Conv2d(n_filter=self.output_dim,in_channels=512,filter_size=(1,1),strides=(1,1),data_format=self.data_format)
def __init__(self, in_channels=64, n_filter=64, strides=(1, 1), data_format="channels_first"): super().__init__() self.in_channels = in_channels self.n_filter = n_filter self.strides = strides self.data_format = data_format self.downsample = None if (self.strides != (1, 1) or self.in_channels != self.n_filter): self.downsample=LayerList([ Conv2d(n_filter=self.n_filter,in_channels=self.in_channels,filter_size=(1,1),strides=self.strides,b_init=None,\ data_format=self.data_format), BatchNorm2d(is_train=True,num_features=self.n_filter,data_format=self.data_format) ]) self.main_block = LayerList([ Conv2d(n_filter=self.n_filter, in_channels=self.in_channels, filter_size=(3, 3), strides=self.strides, b_init=None, data_format=self.data_format), BatchNorm2d(is_train=True, num_features=self.n_filter, act=tf.nn.relu, data_format=self.data_format), Conv2d(n_filter=self.n_filter, in_channels=self.n_filter, filter_size=(3, 3), b_init=None, data_format=self.data_format), BatchNorm2d(is_train=True, num_features=self.n_filter, data_format=self.data_format) ])
def conv_block(self, n_filter=32, in_channels=3, filter_size=(3, 3), strides=(1, 1), padding="SAME"): layer_list = [] layer_list.append(Conv2d(n_filter=n_filter,in_channels=in_channels,filter_size=filter_size,strides=strides,\ data_format=self.data_format,padding=padding)) layer_list.append( BatchNorm2d(num_features=n_filter, is_train=True, act=tf.nn.relu, data_format=self.data_format)) return LayerList(layer_list)
def get_D(input_shape): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) df_dim = 8 lrelu = lambda x: tl.act.lrelu(x, 0.2) nin = Input(input_shape) n = Conv2d(df_dim, (4, 4), (2, 2), act=lrelu, padding='SAME', W_init=w_init)(nin) n = Conv2d(df_dim * 2, (4, 4), (2, 2), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 4, (4, 4), (2, 2), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 8, (4, 4), (2, 2), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 16, (4, 4), (2, 2), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 32, (4, 4), (2, 2), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 16, (1, 1), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 8, (1, 1), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) nn = BatchNorm2d(gamma_init=gamma_init)(n) n = Conv2d(df_dim * 2, (1, 1), (1, 1), padding='SAME', W_init=w_init, b_init=None)(nn) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 2, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 8, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(gamma_init=gamma_init)(n) n = Elementwise(combine_fn=tf.add, act=lrelu)([n, nn]) n = Flatten()(n) no = Dense(n_units=1, W_init=w_init)(n) D = Model(inputs=nin, outputs=no) return D
def convolutional(input_layer, filters_shape, downsample=False, activate=True, bn=True, activate_type='leaky', name=None): if downsample: input_layer = ZeroPad2d(((1, 0), (1, 0)))(input_layer) padding = 'VALID' strides = 2 else: strides = 1 padding = 'SAME' if bn: b_init = None else: b_init = tl.initializers.constant(value=0.0) conv = Conv2d(n_filter=filters_shape[-1], filter_size=(filters_shape[0], filters_shape[1]), strides=(strides, strides), padding=padding, b_init=b_init, name=name)(input_layer) if bn: if activate == True: if activate_type == 'leaky': conv = BatchNorm2d(act='lrelu0.1')(conv) elif activate_type == 'mish': conv = BatchNorm2d(act=mish)(conv) else: conv = BatchNorm2d()(conv) return conv
def __init__(self): super(get_G,self).__init__() w_init = tf.random_normal_initializer(stddev=0.02) g_init = tf.random_normal_initializer(1., 0.02) self.conv1 = Conv2d(n_filter=64,filter_size=(3, 3),strides=(1, 1),in_channels=3, act=tf.nn.relu, padding='SAME', W_init=w_init,b_init=None) self.res = [0]*16 for i in range(16): self.res[i] = ResBlock() self.conv2 = Conv2d(n_filter=64,filter_size=(3, 3),strides=(1, 1),in_channels=64, padding='SAME', W_init=w_init,b_init=None) self.bn1 = BatchNorm2d(num_features = 64,gamma_init=g_init, act=tf.nn.relu) self.conv3 = Conv2d(n_filter=256,filter_size=(3, 3),strides=(1, 1),in_channels=64, padding='SAME', W_init=w_init,b_init=None) self.conv4 = Conv2d(n_filter=256,filter_size=(3, 3),strides=(1, 1),in_channels=64, padding='SAME', W_init=w_init,b_init=None) self.conv5 = Conv2d(n_filter=3,filter_size=(3, 3),strides=(1, 1),in_channels=64, act=tf.nn.tanh, padding='SAME', W_init=w_init,b_init=None) self.subconv1 = SubpixelConv2d(scale=2, n_out_channels=256,in_channels=256, act=tf.nn.relu) self.add1 = Elementwise(tf.add)
def get_G(input_shape): """Get a Generator model with randomly inizialized weights. Args: input_shape : tuple Input shape of the Input layer of the model. """ w_init = tf.random_normal_initializer(stddev=0.02) g_init = tf.random_normal_initializer(1., 0.02) nin = Input(input_shape) n = Conv2d(64, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=w_init)(nin) temp = n def get_G_res_block(n, w_init, g_init): nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) nn = BatchNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn) nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(gamma_init=g_init)(nn) nn = Elementwise(tf.add)([n, nn]) return nn def get_conv_block(n, w_init): n = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(n) n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n) return n # B residual blocks for _ in range(16): n = get_G_res_block(n, w_init, g_init) n = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) n = BatchNorm2d(gamma_init=g_init)(n) n = Elementwise(tf.add)([n, temp]) # B residual blacks end for _ in range(2): n = get_conv_block(n, w_init) nn = Conv2d(3, (1, 1), (1, 1), act=tf.nn.tanh, padding='SAME', W_init=w_init)(n) G = Model(inputs=nin, outputs=nn) # , name="generator" return G
def separable_block(n_filter=32, in_channels=3, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding="SAME", data_format="channels_first"): layer_list = [] layer_list.append(SeparableConv2d(n_filter=n_filter,in_channels=in_channels,filter_size=filter_size,strides=strides,act=act,\ data_format=data_format,padding=padding)) layer_list.append( BatchNorm2d(num_features=n_filter, decay=0.999, is_train=True, act=act, data_format=data_format)) return LayerList(layer_list)
def __init__(self, in_channels=3, n_filter=64, scale_size=8, data_format="channels_first"): super().__init__() self.in_channels = in_channels self.n_filter = n_filter self.scale_size = scale_size self.data_format = data_format self.out_channels = 2048 self.conv1 = Conv2d(n_filter=64, in_channels=self.in_channels, filter_size=(7, 7), strides=(2, 2), padding="SAME", b_init=None, data_format=self.data_format) self.bn1 = BatchNorm2d(is_train=True, num_features=64, data_format=self.data_format, act=tf.nn.relu) self.maxpool1 = MaxPool2d(filter_size=(3, 3), strides=(2, 2), data_format=self.data_format) self.layer1 = self.Basic_block(in_channels=64, n_filter=64, strides=(1, 1), data_format=self.data_format) self.layer2 = self.Basic_block(in_channels=256, n_filter=128, strides=(2, 2), data_format=self.data_format) if (self.scale_size == 8): strides = (1, 1) else: strides = (2, 2) self.layer3 = self.Basic_block(in_channels=512, n_filter=256, strides=strides, data_format=self.data_format) self.layer4 = self.Basic_block(in_channels=1024, n_filter=512, strides=strides, data_format=self.data_format)
def get_generator(shape,gf_dim=64): image_size=256 s16=image_size//16 w_init=tf.random_normal_initializer(stddev=0.02) gamma_init=tf.random_normal_initializer(1.,0.02) ni=Input(shape) nn=Dense(n_units=(gf_dim*16*s16*s16),W_init=w_init,b_init=None)(ni) nn=Reshape(shape=[-1,s16,s16,gf_dim*16])(nn) n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=DeConv2d(gf_dim*16,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+nn n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=DeConv2d(gf_dim*8,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+nn n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=DeConv2d(gf_dim*8,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+nn n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=DeConv2d(gf_dim*4,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+nn n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=DeConv2d(gf_dim*2,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+nn #non local block maybe bugs here f=Conv2d(gf_dim//4,(1,1),(1,1),W_init=w_init,b_init=None)(nn) f=MaxPool2d((2,2),(2,2))(f) g=Conv2d(gf_dim//4,(1,1),(1,1),W_init=w_init,b_init=None)(nn) h=Conv2d(gf_dim,(1,1),(1,1),W_init=w_init,b_init=None)(nn) h=MaxPool2d((2,2),(2,2))(h) s = tf.matmul(Reshape(shape=[g.shape[0],-1,g.shape[1]])(g), Reshape(shape=[f.shape[0],-1,f.shape[1]])(f), transpose_b=True) beta=tf.nn.softmax(s) o=tf.matmul(beta,Reshape(shape=[h.shape[0],-1,h.shape[1]])(h)) o=Reshape(shape=[nn.shape[0],nn.shape[1],nn.shape[2],gf_dim])(o) o=Conv2d(gf_dim*2,(1,1),(1,1),W_init=w_init,b_init=None)(o) nn=nn+gamma_init*o # n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=DeConv2d(gf_dim,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+nn nn=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) nn=Conv2d(3, (3, 3), (1, 1), act=tf.nn.tanh, W_init=w_init)(nn) return tl.models.Model(inputs=ni,outputs=nn,name='generator')
def get_discriminator(shape,df_dim=64): w_init=tf.random_normal_initializer(stddev=0.02) gamma_init=tf.random_normal_initializer(1.,0.02) ni=Input(shape) n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(ni) n1=Conv2d(df_dim,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=n1+ni n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=Conv2d(df_dim*2,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=nn+n1; f=Conv2d(df_dim//4,(1,1),(1,1),W_init=w_init,b_init=None)(nn) f=MaxPool2d((2,2),(2,2))(f) g=Conv2d(df_dim//4,(1,1),(1,1),W_init=w_init,b_init=None)(nn) h=Conv2d(df_dim,(1,1),(1,1),W_init=w_init,b_init=None)(nn) h=MaxPool2d((2,2),(2,2))(h) s = tf.matmul(Reshape(shape=[g.shape[0],-1,g.shape[1]])(g), Reshape(shape=[f.shape[0],-1,f.shape[1]])(f), transpose_b=True) beta=tf.nn.softmax(s) o=tf.matmul(beta,Reshape(shape=[h.shape[0],-1,h.shape[1]])(h)) o=Reshape(shape=[nn.shape[0],nn.shape[1],nn.shape[2],gf_dim])(o) o=Conv2d(df_dim*2,(1,1),(1,1),W_init=w_init,b_init=None)(o) nn=nn+gamma_init*o n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=Conv2d(df_dim*4,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=nn+n1; n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=Conv2d(df_dim*8,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=nn+n1; n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=Conv2d(df_dim*8,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=nn+n1; n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(nn) n1=Conv2d(df_dim*16,(5,5),(2,2),W_init=w_init,b_init=None)(n1); nn=nn+n1; n1=Conv2d(df_dim*16,(5,5),(2,2),W_init=w_init,b_init=None)(nn); n1=BatchNorm2d(decay=0.9,act=tf.nn.relu,gamma_init=gamma_init,name=None)(n1) nn=nn+n1; nn=tf.reduce_sum(nn,axis=[1,2]) nn=Dense(n_units=1,W_init=w_init,act=tf.identity)(nn) return tl.models.Model(inputs=ni,outputs=nn,name='discriminator')
def unet(ni, out_channel, is_tanh, out_size=flags.img_size_h): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ngf = 64 conv1 = Conv2d(ngf, (3, 3), (1, 1), W_init=w_init, act=lrelu)(ni) conv2 = Conv2d(ngf, (4, 4), (2, 2), W_init=w_init, act=None, b_init=None)(conv1) conv2 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(conv2) conv3 = Conv2d(ngf * 2, (4, 4), (1, 1), W_init=w_init, act=None, b_init=None)(conv2) conv3 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(conv3) conv4 = Conv2d(ngf * 2, (4, 4), (2, 2), W_init=w_init, act=None, b_init=None)(conv3) conv4 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(conv4) conv5 = Conv2d(ngf * 4, (4, 4), (1, 1), W_init=w_init, act=None, b_init=None)(conv4) conv5 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(conv5) conv6 = Conv2d(ngf * 4, (4, 4), (2, 2), W_init=w_init, act=None, b_init=None)(conv5) conv6 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(conv6) conv7 = Conv2d(ngf * 8, (4, 4), (1, 1), W_init=w_init, act=None, b_init=None)(conv6) conv7 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(conv7) conv8 = Conv2d(ngf * 8, (4, 4), (2, 2), act=lrelu, W_init=w_init, b_init=None)(conv7) # 8 8 512 now start upsample c_size = conv8.shape[-2] ############################################################################################## no = None for _ in range(1): up8 = DeConv2d(ngf * 8, (4, 4), (2, 2), W_init=w_init, b_init=None)(conv8) up8 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up8) up7 = Concat(concat_dim=3)([up8, conv7]) up7 = DeConv2d(ngf * 8, (4, 4), (1, 1), W_init=w_init, b_init=None)(up7) up7 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up7) c_size = c_size * 2 if c_size == out_size: no = up7 break up6 = Concat(concat_dim=3)([up7, conv6]) up6 = DeConv2d(ngf * 4, (4, 4), (2, 2), W_init=w_init, b_init=None)(up6) up6 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up6) up5 = Concat(concat_dim=3)([up6, conv5]) up5 = DeConv2d(ngf * 4, (4, 4), (1, 1), W_init=w_init, b_init=None)(up5) up5 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up5) c_size = c_size * 2 if c_size == out_size: no = up5 break up4 = Concat(concat_dim=3)([up5, conv4]) up4 = DeConv2d(ngf * 2, (4, 4), (2, 2), W_init=w_init, b_init=None)(up4) up4 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up4) up3 = Concat(concat_dim=3)([up4, conv3]) up3 = DeConv2d(ngf * 2, (4, 4), (1, 1), W_init=w_init, b_init=None)(up3) up3 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up3) c_size = c_size * 2 if c_size == out_size: no = up3 break up2 = Concat(concat_dim=3)([up3, conv2]) up2 = DeConv2d(ngf * 1, (4, 4), (2, 2), W_init=w_init, b_init=None)(up2) up2 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up2) up1 = Concat(concat_dim=3)([up2, conv1]) up1 = DeConv2d(ngf * 1, (4, 4), (1, 1), W_init=w_init, b_init=None)(up1) up1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init, name=None)(up1) c_size = c_size * 2 if c_size == out_size: no = up1 break if is_tanh: up0 = DeConv2d(out_channel, (3, 3), (1, 1), W_init=w_init, act=tf.nn.tanh)(no) else: up0 = DeConv2d(out_channel, (3, 3), (1, 1), W_init=w_init, b_init=None, act=None)(no) return up0
def __init__(self, scale_size=8, data_format="channels_last"): super().__init__() self.data_format = data_format self.scale_size = scale_size self.out_channels = 320 if (self.scale_size == 8): strides = (1, 1) else: strides = (2, 2) #block_1 n=1 self.block_1_1 = Conv2d(n_filter=32, in_channels=3, filter_size=(3, 3), strides=(2, 2), data_format=self.data_format) self.block_1_2 = BatchNorm2d(num_features=32, is_train=True, act=tf.nn.relu6, data_format=self.data_format) #block_2 n=1 self.block_2_1 = self.InvertedResidual(n_filter=16, in_channels=32, strides=(1, 1), exp_ratio=1, data_format=self.data_format) #block_3 n=2 self.block_3_1 = self.InvertedResidual(n_filter=24, in_channels=16, strides=(2, 2), exp_ratio=6, data_format=self.data_format) self.block_3_2 = self.InvertedResidual(n_filter=24, in_channels=24, strides=(1, 1), exp_ratio=6, data_format=self.data_format) #block_4 n=3 self.block_4_1 = self.InvertedResidual(n_filter=32, in_channels=24, strides=(2, 2), exp_ratio=6, data_format=self.data_format) self.block_4_2 = self.InvertedResidual(n_filter=32, in_channels=32, strides=(1, 1), exp_ratio=6, data_format=self.data_format) self.block_4_3 = self.InvertedResidual(n_filter=32, in_channels=32, strides=(1, 1), exp_ratio=6, data_format=self.data_format) #block_5 n=4 self.block_5_1 = self.InvertedResidual(n_filter=64, in_channels=32, strides=(1, 1), exp_ratio=6, data_format=self.data_format) self.block_5_2 = self.InvertedResidual(n_filter=64, in_channels=64, strides=(1, 1), exp_ratio=6, data_format=self.data_format) self.block_5_3 = self.InvertedResidual(n_filter=64, in_channels=64, strides=(1, 1), exp_ratio=6, data_format=self.data_format) self.block_5_4 = self.InvertedResidual(n_filter=64, in_channels=64, strides=(1, 1), exp_ratio=6, data_format=self.data_format) #block_6 n=3 self.block_6_1 = self.InvertedResidual(n_filter=96, in_channels=64, strides=strides, exp_ratio=6, data_format=self.data_format) self.block_6_2 = self.InvertedResidual(n_filter=96, in_channels=96, strides=(1, 1), exp_ratio=6, data_format=self.data_format) self.block_6_3 = self.InvertedResidual(n_filter=96, in_channels=96, strides=(1, 1), exp_ratio=6, data_format=self.data_format) #block_7 n=3 self.block_7_1 = self.InvertedResidual(n_filter=160, in_channels=96, strides=strides, exp_ratio=6, data_format=self.data_format) self.block_7_2 = self.InvertedResidual(n_filter=160, in_channels=160, strides=(1, 1), exp_ratio=6, data_format=self.data_format) self.block_7_3 = self.InvertedResidual(n_filter=160, in_channels=160, strides=(1, 1), exp_ratio=6, data_format=self.data_format) #block_8 n=1 self.block_8 = self.InvertedResidual(n_filter=320, in_channels=160, strides=(1, 1), exp_ratio=6, data_format=self.data_format)