自学教程：Python layers.Input方法代码示例

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def RNNModel(vocab_size, max_len, rnnConfig, model_type):	embedding_size = rnnConfig['embedding_size']	if model_type == 'inceptionv3':		# InceptionV3 outputs a 2048 dimensional vector for each image, which we'll feed to RNN Model		image_input = Input(shape=(2048,))	elif model_type == 'vgg16':		# VGG16 outputs a 4096 dimensional vector for each image, which we'll feed to RNN Model		image_input = Input(shape=(4096,))	image_model_1 = Dropout(rnnConfig['dropout'])(image_input)	image_model = Dense(embedding_size, activation='relu')(image_model_1)	caption_input = Input(shape=(max_len,))	# mask_zero: We zero pad inputs to the same length, the zero mask ignores those inputs. E.g. it is an efficiency.	caption_model_1 = Embedding(vocab_size, embedding_size, mask_zero=True)(caption_input)	caption_model_2 = Dropout(rnnConfig['dropout'])(caption_model_1)	caption_model = LSTM(rnnConfig['LSTM_units'])(caption_model_2)	# Merging the models and creating a softmax classifier	final_model_1 = concatenate([image_model, caption_model])	final_model_2 = Dense(rnnConfig['dense_units'], activation='relu')(final_model_1)	final_model = Dense(vocab_size, activation='softmax')(final_model_2)	model = Model(inputs=[image_input, caption_input], outputs=final_model)	model.compile(loss='categorical_crossentropy', optimizer='adam')	return model 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def weather_l2(hidden_nums=100,l2=0.01):     input_img = Input(shape=(37,))    hn = Dense(hidden_nums, activation='relu')(input_img)    hn = Dense(hidden_nums, activation='relu',               kernel_regularizer=regularizers.l2(l2))(hn)    out_u = Dense(37, activation='sigmoid',                                   name='ae_part')(hn)    out_sig = Dense(37, activation='linear',                     name='pred_part')(hn)    out_both = concatenate([out_u, out_sig], axis=1, name = 'concatenate')    #weather_model = Model(input_img, outputs=[out_ae, out_pred])    mve_model = Model(input_img, outputs=[out_both])    mve_model.compile(optimizer='adam', loss=mve_loss, loss_weights=[1.])        return mve_model 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def weather_ae(layers, lr, decay, loss,                input_len, input_features):        inputs = Input(shape=(input_len, input_features), name='input_layer')        for i, hidden_nums in enumerate(layers):        if i==0:            hn = Dense(hidden_nums, activation='relu')(inputs)        else:            hn = Dense(hidden_nums, activation='relu')(hn)    outputs = Dense(3, activation='sigmoid', name='output_layer')(hn)    weather_model = Model(inputs, outputs=[outputs])    return weather_model 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        model = Sequential()        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))        model.add(Reshape((7, 7, 128)))        model.add(BatchNormalization(momentum=0.8))        model.add(UpSampling2D())        model.add(Conv2D(128, kernel_size=3, padding="same"))        model.add(Activation("relu"))        model.add(BatchNormalization(momentum=0.8))        model.add(UpSampling2D())        model.add(Conv2D(64, kernel_size=3, padding="same"))        model.add(Activation("relu"))        model.add(BatchNormalization(momentum=0.8))        model.add(Conv2D(1, kernel_size=3, padding="same"))        model.add(Activation("tanh"))        model.summary()        noise = Input(shape=(self.latent_dim,))        img = model(noise)        return Model(noise, img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminator(self):        def d_layer(layer_input, filters, f_size=4, normalization=True):            """Discriminator layer"""            d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)            d = LeakyReLU(alpha=0.2)(d)            if normalization:                d = InstanceNormalization()(d)            return d        img = Input(shape=self.img_shape)        d1 = d_layer(img, self.df, normalization=False)        d2 = d_layer(d1, self.df*2)        d3 = d_layer(d2, self.df*4)        d4 = d_layer(d3, self.df*8)        validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4)        return Model(img, validity) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminator(self):        img = Input(shape=self.img_shape)        model = Sequential()        model.add(Conv2D(64, kernel_size=4, strides=2, padding='same', input_shape=self.img_shape))        model.add(LeakyReLU(alpha=0.8))        model.add(Conv2D(128, kernel_size=4, strides=2, padding='same'))        model.add(LeakyReLU(alpha=0.2))        model.add(InstanceNormalization())        model.add(Conv2D(256, kernel_size=4, strides=2, padding='same'))        model.add(LeakyReLU(alpha=0.2))        model.add(InstanceNormalization())        model.summary()        img = Input(shape=self.img_shape)        features = model(img)        validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(features)        label = Flatten()(features)        label = Dense(self.num_classes+1, activation="softmax")(label)        return Model(img, [validity, label]) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_encoder(self):        model = Sequential()        model.add(Flatten(input_shape=self.img_shape))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(self.latent_dim))        model.summary()        img = Input(shape=self.img_shape)        z = model(img)        return Model(img, z) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        model = Sequential()        model.add(Dense(512, input_dim=self.latent_dim))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(np.prod(self.img_shape), activation='tanh'))        model.add(Reshape(self.img_shape))        model.summary()        z = Input(shape=(self.latent_dim,))        gen_img = model(z)        return Model(z, gen_img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminator(self):        z = Input(shape=(self.latent_dim, ))        img = Input(shape=self.img_shape)        d_in = concatenate([z, Flatten()(img)])        model = Dense(1024)(d_in)        model = LeakyReLU(alpha=0.2)(model)        model = Dropout(0.5)(model)        model = Dense(1024)(model)        model = LeakyReLU(alpha=0.2)(model)        model = Dropout(0.5)(model)        model = Dense(1024)(model)        model = LeakyReLU(alpha=0.2)(model)        model = Dropout(0.5)(model)        validity = Dense(1, activation="sigmoid")(model)        return Model([z, img], validity) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_vgg(self):        """        Builds a pre-trained VGG19 model that outputs image features extracted at the        third block of the model        """        vgg = VGG19(weights="imagenet")        # Set outputs to outputs of last conv. layer in block 3        # See architecture at: https://github.com/keras-team/keras/blob/master/keras/applications/vgg19.py        vgg.outputs = [vgg.layers[9].output]        img = Input(shape=self.hr_shape)        # Extract image features        img_features = vgg(img)        return Model(img, img_features) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_classifier(self):        def clf_layer(layer_input, filters, f_size=4, normalization=True):            """Classifier layer"""            d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)            d = LeakyReLU(alpha=0.2)(d)            if normalization:                d = InstanceNormalization()(d)            return d        img = Input(shape=self.img_shape)        c1 = clf_layer(img, self.cf, normalization=False)        c2 = clf_layer(c1, self.cf*2)        c3 = clf_layer(c2, self.cf*4)        c4 = clf_layer(c3, self.cf*8)        c5 = clf_layer(c4, self.cf*8)        class_pred = Dense(self.num_classes, activation='softmax')(Flatten()(c5))        return Model(img, class_pred) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        model = Sequential()        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))        model.add(Reshape((7, 7, 128)))        model.add(BatchNormalization(momentum=0.8))        model.add(UpSampling2D())        model.add(Conv2D(128, kernel_size=3, padding="same"))        model.add(Activation("relu"))        model.add(BatchNormalization(momentum=0.8))        model.add(UpSampling2D())        model.add(Conv2D(64, kernel_size=3, padding="same"))        model.add(Activation("relu"))        model.add(BatchNormalization(momentum=0.8))        model.add(Conv2D(self.channels, kernel_size=3, padding='same'))        model.add(Activation("tanh"))        gen_input = Input(shape=(self.latent_dim,))        img = model(gen_input)        model.summary()        return Model(gen_input, img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        model = Sequential()        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))        model.add(Reshape((7, 7, 128)))        model.add(UpSampling2D())        model.add(Conv2D(128, kernel_size=4, padding="same"))        model.add(BatchNormalization(momentum=0.8))        model.add(Activation("relu"))        model.add(UpSampling2D())        model.add(Conv2D(64, kernel_size=4, padding="same"))        model.add(BatchNormalization(momentum=0.8))        model.add(Activation("relu"))        model.add(Conv2D(self.channels, kernel_size=4, padding="same"))        model.add(Activation("tanh"))        model.summary()        noise = Input(shape=(self.latent_dim,))        img = model(noise)        return Model(noise, img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminator(self):        def d_layer(layer_input, filters, f_size=4, bn=True):            """Discriminator layer"""            d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)            d = LeakyReLU(alpha=0.2)(d)            if bn:                d = BatchNormalization(momentum=0.8)(d)            return d        img_A = Input(shape=self.img_shape)        img_B = Input(shape=self.img_shape)        # Concatenate image and conditioning image by channels to produce input        combined_imgs = Concatenate(axis=-1)([img_A, img_B])        d1 = d_layer(combined_imgs, self.df, bn=False)        d2 = d_layer(d1, self.df*2)        d3 = d_layer(d2, self.df*4)        d4 = d_layer(d3, self.df*8)        validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4)        return Model([img_A, img_B], validity) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        model = Sequential()        model.add(Dense(256, input_dim=self.latent_dim))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(1024))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dense(np.prod(self.img_shape), activation='tanh'))        model.add(Reshape(self.img_shape))        model.summary()        noise = Input(shape=(self.latent_dim,))        img = model(noise)        return Model(noise, img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminator(self):        model = Sequential()        model.add(Flatten(input_shape=self.img_shape))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(Dense(256))        model.add(LeakyReLU(alpha=0.2))        # (!!!) No softmax        model.add(Dense(1))        model.summary()        img = Input(shape=self.img_shape)        validity = model(img)        return Model(img, validity) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminators(self):        img1 = Input(shape=self.img_shape)        img2 = Input(shape=self.img_shape)        # Shared discriminator layers        model = Sequential()        model.add(Flatten(input_shape=self.img_shape))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(Dense(256))        model.add(LeakyReLU(alpha=0.2))        img1_embedding = model(img1)        img2_embedding = model(img2)        # Discriminator 1        validity1 = Dense(1, activation='sigmoid')(img1_embedding)        # Discriminator 2        validity2 = Dense(1, activation='sigmoid')(img2_embedding)        return Model(img1, validity1), Model(img2, validity2) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        X = Input(shape=(self.img_dim,))        model = Sequential()        model.add(Dense(256, input_dim=self.img_dim))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dropout(0.4))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dropout(0.4))        model.add(Dense(1024))        model.add(LeakyReLU(alpha=0.2))        model.add(BatchNormalization(momentum=0.8))        model.add(Dropout(0.4))        model.add(Dense(self.img_dim, activation='tanh'))        X_translated = model(X)        return Model(X, X_translated) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_generator(self):        model = Sequential()        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))        model.add(Reshape((7, 7, 128)))        model.add(UpSampling2D())        model.add(Conv2D(128, kernel_size=3, padding="same"))        model.add(BatchNormalization(momentum=0.8))        model.add(Activation("relu"))        model.add(UpSampling2D())        model.add(Conv2D(64, kernel_size=3, padding="same"))        model.add(BatchNormalization(momentum=0.8))        model.add(Activation("relu"))        model.add(Conv2D(self.channels, kernel_size=3, padding="same"))        model.add(Activation("tanh"))        model.summary()        noise = Input(shape=(self.latent_dim,))        img = model(noise)        return Model(noise, img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_discriminator(self):        model = Sequential()        model.add(Flatten(input_shape=self.img_shape))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(Dense(256))        model.add(LeakyReLU(alpha=0.2))        model.add(Dense(1, activation='sigmoid'))        model.summary()        img = Input(shape=self.img_shape)        validity = model(img)        return Model(img, validity) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_encoder(self):        # Encoder        img = Input(shape=self.img_shape)        h = Flatten()(img)        h = Dense(512)(h)        h = LeakyReLU(alpha=0.2)(h)        h = Dense(512)(h)        h = LeakyReLU(alpha=0.2)(h)        mu = Dense(self.latent_dim)(h)        log_var = Dense(self.latent_dim)(h)        latent_repr = merge([mu, log_var],                mode=lambda p: p[0] + K.random_normal(K.shape(p[0])) * K.exp(p[1] / 2),                output_shape=lambda p: p[0])        return Model(img, latent_repr) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def build_decoder(self):        model = Sequential()        model.add(Dense(512, input_dim=self.latent_dim))        model.add(LeakyReLU(alpha=0.2))        model.add(Dense(512))        model.add(LeakyReLU(alpha=0.2))        model.add(Dense(np.prod(self.img_shape), activation='tanh'))        model.add(Reshape(self.img_shape))        model.summary()        z = Input(shape=(self.latent_dim,))        img = model(z)        return Model(z, img) 

