def new_instance(input_shape, learning_rate): x, y, time, spectral = input_shape inputLayer = Input(shape=input_shape) cnn_model = Conv3D(256, kernel_size=(3, 3, 5), padding='same')(inputLayer) cnn_model = Conv3D(256, kernel_size=(3, 3, 1), padding='valid')(cnn_model) cnn_model = BatchNormalization()(cnn_model) cnn_model = Activation('relu')(cnn_model) cnn_model = Flatten()(cnn_model) lstm_model = Cropping3D(cropping=(1, 1, 0))(inputLayer) lstm_model = Reshape(target_shape=(time, spectral))(lstm_model) lstm_model = BatchNormalization()(lstm_model) lstm_model = Bidirectional(CuDNNLSTM(256, return_sequences=True))(lstm_model) lstm_model = Flatten()(lstm_model) conc_model = concatenate([lstm_model, cnn_model]) conc_model = Dense(256, activation='relu')(conc_model) conc_model = Dropout(0.3)(conc_model) conc_model = Dense(64, activation='relu')(conc_model) conc_model = Dense(2, activation='sigmoid')(conc_model) conc_model = Model(inputLayer, conc_model) optimizer = optimizers.Nadam(lr=learning_rate) conc_model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) return conc_model
def get_rank_net(input_shape=32): #get two input,one is a vector regarded as more relative ,another is a vector regarded as less relative input_relative = Input(shape=(input_shape, ), dtype='float32') input_unrelative = Input(shape=(input_shape, ), dtype='float32') #get a score model which shared by two input vector input_layer = Input(shape=(input_shape, ), dtype='float32') model = Dense( 256, activation='relu', )(input_layer) model = Dense(128, activation='relu')(model) model = Dense(64, activation='relu')(model) model = Dense(32, activation='relu')(model) model = Dense(1)(model) score_model = Model(input_layer, model, name='score_model') #the output of score model by two vector respective out_relative = score_model(input_relative) out_unrelative = score_model(input_unrelative) #get the diff of two score subtract = Subtract()([out_relative, out_unrelative]) #get the probability of the first input is more relative than the second input final_out = Activation('sigmoid')(subtract) #build the model model = Model(inputs=[input_relative, input_unrelative], outputs=final_out) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) return model
def build(): #load mobilenet architecture from keras #top false to get it to classify with our application base_model = keras.applications.mobilenet.MobileNet(include_top=False, input_shape=(224, 224, 3)) model = base_model.output print("good loading of mobilent") #make it more fine grain analysis model = GlobalAveragePooling2D()(model) model = Dense(1024, activation='relu')(model) model = Dense(1024, activation="relu")(model) model = Dense(512, activation="relu")(model) predictions = Dense(10, activation='softmax')(model) model = Model(base_model.input, predictions) #do not train the first 20 layers of the model for layer in model.layers[:20]: layer.trainable = False for layer in model.layers[20:]: layer.trainable = True model.summary() print("good adding") model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) return model
def base_model(): input_img = Input(shape=(83,)) model = Dense(64, activation='relu')(input_img) model = Dense(32, activation='relu')(model) model = Dense(16, activation='relu')(model) model = Dense(1, activation='relu')(model) model = Model(input_img, model) model.compile(loss=keras_loss.mse, optimizer = 'adam', metrics=['accuracy']) #, metrics=['accuracy'] return model
def build_model(): inputs = Input([13, ], name='data') model = Dense(2, activation='relu', name='fc1')(inputs) outputs = Dense(1, activation='linear', name='fc3')(model) model = Model(inputs=[inputs], outputs=outputs) model.compile(optimizer=Adam(lr=4e-5), #Gradient Descend Algorithm. loss='mse', #MSE = Mean Squared Error metrics=['mae']) return model
def gan_model(latent_dim, discriminator): gan_inputs = Input(shape=(latent_dim,)) gan = Dense(128)(gan_inputs) gan = lrelu()(gan) gan = Dense(128)(gan) gan = lrelu()(gan) gan_outputs = Dense(x_mnist.shape[1], activation="sigmoid")(gan) discriminator.trainable = False gan = discriminator(gan_outputs) gan = Model(input=gan_inputs, output=gan) gan.compile(loss='binary_crossentropy', optimizer="adam") return gan, gan_inputs, gan_outputs
def create_unconditional_discriminator(**kwargs): # # Parse settings # dropout = kwargs.get("dropout", -1.) leaky_relu = kwargs.get("leaky_relu", 0.2) num_categories = kwargs.get("num_categories") num_conditions = kwargs.get("num_conditions") num_observables = kwargs.get("num_observables") use_batch_norm = kwargs.get("batch_norm", False) verbose = kwargs.get("verbose", True) mid_layers = kwargs.get("mid_layers", (10, )) use_dropout = False if dropout > 0: use_dropout = True # # Print stage # if verbose: print( f"Creating discriminator with {num_observables} observables and {num_conditions} conditions" ) # # Create input layers # data_input = Input((num_observables, )) # # Create initially separate layers for the condition and data # discriminator = data_input for layer_size in mid_layers: discriminator = Dense(layer_size)(discriminator) discriminator = LeakyReLU(leaky_relu)(discriminator) if use_batch_norm: discriminator = BatchNormalization()(discriminator) if use_dropout: discriminator = Dropout(dropout)(discriminator) # # Compile discriminator model # discriminator = Dense(num_categories, activation="sigmoid")(discriminator) discriminator = Model(name="Discriminator", inputs=[data_input], outputs=[discriminator]) if num_categories == 1: discriminator.compile(loss="binary_crossentropy", optimizer=Adam()) else: discriminator.compile(loss="categorical_crossentropy", optimizer=Adam()) if verbose: discriminator.summary() # # return discriminator # return discriminator
def get_model(): inp = Input(shape=(TF_IDF_FEATURES, )) model = Dense(1024, activation='relu')(inp) model = Dropout(0.8)(model) model = Dense(NUM_CLASS, activation="softmax")(model) model = Model(inputs=inp, outputs=model) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() return model
def siamese_cnn_lstm(max_sent_len, wordvec_dim, gru_output_dim, output_dim): #input_layers = [] gru_f, gru_b, gru_sent_fwd, gru_sent_bwd = [], [], [], [] input_layers = [ Input(shape=(max_sent_len, wordvec_dim)) for i in xrange(2) ] #input_2 = Input(shape = (max_sent_len, wordvec_dim)) siamese_sub_parts = [] for i in xrange(2): gru_sent_fwd.append( GRU(gru_output_dim, return_sequences=False, go_backwards=False, activation='tanh', inner_activation='hard_sigmoid', input_shape=(max_sent_len, wordvec_dim))) gru_sent_bwd.append( GRU(gru_output_dim, return_sequences=False, go_backwards=True, activation='tanh', inner_activation='hard_sigmoid', input_shape=(max_sent_len, wordvec_dim))) gru_f.append(gru_sent_fwd[i](input_layers[i])) gru_b.append(gru_sent_bwd[i](input_layers[i])) gru_f[i] = BatchNormalization()(gru_f[i]) gru_f[i] = Activation('softmax')(gru_f[i]) gru_b[i] = BatchNormalization()(gru_b[i]) gru_b[i] = Activation('softmax')(gru_b[i]) gru_merge = merge([gru_f[i], gru_b[i]], mode='concat', concat_axis=-1) gru_merge = Dense(20)(gru_merge) #gru_merge = Dropout(0.25)(gru_merge) #gru_merge = Dense(100)(gru_merge) siamese_sub_parts.append(gru_merge) #distance = Lambda(euclidean_distance, output_shape = eucl_dist_output_shape)(siamese_sub_parts) #model = Dense(output_dim)(distance) model = merge(siamese_sub_parts, mode='concat', concat_axis=-1) model = Dense(output_dim)(model) sgd = optimizers.SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True) model = BatchNormalization()(model) out_layer = Activation('softmax')(model) model = Model(input=input_layers, output=out_layer) model.compile(loss='categorical_crossentropy', optimizer='adagrad', metrics=['accuracy']) return model
def EnhancedHybridResSppNet(class_num, enhanced_class_num): _input = Input(shape=(None, None, 3)) model = _input model = ZeroPadding2D((3, 3))(model) model = Conv2D(64, (7, 7), strides=(2, 2))(model) model = BatchNormalization(axis=3)(model) model = Activation('relu')(model) model = MaxPooling2D((3, 3), strides=(2, 2))(model) model = conv_block(model, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) model = identity_block(model, 3, [64, 64, 256], stage=2, block='b') model = identity_block(model, 3, [64, 64, 256], stage=2, block='c') model = conv_block(model, 3, [128, 128, 512], stage=3, block='a') model = identity_block(model, 3, [128, 128, 512], stage=3, block='b') model = identity_block(model, 3, [128, 128, 512], stage=3, block='c') model = identity_block(model, 3, [128, 128, 512], stage=3, block='d') model = MaxPooling2D((2, 2))(model) model = SpatialPyramidPooling([1, 2, 4])(model) model1 = Dense(units=class_num)(model) model1 = Activation(activation="softmax")(model1) model1 = Model(_input, model1) model1.compile(loss="categorical_crossentropy", optimizer=RMSprop(lr=1e-4, decay=1e-6), metrics=['accuracy']) model2 = Dense(units=enhanced_class_num)(model) model2 = Activation(activation="softmax")(model2) model2 = Model(_input, model2) model2.compile(loss="categorical_crossentropy", optimizer=RMSprop(lr=1e-4, decay=1e-6), metrics=['accuracy']) input2 = Input(shape=(100, )) model3 = Concatenate((input2, model)) model3 = Dense(units=class_num)(model3) model3 = Activation(activation="softmax")(model3) model3 = Model(inputs=[_input, input2], outputs=model3) model3.compile(loss="categorical_crossentropy", optimizer=RMSprop(lr=1e-4, decay=1e-6), metrics=['accuracy']) return model1, model2, model3
def train(self): batch_size = 32 mobilenet = MobileNet(weights='imagenet', include_top=False) new_model = mobilenet.output new_model = GlobalAveragePooling2D()(new_model) new_model = Dense(128, activation='relu', name='relu_layer_3')(new_model) new_model = Dropout(0.25)(new_model) predictions = Dense(2, activation='softmax', name='output')(new_model) new_model = Model(inputs=mobilenet.input, outputs=predictions) #all mobile layers are frozen for layer in new_model.layers[:87]: layer.trainable = False for layer in new_model.layers[87:]: layer.trainable = True logdir = "logs/scalars/train/" + datetime.now().strftime( "%Y%m%d-%H%M%S") tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir) train_data_gen = ImageDataGenerator(validation_split=0.2) train_gen = train_data_gen.flow_from_directory( './train', target_size=(224, 224), color_mode='rgb', batch_size=32, class_mode='categorical', shuffle=True, subset='training') validation_gen = train_data_gen.flow_from_directory( './train', target_size=(224, 224), color_mode='rgb', batch_size=32, class_mode='categorical', shuffle=True, subset='validation') new_model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy']) print(new_model.summary()) new_model.fit_generator( generator=train_gen, steps_per_epoch=train_gen.samples // batch_size, validation_data=validation_gen, validation_steps=validation_gen.samples // batch_size, epochs=10, callbacks=[tensorboard_callback]) new_model.save_weights('my_weights') new_model.save('my_model')
def counter_model(x_train_all, x_val_all, y_train_genotype, y_val_genotype, results_path): res_model = ResNet50(weights='imagenet', include_top=False, input_shape=(321, 321, 3)) model_res = res_model.output model_flat = Flatten(name='flatten')(model_res) model = Dense(1024, activation='relu', activity_regularizer=regularizers.l2(0.10))(model_flat) model_genotype = Dense(5, activation='softmax')(model) input = Input(shape=(128, 128, 3), name='input') model = Conv2D(32, 5, strides=(1, 1), padding="same", activation="relu")(input) model = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(model) model = Conv2D(64, 5, strides=(1, 1), padding="same", activation="relu")(model) model = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(model) model = Conv2D(64, 5, strides=(1, 1), padding="same", activation="relu")(model) model = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(model) model = Conv2D(64, 5, strides=(1, 1), padding="same", activation="relu")(model) model = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(model) model = Dense(4096, activation='relu')(model) model = Dropout(0.5)(model) model = Dense(4096, activation='relu')(model) model = Dropout(0.5)(model) model_genotype = Dense(5, activation='softmax')(model) epoch = 50 csv_logger = keras.callbacks.CSVLogger('training.log', separator=',') early_stop = EarlyStopping(monitor='val_loss', min_delta=0.03, mode='min', patience=8) model = Model(inputs=res_model.input, outputs=model_genotype) model.compile(optimizer=Adam(lr=0.0001), loss='categorical_crossentropy', metrics=[metrics.categorical_accuracy]) fitted_model = model.fit(x_train_all, y_train_genotype, epochs=epoch, validation_data=(x_val_all, y_val_genotype), batch_size=16, callbacks=[csv_logger]) return model
def create_simple_model(**kwargs): # # Parse settings # dropout = kwargs.get("dropout", -1.) leaky_relu = kwargs.get("leaky_relu", 0.2) sigmoid = kwargs.get("sigmoid", False) name = kwargs.get("name", "model") num_outputs = kwargs.get("num_outputs") num_observables = kwargs.get("num_observables") use_batch_norm = kwargs.get("batch_norm", False) verbose = kwargs.get("verbose", True) use_dropout = False if dropout > 0: use_dropout = True layers = kwargs.get("data_layers", (10, )) # # Print stage # if verbose: print(f"Creating model with {num_observables} observables") # # Create input layers # data_input = Input((num_observables, )) # # Create initially separate layers for the condition and data # model = data_input for layer_size in layers: if sigmoid: model = Dense(layer_size, activation="sigmoid")(model) else: model = Dense(layer_size)(model) model = LeakyReLU(leaky_relu)(model) if use_batch_norm: model = BatchNormalization()(model) if use_dropout: model = Dropout(dropout)(model) # # Compile model # model = Dense(num_outputs, activation="linear")(model) model = Model(name=name, inputs=[data_input], outputs=[model]) model.compile(loss="mse", optimizer=Adam()) if verbose: model.summary() # # return model # return model
def get_model_1(): inputs = Input(shape=(6912, )) model = Dense(3951, activation='relu')(inputs) model = Dropout(0.5)(model) model = Dense(1024, activation='relu')(model) model = Dropout(0.3)(model) model = Dense(512, activation='relu')(model) model = Dropout(0.2)(model) model = Dense(64, activation='relu')(model) model = Dropout(0.2)(model) predictions = Dense(4, activation='softmax')(model) model = Model(inputs=inputs, outputs=predictions) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) return model
def build_model(): # Input layer inputs = Input([4, ], name='data') # Hidden layers model = Dense(6, activation='relu', name='fc1')(inputs) model = Dense(6, activation='relu', name='fc2')(model) # Output layer outputs = Dense(3, activation='softmax', name='fc3')(model) # Define the model model = Model(inputs=[inputs], outputs=outputs) model.compile(optimizer='adam',#Adam(lr=1e-5), loss='categorical_crossentropy', metrics=['accuracy']) return model
def build_model(): # Input layer inputs = Input([ 2, ], name='data') # Hidden layers model = Dense(128, activation='relu')(inputs) # Output layer outputs = Dense(2, activation='softmax', name='fc3')(model) # Define the model model = Model(inputs=[inputs], outputs=outputs) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model
def cnn_rnn(): cnn_input_shape = (128, 1) cnn_inp = Input(shape=cnn_input_shape, dtype='float32', name='cnn') # 两层卷积操作 c = Conv1D(nb_filters, kernel_size=kernel_size, padding='same', strides=1)(cnn_inp) c = MaxPooling1D()(c) c = Conv1D(nb_filters, kernel_size=kernel_size, padding='same', strides=1)(c) c = MaxPooling1D()(c) c = Flatten()(c) c = Dense(32, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(c) c = Dense(32, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(c) rnn_inp = Input(shape=(128, )) r = Embedding(257, 16, input_length=128)(rnn_inp) r = SimpleRNN(128, return_sequences=True)(r) r = SimpleRNN(128)(r) # r=LSTM(128,return_sequences=True)(r) # r=LSTM(128)(r) r = Dense(32, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(r) # r=Dense(32,activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(r) cr_inp = concatenate([c, r]) # 加入注意力机制 attention_probs = Dense(64, activation='softmax', name="attention_probs")(cr_inp) cr_inp = Multiply()([cr_inp, attention_probs]) # wide特征和deep特征拼接,wide特征直接和输出节点相连 cr = Dense(256, activation='relu')(cr_inp) cr = Dense(128, activation='relu')(cr) cr_out = Dense(2, activation='softmax', name='cnn_rnn')(cr) # 模型网络的入口和出口 cr = Model(inputs=[cnn_inp, rnn_inp], outputs=cr_out) cr.compile(optimizer=Adam(lr=0.0001), loss="categorical_crossentropy", metrics=["accuracy"]) # 以下输入数据进行wide and deep模型的训练 print(cr.summary()) return cr
def build_model(): # Input layer inputs = Input([ 13, ], name='data') # Hidden layers model = Dense(32, activation='relu', name='fc1')(inputs) model = Dense(32, activation='relu', name='fc2')(model) # Output layer outputs = Dense(1, activation='linear', name='fc3')(model) # Define the model model = Model(inputs=[inputs], outputs=outputs) model.compile( optimizer=Adam(lr=4e-5), #Gradient Descend Algorithm. loss='mse', #MSE = Mean Squared Error metrics=['mae']) #MAE = Mean Absolute Error return model
def build_model(): inputs = Input([13, ], name='data') # Notice how the regularization can be applied to each layer, instead to the entire network model = Dense(512, activation='relu', name='fc1')(inputs) model = Dense(512, activation='relu', name='fc2')(model) model = Dropout(0.1)(model) model = Dense(512, activation='relu', name='fc3')(model) model = Dense(512, activation='relu', name='fc4')(model) model = Dropout(0.1)(model) model = Dense(512, activation='relu', name='fc5')(model) model = Dropout(0.1)(model) model = Dense(512, activation='relu', name='fc6',kernel_regularizer=keras.regularizers.l1_l2(l1=0.5, l2=0.01))(model) model = Dense(512, activation='relu', name='fc7',kernel_regularizer=keras.regularizers.l1_l2(l1=0.05, l2=0.01))(model) outputs = Dense(1, activation='linear', name='fc8')(model) model = Model(inputs=[inputs], outputs=outputs) model.compile(optimizer=Adam(lr=4e-5), #Gradient Descend Algorithm. loss='mse', #MSE = Mean Squared Error metrics=['mae']) return model
def define_GCP_model(num_classes): input = Input(shape=(1, 250, 250)) concat_input = Concatenate(axis=1)([input, input, input]) inception_net = InceptionV3(input_tensor=concat_input, weights='imagenet', classes=num_classes, include_top=False) layers = inception_net.layers # freeze the first 150 pre-trained layers for layer in layers[0:150]: layer.trainable = False dropout = .50 #add additional layers model = inception_net.output model = GlobalAveragePooling2D()(model) model = Dense(100, kernel_regularizer=regularizers.l2(0.1))(model) model = BatchNormalization()(model) model = Activation(activation='relu')(model) model = Dropout(dropout, seed=7)(model) model = Dense(100, kernel_regularizer=regularizers.l2(0.1))(model) model = BatchNormalization()(model) model = Activation(activation='relu')(model) model = Dropout(dropout, seed=7)(model) model = Dense(100, kernel_regularizer=regularizers.l2(0.1))(model) model = BatchNormalization()(model) model = Activation(activation='relu')(model) model = Dropout(dropout, seed=7)(model) preds = Dense(num_classes, activation='softmax')(model) model = Model(inputs=input, outputs=preds) sgd = optimizers.SGD(lr=0.0025, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='sparse_categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) #model.summary() return model
def get_model_2(): """This is regularised""" inputs = Input(shape=(6912, )) model = Dense(3951, activation='relu')(inputs) model = Dropout(0.5)(model) model = Dense(1024, activation='relu', kernel_regularizer=regularizers.l2(0.01))(model) model = Dropout(0.3)(model) model = Dense(512, activation='relu', kernel_regularizer=regularizers.l2(0.01))(model) model = Dropout(0.3)(model) model = Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.01))(model) model = Dropout(0.3)(model) predictions = Dense(4, activation='softmax')(model) model = Model(inputs=inputs, outputs=predictions) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
def make_neural_network(input_dim): input_layer = Input(shape=(input_dim, )) neural_network = Dense(64, input_dim=45, activation="relu")(input_layer) neural_network = BatchNormalization()(neural_network) neural_network = Dense(64, activation="relu")(neural_network) neural_network = Dropout(.2)(neural_network) neural_network = BatchNormalization()(neural_network) neural_network = Dense(512, activation="relu")(neural_network) neural_network = Dropout(.2)(neural_network) neural_network = BatchNormalization()(neural_network) neural_network = Dense(512, activation="relu")(neural_network) neural_network = Dropout(.2)(neural_network) neural_network = BatchNormalization()(neural_network) neural_network = Dense(1024, activation="relu")(neural_network) neural_network = Dropout(.2)(neural_network) neural_network = BatchNormalization()(neural_network) output_layer = Dense(1, activation="sigmoid")(neural_network) neural_network = Model(input=input_layer, output=output_layer) optimizer = optimizers.Adam(lr=0.003, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) neural_network.compile(loss="binary_crossentropy", optimizer=optimizer, metrics=["accuracy"]) print(neural_network.summary()) return neural_network
def Fit_transfer_learning_AECNN(model_latent, model_feature, gen_train, gen_valid): combined = Concatenate()([model_latent.output, model_feature.output]) model = Dense(2048, activation="relu")(combined) model = Dense(1024, activation="relu")(model) model = Dropout(0.5)(model) out = Dense(7, activation="softmax")(model) model = Model(inputs=[model_latent.input, model_feature.input], outputs=out) print(model.summary) model.compile(loss="binary_crossentropy", metrics=['acc'], optimizer=Adam(1e-5)) earlyStop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=3, verbose=1) #checkpoint = tf.keras.callbacks.ModelCheckpoint(file_path, monitor='val_loss', verbose=1, save_best_only=True, mode='min') callbacks_list = [earlyStop] H = model.fit_generator(gen_train, steps_per_epoch=100, epochs=100, validation_data=gen_valid, validation_steps=50, shuffle=False) #plot_model(model, show_shapes=True, show_layer_names=True) """ loss, acc = model.evaluate_generator(generator=datagen.flow([vect1_train, vect2_train], [vect1_valid, vect2_valid])) """ #loss, acc = model.predict([vect1_valid, vect2_valid]) print("Accuracy: ", H.history) return model
fill_mode='nearest') test_datagen = ImageDataGenerator(rescale=1. / 255, ) training_set = ImageDataGenerator.flow_from_directory(directory='train', target_size=[224, 224], class_mode='categorical', batch_size=32) testing_set = ImageDataGenerator.flow_from_directory(directory='test', target_size=[224, 224], class_mode='categorical', batch_size=32) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(lr=[0.0001], momentum=0.9), metrics=['accuracy']) vgg19_model = model.fit(training_set, validation_data=testing_set, epochs=30, verbose=1, steps_per_epoch=len(training_set), validation_steps=len(testing_set)) plt.plot(r.history['accuracy']) plt.plot(r.history['val_accuracy']) plt.title('Model Accuracy') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.legend(['Accuracy', 'Validation Accuracy', 'Loss', 'Validation Loss'],
adam = Adam(lr=0.0002, beta_1=0.9, beta_2=0.999, epsilon=1e-8, decay=0.0, amsgrad=False) callbacks_list = [ callbacks.TensorBoard(log_dir='./logs', write_graph=True, write_images=False) ] run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() model.compile(loss='mse', optimizer=adam, options=run_options, run_metadata=run_metadata) tick = time.time() for i in range(0, 10): #for a in [0,45]: a = random.randint(0, int(len(data_list_all_) / 512 - 1)) data_list_all = data_list_all_[a * 512:a * 512 + 512] data_list_all_data = np.array([i[0] for i in data_list_all]).astype(np.float64) data_list_all_label = np.array([i[1] for i in data_list_all]).astype(np.float64) data_list = data_list_[a * 384:a * 384 + 384]
weights='imagenet') partial_vgg = vgg.get_layer('block5_pool').output model = GlobalMaxPooling2D()(partial_vgg) model = Dense(len(classes), activation='sigmoid')(model) model = Model(input=[vgg.input], output=model) for l in model.layers[:-4]: try: l.trainable = False except Exception: pass model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) check = ModelCheckpoint("weights.{epoch:02d}-{val_loss:.5f}.hdf5", monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') early = EarlyStopping(monitor='val_loss', patience=20, verbose=0, mode='auto') print(model.summary()) training_generator = ImageDataGenerator(featurewise_center=False, samplewise_center=False, featurewise_std_normalization=False,
model = Dense(500, kernel_initializer='normal', activation='relu')(model_input) model = Dense(400, kernel_initializer='normal', activation='relu')(model) model = Dense(300, kernel_initializer='normal', activation='relu')(model) model = Dense(200, kernel_initializer='normal', activation='relu')(model) model = Dense(100, kernel_initializer='normal', activation='relu')(model) output_reshape = Dense(6, kernel_initializer='normal', activation='linear', name='output')(model) model = Model(inputs=model_input, outputs=output_reshape) model.summary() # Open the file with open(os.path.join(run_name, 'report.txt'), 'w') as fh: # Pass the file handle in as a lambda function to make it callable model.summary(print_fn=lambda x: fh.write(x + '\n')) model.compile(loss='mse', optimizer='adam', metrics=['mae', 'mse']) """**Training the Model**""" # loading the weight if training is already done, if not, then train if use_bestWeight: filename = '13_val_mae:0.0553.hdf5' model = load_model(os.path.join(run_name, filename)) model.fit_generator(generator=training_generator, validation_data=validation_generator, use_multiprocessing=True, workers=2, epochs=40 , verbose=1, callbacks=[callback, reduce_lr, tensorboard, early_stop]) """# **Prediction** ## **Running Prediction** """ model.evaluate_generator(testing_generator, workers=2, use_multiprocessing=True, verbose=1, callbacks=None)
kernel_size = 8 dnn_inp = Input(shape=(18, )) d = Dense(32, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(dnn_inp) d = Dense(32, activation='relu', kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(dnn_inp) d = Dense(32, activation='relu')(d) d_out = Dense(config.HTTPS_CONFIG["num_class"], activation='softmax', name='dnn_cnn_rnn')(d) # 模型网络的入口和出口 d = Model(inputs=[dnn_inp], outputs=d_out) d.compile(optimizer=Adam(lr=0.01), loss="categorical_crossentropy", metrics=["accuracy"]) # 以下输入数据进行wide and deep模型的训练 print(d.summary()) X_tr = [X_train_dnn] Y_tr = y_train_dnn # 测试集 X_te = [X_test_dnn] Y_te = y_test_dnn d.fit(X_tr, Y_tr, epochs=100, batch_size=128) results = d.evaluate(X_te, Y_te) print("\n", results) predicts = d.predict(X_te) y_pre = [np.argmax(i) for i in predicts]
output3 = Dense(31)(model1) output3_1 = Dense(3)(output3) output4 = Dense(32)(model1) output4_1 = Dense(3)(output4) model1 = Model(inputs = [input1, input2], outputs = [output3_1, output4_1] model1.summary() #3. 훈련 model1.compile(loss = 'mse', optimizer = 'adam', metrics=['mse']) # acc분류 지표 따라서 오차가 발생함에도 acc 1이 나옴 model1.fit([x1_train,x2_train] , [y1_train,y2_train],epochs=100, batch_size=1, validation_split=0.25,verbose=1) #epochs를 2000으로 fit을 했을 때 중간에 loss가 감소하다가 증가하는 구간이 발생 why? overfiting x_test = [x1_test, x2_test] y_test = [y1_test, y2_test] #4. 평가,예측 loss_tot, loss1, mse1 ,loss2,mse2= model1.evaluate(x_test,y_test, batch_size=1)
from keras.models import Sequential, Input, Model from keras.layers import Dense, Dropout, Conv2D, Flatten from keras.constraints import unit_norm from keras.optimizers import Adam input_shape = 70*13 print(input_shape) """MultiLayer Perceprton implementation""" model_dense_input = Input(shape=(input_shape,)) model_dense = Dense(units=128, activation='relu', input_dim=input_shape, kernel_constraint=unit_norm())(model_dense_input) model_dense = Dropout(0.5)(model_dense) model_dense = Dense(units=128, activation='relu')(model_dense) model_dense = Dense(units=64, activation='relu')(model_dense) model_dense = Dense(units=10, activation='softmax')(model_dense) model_dense = Model(inputs=model_dense_input, output=model_dense) model_dense.summary() adam = Adam(lr = 0.001) model_dense.compile(loss='categorical_crossentropy', optimizer = adam, metrics=['accuracy']) model_dense.save('model_dense_untrained.h5')