def TrainModel(path, train_dir, val_dir, batch_size, epochs, out_nums, nb_train_samples, nb_val_samples, img_width=256, img_height=256, freeze=13): #生成训练和验证数据 train_datagen = ImageDataGenerator( preprocessing_function=preprocess_input, rotation_range=40, # width_shift_range=0.2, # height_shift_range=0.2, # shear_range=0.2, # zoom_range=0.2, horizontal_flip=True, ) # 训练数据预处理器,随机水平翻转 test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) # 测试数据预处理器 train_generator = train_datagen.flow_from_directory(train_dir, target_size=(img_width, img_height), batch_size=batch_size, # class_mode='binary' ) # 训练数据生成器 validation_generator = test_datagen.flow_from_directory(val_dir, target_size=(img_width, img_height), batch_size=batch_size, # class_mode='binary', shuffle=True) # 验证数据生成器 base_model = VGG16(weights=path, include_top=False, #加载迁移学习模型 input_shape=(img_width, img_height, 3)) for ix, layers in enumerate(base_model.layers): if ix < freeze: #冻结指定层 layers.trainable = False # layers.trainable = False #冻结指定层数层 #添加新的层用于训练 model = Flatten()(base_model.output) model = Dense(256, activation='relu', name='fc1')(model) model = Dropout(0.5, name='dropout1')(model) #=========================新加一层全连接======================= # model = Dense(64, activation='relu', name='fc2')(model) # model = Dropout(0.5, name='dropout2')(model) #============================================================== model = Dense(out_nums, activation='softmax')(model) # model = Dense(out_nums, activation='sigmoid')(model) model_final = Model(inputs=base_model.input, outputs=model) model_final.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.0001, momentum=0.9), metrics=['accuracy']) # model_final.compile(loss='binary_crossentropy', # optimizer=SGD(lr=0.0001, momentum=0.9), # metrics=['accuracy']) print(model_final.summary()) callbacks = [ EarlyStopping(patience=2, verbose=1), ModelCheckpoint('savemodel_1fc256.h5', monitor='val_acc', verbose=1, save_best_only=True, mode='max') # ModelCheckpoint('savemodel_1fc256_3conv_binary.h5', verbose=1, save_best_only=False, mode='max') ] # 训练&评估 model_final.fit_generator(train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=nb_val_samples // batch_size, callbacks=callbacks, initial_epoch=0) # 每轮一行输出结果
def evaluate_on_cifar10(): total_depth = 36 n_blocks = 3 basic_block_count = total_depth // n_blocks # region Model input_layer = Input(shape=[32, 32, 3]) layer = input_layer kernel_initializer = ResBlock2D.get_fixup_initializer(total_depth) for k in range(n_blocks): strides = 2 if k < (n_blocks - 1) else 1 layer = ResBlock2D(filters=16 * (2**k), basic_block_count=basic_block_count, strides=strides, kernel_initializer=kernel_initializer, use_residual_bias=True)(layer) if k == (n_blocks - 1): layer = AveragePooling2D(pool_size=8)(layer) layer = Flatten()(layer) layer = Dense(units=10, activation="softmax")(layer) model = Model(inputs=input_layer, outputs=layer) model.summary() model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["acc"]) # endregion # region Data (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train = x_train.astype(np.float32) / 255.0 x_test = x_test.astype(np.float32) / 255.0 y_train = to_categorical(y_train, num_classes=10) y_test = to_categorical(y_test, num_classes=10) generator = ImageDataGenerator(rotation_range=15, width_shift_range=5. / 32, height_shift_range=5. / 32, horizontal_flip=True) generator.fit(x_train, seed=0) # endregion log_dir = "../logs/tests/res_block_cifar10/{}".format(int(time())) log_dir = os.path.normpath(log_dir) tensorboard = TensorBoard(log_dir=log_dir, profile_batch=0) model.fit_generator(generator.flow(x_train, y_train, batch_size=64), steps_per_epoch=100, epochs=300, validation_data=(x_test, y_test), validation_steps=100, verbose=1, callbacks=[tensorboard])
def train_raw(): # show class indices print('****************') for cls, idx in train_batches.class_indices.items(): print('Class #{} = {}'.format(idx, cls)) print('****************') # build our classifier model based on pre-trained InceptionResNetV2: # 1. we don't include the top (fully connected) layers of InceptionResNetV2 # 2. we add a DropOut layer followed by a Dense (fully connected) # layer which generates softmax class score for each class # 3. we compile the final model using an Adam optimizer, with a # low learning rate (since we are 'fine-tuning') net = InceptionResNetV2(include_top=False, weights='imagenet', input_tensor=None, input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3)) x = net.output x = Flatten()(x) x = Dropout(0.5)(x) output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(x) net_final = Model(inputs=net.input, outputs=output_layer) for layer in net_final.layers[:FREEZE_LAYERS]: layer.trainable = False for layer in net_final.layers[FREEZE_LAYERS:]: layer.trainable = True net_final.compile(optimizer=Adam(lr=1e-5), loss='categorical_crossentropy', metrics=['accuracy']) #print(net_final.summary()) # train the model for i in range(1): net_final.fit_generator( train_batches, steps_per_epoch=train_batches.samples // BATCH_SIZE // 10, validation_data=valid_batches, validation_steps=valid_batches.samples // BATCH_SIZE // 10, epochs=1) gen_sub(net_final, testdf, sn=i) WEIGHTS_FINAL = f'./output/model-inception_resnet_v{i}-27.h5' # save trained weights net_final.save(WEIGHTS_FINAL) print(f'weight save to {WEIGHTS_FINAL}') return WEIGHTS_FINAL
async def training(): if not os.path.exists(file_path): flatten = Flatten()(merged) dense = Dense(64)(flatten) activation = Activation('softmax')(dense) dropout = Dropout(0.5)(activation) dense = Dense(1591)(dropout) activation = Activation('softmax')(dense) base_model = Model(input_img, activation) else: base_model = load_model(file_path) for layer in base_model.layers: if layer.name is 'inception4_branch_3' \ and layer.name is 'inception4d_activation_branch_3' \ and layer.name is 'inception4e_activation_branch_3' \ and layer.name is 'inception5a_activation_branch_3' \ and layer.name is 'inception5b_4_branch_3': layer.trainable = False # base_model.load_weights(file_path) base_model.summary() train_generator_lr = datagen.flow_from_directory( str(path_data_set + '/train'), target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical', shuffle=True) validation_generator_lr = datagen.flow_from_directory( str(path_data_set + '/validate'), target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical', shuffle=True) print('training: ') base_model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) checkpoint = ModelCheckpoint(file_path, monitor='val_loss', save_best_only=True, mode='auto', verbose=1) callbacks_list = [checkpoint] history = base_model.fit_generator(generator=train_generator_lr, steps_per_epoch=num_train_images // batch_size, epochs=epochs, validation_data=validation_generator_lr, validation_steps=800 // batch_size, callbacks=callbacks_list) common_func = common_function.CommonFunction() common_func.plot_training(history, 'TBE-CNN (2 Branch - Epoch 40)')
def fit_train(train_path, test_path): train_datagen = ImageDataGenerator() test_datagen = ImageDataGenerator() print("获取测试数据... ...") test_generator = test_datagen.flow_from_directory(test_path, target_size=(224, 224), batch_size=32) print("获取训练数据... ...") train_generator = train_datagen.flow_from_directory(train_path, target_size=(224, 224), batch_size=32) print("开始训练... ...") logging = TensorBoard(log_dir='/home/app/program/micro_emotion/log') early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=1) model_check = ModelCheckpoint(filepath=pre_model, monitor='val_loss', save_best_only=True) lr_decay = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, min_delta=0.001) model = RN.resnet10(include_top=False, weights=ori_model, pooling='avg', input_shape=(224, 224, 3), classes=7) x = model.output x = Dense(7, activation='softmax', name='fc8_5')(x) model = Model(inputs=model.input, outputs=x) model.compile(loss="categorical_crossentropy", optimizer=SGD(lr=0.01, momentum=0.9, decay=0.1 / 20), metrics=['accuracy']) history = model.fit_generator( train_generator, steps_per_epoch=346, epochs=60, validation_data=test_generator, validation_steps=38, callbacks=[logging, early_stopping, model_check, lr_decay])
model = Model(inputs=inputs, outputs=outputs, name='CNN') model.summary() # training # https://github.com/keras-team/keras/issues/10842 # https://stackoverflow.com/questions/52932406/is-the-class-generator-inheriting-sequence-thread-safe-in-keras-tensorflow # use_multiprocessing not working on Windows if gpus <= 1: # 1 gpu model.compile(optimizer=Adam(lr=1e-3), loss='mean_squared_error', metrics=[r_squared]) original_weights = keras.backend.batch_get_value(model.weights) model.fit_generator(generator=training_generator, validation_data=validation_generator, epochs=epochs, use_multiprocessing=False, callbacks=callbacks, workers=4) # check weights weights = keras.backend.batch_get_value(model.weights) if all([np.all(w == ow) for w, ow in zip(weights, original_weights)]): print('Weights in the template model have not changed') else: print('Weights in the template model have changed') else: # 2 gpus original_weights = keras.backend.batch_get_value(model.weights) parallel_model = multi_gpu_model(model, gpus=gpus, cpu_relocation=False, cpu_merge=True)
K.clear_session() basemodel = VGG16(weights='imagenet') LAYER = "fc2" headModel = basemodel.get_layer(LAYER).output headModel = Dense(50, activation="softmax")(headModel) model = Model(inputs=basemodel.input, outputs=headModel) opt = optimizers.SGD(lr=1e-3, momentum=0.9) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) for layer in basemodel.layers: layer.trainable = False train_generator = DataGenerator(indexes=train, **generator_parameters) val_generator = DataGenerator(indexes=test, **generator_parameters) model.fit_generator(generator=train_generator, validation_data=val_generator, epochs=8) model.save("%s/VGG16_%s.h5" % (dump_folder, fold_id)) generator_parameters["shuffle"] = False val_generator = DataGenerator(indexes=test, **generator_parameters) y_pred_raw = model.predict_generator(val_generator) y_pred = np.argmax(y_pred_raw, axis=-1) y_true = np.argmax(y[test], axis=-1) model_predictions = ({ "path": np.array(metadata_df.path.values.tolist())[test], "y_true": y_true, "y_pred": y_pred,
return loss_mean optimizer = optimizers.RMSprop() decoder_target = tf.placeholder(dtype='int32', shape=(None, None)) language_model.compile(optimizer=optimizer, loss=sparse_cross_entropy, target_tensors=[decoder_target]) path_checkpoint = 'model_weights.keras' callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint, verbose=1, save_weights_only=True) callback_tensorboard = TensorBoard(log_dir='./train_logs/', histogram_freq=0, write_graph=False) callbacks = [callback_checkpoint, callback_tensorboard] for i in range(epoch_start, epoch_end, 1): generator = data_generator(train_tokens, id_map, vgg_activations, batch_size=batch_size, single_caption=False) steps = int(len(all_caps_train) / batch_size) language_model.fit_generator(generator, steps_per_epoch=steps, epochs=i + 1, callbacks=callbacks, initial_epoch=i)
def evaluate_on_cifar10(): total_depth = 100 n_blocks = 3 depth = (total_depth - 4) // n_blocks growth_rate = 12 filters = growth_rate * 2 # region Model input_layer = Input(shape=[32, 32, 3]) layer = input_layer layer = Conv2D(filters=filters, kernel_size=3, strides=1, padding="same")(layer) for k in range(n_blocks): layer = DenseBlock2D(kernel_size=3, growth_rate=growth_rate, depth=depth, use_batch_normalization=True)(layer) if k < (n_blocks - 1): filters += growth_rate * depth // 4 layer = transition_block(layer, filters) else: layer = AveragePooling2D(pool_size=8)(layer) layer = Flatten()(layer) layer = Dense(units=10, activation="softmax")(layer) model = Model(inputs=input_layer, outputs=layer) model.summary() model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["acc"]) # endregion # region Data (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train = x_train.astype(np.float32) / 255.0 x_test = x_test.astype(np.float32) / 255.0 y_train = to_categorical(y_train, num_classes=10) y_test = to_categorical(y_test, num_classes=10) generator = ImageDataGenerator(rotation_range=15, width_shift_range=5. / 32, height_shift_range=5. / 32, horizontal_flip=True) generator.fit(x_train, seed=0) # endregion log_dir = "../logs/tests/dense_block_cifar10/{}".format(int(time())) log_dir = os.path.normpath(log_dir) tensorboard = TensorBoard(log_dir=log_dir, profile_batch=0) model.fit_generator(generator.flow(x_train, y_train, batch_size=64), steps_per_epoch=100, epochs=300, validation_data=(x_test, y_test), validation_steps=100, verbose=1, callbacks=[tensorboard])
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc', recall, precision]) history = History() npt_monitor = NeptuneMonitor(hprm['BATCH_SIZE']) # --------------------------------------------------------------------------------------------------------------------- # --------------------------------------------- # TRAIN TOP LAYERS ON NEW DATA FOR A FEW EPOCHS| # --------------------------------------------- post_training_model = model.fit_generator(training_generator, steps_per_epoch=((hprm['TRAIN_SIZE'] // hprm['BATCH_SIZE'])+1), epochs=10, # number of epochs, training cycles validation_data=validation_generator, # performance eval on test set validation_steps=((hprm['TEST_SIZE'] // hprm['BATCH_SIZE'])+1), verbose=1, callbacks=[history, npt_monitor]) # validation_output_callback]) y_pred = model.predict_generator(validation_generator, steps=(hprm['TEST_SIZE'] // hprm['BATCH_SIZE'])+1, callbacks=[], verbose=1) # --------------------------------------------------------------------------------------------------------------------- # -------------------------------------- # EXPORT MODEL ARCHITECTURE AND WEIGHTS | # -------------------------------------- # export model structure to json file:
class BaseModel(object): """Base Model Interface Methods ---------- fit(train_data, valid_data, epohcs, batch_size, **kwargs) predict(X) evaluate(X, y) Examples ---------- >>> model = Model("example", inference, "model.h5") >>> model.fit([X_train, y_train], [X_val, y_val]) """ def __init__(self, name, fn, model_path): """Constructor for BaseModel Parameters ---------- name : str Name of this model fn : function Inference function, y = fn(X) model_path : str Path to a model.h5 """ X = Input(shape=[28, 28, 1]) y = fn(X) self.model = Model(X, y, name=name) self.model.compile("adam", "categorical_crossentropy", ["accuracy"]) self.model.summary() self.path = model_path self.name = name ##self.load() def fit(self, train_data, valid_data, epochs=10, batchsize=128, **kwargs): """Training function Evaluate at each epoch against validation data Save the best model according to the validation loss Parameters ---------- train_data : tuple, (X_train, y_train) X_train.shape == (N, H, W, C) y_train.shape == (N, N_classes) valid_data : tuple (X_val, y_val) epochs : int Number of epochs to train batchsize : int Minibatch size **kwargs Keywords arguments for `fit_generator` """ callback_best_only = ModelCheckpoint(self.path, save_best_only=True) train_gen, val_gen = train_generator() X_train, y_train = train_data X_val, y_val = valid_data N = X_train.shape[0] print("[DEBUG] N -> {}", X_train.shape) N_val = X_val.shape[0] self.model.fit_generator(train_gen.flow(X_train, y_train, batchsize), steps_per_epoch=N / batchsize, validation_data=val_gen.flow( X_val, y_val, batchsize), validation_steps=N_val / batchsize, epochs=epochs, callbacks=[callback_best_only], **kwargs) def save(self): """Save weights Should not be used manually """ self.model.save_weights(self.path) def freeze(self, export_dir): """ Save Freeze Model """ tf.saved_model.simple_save( K.get_session(), os.path.join(export_dir, str(int(time.time()))), inputs={'inputs': self.model.input}, outputs={t.name: t for t in self.model.outputs}) def load(self): """Load weights from self.path """ if os.path.isfile(self.path): self.model.load_weights(self.path) print("Model loaded") else: print("No model is found") def predict(self, X): """Return probabilities for each classes Parameters ---------- X : array-like (N, H, W, C) Returns ---------- y : array-like (N, N_classes) Probability array """ return self.model.predict(X) def evaluate(self, X, y): """Return an accuracy Parameters ---------- X : array-like (N, H, W, C) y : array-like (N, N_classes) Returns ---------- acc : float Accuracy """ return self.model.evaluate(X, y)
verbose=1, factor=0.2, min_lr=0.0001) tensor_board = TensorBoard(log_dir='./graph') callbacks = [early_stop, checkpoint, learning_rate_reduction, tensor_board] model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['accuracy']) nb_train_samples = 28789 nb_validation_samples = 3589 epochs = 25 history = model.fit_generator(train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, callbacks=callbacks, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size) model_json = model.to_json() with open("emotion_classification_mobilenet_7_emotions.json", "w") as json_file: json_file.write(model_json)
outputs=[center_output], name='CenterNet') optimizer = Adam(lr=learning_rate) model.compile(loss='mean_squared_error', optimizer=optimizer) model.summary() ''' Train ''' checkpoint = ModelCheckpoint('models/'+model_name+'.h5', monitor='val_loss', verbose=1, save_best_only=True, mode='min') early_stopping = EarlyStopping( monitor='val_loss', mode='min', verbose=1, patience=50) history = model.fit_generator(generator(X_img_train, X_route_train, X_lane_train, y_train, batch_size), epochs=epochs, steps_per_epoch=X_img_train.shape[0]/batch_size, validation_data=generator(X_img_test, X_route_test, X_lane_test, y_test, batch_size), validation_steps=X_img_test.shape[0]/batch_size, callbacks=[checkpoint, early_stopping]) ''' Save graph ''' # inputs: ['dense_input'] print('inputs: ', [input.op.name for input in model.inputs]) # outputs: ['dense_4/Sigmoid'] print('outputs: ', [output.op.name for output in model.outputs]) # model.save(model_name+'.h5') frozen_graph = freeze_session(tf.keras.backend.get_session(), output_names=[ out.op.name for out in model.outputs]) tf.train.write_graph(frozen_graph, 'models', model_name+'.pbtxt', as_text=True)
## NN ends here # callbacks # tensorboard = TensorBoard(log_dir="logs/{}".format(time())) model_name = str(config[parser_args.task]['MODEL_FOLDER']) + '_temporal' + curr_time + '.h5' model_checkpoint = ModelCheckpoint(model_name, verbose=1, monitor='val_loss',save_best_only=True, mode='auto') early_stopping = EarlyStopping(monitor="val_loss", verbose=1, patience=8) log_file_name = os.path.join(config['plotting']['MEASURE_FOLDER'], 'evals-{}.json'.format(curr_time)) csv_logger = CSVLogger(filename=log_file_name, append = True) # generate a model by training history = model.fit_generator(train_generator, epochs=num_epochs, steps_per_epoch=36690//batch_size, validation_data= val_generator, validation_steps=12227//batch_size, verbose=1, callbacks=[model_checkpoint, early_stopping, csv_logger]) with open('{}-config_{}.ini'.format(config[parser_args.task]['MODEL_FOLDER'], curr_time), 'w') as cfgfile: newConfig = configparser.ConfigParser() newConfig[parser_args.task] = config[parser_args.task] #print(config[parser_args.task]) newConfig.write(cfgfile) print("Model is saved at: {}".format(model_name)) # model history generate plot visualize.visualize_curves(n_epochs=num_epochs, tr=history.history['loss'], val=history.history['val_loss'], filename='{}/loss_{}.png'.format(plot_path, curr_time), network='temporal', optimizer='adam', learning_rate=learning_rate, epsilon=epsilon, clf_type=parser_args.task, batch_size=batch_size, viz_type="loss", early_stopping=True)
metrics=['accuracy']) """ 8. 重新训练组合的新模型,仍然保持 VGG16 的 15 个最低层处于冻结状态。在这个特定的例子中,也使用 Image Augumentator 来增强训练集: """ train_datagen = ImageDataGenerator(rescale=1. / 255, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory(train_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='binary', shuffle=False) model.fit_generator(train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=nb_validation_samples // batch_size, verbose=2, workers=12) """ 9. 在组合网络上评估结果 """ score = model.evaluate_generator(validation_generator, nb_validation_samples / batch_size) scores = model.predict_generator(validation_generator, nb_validation_samples / batch_size) # print(score, scores)
ModelCheckpoint(monitor='val_loss', filepath=root_dir + 'weights/' + weight_name, save_best_only=True, save_weights_only=True, mode='min'), TQDMCallback(), TensorBoard(log_dir=root_dir + weight_name.split('.')[0], histogram_freq=0, write_graph=True, write_images=True) ] history = model.fit_generator( generator=train_generator(batch_size), steps_per_epoch=int((train_df.shape[0] / batch_size) / 18), #344, epochs=50, verbose=2, callbacks=callbacks, validation_data=valid_generator(batch_size), validation_steps=int(np.ceil(valid_df.shape[0] / batch_size))) model.load_weights(root_dir + 'weights/' + weight_name) test_paths = glob(os.path.join(root_dir, 'test/audio/*wav')) def get_test_set_1d(path, tta=1): if tta == 1: x_batch = [] x_batch.append(process_wav_file(path, phase='TEST', dim='1D')) x_batch = np.array(x_batch) return x_batch
x = Dense(len(POSSIBLE_LABELS), activation='sigmoid')(x) model = Model(inputs=x_in, outputs=x) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.summary() # In[ ]: from keras_tqdm import TQDMNotebookCallback from tensorflow.python.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau history = model.fit_generator(generator=train_generator(64), steps_per_epoch=344, epochs=10, verbose=1, validation_data=valid_generator(64), validation_steps=int( np.ceil(valid_df.shape[0] / 64))) # In[ ]: # In[ ]: test_paths = glob(os.path.join('./data/', 'test/audio/*wav')) # In[ ]: def read(): tmp = []
x = Dropout(0.5)(x) # 增加 Dense layer,以 softmax 產生個類別的機率值 output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(x) # 設定凍結與要進行訓練的網路層 net_final = Model(inputs=net.input, outputs=output_layer) for layer in net_final.layers[:FREEZE_LAYERS]: layer.trainable = False for layer in net_final.layers[FREEZE_LAYERS:]: layer.trainable = True # 使用 Adam optimizer,以較低的 learning rate 進行 fine-tuning net_final.compile(optimizer=Adam(lr=1e-5), loss='categorical_crossentropy', metrics=['accuracy']) # 輸出整個網路結構 print(net_final.summary()) # 訓練模型 history = net_final.fit_generator( train_datagen.flow(x_train, y_train, batch_size=BATCH_SIZE), steps_per_epoch=x_train.shape[0] // BATCH_SIZE, validation_data=(x_val, y_val), epochs=50, callbacks=[ ModelCheckpoint('ResNet_transferlearning.model', monitor='val_acc', save_best_only=True) ])
def iterative_prune_model(): # build the inception v3 network base_model = inception_v3.InceptionV3(include_top=False, weights='imagenet', pooling='avg', input_shape=(299, 299, 3)) print('Model loaded.') top_output = Dense(5, activation='softmax')(base_model.output) # add the model on top of the convolutional base model = Model(base_model.inputs, top_output) del base_model model.load_weights(tuned_weights_path) # compile the model with a SGD/momentum optimizer # and a very slow learning rate. model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) # Set up data generators train_datagen = ImageDataGenerator( preprocessing_function=inception_v3.preprocess_input, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='categorical') train_steps = train_generator.n // train_generator.batch_size test_datagen = ImageDataGenerator( preprocessing_function=inception_v3.preprocess_input) validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_height, img_width), batch_size=val_batch_size, class_mode='categorical') val_steps = validation_generator.n // validation_generator.batch_size # Evaluate the model performance before pruning loss = model.evaluate_generator(validation_generator, validation_generator.n // validation_generator.batch_size) print('original model validation loss: ', loss[0], ', acc: ', loss[1]) total_channels = get_total_channels(model) n_channels_delete = int(math.floor(percent_pruning / 100 * total_channels)) # Incrementally prune the network, retraining it each time percent_pruned = 0 # If percent_pruned > 0, continue pruning from previous checkpoint if percent_pruned > 0: checkpoint_name = ('inception_flowers_pruning_' + str(percent_pruned) + 'percent') model = load_model(output_dir + checkpoint_name + '.h5') while percent_pruned <= total_percent_pruning: # Prune the model apoz_df = get_model_apoz(model, validation_generator) percent_pruned += percent_pruning print('pruning up to ', str(percent_pruned), '% of the original model weights') model = prune_model(model, apoz_df, n_channels_delete) # Clean up tensorflow session after pruning and re-load model checkpoint_name = ('inception_flowers_pruning_' + str(percent_pruned) + 'percent') model.save(output_dir + checkpoint_name + '.h5') del model tensorflow.python.keras.backend.clear_session() tf.reset_default_graph() model = load_model(output_dir + checkpoint_name + '.h5') # Re-train the model model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) checkpoint_name = ('inception_flowers_pruning_' + str(percent_pruned) + 'percent') csv_logger = CSVLogger(output_dir + checkpoint_name + '.csv') model.fit_generator(train_generator, steps_per_epoch=train_steps, epochs=epochs, validation_data=validation_generator, validation_steps=val_steps, workers=4, callbacks=[csv_logger]) # Evaluate the final model performance loss = model.evaluate_generator(validation_generator, validation_generator.n // validation_generator.batch_size) print('pruned model loss: ', loss[0], ', acc: ', loss[1])
# Step 2-1: Replace softmax Layer and add one dense layer # include top = false will remove the last softmax layer, remove 1000 neutron from the model base_model = VGG16(weights='imagenet', include_top=False) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) prediction = Dense(2, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=prediction) for layer in model.layers: layer.trainable = False model.compile(loss='binary_crossentropy', optimizer=optimizers.SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) model.fit_generator(train_generator, steps_per_epoch=10, epochs=epochs) # Step 2-2: Unfreeze and train the top 5 layers for layer in model.layers[:5]: layer.trainable = False for layer in model.layers[5:]: layer.trainable = True model.compile(loss='binary_crossentropy', optimizer=optimizers.SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) model.fit_generator(train_generator, steps_per_epoch=10, epochs=epochs) # Save fine tuned weight model.save('./model/vgg16_cat_dog.h5')
subset='validation', batch_size=64, class_mode='categorical') model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy']) print(train_generator.n) print(train_generator.batch_size) print(239 // 32) # train the model step_size_train = train_generator.n // train_generator.batch_size r = model.fit_generator(generator=train_generator, steps_per_epoch=step_size_train, epochs=25, validation_data=val_generator) #save model from tensorflow.python.keras.models import load_model keras.models.save_model(model, 'tumor_prediction.h5', overwrite=True, include_optimizer=True) model.save('tumor_prediction.h5') train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) train_generator = train_datagen.flow_from_directory('./train_dataset', target_size=(224, 224),
adam = Adam(lr=0.0) metrics = ['accuracy'] model.compile(optimizer=adam, metrics=metrics, loss=categorical_crossentropy) model.fit_generator( train_generator, validation_data=test_generator, epochs=100, use_multiprocessing=False, workers=10, callbacks=[ ModelCheckpoint( '%s/model_{epoch:d}_loss{loss:.4f}_acc_{acc:.4f}.h5' % folder, monitor='val_loss', verbose=1, save_best_only=False, save_weights_only=True, mode='auto', period=1), CSVLogger(logger, append=log_append), lr_scheduler(initial_lr=3e-4, decay_factor=0.75, step_size=5, min_lr=1e-8) ], max_queue_size=30, ) elif mode == 'testing': adam = tf.train.AdamOptimizer(learning_rate=1e-3) model.compile(loss="categorical_crossentropy", optimizer=adam, metrics=['accuracy']) res = model.evaluate_generator( test_sequence,
def start_training(tn,vn,ims,bas,epc): training_num = tn validation_num = vn image_size = ims batch_size = bas epochs = epc WEIGHTS_FOLDER = './weights/' #WEIGHTS_FOLDER = save_path if not os.path.exists(WEIGHTS_FOLDER): os.mkdir(WEIGHTS_FOLDER) # Check if image dimension is correct. if type(image_size) is list: val1 = image_size[0] val2 = image_size[1] if val1 < 139 or val2 < 139: print("The size is not ok....") sys.exit(2) elif type(image_size) is int: if image_size <139: print("The size is not ok...") sys.exit(2) # Show the training condition print("Image size is {}".format(image_size)) print("The batch_size is {}".format(batch_size)) print("The epochs is {}".format(epochs)) # Load images and data from cifar 10 (x_train,y_train),(x_validation,y_validation) = cifar10.load_data() # Load part of train and test data. x_train = x_train[:training_num] x_validation = x_validation[:validation_num] Y_train = y_train[:training_num] Y_validation = y_validation[:validation_num] print("Total Train & Validation Num as shown below") print("Num of training images : {}".format(x_train.shape[0])) print("Num of validation images : {}".format(x_validation.shape[0])) X_train,X_validation = helpResize(x_train,x_validation,image_size) # Check if both of the list has the correct length. Y_new_train = np.array([np.zeros(10) for x in range(len(Y_train))],dtype='float32') for i,x in enumerate(Y_train): Y_new_train[i][x] = 1 Y_new_val = np.array([np.zeros(10) for x in range(len(Y_validation))],dtype='float32') for i,x in enumerate(Y_validation): Y_new_val[i][x] = 1 # This could also be the output of a different Keras model or layer if type(image_size) is list: input_shape = tuple(image_size) + (3,) else: input_shape = (image_size,image_size,3) base_model = InceptionV3(weights='imagenet', include_top=False,input_shape=input_shape) # Get the output of the Inception V3 pretrain model. x = base_model.output # Works same as Flatten(), but Flatten has larger dense layers, it might cause worse overfitting. # However, if the user has a larger dataset then the user can use Flatten() instead of GlobalAveragePooling2D or GlobalMaxPooling2D x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(10, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) # Use SGD as an optimizer model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy']) datagen = ImageDataGenerator( rotation_range=0, # Randomly rotate images in the range (degrees, 0 to 180) # Randomly shift images horizontally (fraction of total width) width_shift_range=0.1, # Randomly shift images vertically (fraction of total height) height_shift_range=0.1, zoom_range=0., # set range for random zoom # Set the mode for filling points outside the input boundaries horizontal_flip=True, # randomly flip images ) datagen.fit(X_train) histories = NCHC_CallBack() c_time = "{}_{}_{}_{}_{}".format(time.localtime().tm_year,time.localtime().tm_mon,time.localtime().tm_mday,time.localtime().tm_hour,time.localtime().tm_min) mc = ModelCheckpoint(WEIGHTS_FOLDER+c_time+"_weights.{epoch:02d}-acc-{acc:.2f}-loss-{loss:.2f}.hdf5", monitor='val_loss', verbose=0, save_best_only=False, save_weights_only=False, mode='auto', period=1) # Fit the model on the batches generated by datagen.flow(). model.fit_generator(datagen.flow(X_train, Y_new_train, batch_size=batch_size), callbacks = [ histories,mc ], #added here epochs=epochs, validation_data=(X_validation, Y_new_val) ) K.clear_session() del model
for layer in net_final.layers[FREEZE_LAYERS:]: layer.trainable = True # 使用 Adam optimizer,以較低的 learning rate 進行 fine-tuning net_final.compile(optimizer=Adam(lr=1e-5), loss='categorical_crossentropy', metrics=['accuracy']) # 輸出整個網路結構 print(net_final.summary()) # 訓練模型 history = net_final.fit_generator( train_batches, steps_per_epoch=train_batches.samples // BATCH_SIZE, validation_data=valid_batches, validation_steps=valid_batches.samples // BATCH_SIZE, epochs=NUM_EPOCHS, callbacks=[model_checkpoint_callback]) data_file_path = r'C:\Users\user\Documents\history.pkl' plt.figure(figsize=(15, 5)) plt.subplot(1, 2, 1) plt.plot(range(1, NUM_EPOCHS + 1), history.history['acc']) plt.plot(range(1, NUM_EPOCHS + 1), history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left')
x = Dropout(0.5)(x) #Fully connected layer 1 fc1 = tf.keras.layers.Dense(100, activation='relu', name="AddedDense1")(x) # Use softmax output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(fc1) net_final = Model(inputs=net.input, outputs=output_layer) for layer in net_final.layers[:FREEZE_LAYERS]: layer.trainable = False for layer in net_final.layers[FREEZE_LAYERS:]: layer.trainable = True # Use Adam optimizer net_final.compile(optimizer=Adam(lr=0.00001), loss='categorical_crossentropy', metrics=['accuracy']) # Whole network print(net_final.summary()) # Training model net_final.fit_generator(train_batches, steps_per_epoch=train_batches.samples // BATCH_SIZE, validation_data=valid_batches, validation_steps=valid_batches.samples // BATCH_SIZE, epochs=NUM_EPOCHS, callbacks=callbacks) net_final.save(WEIGHTS_FINAL)
class STSTask(): def __init__(self, c): self.c = c def load_resc(self, dictname): self.embed = Embedder(dictname, self.c['wordvectdim']) def load_data(self, trainfile, validfile, testfile): self.traindata = self._load_data(trainfile) self.validdata = self._load_data(validfile) self.testdata = self._load_data(testfile) def _load_data(self, filename): global ADD_PREFIX print(filename) s0, s1, labels = [], [], [] lines = open(filename, 'r', encoding='utf8').read().splitlines() for line in lines: try: s0x, s1x, label = line.rstrip().split('\t') labels.append(float(label)) if ADD_PREFIX: prefix = '' if filename == 'Dataset/train_set.csv' or filename == 'Dataset/dev_set.csv': prefix = 'en/' else: prefix = 'es/' s0.append([ prefix + word for word in word_tokenize(s0x) if word not in string.punctuation ]) s1.append([ prefix + word for word in word_tokenize(s1x) if word not in string.punctuation ]) #s0.append([prefix+word.lower() for word in word_tokenize(s0x) if word not in string.punctuation]) #s1.append([prefix+word.lower() for word in word_tokenize(s1x) if word not in string.punctuation]) else: s0.append([ word for word in word_tokenize(s0x) if word not in string.punctuation ]) s1.append([ word for word in word_tokenize(s1x) if word not in string.punctuation ]) #s0.append([word.lower() for word in word_tokenize(s0x) if word not in string.punctuation]) #s1.append([word.lower() for word in word_tokenize(s1x) if word not in string.punctuation]) except: print('Error in line: ' + str(line)) m0 = self.embed.matrixize(s0, self.c['sentencepad']) m1 = self.embed.matrixize(s1, self.c['sentencepad']) classes = np.zeros((len(labels), self.c['num_classes'])) for i, label in enumerate(labels): if np.floor(label) + 1 < self.c['num_classes']: classes[i, int(np.floor(label)) + 1] = label - np.floor(label) classes[i, int(np.floor(label))] = np.floor(label) - label + 1 #print(classes) return { 'labels': labels, 's0': s0, 's1': s1, 'classes': classes, 'm0': m0, 'm1': m1 } def create_model(self): K.clear_session() input0 = Input(shape=(self.c['sentencepad'], self.c['wordvectdim'])) input1 = Input(shape=(self.c['sentencepad'], self.c['wordvectdim'])) Convolt_Layer = [] MaxPool_Layer = [] Flatten_Layer = [] for kernel_size, filters in self.c['cnnfilters'].items(): Convolt_Layer.append( Convolution1D(filters=filters, kernel_size=kernel_size, padding='valid', activation=self.c['cnnactivate'], kernel_initializer=self.c['cnninitial'])) MaxPool_Layer.append( MaxPooling1D(pool_size=int(self.c['sentencepad'] - kernel_size + 1))) Flatten_Layer.append(Flatten()) Convolted_tensor0 = [] Convolted_tensor1 = [] for channel in range(len(self.c['cnnfilters'])): Convolted_tensor0.append(Convolt_Layer[channel](input0)) Convolted_tensor1.append(Convolt_Layer[channel](input1)) MaxPooled_tensor0 = [] MaxPooled_tensor1 = [] for channel in range(len(self.c['cnnfilters'])): MaxPooled_tensor0.append(MaxPool_Layer[channel]( Convolted_tensor0[channel])) MaxPooled_tensor1.append(MaxPool_Layer[channel]( Convolted_tensor1[channel])) Flattened_tensor0 = [] Flattened_tensor1 = [] for channel in range(len(self.c['cnnfilters'])): Flattened_tensor0.append(Flatten_Layer[channel]( MaxPooled_tensor0[channel])) Flattened_tensor1.append(Flatten_Layer[channel]( MaxPooled_tensor1[channel])) if len(self.c['cnnfilters']) > 1: Flattened_tensor0 = concatenate(Flattened_tensor0) Flattened_tensor1 = concatenate(Flattened_tensor1) else: Flattened_tensor0 = Flattened_tensor0[0] Flattened_tensor1 = Flattened_tensor1[0] absDifference = Lambda(lambda X: K.abs(X[0] - X[1]))( [Flattened_tensor0, Flattened_tensor1]) mulDifference = multiply([Flattened_tensor0, Flattened_tensor1]) allDifference = concatenate([absDifference, mulDifference]) for ilayer, densedimension in enumerate(self.c['densedimension']): allDifference = Dense( units=int(densedimension), activation=self.c['denseactivate'], kernel_initializer=self.c['denseinitial'])(allDifference) output = Dense( name='output', units=self.c['num_classes'], activation='softmax', kernel_initializer=self.c['denseinitial'])(allDifference) self.model = Model(inputs=[input0, input1], outputs=output) self.model.compile(loss='mean_squared_error', optimizer=self.c['optimizer']) #self.model.compile(loss={'output': self._lossfunction}, optimizer=self.c['optimizer']) def _lossfunction(self, y_true, y_pred): ny_true = y_true[:, 1] #+ 2*y_true[:,2] + 3*y_true[:,3] + 4*y_true[:,4] + 5*y_true[:,5] ny_pred = y_pred[:, 1] #+ 2*y_pred[:,2] + 3*y_pred[:,3] + 4*y_pred[:,4] + 5*y_pred[:,5] my_true = K.mean(ny_true) my_pred = K.mean(ny_pred) var_true = (ny_true - my_true)**2 var_pred = (ny_pred - my_pred)**2 return -K.sum( (ny_true - my_true) * (ny_pred - my_pred), axis=-1) / (K.sqrt( K.sum(var_true, axis=-1) * K.sum(var_pred, axis=-1))) def eval_model(self): global TEXT_EVAL results = [] for data in [self.traindata, self.validdata, self.testdata]: predictionclasses = [] for dataslice, _ in self._sample_pairs(data, len(data['classes']), shuffle=False, once=True): predictionclasses += list(self.model.predict(dataslice)) #print(predictionclasses) scores = [] for p in predictionclasses: if p[0] > p[1]: scores.append(0) else: scores.append(1) #prediction = np.dot(np.array(predictionclasses),np.arange(self.c['num_classes'])) gold_scores = data['labels'] result = sklearn.metrics.log_loss(gold_scores, scores) TP, FP, TN, FN = perf_measure(gold_scores, scores) acc = np.sum( np.array(gold_scores) == np.array(scores)) / len(gold_scores) print('Log Loss: ' + str(result)) print('Acc: ' + str(acc)) print('TP: ' + str(TP) + '\tFP: ' + str(FP) + '\tTN: ' + str(TN) + '\tFN: ' + str(FN)) #print(scores) #print(gold_scores) results.append([result, acc, TP, FP, TN, FN]) #result=pearsonr(prediction, goldlabels)[0] #results.append(round(result,4)) print('TEST:' + str(results[0])) print('DEV:' + str(results[1])) print('TEST:' + str(results[2])) #print(results) return results def fit_model(self, wfname): kwargs = dict() kwargs['generator'] = self._sample_pairs(self.traindata, self.c['batch_size']) kwargs['steps_per_epoch'] = self.c['num_batchs'] kwargs['epochs'] = self.c['num_epochs'] class Evaluate(Callback): def __init__(self, task, wfname): self.task = task self.bestresult = 0.0 self.wfname = wfname def on_epoch_end(self, epoch, logs={}): results = self.task.eval_model() if results[1][0] > self.bestresult: self.bestresult = results[1][0] self.task.model.save(self.wfname) #_,validresult,_,_,_,_,_ = self.task.eval_model() #if validresult > self.bestresult: # self.bestresult = validresult # self.task.model.save(self.wfname) kwargs['callbacks'] = [Evaluate(self, wfname)] return self.model.fit_generator(verbose=2, **kwargs) def _sample_pairs(self, data, batch_size, shuffle=True, once=False): num = len(data['classes']) idN = int((num + batch_size - 1) / batch_size) ids = list(range(num)) while True: if shuffle: random.shuffle(ids) datacopy = copy.deepcopy(data) for name, value in datacopy.items(): valuer = copy.copy(value) for i in range(num): valuer[i] = value[ids[i]] datacopy[name] = valuer for i in range(idN): sl = slice(i * batch_size, (i + 1) * batch_size) dataslice = dict() for name, value in datacopy.items(): dataslice[name] = value[sl] x = [dataslice['m0'], dataslice['m1']] y = dataslice['classes'] yield (x, y) if once: break
shape=(None, None)) #为解码器的输出创建一个占位符变量 #编译训练模型 decoder_output = connect_decoder(transfer_values=transfer_values_input) decoder_model = Model(inputs=[transfer_values_input, decoder_input], outputs=[decoder_output]) decoder_model.compile(optimizer=optimizer, loss=sparse_cross_entropy, target_tensors=[decoder_target]) #编写检查点回调 path_checkpoint = '22_checkpoint.keras' callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint, verbose=1, save_weights_only=True) callback_tensorboard = TensorBoard(log_dir='./22_logs/', histogram_freq=0, write_graph=False) callbacks = [callback_checkpoint, callback_tensorboard] path_checkpoint = '22_checkpoint.keras' try: decoder_model.load_weights(path_checkpoint) except Exception as error: print("Error trying to load checkpoint.") print(error) #开始训练 decoder_model.fit_generator(generator=generator, steps_per_epoch=steps_per_epoch, epochs=50, callbacks=callbacks)
def train(run_name, start_epoch, stop_epoch, img_w, build_word_count, max_string_len, mono_fraction, save_model_path=None): # Input Parameters img_h = 64 words_per_epoch = 16000 val_split = 0.2 val_words = int(words_per_epoch * (val_split)) # Network parameters conv_filters = 16 kernel_size = (3, 3) pool_size = 2 time_dense_size = 32 # GRU output NAN when rnn_size=512 with my GPU, but CPU or rnn_size=256 is ok. # Tensorflow 1.10 appears, but vanishes in 1.12! rnn_size = 512 minibatch_size = 32 # if start_epoch >= 12: # minibatch_size = 8 # 32 is to large for my poor GPU if K.image_data_format() == 'channels_first': input_shape = (1, img_w, img_h) else: input_shape = (img_w, img_h, 1) img_gen = TextImageGenerator(minibatch_size=minibatch_size, img_w=img_w, img_h=img_h, downsample_factor=(pool_size**2), val_split=words_per_epoch - val_words, build_word_count=build_word_count, max_string_len=max_string_len, mono_fraction=mono_fraction) act = 'relu' kernel_init = 'he_normal' input_data = Input(name='the_input', shape=input_shape, dtype='float32') inner = Conv2D(conv_filters, kernel_size, padding='same', activation=None, kernel_initializer=kernel_init, name='conv1')(input_data) inner = BatchNormalization(axis=3, scale=False, name='bn1')(inner) inner = Activation(activation=act)(inner) inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner) inner = Conv2D(conv_filters, kernel_size, padding='same', activation=None, kernel_initializer=kernel_init, name='conv2')(inner) inner = BatchNormalization(axis=3, scale=False, name='bn2')(inner) inner = Activation(activation=act)(inner) inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max2')(inner) conv_to_rnn_dims = (img_w // (pool_size**2), (img_h // (pool_size**2)) * conv_filters) inner = Reshape(target_shape=conv_to_rnn_dims, name='reshape')(inner) # cuts down input size going into RNN: inner = Dense(time_dense_size, activation=act, name='dense1')(inner) # bidirectional GRU, GRU seems to work as well, if not better than LSTM: gru_1 = GRU(rnn_size, return_sequences=True, kernel_initializer=kernel_init, name='gru1')(inner) gru_1b = GRU(rnn_size, return_sequences=True, go_backwards=True, kernel_initializer=kernel_init, name='gru1_b')(inner) gru1_merged = concatenate([gru_1, gru_1b]) # transforms RNN output to character activations: inner = Dense(img_gen.get_output_size(), kernel_initializer=kernel_init, name='dense2')(gru1_merged) y_pred = Activation('softmax', name='softmax')(inner) labels = Input(name='the_labels', shape=[img_gen.max_string_len], dtype='float32') input_length = Input(name='input_length', shape=[1], dtype='int64') label_length = Input(name='label_length', shape=[1], dtype='int64') # Keras doesn't currently support loss funcs with extra parameters # so CTC loss is implemented in a lambda layer loss_out = Lambda(ctc_lambda_func, output_shape=(1, ), name='ctc')([y_pred, labels, input_length, label_length]) # clipnorm seems to speeds up convergence sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5) model = Model(inputs=[input_data, labels, input_length, label_length], outputs=loss_out) # the loss calc occurs elsewhere, so use a dummy lambda func for the loss model.compile(loss={ 'ctc': lambda y_true, y_pred: y_pred }, optimizer=sgd, metrics=['accuracy']) if start_epoch > 0: weight_file = os.path.join( OUTPUT_DIR, os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1))) model.load_weights(weight_file) print("load_weight: ", weight_file) # captures output of softmax so we can decode the output during visualization test_func = K.function([input_data], [y_pred]) viz_cb = VizCallback(run_name, test_func, img_gen.next_val()) model.fit_generator(generator=img_gen.next_train(), steps_per_epoch=(words_per_epoch - val_words) // minibatch_size, epochs=stop_epoch, validation_data=img_gen.next_val(), validation_steps=val_words // minibatch_size, callbacks=[viz_cb, img_gen], initial_epoch=start_epoch, verbose=1) if save_model_path: predict_model = Model(inputs=input_data, outputs=y_pred) predict_model.save(save_model_path)
class ConvMnist: def __init__(self, filename=None): ''' 学習済みモデルファイルをロードする (optional) ''' self.model = None if filename is not None: print('load model: ', filename) self.model = load_model(filename) self.model.summary() def preprocess_input(x, **kwargs): ''' 画像前処理(ここでは何もしない) ''' # x = 255 - x return x.astype(np.float32) def train(self): ''' 学習する ''' # Convolutionモデルの作成 input = Input(shape=(MODEL_WIDTH, MODEL_HEIGHT, 1)) conv1 = Conv2D(filters=8, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu')(input) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(filters=4, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu')(pool1) dropout1 = Dropout(0.2)(conv2) flatten1 = Flatten()(dropout1) output = Dense(units=10, activation='softmax')(flatten1) self.model = Model(inputs=[input], outputs=[output]) self.model.summary() self.model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) ## fit_generatorを使用する場合。windowsだと遅い(画像読み込みをうまく並列化できない) # データセットをディレクトリ内画像から読み込む用意 idg_train = ImageDataGenerator( validation_split=0.2, rescale=1 / 255., # preprocessing_function=preprocess_input ) # training用データのgenerator(全学習画像の内80%) img_itr_train = idg_train.flow_from_directory( 'mnist_images/train', subset="training", color_mode="grayscale", target_size=(MODEL_WIDTH, MODEL_HEIGHT), batch_size=BATCH_SIZE, class_mode='categorical', ) # validation用データのgenerator(全学習画像の内20%) img_itr_validation = idg_train.flow_from_directory( 'mnist_images/train', subset="validation", color_mode="grayscale", target_size=(MODEL_WIDTH, MODEL_HEIGHT), batch_size=BATCH_SIZE, class_mode='categorical', ) # Convolutionモデルの学習 self.model.fit_generator( img_itr_train, steps_per_epoch=math.ceil(img_itr_train.samples / BATCH_SIZE), epochs=EPOCH_NUM, validation_data=img_itr_validation, validation_steps=math.ceil(img_itr_validation.samples / BATCH_SIZE), ) # テスト用データで評価する idg_test = ImageDataGenerator( rescale=1 / 255., # preprocessing_function=preprocess_input ) img_itr_test = idg_test.flow_from_directory('mnist_images/test', color_mode="grayscale", target_size=(MODEL_WIDTH, MODEL_HEIGHT), batch_size=BATCH_SIZE, class_mode=None, shuffle=False) # 識別処理実施 probs = self.model.predict_generator( img_itr_test, steps=math.ceil(img_itr_test.samples / BATCH_SIZE)) # 識別精度を計算 predictions = np.argmax(probs, axis=1) print("score: " + str(1.0 * np.sum(predictions == img_itr_test.classes) / img_itr_test.n)) def save_trained_model(self, filename): ''' 学習済みモデルをファイル(h5)に保存する ''' self.model.save(filename) def predict(self, input_image): ''' 1つのグレースケール入力画像(28x28のndarray)に対して、数字(0~9)を判定する ret: result, score ''' if input_image.shape != (MODEL_WIDTH, MODEL_HEIGHT): return -1, -1 input_image = input_image.reshape(1, input_image.shape[0], input_image.shape[1], 1) input_image = input_image / 255. probs = self.model.predict(input_image) result = np.argmax(probs[0]) return result, probs[0][result]
def main(cfg): print("Training has Started!") sess = tf.Session() graph = tf.get_default_graph() set_session(sess) #print(sess) batch_size = 32 test_train_split = cfg['test_train_split'] max_epoch = cfg['epochs'] shape = (224, 224) #dropout_prob = 0.3 #train_size_per_label = 500 #test_size_per_label = 100 meta = {} meta['img_fmt'] = cfg['image_extension'] meta['shape'] = shape input_train, input_test, out_train, out_test, classes = fe.util.get_local_images( cfg['pth_data'], test_train_split, meta['img_fmt'], shape) meta['classes'] = classes print("input_test shape: {}".format(input_test.shape)) x = fe.util.get_cifar10() print("cifar10 shape: {}".format(x[0].shape)) total_train_steps = len(input_train) // batch_size out_train = to_categorical(out_train, len(classes)) out_test = to_categorical(out_test, len(classes)) print( "\nloading ResNet50... this could take a bit of time. I'll let you know when I'm done.\n" ) st = time.time() resnet50 = fe.util.get_resnet50(shape=shape + (3, )) bottleneck_train_features = resnet50.predict(input_train) bottleneck_test_features = resnet50.predict(input_test) print("\nCompleted loading ResNet50 in {0:.2f}s \n".format(time.time() - st)) in_layer = Input(shape=(bottleneck_train_features.shape[1:])) x = Conv2D(filters=100, kernel_size=2)(in_layer) x = Dropout(0.4)(x) x = GlobalAveragePooling2D()(x) x = Dropout(0.3)(x) predictions = Dense(len(classes), activation='softmax')(x) model = Model(inputs=in_layer, outputs=predictions) print(model.summary()) def save_model(cfg, epoch): pth_save = os.path.join( cfg['pth_model_save'], "{}-{:05d}".format(cfg['data_to_train_on'], epoch)) print("saving model to {}".format(pth_save)) if not os.path.exists('my_folder'): os.makedirs(pth_save) pth_modl = os.path.join(pth_save, SAVED_MODEL_NAME) tf.keras.models.save_model(model, pth_modl, overwrite=True, include_optimizer=True, save_format=None) pth_meta = os.path.join(pth_save, SAVED_META_NAME) with open(pth_meta, "w") as write_file: json.dump(meta, write_file) class RecordAccuracy(Callback): def on_epoch_begin(self, epoch, logs=None): print(f'Running epoch {epoch}. Total {total_train_steps} batches') def on_batch_end(self, batch, logs=None): loss = logs['loss'] if not batch % 10: print(f'Running batch {batch}: train loss - {loss}') def on_epoch_end(self, epoch, logs=None): loss = logs["loss"] val_acc = logs["val_acc"] print( f'Epoch {epoch}: train loss - {loss}. test accuracy - {val_acc}' ) save_model(cfg, epoch) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc']) model.fit_generator(batch_generator(bottleneck_train_features, out_train), steps_per_epoch=len(bottleneck_train_features) // batch_size, validation_data=(bottleneck_test_features, out_test), verbose=2, epochs=max_epoch, callbacks=[RecordAccuracy(), TensorBoard()]) print(asci_eye.format("Training Complete!")) save_model(cfg, max_epoch)