def loadVanillaCNN(self): if (path.isfile(config.get_model_path())): # load weights into new model self.model = load_model(config.get_model_path()) print("Loaded model from disk ....", config.get_model_path()) else: print("Model weights file does not exists!!") self.getVanillaCNN()
def load_pretrained_model(self): print("Loading pre-trained model ******", config.get_model_path()) self.load_classes() if (path.isfile(config.get_model_path())): # load weights into new model self.model = load_model(config.get_model_path()) #self.model.load_weights(config.get_model_path()) print("Loaded model from disk ....", config.get_model_path()) else: print("Model weights file does not exists!!") return self.model
def _fine_tuning(self): self.freeze_top_layers() self.model.compile( loss='categorical_crossentropy', optimizer=Adam(lr=1e-5), metrics=['accuracy']) self.model.summary() train_data = self.get_train_datagen(rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True) callbacks = self.get_callbacks(config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience) if util.is_keras2(): self.model.fit_generator( train_data, steps_per_epoch=config.nb_train_samples / float(self.batch_size), epochs=self.nb_epoch, validation_data=self.get_validation_datagen(), validation_steps=config.nb_validation_samples / float(self.batch_size), callbacks=callbacks, class_weight=self.class_weight) else: self.model.fit_generator( train_data, samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen(), nb_val_samples=config.nb_validation_samples, callbacks=callbacks, class_weight=self.class_weight) self.model.save(config.get_model_path())
def _fine_tuning(self): self.freeze_top_layers() self.model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=1e-4, decay=1e-6, momentum=0.9, nesterov=True), metrics=['accuracy']) self.model.fit_generator( self.get_train_datagen( rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True, preprocessing_function=self.preprocess_input), samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen( preprocessing_function=self.preprocess_input), nb_val_samples=config.nb_validation_samples, callbacks=self.get_callbacks(config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience), class_weight=self.class_weight) self.model.save(config.get_model_path())
def _fine_tuning(self): self.freeze_top_layers() self.model.compile( loss='categorical_crossentropy', optimizer=Adam(lr=1e-5), metrics=['accuracy']) self.model.summary() plot_model(self.model, to_file='model1.png', show_shapes=True) self.model.fit_generator( self.get_train_datagen(rotation_range=15., shear_range=0.1, zoom_range=0.2, width_shift_range=0.05, height_shift_range=0.05, horizontal_flip=True, preprocessing_function=self.preprocess_input), samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen(preprocessing_function=self.preprocess_input), nb_val_samples=config.nb_validation_samples, callbacks=self.get_callbacks(config.get_fine_tuned_weights_path(),os.path.join(os.path.abspath("."),"checkpoint"),patience=self.fine_tuning_patience), class_weight=self.class_weight) self.model.save(config.get_model_path())
def _fine_tuning(self): self.freeze_top_layers() self.model.compile( loss='categorical_crossentropy', optimizer=Adam(lr=1e-5), metrics=['accuracy']) self.model.summary() # save the model to png in order to visualize plot_model(self.model, to_file='model1.png', show_shapes=True) train_data = self.get_train_datagen(rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True, preprocessing_function=self.preprocess_input) # early stopping callbacks = self.get_callbacks(config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience) if util.is_keras2(): self.model.fit_generator( train_data, steps_per_epoch=config.nb_train_samples / float(self.batch_size), epochs=self.nb_epoch, validation_data=self.get_validation_datagen(), validation_steps=config.nb_validation_samples / float(self.batch_size), callbacks=callbacks, class_weight=self.class_weight) else: self.model.fit_generator( train_data, samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen(), nb_val_samples=config.nb_validation_samples, callbacks=callbacks, class_weight=self.class_weight) self.model.save(config.get_model_path())
def __init__(self, model_type='electra', max_seq_len=128, dropout_rate=0.1, last_n_layers=2): super(SentimentExtractor, self).__init__() model_path_dict = cfg.get_model_path(model_type) self.model_type = model_type.lower() self.last_n_layers = last_n_layers self.bert, self.config = _get_bert(self.model_type, model_path_dict) bert_hidden_dim = self.bert.config.hidden_size self.fc_for_idx = torch.nn.Linear(bert_hidden_dim * last_n_layers, 2) self.fc_for_seq = torch.nn.Linear(bert_hidden_dim * last_n_layers, 1) self.bn_1 = torch.nn.BatchNorm1d(max_seq_len) self.bn_2 = torch.nn.BatchNorm1d(max_seq_len) self.dropout = torch.nn.Dropout(dropout_rate) torch.nn.init.normal_(self.fc_for_idx.weight, std=0.02) torch.nn.init.normal_(self.fc_for_seq.weight, std=0.02)
def fine_tune_top_2_inception_blocks(model, X_train, Y_train, X_test, Y_test, datagen): # we chose to train the top 2 inception blocks, i.e. we will freeze # the first 172 layers and unfreeze the rest: for layer in model.layers[:172]: layer.trainable = False for layer in model.layers[172:]: layer.trainable = True # we need to recompile the model for these modifications to take effect # we use SGD with a low learning rate # print("Compiling model...") model.compile(optimizer=SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True), loss='categorical_crossentropy', metrics=["accuracy"]) # train_datagen = ImageDataGenerator( # featurewise_center=False, # samplewise_center=False, # featurewise_std_normalization=False, # samplewise_std_normalization=False, # zca_whitening=False, # # rotation_range=0, # width_shift_range=0.125, # height_shift_range=0.125, # horizontal_flip=True, # vertical_flip=False, # fill_mode='nearest', # rotation_range=30., shear_range=0.2, zoom_range=0.2, # # horizontal_flip=True # ) # train_gen, val_gen = _get_data_generators(train_datagen) callbacks = _get_callbacks(config.get_fine_tuned_weights_path(), patience=30) test_datagen = ImageDataGenerator() # we train our model again (this time fine-tuning the top 2 inception blocks # alongside the top Dense layers model.fit_generator(datagen.flow(X_train, Y_train, shuffle=True), samples_per_epoch=X_train.shape[0], nb_epoch=fine_tune_nb_epoch, validation_data=test_datagen.flow(X_test, Y_test), nb_val_samples=X_test.shape[0], callbacks=callbacks) model.save(config.get_model_path())
def init_tokenizer(model_type): """토크나이저 사용 전에 반드시 호출""" model_path_dict = cfg.get_model_path(model_type) print(model_path_dict) if model_type in ['bert', 'electra']: tokenizer = BertWordPieceTokenizer(model_path_dict['tokenizer'], lowercase=True) elif model_type == 'roberta': tokenizer = ByteLevelBPETokenizer( vocab_file=model_path_dict['tokenizer']['vocab_file'], merges_file=model_path_dict['tokenizer']['merges_file'], lowercase=True, add_prefix_space=True) return tokenizer
def _fine_tuning(self): self.freeze_top_layers() self.model.compile( loss='binary_crossentropy', optimizer=Adam(lr=1e-5), #optimizer=SGD(lr=5e-6, momentum=0.9), metrics=['binary_accuracy']) train_data = self.get_train_datagen( rescale=1. / 255, rotation_range=60., #shear_range=0.2, #zoom_range=0.2, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, vertical_flip=True) callbacks = self.get_callbacks(config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience) if util.is_keras2(): hist = self.model.fit_generator( train_data, steps_per_epoch=config.nb_train_samples / float(self.batch_size), epochs=self.nb_epoch, validation_data=self.get_validation_datagen(rescale=1. / 255), #validation_data=self.get_validation_datagen(), validation_steps=config.nb_validation_samples / float(self.batch_size), callbacks=callbacks, class_weight=self.class_weight) else: hist = self.model.fit_generator( train_data, samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen(), nb_val_samples=config.nb_validation_samples, callbacks=callbacks, class_weight=self.class_weight) print(hist.history) util.save_history(history=hist, prefix=time.time()) self.model.save(config.get_model_path())
def _fine_tuning(self): self.freeze_top_layers() self.model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=1e-4, decay=1e-6, momentum=0.9, nesterov=True), metrics=['accuracy']) history = self.model.fit_generator( self.get_train_datagen(rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True), samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen(), nb_val_samples=config.nb_validation_samples, callbacks=self.get_callbacks(config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience), class_weight=self.class_weight) self.model.save(config.get_model_path()) # list all data in history print(history.history.keys()) # summarize history for accuracy plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.show() # summarize history for loss plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.show()
def _fine_tuning(self): self.freeze_top_layers() self.model.compile( loss='categorical_crossentropy', optimizer=SGD(lr=1e-4, decay=1e-6, momentum=0.9, nesterov=True), metrics=['accuracy']) self.model.fit_generator( self.get_train_datagen(rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True, preprocessing_function=self.preprocess_input), samples_per_epoch=config.nb_train_samples, nb_epoch=self.nb_epoch, validation_data=self.get_validation_datagen(preprocessing_function=self.preprocess_input), nb_val_samples=config.nb_validation_samples, callbacks=self.get_callbacks(config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience), class_weight=self.class_weight) self.model.save(config.get_model_path())
def _fine_tuning(self): # self.model.load_weights(config.get_fine_tuned_weights_path()) self.freeze_top_layers() # let's decide the mode and set the matched compile method and data generator # the under codes may seemed to be repeated, but I prefer to make it easier to understand and read. if self.loss_choice == 0: self.model.compile( loss=['categorical_crossentropy', self.triplet_loss_fn], optimizer=Adam(lr=1e-5), loss_weights=[1, 1], # SGD(lr=1e-5, decay=1e-6, momentum=0.8, nesterov=True),#Adadelta(),#Adam(lr=1e-5), metrics=['accuracy']) train_data_generator = util.triplet_transformed_generator( self.get_train_datagen( rotation_range=10., shear_range=0.05, zoom_range=0.1, width_shift_range=0.05, height_shift_range=0.05, horizontal_flip=True, preprocessing_function=self.preprocess_input), self.noveltyDetectionLayerSize) validation_data_generator = util.triplet_transformed_generator( self.get_validation_datagen( preprocessing_function=self.preprocess_input), self.noveltyDetectionLayerSize) elif self.loss_choice == 1: self.model.compile( loss=["categorical_crossentropy", self.center_loss_fn], optimizer=Adam(lr=1e-5), loss_weights=[1, 0.15], metrics=['accuracy']) train_data_generator = util.centerloss_transformed_generator( self.get_train_datagen( rotation_range=10., shear_range=0.05, zoom_range=0.1, width_shift_range=0.05, height_shift_range=0.05, horizontal_flip=True, preprocessing_function=self.preprocess_input)) validation_data_generator = util.centerloss_transformed_generator( self.get_validation_datagen( preprocessing_function=self.preprocess_input)) elif self.loss_choice == 2: self.model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=1e-5), metrics=['accuracy']) train_data_generator = self.get_train_datagen( rotation_range=10., shear_range=0.05, zoom_range=0.1, width_shift_range=0.05, height_shift_range=0.05, horizontal_flip=True, preprocessing_function=self.preprocess_input) validation_data_generator = self.get_validation_datagen( preprocessing_function=self.preprocess_input) # print the mode construction and key info self.model.summary() # fit the generator in batch sequence mode self.model.fit_generator( train_data_generator, steps_per_epoch=config.nb_train_samples / self.batch_size, epochs=self.nb_epoch, validation_data=validation_data_generator, validation_steps=config.nb_validation_samples / self.batch_size, callbacks=self.get_callbacks( config.get_fine_tuned_weights_path(), patience=self.fine_tuning_patience, embedding_mode=(True if self.loss_choice is not 2 else False), target_object=self, visual_embedding=[self.noveltyDetectionLayerName], center_loss_input=(True if self.loss_choice is 1 else False)), class_weight=self.class_weight) #self.model.save(config.get_model_path()) keras.models.save_model(self.model, config.get_model_path())
def load_trained(): model = load_model(config.get_model_path()) util.load_classes() return model
import sys import os from sklearn.decomposition import TruncatedSVD from sklearn.svm import SVC import numpy as np import joblib from config import tags, get_data_path, get_model_path def train(train_data, reducer_model_path, classifier_model_path): train_data = np.load(train_data) train_xs, train_ys = train_data["xs"], train_data["ys"] reducer = TruncatedSVD(n_components=300) train_xs = reducer.fit_transform(train_xs) classifier = SVC(C=10.0, gamma="scale", probability=True) classifier.fit(train_xs, train_ys) joblib.dump(reducer, reducer_model_path) joblib.dump(classifier, classifier_model_path) if __name__ == '__main__': if len(sys.argv) != 2 or sys.argv[1] not in tags: raise ValueError("""usage: 情绪效价,情绪用户""") tag_type = sys.argv[1] origin_file_path, train_npz_path, test_npz_path = get_data_path(tag_type) _, reducer_model_path, classifier_model_path = get_model_path(tag_type) train(train_npz_path, reducer_model_path, classifier_model_path)
def _fine_tuning(self): self.freeze_top_layers1() train_data = self.get_train_datagen( rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True, preprocessing_function=self.preprocess_input) checkpoint_dir = os.path.join(os.path.abspath('.'), 'checkpoint') callbacks = self.get_callbacks(config.get_fine_tuned_weights_path(), checkpoint_dir, patience=self.fine_tuning_patience) if util.is_keras2(): if config.isCenterLoss: self.center_model.load_weights( '/home/yuzhg/Inception-v3/trained/fine-tuned-best-inception-weights.h5', by_name=True) self.center_model.compile(loss=[ 'categorical_crossentropy', lambda y_true, y_pred: y_pred ], loss_weights=[1, 0.2], metrics=['accuracy'], optimizer=Adam(lr=1e-5)) self.center_model.summary() self.history = self.center_model.fit_generator( util.clone_y_generator(train_data), steps_per_epoch=config.nb_train_samples / float(self.batch_size), epochs=self.nb_epoch, validation_data=util.clone_y_generator( self.get_validation_datagen()), validation_steps=config.nb_validation_samples / float(self.batch_size), callbacks=callbacks, class_weight=self.class_weight) elif config.isTripletLoss: self.triplet_model.load_weights( '/home/yuzhg/Inception-v3/trained/fine-tuned-best-inception-weights.h5', by_name=True) #self.triplet_model.compile(loss=self.hard_triplet_loss, optimizer=Adam(lr=1e-5), metrics=['accuracy']) self.triplet_model.compile( optimizer=Adam(lr=1e-5), loss=['categorical_crossentropy', self.hard_triplet_loss], loss_weights=[1.0, 1.0], metrics=['accuracy']) self.triplet_model.summary() valid_data = self.get_validation_datagen( rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True, preprocessing_function=self.preprocess_input) # util.clone_y_generator1(train_data), self.history = self.triplet_model.fit_generator( #util.triplet_transformed_generator(train_data, 4096), util.clone_y_generator1(train_data), steps_per_epoch=config.nb_train_samples / float(self.batch_size), epochs=self.nb_epoch, #validation_data=util.triplet_transformed_generator(valid_data, 4096), validation_data=util.clone_y_generator1(valid_data), validation_steps=config.nb_validation_samples / float(self.batch_size), callbacks=callbacks, class_weight=self.class_weight) else: self.model.load_weights( '/home/yuzhg/Inception-v3/trained/fine-tuned-best-inception-weights.h5', by_name=True) self.model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=1e-5), metrics=['accuracy']) self.model.summary() self.history = self.model.fit_generator( train_data, steps_per_epoch=config.nb_train_samples / float(self.batch_size), epochs=self.nb_epoch, validation_data=self.get_validation_datagen( rotation_range=30., shear_range=0.2, zoom_range=0.2, horizontal_flip=True, preprocessing_function=self.preprocess_input), validation_steps=config.nb_validation_samples / float(self.batch_size), callbacks=callbacks, class_weight=self.class_weight) # else: # if config.isCenterLoss: # self.center_model.compile(loss=['categorical_crossentropy', lambda y_true, y_pred:y_pred], # loss_weights=[1, 0.2], metrics=['accuracy'], # optimizer=Adam(lr=1e-5)) # self.center_model.summary() # self.history = self.center_model.fit_generator( # util.clone_y_generator(train_data), # samples_per_epoch=config.nb_train_samples, # nb_epoch=self.nb_epoch, # validation_data=util.clone_y_generator(self.get_validation_datagen()), # nb_val_samples=config.nb_validation_samples, # callbacks=callbacks, # class_weight=self.class_weight) # elif config.isTripletLoss: # self.triplet_model.compile(loss=triplet_loss, optimizer=Adam(lr=1e-5)) # self.triplet_model.summary() # self.history = self.triplet_model.fit_generator( # util.clone_y_generator(train_data), # steps_per_epoch=config.nb_train_samples / float(self.batch_size), # epochs=self.nb_epoch, # validation_data=util.clone_y_generator(self.get_validation_datagen()), # validation_steps=config.nb_validation_samples / float(self.batch_size), # callbacks=callbacks, # class_weight=self.class_weight # ) # else: # self.model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=1e-5), metrics=['accuracy']) # self.model.summary() # self.history = self.model.fit_generator( # train_data, # steps_per_epoch=config.nb_train_samples / float(self.batch_size), # epochs=self.nb_epoch, # validation_data=self.get_validation_datagen(), # validation_steps=config.nb_validation_samples / float(self.batch_size), # callbacks=callbacks, # class_weight=self.class_weight # ) if config.isCenterLoss: #self.center_model.save_weights('vgg16-model-weights.h5') self.center_model.save(config.get_model_path()) util.save_history(self.history, self.center_model) elif config.isTripletLoss: self.triplet_model.save(config.get_model_path()) util.save_history(self.history, self.triplet_model) else: self.model.save(config.get_model_path()) util.save_history(self.history, self.model)
def save_checkpoint(epoch): state = model.extractor.state_dict() file_path = config.get_model_path('extractor_%03d' % epoch) print 'save checkpoint: %s' % file_path torch.save(state, file_path)