# 需要导入模块: from keras import layers [as 别名]# 或者: from keras.layers import Input [as 别名]def AlternativeRNNModel(vocab_size, max_len, rnnConfig, model_type):	embedding_size = rnnConfig['embedding_size']	if model_type == 'inceptionv3':		# InceptionV3 outputs a 2048 dimensional vector for each image, which we'll feed to RNN Model		image_input = Input(shape=(2048,))	elif model_type == 'vgg16':		# VGG16 outputs a 4096 dimensional vector for each image, which we'll feed to RNN Model		image_input = Input(shape=(4096,))	image_model_1 = Dense(embedding_size, activation='relu')(image_input)	image_model = RepeatVector(max_len)(image_model_1)	caption_input = Input(shape=(max_len,))	# mask_zero: We zero pad inputs to the same length, the zero mask ignores those inputs. E.g. it is an efficiency.	caption_model_1 = Embedding(vocab_size, embedding_size, mask_zero=True)(caption_input)	# Since we are going to predict the next word using the previous words	# (length of previous words changes with every iteration over the caption), we have to set return_sequences = True.	caption_model_2 = LSTM(rnnConfig['LSTM_units'], return_sequences=True)(caption_model_1)	# caption_model = TimeDistributed(Dense(embedding_size, activation='relu'))(caption_model_2)	caption_model = TimeDistributed(Dense(embedding_size))(caption_model_2)	# Merging the models and creating a softmax classifier	final_model_1 = concatenate([image_model, caption_model])	# final_model_2 = LSTM(rnnConfig['LSTM_units'], return_sequences=False)(final_model_1)	final_model_2 = Bidirectional(LSTM(rnnConfig['LSTM_units'], return_sequences=False))(final_model_1)	# final_model_3 = Dense(rnnConfig['dense_units'], activation='relu')(final_model_2)	# final_model = Dense(vocab_size, activation='softmax')(final_model_3)	final_model = Dense(vocab_size, activation='softmax')(final_model_2)	model = Model(inputs=[image_input, caption_input], outputs=final_model)	model.compile(loss='categorical_crossentropy', optimizer='adam')	# model.compile(loss='categorical_crossentropy', optimizer='rmsprop')	return model