def model_instance_master(channels, loss_rate, clip_norm): input_img = Input((None, None, channels)) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(input_img) # padding = 'same' should be zero padding for ii in range(0, 18): model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(1, (3, 3), padding='same', kernel_initializer='he_normal')(model) res_img = model output_img = add([res_img, input_img]) model = Model(input_img, output_img) adam = Adam(lr=loss_rate, clipnorm=clip_norm) # loss function is an input argument but MSE seems to generally work well model.compile(optimizer=adam, loss='mean_squared_error', metrics=['mean_squared_error']) return model
def residual_TCN_LSTM(n_nodes, conv_len, n_classes, n_feat, max_len, loss='categorical_crossentropy', online=False, optimizer="rmsprop", depth=3, return_param_str=False): n_layers = len(n_nodes) inputs = Input(shape=(max_len, n_feat)) model = inputs prev = Conv1D(n_nodes[0], conv_len, padding='same')(model) # encoder for i in range(n_layers): for j in range(depth): # convolution over the temporal dimension current = encoder_identify_block(prev, n_nodes[i], conv_len) # residual connection within residual block if j != 0: model = add([prev, current]) model = Activation('relu')(model) prev = current if i < (n_layers - 1): model = MaxPooling1D(2)(model) # decoder # for i in range(n_layers): # # for j in range(depth): # # current = decoder_identify_block(model, n_nodes[-i - 1]) # model = add([prev, current]) # prev = current # model = UpSampling1D(2)(model) # Output FC layer model = TimeDistributed(Dense(n_classes, activation="softmax"))(model) model = Model(inputs=inputs, outputs=model) model.compile(loss=loss, optimizer=optimizer, sample_weight_mode="temporal", metrics=['accuracy']) model.summary() if return_param_str: param_str = "ED-TCN_C{}_L{}".format(conv_len, n_layers) if online: param_str += "_online" return model, param_str else: return model
def build_model(self): inputs = Input(shape=(self.img_dims[0], self.img_dims[1], self.num_consecutive_frames)) model = Conv2D(32, (8, 8), strides=(4, 4), padding='valid')(inputs) model = Activation('relu')(model) model = Conv2D(64, (4, 4), strides=(2, 2), padding='valid')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), strides=(1, 1), padding='valid')(model) model = Activation('relu')(model) model = Flatten()(model) model = Dense(512)(model) model = Activation('relu')(model) model = Dense(self.num_actions)(model) model = Model(inputs=inputs, outputs=model) adam = Adam(lr=self.learning_rate) model.compile(loss='mse', optimizer=adam) print("We finish building the model") self.model = model
def build_model(self): inputs = Input(shape=(self.img_dims[0], self.img_dims[1], self.num_consecutive_frames)) model = Conv2D(32, (8, 8), strides=(4, 4), padding='valid')(inputs) model = Activation('relu')(model) model = Conv2D(64, (4, 4), strides=(2, 2), padding='valid')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), strides=(1, 1), padding='valid')(model) model = Activation('relu')(model) stream = Flatten()(model) advantage = Dense(self.num_actions, name='Advantage_stream')(stream) value = Dense(1, name='Value_stream')(stream) def mean(x): import keras.backend res = keras.backend.mean(x, axis=1, keepdims=True) return res meanRes = Lambda(function=mean, name='Mean_layer')(advantage) from keras.layers import Concatenate concatenations = [] for i in range(self.num_actions): concatenations.append(meanRes) meanRes = Concatenate(name='Mean_broadcasting')(concatenations) advantage = keras.layers.subtract([advantage, meanRes], name='A_z') qOut = keras.layers.add([value, advantage], name='Q_out') model = Model(inputs=inputs, outputs=qOut) adam = Adam(lr=self.learning_rate) model.compile(loss='mse', optimizer=adam) print("We finish building the model") self.model = model self.target_model = Agent.copy_model(self.model)
def model_train(img_size, batch_size, epochs, optimizer, learning_rate, train_list, validation_list, style=2): print('Style {}.'.format(style)) if style == 1: input_img = Input(shape=img_size) #model = Sequential() model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', input_shape=img_size)(input_img) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(1, (3, 3), padding='same', kernel_initializer='he_normal')(model) res_img = model output_img = merge.Add()([res_img, input_img]) model = Model(input_img, output_img) #model.load_weights('vdsr_model_edges.h5') adam = Adam(lr=0.000005) #sgd = SGD(lr=1e-3, momentum=0.9, decay=1e-4, nesterov=False) sgd = SGD(lr=0.01, momentum=0.9, decay=0.001, nesterov=False) #model.compile(sgd, loss='mse', metrics=[PSNR, "accuracy"]) model.compile(adam, loss='mse', metrics=[ssim, ssim_metric, PSNR, "accuracy"]) model.summary() else: input_img = Input(shape=img_size) model = Conv2D(64, (3, 3), padding='valid', kernel_initializer='he_normal')(input_img) model_0 = Activation('relu')(model) total_conv = 22 # should be even number total_conv -= 2 # subtract first and last residual_block_num = 5 # should be even number for _ in range(residual_block_num): # residual block model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model_0) model = Activation('relu')(model) for _ in range(int(total_conv / residual_block_num) - 1): model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model_0 = add([model, model_0]) model = Conv2D(1, (3, 3), padding='valid', kernel_initializer='he_normal')(model) res_img = model input_img1 = crop(1, 2, -2)(input_img) input_img1 = crop(2, 2, -2)(input_img1) print(input_img.shape) print(input_img1.shape) output_img = merge.Add()([res_img, input_img1]) # output_img = res_img model = Model(input_img, output_img) # model.load_weights('./vdsr_model_edges.h5') # adam = Adam(lr=learning_rate) adam = Adadelta() # sgd = SGD(lr=1e-7, momentum=0.9, decay=1e-2, nesterov=False) sgd = SGD(lr=learning_rate, momentum=0.9, decay=1e-4, nesterov=False, clipnorm=1) if optimizer == 0: model.compile(adam, loss='mse', metrics=[ssim, ssim_metric, PSNR]) else: model.compile(sgd, loss='mse', metrics=[ssim, ssim_metric, PSNR]) model.summary() mycallback = MyCallback(model) timestamp = time.strftime("%m%d-%H%M", time.localtime(time.time())) csv_logger = callbacks.CSVLogger( 'data/callbacks/training_{}.log'.format(timestamp)) filepath = "./checkpoints/weights-improvement-{epoch:03d}-{PSNR:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor=PSNR, verbose=1, mode='max') callbacks_list = [mycallback, checkpoint, csv_logger] # print('Loading training data.') # x = load_images(DATA_PATH) # print('Loading data label.') # y = load_images(LABEL_PATH) # print('Loading validation data.') # val = load_images(VAL_PATH) # print('Loading validation label.') # val_label = load_images(VAL_LABEL_PATH) # print(x.shape) # print(y.shape) # print(val.shape) # print(val_label.shape) with open('./model/vdsr_architecture.json', 'w') as f: f.write(model.to_json()) # datagen = ImageDataGenerator(rotation_range=45, # zoom_range=0.15, # horizontal_flip=True, # vertical_flip=True) # history = model.fit_generator(datagen.flow(x, y, batch_size=batch_size), # steps_per_epoch=len(x) // batch_size, # validation_data=(val, val_label), # validation_steps=len(val) // batch_size, # epochs=epochs, # callbacks=callbacks_list, # verbose=1, # shuffle=True, # workers=256, # use_multiprocessing=True) history = model.fit_generator( image_gen(train_list, batch_size=batch_size), steps_per_epoch=384400 * (len(train_list)) // batch_size, # steps_per_epoch=4612800//batch_size, validation_data=image_gen(validation_list, batch_size=batch_size), validation_steps=384400 * (len(validation_list)) // batch_size, epochs=epochs, workers=1024, callbacks=callbacks_list, verbose=1) print("Done training!!!") print("Saving the final model ...") model.save('vdsr_model.h5') # creates a HDF5 file del model # deletes the existing model # plt.plot(history.history['accuracy']) # plt.plot(history.history['val_accuracy']) # plt.title('Model accuracy') # plt.ylabel('Accuracy') # plt.xlabel('Epoch') # plt.legend(['Train', 'validation'], loc='upper left') # # plt.show() # plt.savefig('accuracy.png') # Plot training & validation loss values plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'validation'], loc='upper left') # plt.show() plt.savefig('loss.png') plt.plot(history.history['PSNR']) plt.plot(history.history['val_PSNR']) plt.title('Model PSNR') plt.ylabel('PSNR') plt.xlabel('Epoch') plt.legend(['Train', 'validation'], loc='upper left') # plt.show() plt.savefig('PSNR.png')
model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(1, (3, 3), padding='same', kernel_initializer='he_normal')(model) res_img = model output_img = add([res_img, input_img]) model = Model(input_img, output_img) # model.load_weights('./checkpoints/weights-improvement-20-26.93.hdf5') adam = Adam(lr=0.001, decay=1e-5, clipvalue=0.1, epsilon=1e-8) sgd = SGD(lr=1e-2, momentum=0.9, decay=1e-4, nesterov=False) model.compile(adam, loss='mse', metrics=[PSNR, "accuracy"]) model.summary() # 每个epoch保存一次模型 filepath = "./checkpoints2/vdsr-{epoch:02d}-{PSNR:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor=PSNR, verbose=1, mode='max') callbacks_list = [checkpoint] # 记录每次训练的loss,PSNR值 train_log = CSVLogger(filename="train.log") model.fit(x=train_input, y=train_label, batch_size=BATCH_SIZE, epochs=EPOCHS, callbacks=callbacks_list, shuffle=True) print("Done training!!!")
def ED_TCN(n_nodes, conv_len, n_classes, n_feat, max_len, loss='categorical_crossentropy', online=False, optimizer="rmsprop", activation='norm_relu', attention=True, return_param_str=False): n_layers = len(n_nodes) # inputs = Input(shape=(max_len, n_feat)) inputs = Input(shape=(None, n_feat)) # attention layer, apply weightings to input if attention: model = attention_block(inputs, 100) else: model = inputs # ---- Encoder ---- for i in range(n_layers): # Pad beginning of sequence to prevent usage of future data if online: model = ZeroPadding1D((conv_len // 2, 0))(model) # convolution over the temporal dimension model = Conv1D(n_nodes[i], conv_len, padding='same')(model) if online: model = Cropping1D((0, conv_len // 2))(model) model = SpatialDropout1D(0.3)(model) if activation == 'norm_relu': model = Activation('relu')(model) model = Lambda(channel_normalization, name="encoder_norm_{}".format(i))(model) elif activation == 'wavenet': model = WaveNet_activation(model) else: model = Activation(activation)(model) # hidden features layer when in the last interation model = MaxPooling1D(2)(model) # ---- Decoder ---- for i in range(n_layers): model = UpSampling1D(2)(model) if online: model = ZeroPadding1D((conv_len // 2, 0))(model) model = Conv1D(n_nodes[-i - 1], conv_len, padding='same')(model) if online: model = Cropping1D((0, conv_len // 2))(model) model = SpatialDropout1D(0.3)(model) if activation == 'norm_relu': model = Activation('relu')(model) model = Lambda(channel_normalization, name="decoder_norm_{}".format(i))(model) elif activation == 'wavenet': model = WaveNet_activation(model) else: model = Activation(activation)(model) # Output FC layer model = TimeDistributed(Dense(n_classes, activation="softmax"))(model) model = Model(inputs=inputs, outputs=model) model.compile(loss=loss, optimizer=optimizer, sample_weight_mode="temporal", metrics=['accuracy']) model.summary() if return_param_str: param_str = "ED-TCN_C{}_L{}".format(conv_len, n_layers) if online: param_str += "_online" return model, param_str else: return model
def define_model_weighted(structure, filters, dropouts, init_shape, weight_decay, num_classes, weight = 1., temperature = 1): """ This model is a modified version of the previous one. The only difference is that this has two outputs: one with soft labels depending on the temperature (same as previous model) and an additional output with the hard labels (softmax with temperature 1). The soft labels are trained by distillation from the complex network and the hard labels with the real labels from the dataset. Cross-entropy loss for both outputs but with different weights, Temperature-normalized. Small pack: conv2d -> elu -> BN Big Pack: at least 1 small pack + maxPool + DropOut :param structure: list of integers. Each number indicates one "Big Pack", and the number itself the number of "small packs" in the "Big Pack". Strcture = [2,2,2] is the one of the complex network :param filters: list of integers, number of filters in the conv2d of each Big Pack. filters = [32, 64, 128] for the complex network :param dropouts: drop-out ratio for the drop out layer at the end of each Big Pack. for the complex network dropouts = [0.2, 0.3, 0.4] :return: model """ # Check that the input of the function has sense assert len(structure)==len(filters)==len(dropouts), "The length of the inputs don't match" assert min(structure) > 0, "All the Big Packs should include at least one Small Pack" assert min(dropouts) > 0 or max(dropouts) < 1, "Drop outs should be between 0 an 1" # Definition of the network, Functional API in order to handle multiple outputs inp = Input(init_shape) for i, number_small_pack in enumerate(structure): for j in range(number_small_pack): if i + j == 0: model = Conv2D(filters[i], (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))(inp) else: model = Conv2D(filters[i], (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))(model) model = Activation('elu')(model) model = BatchNormalization()(model) model = MaxPooling2D(pool_size=(2,2))(model) model = Dropout(dropouts[i])(model) model = Flatten()(model) dense = Dense(num_classes)(model) out_hard = Activation('softmax', name = 'out_hard')(dense) out_soft = Lambda(lambda x: x / temperature)(dense) out_soft = Activation('softmax', name = 'out_soft')(out_soft) model = Model(inputs = inp, outputs = [out_hard, out_soft]) # handle multiple losses and weights losses = { "out_hard": "categorical_crossentropy", "out_soft": "categorical_crossentropy", } lossWeights = {"out_soft": temperature**2, "out_hard": weight} model.compile(loss=losses, loss_weights = lossWeights, optimizer='adam', metrics=['accuracy']) return model
model.fit(X_train, y[train_idx], batch_size=cm.bs, epochs=cm.n_ep, verbose=0, callbacks=[cm.custom_stopping(value=cm.loss, verbose=2)], validation_data=(X_train, y[train_idx])) hyper_net = LatentHyperNet(n_comp=19, model=model, layers=layers, dm_method='pls') hyper_net.fit(X_train, y[train_idx]) X_train = hyper_net.transform(X_train) X_test = hyper_net.transform(X_test) inp = Input((X_train.shape[1],)) fc = Dense(n_class)(inp) model = Activation('softmax')(fc) model = Model(inp, model) model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='Adadelta') callbacks = [cm.custom_stopping(value=cm.loss, verbose=2)] model.fit(X_train, y[train_idx], batch_size=len(X_train), epochs=4*cm.n_ep,#The drawback of the method is that it requires more iterations to converge (loss <= cm.loss) verbose=0, callbacks=callbacks, validation_data=(X_train, y[train_idx])) y_pred = model.predict(X_test) y_pred = np.argmax(y_pred, axis=1) y_true = np.argmax(y[test_idx], axis=1) acc_fold = accuracy_score(y_true, y_pred) avg_acc.append(acc_fold) recall_fold = recall_score(y_true, y_pred, average='macro')
activation='relu', kernel_initializer='he_normal')(model) model = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal')(model) res_img = model #Skip Connection output_img = add([res_img, input_img]) model = Model(input_img, output_img) #model.load_weights('./Saved Models/sr_PBNet_model_with200epoch') adam = Adam(lr=0.001, decay=1e-4) sgd = SGD(lr=1e-5, momentum=0.9, decay=1e-4, nesterov=False) #custom_loss = mae_mssim_loss(alpha=0.8) model.compile(adam, loss='mae', metrics=[PSNR, SSIM]) model.summary() filepath = "./saved_weights/weights-improvement-{epoch:02d}-{val_PSNR:.2f}.h5" checkpoint = ModelCheckpoint(filepath, monitor='val_PSNR', verbose=1, save_best_only=True, save_weights_only=True, mode='max') lrate = LearningRateScheduler(step_decay) callbacks_list = [checkpoint, lrate] print("Started training") history = model.fit_generator(image_gen(train_list), steps_per_epoch=len(train_list) // BATCH_SIZE, \ validation_data=image_gen(test_list), validation_steps=len(test_list) // BATCH_SIZE, epochs=EPOCHS, workers=32, callbacks=callbacks_list, verbose=1)
def model_train(img_size, batch_size, epochs, optimizer, learning_rate, train_list, validation_list, style=2): print('Style {}.'.format(style)) if style == 1: input_img = Input(shape=img_size) #model = Sequential() model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', input_shape=img_size)(input_img) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(1, (3, 3), padding='same', kernel_initializer='he_normal')(model) res_img = model output_img = merge.Add()([res_img, input_img]) model = Model(input_img, output_img) #model.load_weights('vdsr_model_edges.h5') adam = Adam(lr=0.000005) sgd = SGD(lr=0.01, momentum=0.9, decay=0.001, nesterov=False) model.compile(adam, loss='mse', metrics=[ssim, ssim_metric, PSNR, "accuracy"]) model.summary() else: input_img = Input(shape=img_size) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', use_bias=False)(input_img) model = BatchNormalization()(model) model_0 = Activation('relu')(model) total_conv = 22 # should be even number total_conv -= 2 # subtract first and last residual_block_num = 5 # should be even number for _ in range(residual_block_num): # residual block model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', use_bias=False)(model_0) model = BatchNormalization()(model) model = Activation('relu')(model) print(_) for _ in range(int(total_conv/residual_block_num)-1): model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', use_bias=False)(model) model = BatchNormalization()(model) model = Activation('relu')(model) model_0 = add([model, model_0]) print(_) model = Conv2DTranspose(64, (5, 5), padding='valid', kernel_initializer='he_normal', use_bias=False)(model) model = BatchNormalization()(model) model = LeakyReLU()(model) model = Conv2D(1, (5, 5), padding='valid', kernel_initializer='he_normal')(model) res_img = model #input_img1 = crop(1,22,-22)(input_img) #input_img1 = crop(2,22,-22)(input_img1) print(input_img.shape) output_img = merge.Add()([res_img, input_img]) # output_img = res_img model = Model(input_img, output_img) # model.load_weights('./vdsr_model_edges.h5') # adam = Adam(lr=learning_rate) adam = Adadelta() sgd = SGD(lr=learning_rate, momentum=0.9, decay=1e-4, nesterov=False, clipnorm=1) if optimizer == 0: model.compile(adam, loss='mse', metrics=[ssim, ssim_metric, PSNR]) else: model.compile(sgd, loss='mse', metrics=[ssim, ssim_metric, PSNR]) model.summary() mycallback = MyCallback(model) timestamp = time.strftime("%m%d-%H%M", time.localtime(time.time())) csv_logger = callbacks.CSVLogger('data/callbacks/deconv/training_{}.log'.format(timestamp)) filepath="./checkpoints/deconv/weights-improvement-{epoch:03d}-{PSNR:.2f}-{ssim:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor=PSNR, verbose=1, mode='max') callbacks_list = [mycallback, checkpoint, csv_logger] with open('./model/deconv/vdsr_architecture.json', 'w') as f: f.write(model.to_json()) history = model.fit_generator(image_gen(train_list, batch_size=batch_size), steps_per_epoch=(409600//8)*len(train_list) // batch_size, validation_data=image_gen(validation_list,batch_size=batch_size), validation_steps=(409600//8)*len(validation_list) // batch_size, epochs=epochs, workers=1024, callbacks=callbacks_list, verbose=1) print("Done training!!!") print("Saving the final model ...") model.save('vdsr_model.h5') # creates a HDF5 file del model # deletes the existing model # Plot training & validation loss values plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'validation'], loc='upper left') # plt.show() plt.savefig('loss.png') plt.plot(history.history['PSNR']) plt.plot(history.history['val_PSNR']) plt.title('Model PSNR') plt.ylabel('PSNR') plt.xlabel('Epoch') plt.legend(['Train', 'validation'], loc='upper left') # plt.show() plt.savefig('PSNR.png')
model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(model) model = Activation('relu')(model) model = Conv2D(1, (3, 3), padding='same', kernel_initializer='he_normal')(model) res_img = model output_img = add([res_img, input_img]) model = Model(input_img, output_img) # model.load_weights('./checkpoints/weights-improvement-20-26.93.hdf5') adam = Adam(lr=0.00001) sgd = SGD(lr=1e-5, momentum=0.9, decay=1e-4, nesterov=False) model.compile(adam, loss='mse', metrics=[PSNR, "accuracy"]) model.summary() filepath="./checkpoints/weights-improvement-{epoch:02d}-{PSNR:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor=PSNR, verbose=1, mode='max') callbacks_list = [checkpoint] model.fit_generator(image_gen(train_list), steps_per_epoch=len(train_list) // BATCH_SIZE, \ validation_data=image_gen(test_list), validation_steps=len(train_list) // BATCH_SIZE, \ epochs=EPOCHS, workers=8, callbacks=callbacks_list) print("Done training!!!") print("Saving the final model ...")