def get_discriminator(latent_shape, image_shape, df_dim=64): 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) n1i = Input(image_shape) n1 = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(n1i) n1 = Conv2d(df_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1) n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1) n1 = Dropout(keep=0.8)(n1) n1 = Conv2d(df_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1) n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1) n1 = Dropout(keep=0.8)(n1) n1 = Conv2d(df_dim * 8, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1) n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1) n1 = Dropout(keep=0.8)(n1) n1 = Flatten()(n1) # [-1,4*4*df_dim*8] n2i = Input(latent_shape) n2 = Dense(n_units=4 * 4 * df_dim * 8, W_init=w_init, b_init=None)(n2i) n2 = Dropout(keep=0.8)(n2) nn = Concat()([n1, n2]) nn = Dense(n_units=1, W_init=w_init, b_init=None)(nn) return tl.models.Model(inputs=[n1i, n2i], outputs=nn, name='discriminator')
def hidden_model(inputs_shape): ni = Input(inputs_shape) nn = Dropout(keep=0.8)(ni) nn = Dense(n_units=800, act=tf.nn.relu)(nn) nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=800, act=tf.nn.relu)(nn) return Model(inputs=ni, outputs=nn, name="mlp_hidden")
def __init__(self): super(CustomModel, self).__init__() self.dropout1 = Dropout(keep=0.8) #(self.innet) self.dense1 = Dense(n_units=800, act=tf.nn.relu, in_channels=784) #(self.dropout1) self.dropout2 = Dropout(keep=0.8) #(self.dense1) self.dense2 = Dense(n_units=800, act=tf.nn.relu, in_channels=800) #(self.dropout2) self.dropout3 = Dropout(keep=0.8) #(self.dense2) self.dense3 = Dense(n_units=10, act=tf.nn.relu, in_channels=800) #(self.dropout3)
def __init__(self): super(CustomModelHidden, self).__init__() self.dropout1 = Dropout(keep=0.8) #(self.innet) self.seq = LayerList([ Dense(n_units=800, act=tf.nn.relu, in_channels=784), Dropout(keep=0.8), Dense(n_units=800, act=tf.nn.relu, in_channels=800), ]) self.dropout3 = Dropout(keep=0.8) #(self.seq)
def get_model(inputs_shape): ni = Input(inputs_shape) nn = Dropout(keep=0.8)(ni) nn = Dense(n_units=800, act=tf.nn.relu)(nn) nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=800, act=tf.nn.relu)(nn) nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=10, act=tf.nn.relu)(nn) M = Model(inputs=ni, outputs=nn, name="mlp") return M
def create_base_network(input_shape): '''Base network to be shared (eq. to feature extraction). ''' input = Input(shape=input_shape) x = Flatten()(input) x = Dense(128, act=tf.nn.relu)(x) x = Dropout(0.9)(x) x = Dense(128, act=tf.nn.relu)(x) x = Dropout(0.9)(x) x = Dense(128, act=tf.nn.relu)(x) return Model(input, x)
def get_model(inputs_shape): ni = Input(inputs_shape) nn = Dropout(keep=0.8)(ni) nn = Dense(n_units=800, act=tf.nn.relu)(nn) nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=800, act=tf.nn.relu)(nn) # FIXME: currently assume the inputs and outputs are both Layer. They can be lists. M_hidden = Model(inputs=ni, outputs=nn, name="mlp_hidden") nn = Dropout(keep=0.8)(M_hidden.as_layer()) nn = Dense(n_units=10, act=tf.nn.relu)(nn) return Model(inputs=ni, outputs=nn, name="mlp")
def get_model(inputs_shape): ni = Input(inputs_shape) nn = Dropout(keep=0.8)(ni) nn = Dense(n_units=800, act=tf.nn.relu, in_channels=784)( nn ) # in_channels is optional in this case as it can be inferred by the previous layer nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=800, act=tf.nn.relu, in_channels=800)( nn ) # in_channels is optional in this case as it can be inferred by the previous layer nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=10, act=tf.nn.relu, in_channels=800)( nn ) # in_channels is optional in this case as it can be inferred by the previous layer M = Model(inputs=ni, outputs=nn, name="mlp") return M
def get_model(inputs_shape, hmodel): hidden = hmodel.as_layer() ni = Input(inputs_shape) nn = hidden(ni) nn = Dropout(keep=0.8)(nn) nn = Dense(n_units=10, act=tf.nn.relu)(nn) return Model(inputs=ni, outputs=nn, name="mlp")
def SqueezeNetV1(pretrained=False, end_with='out', name=None): """Pre-trained SqueezeNetV1 model (static mode). Input shape [?, 224, 224, 3], value range [0, 1]. Parameters ------------ pretrained : boolean Whether to load pretrained weights. Default False. end_with : str The end point of the model [conv1, maxpool1, fire2, fire3, fire4, ..., out]. Default ``out`` i.e. the whole model. name : None or str Name for this model. Examples --------- Classify ImageNet classes, see `tutorial_models_squeezenetv1.py <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_models_squeezenetv1.py>`__ >>> # get the whole model >>> squeezenet = tl.models.SqueezeNetV1(pretrained=True) >>> # use for inferencing >>> output = squeezenet(img1, is_train=False) >>> prob = tf.nn.softmax(output)[0].numpy() Extract features and Train a classifier with 100 classes >>> # get model without the last layer >>> cnn = tl.models.SqueezeNetV1(pretrained=True, end_with='drop1').as_layer() >>> # add one more layer and build new model >>> ni = Input([None, 224, 224, 3], name="inputs") >>> nn = cnn(ni) >>> nn = Conv2d(100, (1, 1), (1, 1), padding='VALID', name='conv10')(nn) >>> nn = GlobalMeanPool2d(name='globalmeanpool')(nn) >>> model = tl.models.Model(inputs=ni, outputs=nn) >>> # train your own classifier (only update the last layer) >>> train_params = model.get_layer('conv10').trainable_weights Returns ------- static SqueezeNetV1. """ ni = Input([None, 224, 224, 3], name="input") n = Lambda(lambda x: x * 255, name='scale')(ni) for i in range(len(layer_names)): if layer_names[i] == 'conv1': n = Conv2d(64, (3, 3), (2, 2), tf.nn.relu, 'SAME', name='conv1')(n) elif layer_names[i] == 'maxpool1': n = MaxPool2d((3, 3), (2, 2), 'VALID', name='maxpool1')(n) elif layer_names[i] == 'drop1': n = Dropout(keep=0.5, name='drop1')(n) elif layer_names[i] == 'out': n = Conv2d(1000, (1, 1), (1, 1), padding='VALID', name='conv10')(n) # 13, 13, 1000 n = GlobalMeanPool2d(name='globalmeanpool')(n) elif layer_names[i] in ['fire3', 'fire5']: n = fire_block(n, n_filters[i - 2], max_pool=True, name=layer_names[i]) else: n = fire_block(n, n_filters[i - 2], max_pool=False, name=layer_names[i]) if layer_names[i] == end_with: break network = Model(inputs=ni, outputs=n, name=name) if pretrained: restore_params(network) return network
def u_net(inputs, refine=False): w_init = tf.random_normal_initializer(stddev=0.02) g_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tl.act.lrelu(x, 0.2) # ENCODER conv1 = Conv2d(64, (4, 4), (2, 2), padding='SAME', W_init=w_init)(inputs) conv1 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv1) conv2 = Conv2d(128, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv1) conv2 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv2) conv3 = Conv2d(256, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv2) conv3 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv3) conv4 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv3) conv4 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv4) conv5 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv4) conv5 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv5) conv6 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv5) conv6 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv6) conv7 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv6) conv7 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv7) conv8 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv7) conv8 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv8) # DECODER d0 = DeConv2d(n_filter=512, filter_size=(4, 4))(conv8) d0 = Dropout(0.5)(d0) d0 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d0), conv7]) d1 = DeConv2d(n_filter=512, filter_size=(4, 4))(d0) d1 = Dropout(0.5)(d1) d1 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d1), conv6]) d2 = DeConv2d(n_filter=512, filter_size=(4, 4))(d1) d2 = Dropout(0.5)(d2) d2 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d2), conv5]) d3 = DeConv2d(n_filter=512, filter_size=(4, 4))(d2) d3 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d3), conv4]) d4 = DeConv2d(n_filter=256, filter_size=(4, 4))(d3) d4 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d4), conv3]) d5 = DeConv2d(n_filter=128, filter_size=(4, 4))(d4) d5 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d5), conv2]) d6 = DeConv2d(n_filter=64, filter_size=(4, 4))(d5) d6 = Concat()( [InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d6), conv1]) d7 = DeConv2d(n_filter=64, filter_size=(4, 4))(d6) d7 = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d7) nn = Conv2d(1, (1, 1), (1, 1), act=tf.nn.tanh, padding='SAME', W_init=w_init)(d7) if refine: nn = RampElementwise(tf.add, act=tl.act.ramp, v_min=-1)([nn, inputs]) return nn