def build_representation_network(input_shape, filter_size1=3, filter_size2=6, conv_strides=1, avg_pool_strides=2): input = Input(input_shape) c1 = Conv2D(filters=filter_size1, kernel_size=3, strides=conv_strides, padding='same', activation='relu', input_shape=input_shape)(input) r1 = residual(filter_size1, filter_size1, c1) r2 = residual(filter_size1, filter_size1, r1) c2 = Conv2D(filters=filter_size2, kernel_size=3, strides=conv_strides, padding='same', activation='relu', input_shape=(input_shape[0]/conv_strides, input_shape[0]/conv_strides, 3))(r2) r3 = residual(filter_size2, filter_size2, c2) r4 = residual(filter_size2, filter_size2, r3) r5 = residual(filter_size2, filter_size2, r4) a1 = AveragePooling2D(strides=avg_pool_strides)(r5) r6 = residual(filter_size2, filter_size2, a1) r7 = residual(filter_size2, filter_size2, r6) r8 = residual(filter_size2, filter_size2, r7) a2 = AveragePooling2D(strides=avg_pool_strides)(r8) model = Model(inputs=input, outputs=a2) return model
def __init__(self, latent_dim=49): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) # ENCODER inp = Input((896, 896, 1)) e = Conv2D(32, (10, 10), activation='relu')(inp) e = MaxPooling2D((10, 10))(e) e = Conv2D(64, (6, 6), activation='relu')(e) e = MaxPooling2D((10, 10))(e) e = Conv2D(64, (3, 3), activation='relu')(e) l = Flatten()(e) l = Dense(49, activation='softmax')(l) # DECODER d = Reshape((7, 7, 1))(l) d = Conv2DTranspose(64, (3, 3), strides=8, activation='relu', padding='same')(d) d = BatchNormalization()(d) d = Conv2DTranspose(64, (3, 3), strides=8, activation='relu', padding='same')(d) d = BatchNormalization()(d) d = Conv2DTranspose(64, (3, 3), strides=2, activation='relu', padding='same')(d) d = BatchNormalization()(d) d = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(d) decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(d) self.CAD = tf.keras.Model(inp, decoded) opt = tf.keras.optimizers.RMSprop(lr=0.0001, decay=1e-6) self.CAD.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"]) self.Flow = tf.keras.Sequential([ tf.keras.layers.LSTM(32, input_shape=(3, 2), return_sequences=True), tf.keras.layers.Dropout(0.4), tf.keras.layers.Bidirectional( tf.keras.layers.LSTM(32, return_sequences=True)), tf.keras.layers.Dropout(0.4), tf.keras.layers.TimeDistributed( tf.keras.layers.Dense(10, activation='relu')), tf.keras.layers.Flatten(), tf.keras.layers.Dense(2, activation='relu') ]) opt = tf.keras.optimizers.RMSprop(lr=0.0001, decay=1e-6) self.Flow.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"]) print(self.Flow.summary()) print(self.CAD.summary())
def conv_block(feat_maps_out, prev): prev = BatchNormalization(axis=-1)(prev) # Specifying the axis and mode allows for later merging prev = Activation('relu')(prev) prev = Conv2D(filters=feat_maps_out, kernel_size=3, padding='same')(prev) prev = BatchNormalization(axis=-1)(prev) # Specifying the axis and mode allows for later merging prev = Activation('relu')(prev) prev = Conv2D(filters=feat_maps_out, kernel_size=3, padding='same')(prev) return prev
def modelDemoStandardConvLSTMInception(input_shape, parameter=None): # define LSTM input = Input(shape=input_shape, name='main_input') I_1 = TimeDistributed(Conv2D(16, (1, 1), activation='relu', padding='same', name='C_1'), name='I_11')(input) I_1 = TimeDistributed(Conv2D(16, (5, 5), activation='relu', padding='same', name='C_2'), name='I_12')(I_1) I_2 = TimeDistributed(MaxPooling2D((3, 3), strides=(1, 1), padding='same', name='C_3'), name='I_21')(input) I_2 = TimeDistributed(Conv2D(16, (1, 1), activation='relu', padding='same', name='C_4'), name='I_22')(I_2) concatenate_output = concatenate([I_1, I_2], axis=-1) # x = TimeDistributed(Flatten())(x) x = ConvLSTM2D(filters=32, kernel_size=(3, 3), padding='same', return_sequences=False)(concatenate_output) #x = MaxPooling2D((3, 3), strides=(1, 1), padding='same', name='M_1')(x) x = (Flatten())(x) x = RepeatVector(8)(x) x = LSTM(50, return_sequences=True)(x) output = TimeDistributed(Dense(8, activation='softmax'), name='main_output')(x) #with tensorflow.device('/cpu'): model = Model(inputs=[input], outputs=[output]) # compile the model with gpu #parallel_model = multi_gpu_model(model, gpus=2) #parallel_model.compile(loss={'main_output': 'categorical_crossentropy'}, # loss_weights={'main_output': 1.}, optimizer='adam', metrics=['accuracy']) #model = multi_gpu(model, gpus=[1, 2]) model.compile(loss={'main_output': 'categorical_crossentropy'}, loss_weights={'main_output': 1.}, optimizer='adam', metrics=['accuracy']) return model
def build_model(): model = keras.Sequential() model.add( Conv2D(64, kernel_size=3, activation='relu', input_shape=(28, 28, 1))) model.add(Conv2D(32, kernel_size=3, activation='relu')) model.add(Flatten()) model.add(Dense(10, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def modelB(row, col, parameter=None): # define LSTM input = Input(shape=(None, row, col, 1), name='main_input') ''' x = TimeDistributed(Conv2D(16, (2, 2)))(input) x = BatchNormalization()(x) x = Activation('relu')(x) x = Dropout(0.25)(x) ''' # tower_1 = TimeDistributed(Conv2D(16, (1, 1), padding='same', activation='relu'))(input) # tower_1 = TimeDistributed(Conv2D(16, (3, 3), padding='same', activation='relu'))(tower_1) tower_2 = TimeDistributed(Conv2D(16, (1, 1), padding='same'))(input) x = BatchNormalization()(tower_2) x = Activation('relu')(x) x = Dropout(0.25)(x) tower_2 = TimeDistributed(Conv2D(16, (5, 5), padding='same'))(x) x = BatchNormalization()(tower_2) x = Activation('relu')(x) tower_2 = Dropout(0.25)(x) tower_3 = TimeDistributed( MaxPooling2D((3, 3), strides=(1, 1), padding='same'))(input) tower_3 = TimeDistributed(Conv2D(16, (1, 1), padding='same'))(tower_3) x = BatchNormalization()(tower_3) x = Activation('relu')(x) tower_3 = Dropout(0.25)(x) concatenate_output = concatenate([tower_2, tower_3], axis=-1) x = TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides=2))(concatenate_output) x = Dropout(0.25)(x) x = TimeDistributed(Flatten())(x) # convLstm = ConvLSTM2D(filters=40, kernel_size=(3, 3),padding='same', return_sequences=False)(x) lstm_output = LSTM(75)(x) lstm_output = BatchNormalization()(lstm_output) # lstm_output = BatchNormalization()(convLstm) # auxiliary_output = Dense(1, activation='sigmoid', name='aux_output')(lstm_output) # auxiliary_input = Input(shape=(4,), name='aux_input') # x = concatenate([lstm_output, auxiliary_input]) x = RepeatVector(4)(lstm_output) x = LSTM(50, return_sequences=True)(x) # model.add(Dropout(0.25)) x = BatchNormalization()(x) output = TimeDistributed(Dense(4, activation='softmax'), name='main_output')(x) model = Model(inputs=[input], outputs=[output]) model.compile(loss={'main_output': 'categorical_crossentropy'}, loss_weights={'main_output': 1.}, optimizer='adam', metrics=['accuracy']) return model
def build_reward_network(shape, filter_size1=3, filter_size2=1): input = Input(shape) c1 = Conv2D(filters=filter_size1, kernel_size=(3, 3), strides=2, padding='same', activation='relu', input_shape=shape)(input) a1 = AveragePooling2D(strides=2)(c1) c2 = Conv2D(filters=filter_size2, kernel_size=(3, 3), strides=1, padding='same', activation='relu', input_shape=shape)(a1) a2 = AveragePooling2D(strides=2)(c2) f1 = Flatten()(a2) model = Model(inputs=input, outputs=f1) return model
def modelStandard(input_shape, parameter=None): # define LSTM model = Sequential() model.add( TimeDistributed(Conv2D(16, (2, 2), activation='relu'), input_shape=input_shape)) model.add(Dropout(parameter['dropout'])) model.add(BatchNormalization()) model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides=2))) model.add(Dropout(parameter['dropout'])) model.add(TimeDistributed(Flatten())) model.add(LSTM(parameter['cell1'])) # model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(RepeatVector(8)) model.add(LSTM(parameter['cell2'], return_sequences=True)) # model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(TimeDistributed(Dense(5, activation='softmax'))) # Replicates `model` on 8 GPUs. # This assumes that your machine has 8 available GPUs. #parallel_model = multi_gpu_model(model, gpus=2) #parallel_model.compile(loss='categorical_crossentropy', # optimizer='adam', metrics=['accuracy']) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def modelC(row, col): # define LSTM model = Sequential() model.add( TimeDistributed(Conv2D(16, (2, 2), activation='relu'), input_shape=(None, row, col, 1))) model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2)))) model.add(Dropout(0.25)) model.add(TimeDistributed(Flatten())) model.add(LSTM(75)) # model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(RepeatVector(4)) model.add(LSTM(50, return_sequences=True)) # model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(TimeDistributed(Dense(4, activation='softmax'))) # Replicates `model` on 8 GPUs. # This assumes that your machine has 8 available GPUs. # parallel_model = multi_gpu_model(model, gpus=[2]) # parallel_model.compile(loss='categorical_crossentropy', # optimizer='adam', metrics=['accuracy']) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def build_dynamic_network(shape, filter_size=6, conv_strides=1): input = Input(shape) c1 = Conv2D(filters=filter_size, kernel_size=(3, 3), strides=conv_strides, padding='same', activation='relu', input_shape=shape)(input) r1 = residual(filter_size, filter_size, c1) model = Model(inputs=input, outputs=r1) return model
def __init__(self): super(Z2Model, self).__init__() # self.gcnn1 = tf.keras.layers.Conv2D(filters=20, kernel_size=(3, 3), activation='relu') # self.gcnn2 = tf.keras.layers.Conv2D(filters=20, kernel_size=(3, 3), activation='relu') # self.gcnn3 = tf.keras.layers.Conv2D(filters=20, kernel_size=(3, 3), activation='relu') # self.gcnn4 = tf.keras.layers.Conv2D(filters=20, kernel_size=(3, 3), activation='relu') # self.gcnn5 = tf.keras.layers.Conv2D(filters=20, kernel_size=(3, 3), activation='relu') # self.gcnn6 = tf.keras.layers.Conv2D(filters=20, kernel_size=(3, 3), activation='relu') # self.gcnn7 = tf.keras.layers.Conv2D(filters=20, kernel_size=(4, 4), activation='relu') self.gcnn1 = ConvBatchLayer( conv=Conv2D(filters=20, kernel_size=(3, 3), activation='relu')) self.gcnn2 = ConvBatchLayer( conv=Conv2D(filters=20, kernel_size=(3, 3), activation='relu')) self.gcnn3 = ConvBatchLayer( conv=Conv2D(filters=20, kernel_size=(3, 3), activation='relu')) self.gcnn4 = ConvBatchLayer( conv=Conv2D(filters=20, kernel_size=(3, 3), activation='relu')) self.gcnn5 = ConvBatchLayer( conv=Conv2D(filters=20, kernel_size=(3, 3), activation='relu')) self.gcnn6 = ConvBatchLayer( conv=Conv2D(filters=20, kernel_size=(3, 3), activation='relu')) self.gcnn7 = ConvBatchLayer(conv=Conv2D(filters=9, kernel_size=(3, 3))) self.flatten = Flatten() self.dense = Dense(9)
def build_policy_network(shape, action_size, regularizer): policy_input = Input(shape) c1 = Conv2D(filters=1, kernel_size=1, padding='same', activation='linear', kernel_regularizer=regularizer)(policy_input) b1 = BatchNormalization(axis=-1)(c1) l1 = LeakyReLU()(b1) f1 = Flatten()(l1) d1 = Dense(action_size, use_bias=False, activation='sigmoid', kernel_regularizer=regularizer)(f1) policy_model = Model(inputs=policy_input, outputs=d1) return policy_model
def build_value_network(shape, value_support_size): value_input = Input(shape) c1 = Conv2D(filters=1, kernel_size=1, padding='same', activation='linear')(value_input) b1 = BatchNormalization(axis=-1)(c1) l1 = LeakyReLU()(b1) f1 = Flatten()(l1) d2 = Dense(20, use_bias=False, activation='linear')(f1) l2 = LeakyReLU()(d2) d2 = Dense(value_support_size, use_bias=False, activation='tanh')(l2) value_model = Model(inputs=value_input, outputs=d2) return value_model
def ModelInception(): input_img = Input(shape=(256, 256, 3)) tower_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img) tower_1 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_1) tower_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img) tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_2) tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(input_img) tower_3 = Conv2D(64, (1, 1), padding='same', activation='relu')(tower_3) output = concatenate([tower_1, tower_2, tower_3], axis=1) model = Model(inputs=[input_img], outputs=output) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) return model
def SingleOutputCNN( input_shape, output_shape, cnns_per_maxpool=1, maxpool_layers=1, dense_layers=1, dense_units=64, dropout=0.25, regularization=False, global_maxpool=False, name='', ) -> Model: function_name = cast(types.FrameType, inspect.currentframe()).f_code.co_name model_name = f"{function_name}-{name}" if name else function_name # model_name = seq([ function_name, name ]).filter(lambda x: x).make_string("-") # remove dependency on pyfunctional - not in Kaggle repo without internet inputs = Input(shape=input_shape) x = inputs for cnn1 in range(0, maxpool_layers): for cnn2 in range(1, cnns_per_maxpool + 1): x = Conv2D(32 * cnn2, kernel_size=(3, 3), padding='same', activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = BatchNormalization()(x) x = Dropout(dropout)(x) if global_maxpool: x = GlobalMaxPooling2D()(x) x = Flatten()(x) for nn1 in range(0, dense_layers): if regularization: x = Dense(dense_units, activation='relu', kernel_regularizer=regularizers.l2(0.01), activity_regularizer=regularizers.l1(0.01))(x) else: x = Dense(dense_units, activation='relu')(x) x = BatchNormalization()(x) x = Dropout(dropout)(x) x = Dense(output_shape, activation='softmax')(x) model = Model(inputs, x, name=model_name) # plot_model(model, to_file=os.path.join(os.path.dirname(__file__), f"{name}.png")) return model
def build_model(): model = Sequential() model.add(Conv2D(filters=16, kernel_size=2, input_shape=(64, 64, 1), activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(Conv2D(filters=32, kernel_size=2, activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(Conv2D(filters=64, kernel_size=2, activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(Conv2D(filters=128, kernel_size=2, activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(GlobalAveragePooling2D()) model.add(Dense(9, activation='softmax')) return model
def ModelSharedVision(): # First, define the vision modules digit_input = Input(shape=(27, 27, 1)) x = Conv2D(64, (3, 3))(digit_input) x = Conv2D(64, (3, 3))(x) x = MaxPooling2D((2, 2))(x) out = Flatten()(x) vision_model = Model(digit_input, out) # Then define the tell-digits-apart model digit_a = Input(shape=(27, 27, 1)) digit_b = Input(shape=(27, 27, 1)) # The vision model will be shared, weights and all out_a = vision_model(digit_a) out_b = vision_model(digit_b) concatenated = concatenate([out_a, out_b]) out = Dense(1, activation='sigmoid')(concatenated) classification_model = Model([digit_a, digit_b], out) return classification_model
def ModelResidual(): # input tensor for a 3-channel 256x256 image x = Input(shape=(256, 256, 3)) # 3x3 conv with 3 output channels (same as input channels) y = Conv2D(3, (3, 3), padding='same')(x) # this returns x + y. z = add([x, y]) model = Model(inputs=[x], outputs=z) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) return model
def modelDemoStandard(row, col): # define LSTM input = Input(shape=(None, row, col, 1), name='main_input') x = TimeDistributed(Conv2D(16, (2, 2), activation='relu'))(input) x = TimeDistributed(Flatten())(x) lstm_output = LSTM(75)(x) x = RepeatVector(4)(lstm_output) x = LSTM(50, return_sequences=True)(x) output = TimeDistributed(Dense(4, activation='softmax'), name='main_output')(x) model = Model(inputs=[input], outputs=[output]) model.compile(loss={'main_output': 'categorical_crossentropy'}, loss_weights={'main_output': 1.}, optimizer='adam', metrics=['accuracy']) return model
def ModelVisualQuestionAnswering(): # First, let's define a vision model using a Sequential model. # This model will encode an image into a vector. vision_model = Sequential() vision_model.add( Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(224, 224, 3))) vision_model.add(Conv2D(64, (3, 3), activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) vision_model.add(Conv2D(128, (3, 3), activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Conv2D(256, (3, 3), activation='relu', padding='same')) vision_model.add(Conv2D(256, (3, 3), activation='relu')) vision_model.add(Conv2D(256, (3, 3), activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Flatten()) # Now let's get a tensor with the output of our vision model: image_input = Input(shape=(224, 224, 3)) encoded_image = vision_model(image_input) # Next, let's define a language model to encode the question into a vector. # Each question will be at most 100 words long, # and we will index words as integers from 1 to 9999. question_input = Input(shape=(100, ), dtype='int32') embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input) encoded_question = LSTM(256)(embedded_question) # Let's concatenate the question vector and the image vector: merged = concatenate([encoded_question, encoded_image]) # And let's train a logistic regression over 1000 words on top: output = Dense(1000, activation='softmax')(merged) # This is our final model: vqa_model = Model(inputs=[image_input, question_input], outputs=output) return vqa_model
def modelA(row, col): # define LSTM input = Input(shape=(None, row, col, 1), name='main_input') x = TimeDistributed(Conv2D(16, (2, 2), activation='relu'))(input) x = Dropout(0.25)(x) x = BatchNormalization()(x) x = TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides=2))(x) x = Dropout(0.25)(x) x = TimeDistributed(Flatten())(x) lstm_output = LSTM(75)(x) lstm_output = BatchNormalization()(lstm_output) auxiliary_output = Dense(1, activation='sigmoid', name='aux_output')(lstm_output) auxiliary_input = Input(shape=(4, ), name='aux_input') x = concatenate([lstm_output, auxiliary_input]) x = RepeatVector(8)(x) x = LSTM(50, return_sequences=True)(x) # model.add(Dropout(0.25)) x = BatchNormalization()(x) output = TimeDistributed(Dense(5, activation='softmax'), name='main_output')(x) model = Model(inputs=[input, auxiliary_input], outputs=[output, auxiliary_output]) model.compile(loss={ 'main_output': 'categorical_crossentropy', 'aux_output': 'binary_crossentropy' }, loss_weights={ 'main_output': 1., 'aux_output': 0.2 }, optimizer='adam', metrics=['accuracy']) return model
def modelStandardB(row, col): # define LSTM input_img = Input(shape=(None, row, col, 1), name='input') x = TimeDistributed(Conv2D(16, (2, 2), activation='relu'))(input_img) x = Dropout(0.25)(x) x = BatchNormalization()(x) x = TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides=2))(x) x = Dropout(0.25)(x) x = TimeDistributed(Flatten())(x) x = LSTM(75)(x) # model.add(Dropout(0.25)) x = BatchNormalization()(x) x = RepeatVector(4)(x) x = LSTM(50, return_sequences=True)(x) # model.add(Dropout(0.25)) x = BatchNormalization()(x) output = TimeDistributed(Dense(4, activation='softmax'))(x) model = Model(input_img, output) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def build(self): input_img = Input(shape=(28, 28, 1)) cnn = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img) cnn = MaxPooling2D((2, 2), padding='same')(cnn) cnn = Conv2D(32, (3, 3), activation='relu', padding='same')(cnn) cnn = MaxPooling2D((2, 2), padding='same')(cnn) cnn = Conv2D(32, (3, 3), activation='relu', padding='same')(cnn) encoded = MaxPooling2D((2, 2), padding='same')(cnn) cnn = Conv2D(32, (3, 3), activation='relu', padding='same')(encoded) cnn = UpSampling2D((2, 2))(cnn) cnn = Conv2D(32, (3, 3), activation='relu', padding='same')(cnn) cnn = UpSampling2D((2, 2))(cnn) cnn = Conv2D(32, (3, 3), activation='relu')(cnn) cnn = UpSampling2D((2, 2))(cnn) decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(cnn) cnn_autoencoder = Model(input_img, decoded) cnn_autoencoder.compile(optimizer='adam', loss='binary_crossentropy') x_train = self.x_train.reshape(-1, 28, 28, 1) x_train_split, x_valid_split = train_test_split(x_train, test_size=self.train_test_split, random_state=self.seed) cnn_autoencoder.fit(x_train_split, x_train_split, epochs=self.epochs, batch_size=self.batch_size, validation_data=(x_valid_split, x_valid_split), verbose=self.verbosity) x_train_pred = cnn_autoencoder.predict(x_train) mse = np.mean(np.power(x_train - x_train_pred, 2), axis=1) # Semi-supervised due to given threshold self.threshold = np.quantile(mse, 0.9) self.cnn_autoencoder = cnn_autoencoder
def get_model(self): model = Sequential() model.add(Conv2D(32, kernel_size=(2, 2), activation='relu', input_shape=(self.feature_dim_1, self.feature_dim_2, self.channel))) model.add(Conv2D(64, kernel_size=(2, 2), activation='relu')) model.add(Conv2D(128, kernel_size=(2, 2), activation='relu')) model.add(MaxPool2D(pool_size=(1, 1))) model.add(Dropout(0.5)) model.add(Conv2D(128, kernel_size=(2, 2), activation='relu')) model.add(Conv2D(256, kernel_size=(2, 2), activation='relu')) model.add(MaxPool2D(pool_size=(1, 1))) model.add(Dropout(0.5)) model.add(Conv2D(128, kernel_size=(2, 2), activation='relu')) model.add(Conv2D(256, kernel_size=(4, 4), activation='relu')) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dropout(0.5)) model.add(Dense(256, kernel_regularizer=regularizers.l2(0.2), activation='relu')) model.add(Dense(32, kernel_regularizer=regularizers.l2(0.2), activation='relu')) model.add(Dense(self.num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='RMSProp', metrics=['accuracy']) return model
def ModelVideoQuestionAnswering(): # First, let's define a vision model using a Sequential model. # This model will encode an image into a vector. vision_model = Sequential() vision_model.add( Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(224, 224, 3))) vision_model.add(Conv2D(64, (3, 3), activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) vision_model.add(Conv2D(128, (3, 3), activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Conv2D(256, (3, 3), activation='relu', padding='same')) vision_model.add(Conv2D(256, (3, 3), activation='relu')) vision_model.add(Conv2D(256, (3, 3), activation='relu')) vision_model.add(MaxPooling2D((2, 2))) vision_model.add(Flatten()) # Now let's get a tensor with the output of our vision model: image_input = Input(shape=(224, 224, 3)) encoded_image = vision_model(image_input) # Next, let's define a language model to encode the question into a vector. # Each question will be at most 100 words long, # and we will index words as integers from 1 to 9999. question_input = Input(shape=(100, ), dtype='int32') embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input) encoded_question = LSTM(256)(embedded_question) # Let's concatenate the question vector and the image vector: merged = concatenate([encoded_question, encoded_image]) # And let's train a logistic regression over 1000 words on top: output = Dense(1000, activation='softmax')(merged) # This is our final model: # vqa_model = Model(inputs=[image_input, question_input], outputs=output) video_input = Input(shape=(100, 224, 224, 3)) # This is our video encoded via the previously trained vision_model (weights are reused) encoded_frame_sequence = TimeDistributed(vision_model)( video_input) # the output will be a sequence of vectors encoded_video = LSTM(256)( encoded_frame_sequence) # the output will be a vector # This is a model-level representation of the question encoder, reusing the same weights as before: question_encoder = Model(inputs=question_input, outputs=encoded_question) # Let's use it to encode the question: video_question_input = Input(shape=(100, ), dtype='int32') encoded_video_question = question_encoder(video_question_input) # And this is our video question answering model: merged = concatenate([encoded_video, encoded_video_question]) output = Dense(1000, activation='softmax')(merged) video_qa_model = Model(inputs=[video_input, video_question_input], outputs=output) return video_qa_model
plot_images(augmented_images) val_image_gen = ImageDataGenerator(rescale=1. / 255) val_data_gen = val_image_gen.flow_from_directory(batch_size=batch_size, directory=val_dir, target_size=(IMG_SHAPE, IMG_SHAPE), class_mode='sparse') print("Configuring model...") model = Sequential() model.add( Conv2D(16, 3, padding='same', activation='relu', input_shape=(IMG_SHAPE, IMG_SHAPE, 3))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, 3, padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, 3, padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dropout(0.2)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.2))
def skip_block(feat_maps_in, feat_maps_out, prev): if feat_maps_in != feat_maps_out: # This adds in a 1x1 convolution on shortcuts that map between an uneven amount of channels prev = Conv2D(filters=feat_maps_out, kernel_size=1, padding='same')(prev) return prev
print(f'X_train: {X_train.shape}, Y_train: {Y_train.shape}') print(f'X_test: {X_test.shape}, Y_test: {Y_test.shape}') X_train = X_train.reshape(*X_train.shape, 1).astype('float16') / 255 X_test = X_test.reshape(*X_test.shape, 1).astype('float16') / 255 Y_train = to_categorical(Y_train, 10, dtype='float16') Y_test = to_categorical(Y_test, 10, dtype='float16') print(f'X_train: {X_train.shape}, Y_train: {Y_train.shape}') print(f'X_test: {X_test.shape}, Y_test: {Y_test.shape}') model = Sequential() model.add( Conv2D(filters=32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu')) model.add(MaxPool2D(pool_size=2)) model.add(Dropout(rate=0.25)) model.add(Flatten()) model.add(Dense(units=128, activation='relu')) model.add(Dropout(rate=0.5)) model.add(Dense(units=10, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) early_stop = EarlyStopping(monitor='val_loss', patience=10, verbose=0)
from tensorflow import keras from tensorflow_core.python.keras import Sequential from tensorflow_core.python.keras.layers.core import Dense, Dropout, Flatten from tensorflow_core.python.keras.layers import Conv2D, MaxPooling2D mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(x_train.shape[0], 28, 28, 1) x_test = x_test.reshape(x_test.shape[0], 28, 28, 1) model = tf.keras.models.Sequential() #-------------MOD------------------------ model.add( Conv2D(16, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(10, activation='softmax')) #------------------------------------- model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5) model.evaluate(x_test, y_test, verbose=2)
class_names = [ 'T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot' ] # Create CNN Model NUM_EPOCHS = 25 LR = 0.001 BATCH_SIZE = 32 model = tf.keras.Sequential() model.add( Conv2D(28, (3, 3), strides=2, padding='same', activation='relu', input_shape=(28, 28, 1))) model.add(BatchNormalization()) model.add(MaxPooling2D((2, 2))) model.add(Dropout(0.25)) model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D((2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dense(256, activation='relu')) model.add(Dense(64, activation='relu'))