def predict(image_size, alphabet, max_sequence_length, max_lines): img_w, img_h = image_size images_input = tf.placeholder(shape=(1, img_h, img_w, 1), dtype=tf.float32) sequences_input = tf.placeholder(shape=(1, max_sequence_length), dtype=tf.int32) is_training = tf.constant(False, dtype=tf.bool) add_eos = tf.constant(False, dtype=tf.bool) model = Model( images_input, sequences_input, is_training, add_eos, max_sequence_length, alphabet, alignments_type='full') endpoints = model.endpoints() test_generator = BatchGenerator( size=image_size, alphabet=alphabet, max_sequence_length=max_sequence_length, max_lines=3, batch_size=1) saver = tf.train.Saver() with tf.Session() as sess: init = tf.global_variables_initializer() sess.run(init) ckpt = tf.train.get_checkpoint_state('train/') if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) else: raise Exception('Cannot load checkpoint') for imgs, seqs in test_generator.generate_batch(): predictions, alignments = sess.run([endpoints['predictions'], endpoints['alignments']], feed_dict={images_input: imgs}) img = np.squeeze(imgs[0]) predicted_text = ''.join([alphabet[x] for x in predictions[0] if x < len(alphabet)]) print("Predicted: {}".format(predicted_text)) font = cv2.FONT_HERSHEY_SIMPLEX for ind, alignment in enumerate(alignments[0]): if ind == len(predicted_text): break h, w = img.shape[:2] img_al = cv2.resize(alignment, (w, h), interpolation=cv2.INTER_AREA) highlighted = cv2.resize((img + img_al * 2) / 3., (500, 300), interpolation=cv2.INTER_AREA) font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(highlighted, predicted_text[ind], (50, 50), font, 2, (255,255,255), 2, cv2.LINE_AA) cv2.imshow('alignment', highlighted) k = cv2.waitKey(1000) & 0xFF if k == 27: break k = cv2.waitKey(0) & 0xFF if k == 27: break
def train(model): model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-4), loss=[smooth_l1, focal], metrics=None) print(model.summary()) for var in model.variables: print(var.name + '___' + str(var.shape)) pass from generator import BatchGenerator train_data_generator = BatchGenerator(train_ann_fnames, train_img_dir, LABELS, batch_size) val_data_generator = BatchGenerator(val_ann_fnames, val_img_dir, LABELS, batch_size) callbacks = [ #TrainCallback(), #tf.keras.callbacks.LearningRateScheduler(schedule=lr_schedule, verbose=1), #tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True, write_images=False), tf.keras.callbacks.ModelCheckpoint(os.path.join( log_dir, "retinanet_voc_{epoch:02d}_loss-{loss:.4f}_val_loss-{val_loss:.4f}.h5" ), monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=True, save_freq='epoch') ] model.fit_generator(train_data_generator, epochs=100, callbacks=callbacks, validation_data=val_data_generator) pass
def train(): voc_path = 'voc' file_list_train = get_data_paths('train') file_list_test = get_data_paths('test') line_parser = MbtiParser() train_generator = BatchGenerator(file_list_train, line_parser, batch_size=batch_size_train, build_voc=build_voc, voc_path=voc_path, max_sentence_length=max_sentence_length) #Do not build vocabulary for testing test_generator = BatchGenerator(file_list_test, line_parser, batch_size=batch_size_test, build_voc=False, max_sentence_length=max_sentence_length, voc_path=voc_path) print("vocab_size {}".format(train_generator.vocab_size)) cnn = CnnTextClassifier(**cnn_hyperparameters) cnn.fit_generator(train_generator, test_generator)
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) makedirs(os.path.dirname(config['train']['cache_name'])) train_ints, labels = parse_voc_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['train']['cache_name'], config['model']['labels']) # valid_ints, _ = parse_voc_annotation(config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) instances = train_ints max_box_per_image = max([len(inst['object']) for inst in instances]) print(list(labels.keys())) train_generator = BatchGenerator( instances = instances, anchors = config['model']['anchors'], labels = list(labels.keys()), downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image = max_box_per_image, batch_size = 1, min_net_size = config['model']['min_input_size'], max_net_size = config['model']['max_input_size'], norm = None ) valid_generator = BatchGenerator( instances = instances, anchors = config['model']['anchors'], labels = list(labels.keys()), downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image = max_box_per_image, batch_size = 1, min_net_size = config['model']['min_input_size'], max_net_size = config['model']['max_input_size'], norm = None, infer_sz = config['model']['infer_shape'] ) for i in range(len(instances)): timg = train_generator[i][0] vimg = valid_generator[i][0] timg = cv2.resize(timg, (640, 480)) vimg = cv2.resize(vimg, (640, 480)) cv2.imshow('1', np.vstack((timg.astype(np.uint8), vimg.astype(np.uint8)))) if cv2.waitKey(0) == 27: break
def predict(): file_list_predict = get_data_paths('predict') line_parser = MbtiParser() predict_generator = BatchGenerator(file_list_predict, line_parser, batch_size=batch_size_predict, build_voc=False, max_sentence_length=max_sentence_length, voc_path=voc_path) cnn = CnnTextClassifier(**cnn_hyperparameters) pred_dic = cnn.predict(predict_generator) plt.figure() plot_confusion_matrix(pred_dic['ground_truth'], pred_dic['predictions'], list(range(num_classes)), title='Confusion matrix, without normalization') plt.figure() plot_confusion_matrix(pred_dic['ground_truth'], pred_dic['predictions'], list(range(num_classes)), title='Confusion matrix, with normalization', normalize=True) plt.show()
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) labels = labels.keys() if len( config['model']['labels']) == 0 else config['model']['labels'] labels = sorted(labels) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=0, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Load the model and do evaluation ############################### os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] h5_files = [] for root, dirs, files in os.walk('.'): for weights in files: if weights[-3:] == '.h5': if weights[:6] == 'helmet': h5_files.append(weights) print(h5_files) for i in h5_files: infer_model = load_model(i) # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f} of weight {}'.format( sum(average_precisions.values()) / len(average_precisions), i))
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) print(config['valid']['valid_annot_folder']) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) labels = labels.keys() if len( config['model']['labels']) == 0 else config['model']['labels'] labels = sorted(labels) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=0, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Load the model and do evaluation ############################### os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] infer_model = load_model(config['train']['saved_weights_name']) # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator, iou_threshold=iou_threshold, obj_thresh=obj_thresh, nms_thresh=nms_thresh, net_h=net_h, net_w=net_w) # print("recall : {}".format(recall)) # print("precision : {}".format(precision)) # plt.plot(recall, precision) # plt.show() # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def evaluate_main_(args): config_path = args.conf yolo_config_file_exit('pass') \ if os.path.isfile(config_path) \ else yolo_config_file_exit('fail') with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) labels = labels.keys() if len(config['model']['labels']) == 0 \ else config['model']['labels'] labels = sorted(labels) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample=32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=0, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Load the model and do evaluation ############################### #os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] infer_model = load_model(config['train']['saved_weights_name']) # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions))) try: yolo_process_exit('pass') except RuntimeError as e: yolo_process_exit('fail')
def train(config, model, tokenizer): columns = ['epoch', 'trn_cost', 'trn_acc', 'val_cost', 'val_acc', 'val_f1'] results = {key: [] for key in columns} train_generator = BatchGenerator('train', config, tokenizer) dev_generator = BatchGenerator('dev', config, tokenizer) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(1, config.epochs+1): epoch_train_results = model.train(sess, epoch, config, train_generator) epoch_val_results = model.validate(sess, epoch, config, dev_generator) epoch_results = [epoch] + epoch_train_results + epoch_val_results for key, value in zip(results.keys(), epoch_results): results[key].append(value) model_name = str(epoch) + '-acc' + str(epoch_val_results[1]) + '-f1' + str(epoch_val_results[2]) model.save(sess, config.model_save_path, model_name) return results
def train(self): """ Returns a trained word2vec model """ generator_param = { 'parser': self.parser, 'exist_labels': False, 'train_w2v': True, 'data_path': self.data_path, 'header': True, 'batch_size': self.batch_size, 'one_pass': True } self.generator = BatchGenerator(**generator_param) model = gensim.models.Word2Vec( iter=1, size=self.embedding_size, window=5, min_count=5) # an empty model, no training yet print("building vocabulary...") model.build_vocab( self.generator) # can be a non-repeatable, 1-pass generator # we only consider words appearing in the input documents, this is useful when # working with large pre-trained word2vec models, for memory issues. self.dic = {k: i.index for (k, i) in model.wv.vocab.items()} if self.pre_trained: # override model object if using a pre-trained model print("loading word2vec model...") model = gensim.models.KeyedVectors.load_word2vec_format( self.pre_trained_path, binary=True) else: print("training word2vec model...") model.train(self.generator, total_examples=model.corpus_count, epochs=self.n_epochs ) # can be a non-repeatable, 1-pass generator return model
def _main_(args): config_path = args.conf weights = args.weights init_session(1.0) with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation(config['eval']['annot_folder'], config['eval']['image_folder'], config['eval']['cache_name'], config['model']['labels']) valid_ints, labels = replace_all_labels_2_one(valid_ints, 'sign') labels = list(labels.keys()) config['model']['labels'] = labels # labels = labels.keys() if len(config['model']['labels']) == 0 else config['model']['labels'] # labels = sorted(labels) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample=config['model'] ['downsample'], # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=0, batch_size=config['train']['batch_size'], min_net_size=config['train']['min_input_size'], max_net_size=config['train']['max_input_size'], shuffle=False, jitter=0.0, norm=image_normalize) yolo_model = yolo.YOLO_Model(config['model'], ) yolo_model.load_weights(weights) average_precisions, _ = yolo_model.evaluate_generator(valid_generator, verbose=True) c_ut.print_predicted_average_precisions(average_precisions)
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) labels = sorted(labels.keys()) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=config['model']['max_box_per_image'], batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Load the model and do evaluation ############################### infer_model = load_model(config['train']['saved_weights_name']) # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
# 训练集采用generator的方式产生 # 测试集采用yield的方式产生 LEARNINF_RATE = 1e-4 #学习率 EPOCHES = 10 #训练轮数 BATCH_SIZE = 128 #批量大小 N_CLASSES = 10 #标签的维度 DROPOUT = 0.5 #dropout概率 IMAGE_H = 224 #图片大小 IMAGE_W = 224 model_path = "model" model_name = "cifar10.ckpt" # 训练集数据生成器(测试集采用yield的方式产生) train_data = BatchGenerator(target_size=(IMAGE_H, IMAGE_W), batch_size=BATCH_SIZE) # 创建placeholder inputs_placeholder = tf.placeholder(dtype=tf.float32, shape=[None, IMAGE_H, IMAGE_W, 3], name="INPUTS") # 理论上这里写tf.int32更合适,写tf.float32也行 labels_placeholder = tf.placeholder(dtype=tf.int32, shape=[None, N_CLASSES], name="INPUTS") keep_prob_placeholder = tf.placeholder(tf.float32, name='keep_prob') alex_outputs = AlexNet(inputs_placeholder, N_CLASSES, keep_prob_placeholder) cost, accuracy = AlexNet_loss(alex_outputs, labels_placeholder) train_op = tf.train.AdamOptimizer(LEARNINF_RATE).minimize(cost)
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### train_ints, valid_ints, labels, max_box_per_image = create_training_instances( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['train']['cache_name'], config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) print('\nTraining on: \t' + str(labels) + '\n') ############################### # Create the generators ############################### train_generator = BatchGenerator( instances=train_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.3, norm=normalize) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Create the model ############################### if os.path.exists(config['train']['saved_weights_name']): config['train']['warmup_epochs'] = 0 warmup_batches = config['train']['warmup_epochs'] * ( config['train']['train_times'] * len(train_generator)) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] multi_gpu = len(config['train']['gpus'].split(',')) train_model, infer_model = create_model( nb_class=len(labels), anchors=config['model']['anchors'], max_box_per_image=max_box_per_image, max_grid=[ config['model']['max_input_size'], config['model']['max_input_size'] ], batch_size=config['train']['batch_size'], warmup_batches=warmup_batches, ignore_thresh=config['train']['ignore_thresh'], multi_gpu=multi_gpu, saved_weights_name=config['train']['saved_weights_name'], lr=config['train']['learning_rate'], grid_scales=config['train']['grid_scales'], obj_scale=config['train']['obj_scale'], noobj_scale=config['train']['noobj_scale'], xywh_scale=config['train']['xywh_scale'], class_scale=config['train']['class_scale'], ) ############################### # Kick off the training ############################### callbacks = create_callbacks(config['train']['saved_weights_name'], config['train']['tensorboard_dir'], infer_model) history = train_model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * config['train']['train_times'], #(train_images/4)*train_times epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'], verbose=2 if config['train']['debug'] else 1, callbacks=callbacks, workers=4, max_queue_size=8, validation_data=valid_generator, validation_steps=len(valid_generator) * config['valid']['valid_times']) # Prepare folder to save in time = datetime.now() time_str = time.strftime("%Y%m%d-%H:%M") cwd = os.getcwd() save_path = os.path.join(cwd, time_str) print('Data saved in: ' + save_path) makedirs(save_path) # Copy and save config file save_config_path = os.path.join(save_path, 'config.json') shutil.copy2(config_path, save_config_path) # plotting train data and saving mat file with data plot_matlab(history, config['data']['plot_png'], config['data']['save_mat'], save_path) # Save the loaded models to .TXT save_template_path = os.path.join(save_path, 'train_model_params.txt') with open(save_template_path, 'w') as fh: # Pass the file handle in as a lambda function to make it callable train_model.summary(print_fn=lambda x: fh.write(x + '\n')) # make a GPU version of infer_model for evaluation if multi_gpu > 1: infer_model = load_model(config['train']['saved_weights_name']) ############################### # Run the evaluation ############################### # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score print('========== VALIDATION ==========') for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) labels = labels.keys() if len( config['model']['labels']) == 0 else config['model']['labels'] labels = sorted(labels) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=0, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Load the model and do evaluation ############################### ############################### # Create the model ############################## train_model, infer_model = create_yolov3_model( nb_class=len(labels), anchors=config['model']['anchors'], max_box_per_image=0, max_grid=[ config['model']['max_input_size'], config['model']['max_input_size'] ], batch_size=config['train']['batch_size'], warmup_batches=0, ignore_thresh=config['train']['ignore_thresh'], grid_scales=config['train']['grid_scales'], obj_scale=config['train']['obj_scale'], noobj_scale=config['train']['noobj_scale'], xywh_scale=config['train']['xywh_scale'], class_scale=config['train']['class_scale'], ) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] saved_weights_name = config['train']['saved_weights_name'] lr = config['train']['learning_rate'], infer_model.load_weights(saved_weights_name) optimizer = Adam(lr=lr, clipnorm=0.001) infer_model.compile(loss=dummy_loss, optimizer=optimizer) infer_model.summary() #infer_model = load_model(config['train']['saved_weights_name']) # compute mAP for all the classes recall, precision, average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions))) return recall, precision, average_precisions
def main(): # GPU limit_keras_gpu_usage(settings.gpu_limit) # configurations global exp_name exp_name = datetime.strftime(datetime.now(), '%y%m%d-%H%M%S') opt = { 'width': settings.W, 'height': settings.H, 'n_classes': settings.n_classes, 'batch_size': settings.batch_size, 'epochs': settings.epochs, 'workers': settings.workers, 'wandb': settings.use_wandb, 'monitor': settings.monitor, 'mode': settings.mode } if settings.use_wandb: wandb.init( project="seg_keras", name=exp_name, config=opt, #TODO: opt sync_tensorboard=True) # Setup model directory if not os.path.exists("trainings"): os.makedirs("trainings") if not os.path.exists(os.path.join('.', 'trainings', exp_name)): os.makedirs(os.path.join('.', 'trainings', exp_name)) config_file_dst = os.path.join('.', 'trainings', exp_name, os.path.basename(settings.CONFIG_PATH)) with open(config_file_dst, 'w') as f: yaml.dump(opt, f, default_flow_style=False, default_style='') if settings.use_wandb: wandb.save(config_file_dst) # Build data generators train_gen = BatchGenerator(settings.DATA_PATH, settings.batch_size, mode='train', n_classes=settings.n_classes) valid_gen = BatchGenerator(settings.DATA_PATH, settings.batch_size, mode='valid', n_classes=settings.n_classes) # Initialize a model cce = categorical_crossentropy metrics = [MIOU(settings.n_classes), categorical_accuracy] model_path = os.path.join('.', 'trainings', exp_name, exp_name + '.h5') model = Deeplabv3(weights=None, input_shape=(settings.H, settings.W, 3), classes=settings.n_classes, activation='softmax', backbone='mobilenetv2') model.summary() model.compile(optimizer=Adam(lr=settings.lr, epsilon=1e-8, decay=1e-6), sample_weight_mode="temporal", loss=cce, metrics=metrics) #model.summary() # training model.fit_generator(train_gen, steps_per_epoch=len(train_gen), epochs=settings.epochs, verbose=1, callbacks=get_callbacks(model_path), validation_data=valid_gen, validation_steps=len(valid_gen), max_queue_size=10, workers=settings.workers, use_multiprocessing=False) # save trflite model new_path = os.path.join('.', 'trainings', exp_name, exp_name + '.tflite') convert_to_tflite(model_path, new_path) if settings.use_wandb: wandb.save(os.path.join('trainings', exp_name))
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### train_ints, valid_ints, labels = create_training_instances( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['train']['cache_name'], config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) ############################### # Create the generators ############################### train_generator = BatchGenerator( instances=train_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=config['model']['max_box_per_image'], batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.3, norm=normalize) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=config['model']['max_box_per_image'], batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Create the model ############################### if os.path.exists(config['train']['saved_weights_name']): warmup_batches = 0 # no need warmup if the pretrained weight exists else: warmup_batches = config['train']['warmup_epochs'] * (config['train']['train_times']*len(train_generator) + \ config['valid']['valid_times']*len(valid_generator)) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] multi_gpu = len(config['train']['gpus'].split(',')) train_model, infer_model = create_model( nb_class=len(labels), anchors=config['model']['anchors'], max_box_per_image=config['model']['max_box_per_image'], max_grid=[ config['model']['max_input_size'], config['model']['max_input_size'] ], batch_size=config['train']['batch_size'], warmup_batches=warmup_batches, ignore_thresh=config['train']['ignore_thresh'], multi_gpu=multi_gpu, saved_weights_name=config['train']['saved_weights_name']) ############################### # Kick off the training ############################### optimizer = Adam(lr=config['train']['learning_rate'], beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) train_model.compile(loss=dummy_loss, optimizer=optimizer) callbacks = create_callbacks(config['train']['saved_weights_name']) try: train_model.fit_generator(generator=train_generator, steps_per_epoch=len(train_generator) * config['train']['train_times'], epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'], verbose=2 if config['train']['debug'] else 1, validation_data=valid_generator, validation_steps=len(valid_generator) * config['valid']['valid_times'], callbacks=callbacks, workers=4, max_queue_size=8) except: pass # load the best weight before early stop train_model.load_weights(config['train']['saved_weights_name']) if multi_gpu > 1: # fix the saved model structure when multi_gpu > 1 train_model.get_layer("model_1").save( config['train']['saved_weights_name']) # load the best weight to the infer_model infer_model.load_weights(config['train']['saved_weights_name']) # save the weight with the model structure of infer_model infer_model.save(config['train']['saved_weights_name']) # make a GPU version of infer_model for evaluation if multi_gpu > 1: infer_model = load_model(config['train']['saved_weights_name']) ############################### # Run the evaluation ############################### # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
MIN_INPUT_SIZE = 608 DEBUG = True max_box_per_image = max( [len(inst['object']) for inst in (train_ints + valid_ints)]) labels = ['Opacity'] train_generator = BatchGenerator( instances=train_ints, anchors=ANCHORS, labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=BATCH_SIZE, min_net_size=MIN_INPUT_SIZE, max_net_size=MAX_INPUT_SIZE, shuffle=True, jitter=0.3, norm=normalize) valid_generator = BatchGenerator( instances=valid_ints, anchors=ANCHORS, labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=BATCH_SIZE,
""" #得到最终的训练集测试集验证集(注意:这里没有tag_train) X_train = sentences_train X_tag_train = tags_train y_train = labels_train X_valid = sentences_dev X_tag_valid = tags_dev y_valid = labels_dev X_test = Xend_sentence X_tag_test = Xend_tag_test y_test = yend_test #得到batch数据 #data_test = BatchGenerator(Xend_sentence,Xend_tag_test, yend_test, shuffle=False) print('Creating the data generator ...') data_train = BatchGenerator(X_train, X_tag_train, y_train, shuffle=True) data_valid = BatchGenerator(X_valid, X_tag_valid, y_valid, shuffle=False) data_test = BatchGenerator(X_test, X_tag_test, y_test, shuffle=False) print('Finished creating the data generator.') ###################################2.############################################ import tensorflow as tf config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) from tensorflow.contrib import rnn import numpy as np # ##################### config ###################### decay = 0.85
#定义分类 LABELS = ['0', "1", "2", "3", '4', '5', '6', '7', '8', "9"] #定义样本路径 ann_dir = os.path.join(PROJECT_ROOT, "data", "ann", "*.xml") img_dir = os.path.join(PROJECT_ROOT, "data", "img") train_ann_fnames = glob.glob(ann_dir) #获取该路径下的xml文件 imgsize = 416 batch_size = 2 #制作数据集 generator = BatchGenerator(train_ann_fnames, img_dir, net_size=imgsize, anchors=COCO_ANCHORS, batch_size=2, labels=LABELS, jitter=False) #随机变化尺寸。数据增强 #定义训练参数 learning_rate = 1e-4 #定义学习率 num_epoches = 85 #定义迭代次数 save_dir = "./model" #定义模型路径 #循环整个数据集,进行loss值验证 def _loop_validation(model, generator): n_steps = generator.steps_per_epoch loss_value = 0
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Create the validation generator ############################### valid_ints, labels = parse_voc_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) labels = labels.keys() if len( config['model']['labels']) == 0 else config['model']['labels'] labels = sorted(labels) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=0, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Load the model and do evaluation ############################### os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] infer_model = load_model(config['train']['saved_weights_name'], compile=False) # compute mAP for all the classes average_precisions = evaluate( infer_model, test_generator, iou_threshold=config['test']['iou_threshold'], obj_thresh=config['test']['obj_thresh']) # print the score average_precisions = evaluate(infer_model, valid_generator) ap = [] # print the mAP score for label, average_precision in average_precisions.items(): print(labels[label] + ' average precision(AP): {:.6f}'.format(average_precision['ap'])) ap.append(average_precision['ap']) print(labels[label] + ' recall: {:.6f}'.format(average_precision['recall'])) print(labels[label] + ' precision: {:.6f}'.format(average_precision['precision'])) print('[INFO] mAP: {:.6f}'.format(sum(ap) / len(ap)))
def _main(): config_path = './local_config.json' LABELS = read_category() with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ''' Parse annotations ''' config['model']['labels'] = LABELS train_ints, valid_ints, labels, max_box_per_image = create_train_valid_set( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) ''' Create generators ''' # check if images are normal after BatchGenerator batches = BatchGenerator(instances=np.append(train_ints, valid_ints), anchors=config['model']['anchors'], labels=labels, downsample=32, max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], shuffle=False, jitter=False) img = batches[0][0][0][5] # plt.imshow(img.astype('uint8')) train_generator = BatchGenerator( instances=train_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], # min_net_size=config['model']['min_input_size'], # max_net_size=config['model']['max_input_size'], shuffle=True, jitter=True, # add 10% noise for each image for training norm=normalize) img = train_generator[0][0][0][5] # plt.imshow(img.astype('float')) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], # min_net_size=config['model']['min_input_size'], # max_net_size=config['model']['max_input_size'], shuffle=True, jitter=False, norm=normalize) ''' Create the model ''' if os.path.exists(config['train']['saved_weights_name']): config['train']['warmup_epochs'] = 0 warmup_batches = config['train']['warmup_epochs'] * ( config['train']['train_times'] * len(train_generator)) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] multi_gpu = len(config['train']['gpus'].split(',')) train_model, infer_model = create_model( nb_class=len(labels), anchors=config['model']['anchors'], max_box_per_image=max_box_per_image, max_grid=[ config['model']['max_input_size'], config['model']['max_input_size'] ], batch_size=config['train']['batch_size'], warmup_batches=warmup_batches, ignore_thresh=config['train']['ignore_thresh'], multi_gpu=multi_gpu, saved_weights_name=config['train']['saved_weights_name'], lr=config['train']['learning_rate'], grid_scales=config['train']['grid_scales'], obj_scale=config['train']['obj_scale'], noobj_scale=config['train']['noobj_scale'], xywh_scale=config['train']['xywh_scale'], class_scale=config['train']['class_scale'], ) print('\ntrain_model: \n') print(train_model.summary()) print('\ninfer_model: \n') print(infer_model.summary()) ''' Kick off the training ''' callbacks = create_callbacks(config['train']['saved_weights_name'], config['train']['tensorboard_dir'], infer_model) train_model.fit_generator( generator=train_generator, steps_per_epoch=len( train_generator), # * config['train']['train_times'], epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'], verbose=2 if config['train']['debug'] else 1, callbacks=callbacks, workers=16, max_queue_size=8) # make a GPU version of infer_model for evaluation if multi_gpu > 1: infer_model = load_model(config['train']['saved_weights_name']) ''' Evaluate the result ''' # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def main(args): ''' There are 5 simple steps to this program ''' # 1. combine all data into 2 dataframes (train, valid) print("Getting data from arguments") train_dataprops, df_train = combine_all_wavs_and_trans_from_csvs( args.train_files) valid_dataprops, df_valid = combine_all_wavs_and_trans_from_csvs( args.valid_files) # check any special data model requirments e.g. a spectrogram if (args.model_arch == 1): model_input_type = "mfcc" elif (args.model_arch == 2 or args.model_arch == 5): print("Spectrogram required") # spectrogram = True model_input_type = "spectrogram" else: model_input_type = "mfcc" ## 2. init data generators print("Creating data batch generators") traindata = BatchGenerator(dataframe=df_train, training=True, batch_size=args.batchsize, model_input_type=model_input_type) validdata = BatchGenerator(dataframe=df_valid, training=False, batch_size=args.batchsize, model_input_type=model_input_type) inputs, outputs = traindata.get_batch(0) input_shape = inputs['the_input'].shape[1:] output_shape = inputs['the_labels'].shape[1:] output_dir = os.path.join('checkpoints/results', 'model') if not os.path.isdir(output_dir): os.makedirs(output_dir) ## 3. Load existing or create new model if args.loadcheckpointpath: # load existing print("Loading model") cp = args.loadcheckpointpath assert (os.path.isdir(cp)) model_path = os.path.join(cp, "model") # assert(os.path.isfile(model_path)) model = load_model_checkpoint(model_path) print("Model loaded") else: # new model recipes here print('New model DS{}'.format(args.model_arch)) if (args.model_arch == 0): # DeepSpeech1 with Dropout model = ds1_dropout(input_dim=26, fc_size=args.fc_size, rnn_size=args.rnn_size, dropout=[0.1, 0.1, 0.1], output_dim=29) elif (args.model_arch == 1): # DeepSpeech1 - no dropout model = ds1(input_dim=26, fc_size=args.fc_size, rnn_size=args.rnn_size, output_dim=29) elif (args.model_arch == 2): # DeepSpeech2 model model = ds2_gru_model(input_dim=161, fc_size=args.fc_size, rnn_size=args.rnn_size, output_dim=29) elif (args.model_arch == 3): # own model model = ownModel(input_shape, output_shape, fc_size=args.fc_size, rnn_size=args.rnn_size, dropout=[0.1, 0.1, 0.1], output_dim=29) elif (args.model_arch == 4): # graves model model = graves(input_dim=26, rnn_size=args.rnn_size, output_dim=29, std=0.5) elif (args.model_arch == 5): # cnn city model = cnn_city(input_dim=161, fc_size=args.fc_size, rnn_size=args.rnn_size, output_dim=29) elif (args.model_arch == 6): # constrained model model = const(input_dim=26, fc_size=args.fc_size, rnn_size=args.rnn_size, output_dim=29) else: raise ("model not found") print(model.summary(line_length=140)) # required to save the JSON save_model(model, output_dir) if (args.opt.lower() == 'sgd'): opt = SGD(lr=args.learning_rate, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5) elif (args.opt.lower() == 'adam'): opt = Adam(lr=args.learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-8, clipnorm=5) elif (args.opt.lower() == 'nadam'): opt = Nadam(lr=args.learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-8, clipnorm=5) else: raise Exception("optimiser not recognised") model.compile(optimizer=opt, loss=ctc) ## 4. train if args.train_steps == 0: args.train_steps = len(df_train.index) // args.batchsize # print(args.train_steps) # we use 1/xth of the validation data at each epoch end to test val score if args.valid_steps == 0: args.valid_steps = (len(df_valid.index) // args.batchsize) # print(args.valid_steps) if args.memcheck: cb_list = [MemoryCallback()] else: cb_list = [] if args.tensorboard: tb_cb = TensorBoard(log_dir='./tensorboard/{}/'.format(args.name), write_graph=False, write_images=True) cb_list.append(tb_cb) y_pred = model.get_layer('ctc').input[0] input_data = model.get_layer('the_input').input report = K.function([input_data, K.learning_phase()], [y_pred]) report_cb = ReportCallback(report, validdata, model, args.name, save=True) cb_list.append(report_cb) model.fit_generator( generator=traindata.next_batch(), steps_per_epoch=args.train_steps, epochs=args.epochs, callbacks=cb_list, validation_data=validdata.next_batch(), validation_steps=args.valid_steps, ) ## These are the most important metrics print("Mean WER :", report_cb.mean_wer_log) print("Mean LER :", report_cb.mean_ler_log) print("NormMeanLER:", report_cb.norm_mean_ler_log) # export to csv? K.clear_session()
def main(argv): if (len(sys.argv) != 3): print('Usage ./train.py [root_dir] [config.yml]') sys.exit(1) #Load data root_dir = argv[1] + '/' #in case we forgot print('Opening file' + root_dir + argv[2]) with open(root_dir + argv[2], 'r') as configfile: config = yaml.safe_load(configfile) image_dir = root_dir + config['data_dir'] train_dir = root_dir + config['data_dir'] train_image_folder = root_dir + config['data_dir'] weights_dir = root_dir + config['weights_dir'] your_weights = weights_dir + config['specific_weights'] generic_weights = weights_dir + config['generic_weights'] trained_weights = weights_dir + config['trained_weights'] list_of_train_file = train_dir + config['checked_annotations_fname'] list_of_train_files = '/annotations-checked.yml' train_files_regex = config['generic_train_files_regex'] FINE_TUNE = config['FINE_TUNE'] TEST_RUN = config['TEST_RUN'] LABELS = config['LABELS'] IMAGE_H = config['IMAGE_H'] IMAGE_W = config['IMAGE_W'] NO_OBJECT_SCALE = config['NO_OBJECT_SCALE'] OBJECT_SCALE = config['OBJECT_SCALE'] COORD_SCALE = config['COORD_SCALE'] CLASS_SCALE = config['CLASS_SCALE'] valid_image_folder = train_image_folder valid_annot_folder = train_image_folder if FINE_TUNE: BATCH_SIZE = 4 if TEST_RUN: EPOCHS = 1 else: EPOCHS = 100 model = get_yolo_model(IMAGE_W, IMAGE_H, num_class=1, headtrainable=True, trainable=True) model.load_weights(your_weights) else: BATCH_SIZE = 32 EPOCHS = 500 model = get_yolo_model(IMAGE_W, IMAGE_H, num_class=1, headtrainable=True) model.load_weights(generic_weights, by_name=True) ### read saved pickle of parsed annotations with open(train_image_folder + list_of_train_files, 'r') as fp: all_imgs = yaml.load(fp) print('Reading YaML file finished. Time to luck and load!\n') num_ims = len(all_imgs) indexes = np.arange(num_ims) random.shuffle(indexes) num_val = 0 #num_ims//10 #valid_imgs = list(itemgetter(*indexes[:num_val].tolist())(all_imgs)) train_imgs = list(itemgetter(*indexes[num_val:].tolist())(all_imgs)) train_batch = BatchGenerator(instances=train_imgs, labels=LABELS, batch_size=BATCH_SIZE, shuffle=True, jitter=0.0, im_dir=train_image_folder) #valid_batch = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False) def yolo_loss(y_true, y_pred): # compute grid factor and net factor grid_h = tf.shape(y_true)[1] grid_w = tf.shape(y_true)[2] grid_factor = tf.reshape(tf.cast([grid_w, grid_h], tf.float32), [1, 1, 1, 1, 2]) net_h = IMAGE_H / grid_h net_w = IMAGE_W / grid_w net_factor = tf.reshape(tf.cast([net_w, net_h], tf.float32), [1, 1, 1, 1, 2]) pred_box_xy = y_pred[..., 0:2] # t_wh pred_box_wh = tf.log(y_pred[..., 2:4]) # t_wh pred_box_conf = tf.expand_dims(y_pred[..., 4], 4) pred_box_class = y_pred[..., 5:] # adjust class probabilities # initialize the masks object_mask = tf.expand_dims(y_true[..., 4], 4) true_box_xy = y_true[..., 0:2] # (sigma(t_xy) + c_xy) true_box_wh = tf.where(y_true[..., 2:4] > 0, tf.log(tf.cast(y_true[..., 2:4], tf.float32)), y_true[..., 2:4]) true_box_conf = tf.expand_dims(y_true[..., 4], 4) true_box_class = y_true[..., 5:] xy_delta = COORD_SCALE * object_mask * (pred_box_xy - true_box_xy ) #/net_factor #* xywh_scale wh_delta = COORD_SCALE * object_mask * (pred_box_wh - true_box_wh ) #/ net_factor #* xywh_scale obj_delta = OBJECT_SCALE * object_mask * (pred_box_conf - true_box_conf) no_obj_delta = NO_OBJECT_SCALE * (1 - object_mask) * pred_box_conf class_delta = CLASS_SCALE * object_mask * (pred_box_class - true_box_class) loss_xy = tf.reduce_sum(tf.square(xy_delta), list(range(1, 5))) loss_wh = tf.reduce_sum(tf.square(wh_delta), list(range(1, 5))) loss_obj = tf.reduce_sum(tf.square(obj_delta), list(range(1, 5))) lossnobj = tf.reduce_sum(tf.square(no_obj_delta), list(range(1, 5))) loss_cls = tf.reduce_sum(tf.square(class_delta), list(range(1, 5))) loss = loss_xy + loss_wh + loss_obj + lossnobj + loss_cls return loss print('Prepared bathes now we will load weights') wt_file = your_weights optimizer = Adam(lr=0.5e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(loss=yolo_loss, optimizer=optimizer) early_stop = EarlyStopping(monitor='loss', min_delta=0.001, patience=5, mode='min', verbose=1) checkpoint = ModelCheckpoint(wt_file, monitor='loss', verbose=1, save_best_only=True, mode='min', period=1) print('Training starts.') start = time.time() model.fit_generator( generator=train_batch, steps_per_epoch=len(train_batch), epochs=EPOCHS, verbose=1, # validation_data = valid_batch, # validation_steps = len(valid_batch), callbacks=[checkpoint, early_stop], #, tensorboard], max_queue_size=3) model.save_weights(trained_weights) end = time.time() print('Training took ' + str(end - start) + ' seconds') print('Weights saved to ' + trained_weights) print("Finished! :o)")
train_imgs = list(itemgetter(*indexes[:].tolist())(all_imgs)) def normalize(image): image = image / 255. return image train_batch = BatchGenerator( instances=train_imgs, anchors=ANCHORS, labels=LABELS, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=1000, batch_size=BATCH_SIZE, min_net_size=IMAGE_H, max_net_size=IMAGE_H, shuffle=False, jitter=0.0, norm=normalize) if FINE_TUNE: optimizer = Adam(lr=0.5e-6, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) EPOCHS = 20 else:
def _main_(args): config_path = args.conf with open(config_path, encoding='UTF-8') as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### train_ints, valid_ints, labels, max_box_per_image = create_training_instances( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['train']['cache_name'], config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels'] ) print('\n[INFO] Training on: \t' + str(labels) + '\n') ############################### # Create the generators ############################### train_generator = BatchGenerator( instances = train_ints, anchors = config['model']['anchors'], labels = labels, downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image = max_box_per_image, batch_size = config['train']['batch_size'], min_net_size = config['model']['min_input_size'], max_net_size = config['model']['max_input_size'], shuffle = True, jitter = 0.3, norm = normalize ) valid_generator = BatchGenerator( instances = valid_ints, anchors = config['model']['anchors'], labels = labels, downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image = max_box_per_image, batch_size = config['train']['batch_size'], min_net_size = config['model']['min_input_size'], max_net_size = config['model']['max_input_size'], shuffle = True, jitter = 0.0, norm = normalize ) print("[INFO] Creating Model...") ############################### # Create the model ############################### if os.path.exists(config['train']['saved_weights_name']): config['train']['warmup_epochs'] = 0 warmup_batches = config['train']['warmup_epochs'] * (config['train']['train_times']*len(train_generator)) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] multi_gpu = len(config['train']['gpus'].split(',')) train_model, infer_model = create_model( config=config, max_box_per_image=max_box_per_image, warmup_batches= warmup_batches, multi_gpu=multi_gpu, saved_weights_name=config['train']['saved_weights_name'], lr=config['train']['learning_rate'] ) ############################### # Kick off the training ############################### callbacks = create_callbacks(config['train']['saved_weights_name'], config['train']['tensorboard_dir'], infer_model, valid_generator, labels, config_path.split('_')[0]) print("[INFO] Training Model...") train_model.fit_generator( generator = train_generator, steps_per_epoch = len(train_generator) * config['train']['train_times'], epochs = config['train']['nb_epochs'] + config['train']['warmup_epochs'], # validation_data = valid_generator, # validation_steps = len(train_generator) / config['train']['batch_size'], verbose = 2 if config['train']['debug'] else 1, callbacks = callbacks, workers = 4, max_queue_size = 8 ) print("[INFO] Saving Model...") print("[INFO] Start Evalutating Model...") # make a GPU version of infer_model for evaluation if multi_gpu > 1: infer_model = load_model(config['train']['saved_weights_name'])
def main(): 'Main' from argparse import ArgumentParser import os # available architectures models_list = [ 'vgg16', 'vgg19', 'inceptionv3', 'resnet50', 'custom', 'xception', 'inceptionresnet', 'mobilenet', 'densenet121', 'densenet169', 'densenet201', 'nasnet', 'mobilenetv2' ] # available optimizers optimizers_list = ['sgd', 'adam'] losses_list = [ 'categorical_crossentropy', 'sparse_categorical_crossentropy', 'binary_crossentropy', 'mean_squared_error', 'mean_absolute_error', 'mean_absolute_percentage_error', 'mean_squared_logarithmic_error', 'squared_hinge', 'hinge', 'categorical_hinge', 'logcosh', 'kullback_leibler_divergence', 'poisson', 'cosine_proximity' ] # print these names for loss functions losses_dict = { 'mean_squared_error': 'MSE', 'mean_absolute_error': 'MAE', 'mean_absolute_percentage_error': 'MAPE', 'mean_squared_logarithmic_error': 'MSLE', 'squared_hinge': 'Squared Hinge', 'hinge': 'Hinge', 'categorical_hinge': 'Categorical Hinge', 'logcosh': 'Log-Cosh', 'categorical_crossentropy': 'Categorial Cross-entropy', 'sparse_categorical_crossentropy': 'Sparse Categorical Cross-entropy', 'binary_crossentropy': 'Binary Cross-entropy', 'kullback_leibler_divergence': 'Kullback-Leibler Divergence', 'poisson': 'Poisson', 'cosine_proximity': 'Cosine Proximity' } parser = ArgumentParser() parser.add_argument('model', help='which model to use', type=str, choices=models_list) parser.add_argument('path', help='path to data', type=str) parser.add_argument('--loadfrom', help='load previous model', type=str) parser.add_argument( '-e', '--epochs', help='epochs to train for', type=int, default=30) parser.add_argument( '-b', '--batch', help='training batch size', type=int, default=8) parser.add_argument('-o', '--optimizer', help='optimizer to use', type=str, choices=optimizers_list, default='sgd') parser.add_argument( '-s', '--split', help='test split size', default=0.2, type=float) parser.add_argument('-t', '--testset', help='path to test data', type=str) parser.add_argument('--loss', help='loss function to use', type=str, choices=losses_list, default='categorical_crossentropy') parser.add_argument('--nogpu', help='disable GPU', action='store_true', dest='no_gpu') parser.add_argument('--usemp', help='enable multiprocessing for sequences', action='store_true', dest='use_mp') parser.add_argument( '--pretrained', help='load pre-trained weights', action='store_true') parser.add_argument('--output', help='output file', type=str) parser.add_argument('--extsum', help='print extended summary', action='store_true', dest='print_extsum') parser.add_argument('--sum', help='print summary', action='store_true', dest='print_sum') parser.add_argument('--json', help='save model as JSON file', type=str) parser.add_argument('--log', help='test log filename', type=str, default='tests_log.log') parser.add_argument( '--shape', help='input shape in (height:width:depth) format', type=str) parser.add_argument( '--dropout', help='dropout probability (default=0)', type=float) parser.add_argument('--pfldir', help='put .pfl files here', type=str, default='.', dest='pfldir') parser.add_argument('--decay', help='weight decay', default=0.005, type=float, dest='weight_decay') parser.add_argument('-K', help='apply kernel regularization', action='store_true', dest='regularize_kernel') parser.add_argument('-B', help='apply bias regularization', action='store_true', dest='regularize_bias') parser.add_argument('-A', help='apply activity regularization', action='store_true', dest='regularize_activity') parser.add_argument( '-a', '--augment', help='apply perform data augmentation', action='store_true') parser.add_argument( '--seed', help='random seed for train-test split', type=int, default=7) args = parser.parse_args() from keras.callbacks import Callback if args.pfldir: os.makedirs(args.pfldir, exist_ok=True) if args.output: os.makedirs(args.output, exist_ok=True) class PerformanceHistory(Callback): def __init__(self, output_file: str): super().__init__() self.output_file = open(output_file, 'wt') self.csv_file = csv.writer(self.output_file) self.csv_file.writerow( ['ACCURACY', 'LOSS', 'VALIDATION ACCURACY', 'VALIDATION LOSS']) def on_epoch_end(self, batch, logs={}): self.csv_file.writerow([logs.get('accuracy'), logs.get( 'loss'), logs.get('val_accuracy'), logs.get('val_loss')]) self.output_file.flush() def __del__(self): self.output_file.close() if args.no_gpu: os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = '' image_dim = 224 if args.model in ['vgg16', 'vgg19', 'custom'] else 299 input_shape = (image_dim, image_dim, 3) if args.shape is not None: input_shape = [(int(y) if y != '' else 1) for y in args.shape.split(':')] import keras.applications as apps # preprocessing functions dictonary input_preprocessing = { 'vgg16': apps.vgg16.preprocess_input, 'vgg19': apps.vgg19.preprocess_input, 'inceptionv3': apps.inception_v3.preprocess_input, 'resnet50': apps.resnet50.preprocess_input, 'custom': apps.vgg16.preprocess_input, 'xception': apps.xception.preprocess_input, 'inceptionresnet': apps.inception_resnet_v2.preprocess_input, 'mobilenet': apps.mobilenet.preprocess_input, 'densenet121': apps.densenet.preprocess_input, 'densenet169': apps.densenet.preprocess_input, 'densenet201': apps.densenet.preprocess_input, 'nasnet': apps.nasnet.preprocess_input, 'mobilenetv2': apps.mobilenet_v2.preprocess_input } from keras.layers import Dropout from keras.regularizers import l2 from keras.models import load_model from keras import Model from optimizers import getOptimizer from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelBinarizer from generator import AugmentedBatchGenerator, BatchGenerator from extsum import extended_summary import numpy as np import datetime as dt import pickle import csv import subprocess from random import shuffle, seed # load default specified dataset data_path = os.path.abspath(args.path) X_raw = [] y_raw = [] for d in os.listdir(data_path): for f in os.listdir(data_path + '/' + d): X_raw.append('/'.join([data_path, d, f])) y_raw.append(d) lb = LabelBinarizer() lb.fit(y_raw) seed(args.seed) if args.testset: # if a test set was specified, load it print(f'Using data at {args.testset} as test set.') # shuffle training data training_shuffled = list(zip(X_raw, y_raw)) shuffle(training_shuffled) X_data, y_data = zip(*training_shuffled) X_data, y_data = np.asarray(X_data), lb.transform(y_data) X_train, y_train = X_data, y_data data_path = os.path.abspath(args.testset) X_raw = [] y_raw = [] for d in os.listdir(data_path): for f in os.listdir(data_path + '/' + d): X_raw.append('/'.join([data_path, d, f])) y_raw.append(d) # shuffle test test_shuffled = list(zip(X_raw, y_raw)) shuffle(test_shuffled) X_raw, y_raw = zip(*test_shuffled) X_test, y_test = np.asarray(X_raw), lb.transform(y_raw) else: # otherwise split default dataset print(f'Using {args.split} of the provided dataset as test set.') X_data, y_data = np.asarray(X_raw), lb.transform(y_raw) X_train, X_test, y_train, y_test = train_test_split( X_data, y_data, test_size=args.split, random_state=args.seed) del X_raw del y_raw n_classes = y_data.shape[1] models_dict = { 'xception': apps.Xception, 'vgg16': apps.VGG16, 'vgg19': apps.VGG19, 'resnet50': apps.ResNet50, 'inceptionv3': apps.InceptionV3, 'inceptionresnet': apps.InceptionResNetV2, 'mobilenet': apps.MobileNet, 'mobilenetv2': apps.MobileNetV2, 'densenet121': apps.DenseNet121, 'densenet169': apps.DenseNet169, 'densenet201': apps.DenseNet201, 'nasnet': apps.NASNetLarge } # load vanilla model with specified parameters model = models_dict[args.model]( classes=n_classes, input_shape=input_shape, weights='imagenet' if args.pretrained else None) if args.dropout is not None: print('Adding weight decay') # insert dropout layer and regularization preds = model.layers[-1] dp = Dropout(args.dropout)(model.layers[-2].output) preds = preds(dp) model = Model(inputs=model.inputs, outputs=preds) for layer in model.layers: if args.regularize_kernel: layer.kernel_regularizer = l2(args.weight_decay) if args.regularize_bias: layer.bias_regularizer = l2(args.weight_decay) if args.regularize_activity: layer.activity_regularizer = l2(args.weight_decay) opt = getOptimizer(args.optimizer) model.compile(loss=args.loss, optimizer=opt, metrics=['accuracy']) if args.loadfrom: print('Loading', args.loadfrom) model = load_model(os.path.abspath(args.loadfrom)) # iteratively rename performance file pfldir = os.path.abspath(args.pfldir) performance_file = os.path.join( pfldir, f'{args.model}_b{args.batch}_e{args.epochs}.pfl') fnum = 1 while os.path.isfile(performance_file): performance_file = os.path.join( pfldir, f'{args.model}_b{args.batch}_e{args.epochs}_{fnum}.pfl') fnum += 1 os.makedirs(pfldir, exist_ok=True) if args.print_extsum: extended_summary(model) elif args.print_sum: model.summary() perf_log = PerformanceHistory(performance_file) # print test parameters to screen print('\n{:<20}{}'.format('Model', args.model)) print('{:<20}{}'.format('Input shape', input_shape)) print('{:<20}{}'.format('Epochs', args.epochs)) print('{:<20}{}'.format('Batch size', args.batch)) print('{:<20}{}'.format('Optimizer', type(opt).__name__)) print('{:<20}{}'.format('Optimizer params', paramDictFormat(opt.get_config()))) print('{:<20}{}'.format('Loss', args.loss)) print('{:<20}{}'.format('Multiprocessing', 'On' if args.use_mp else 'Off')) print('{:<20}{}'.format('Performance log', performance_file)) print('{:<20}{}'.format('Test log', args.log)) print('{:<20}{}'.format('Dataset', args.path)) reg = [] if args.regularize_kernel: reg.append('kernel') if args.regularize_activity: reg.append('activity') if args.regularize_bias: reg.append('bias') print('{:<20}{}\n'.format('Regularization', 'None' if not reg else ', '.join(reg))) opt = getOptimizer(args.optimizer) model.compile(loss=args.loss, optimizer=opt, metrics=['accuracy']) # create training batch generator if args.augment: print('Data augmentation enabled.') train_gen = AugmentedBatchGenerator(X_train, y_train, args.batch, shape=input_shape, ops=[ input_preprocessing[args.model]], pad=False) else: print('Data augmentation disabled.') train_gen = BatchGenerator(X_train, y_train, args.batch, shape=input_shape, ops=[ input_preprocessing[args.model]], pad=False) # create testing batch generator test_gen = BatchGenerator(X_test, y_test, args.batch, shape=input_shape, ops=[ input_preprocessing[args.model]], pad=False) # train model train_start = dt.datetime.now() model.fit_generator(train_gen, epochs=args.epochs, use_multiprocessing=args.use_mp, validation_data=test_gen, callbacks=[perf_log]) train_end = dt.datetime.now() # evaluate final model on train set train_score = model.evaluate_generator(train_gen) print('Train loss:', train_score[0]) print('Train accuracy:', train_score[1]) # evaluate final model on test set test_score = model.evaluate_generator(test_gen) print('Test loss:', test_score[0]) print('Test accuracy:', test_score[1]) # update tests log with current test data date_format = '{:%Y-%m-%d %H:%M}' log_format = '{:<20}{:<20}{:<20}{:<10}{:<10}{:<15}{:<15.5}{:<15.5}{:<15.5}{:<15.5}{:<30}{:<30}{:<70}{:<15}{:<15}{:<15}{:<15.5}{:<15.5}\n' header_format = '{:<20}{:<20}{:<20}{:<10}{:<10}{:<15}{:<15}{:<15}{:<15}{:<15}{:<30}{:<30}{:<70}{:<15}{:<15}{:<15}{:<15}{:<15}\n' with open(args.log, 'a+t') as test_log: if test_log.tell() <= 0: test_log.write(header_format.format( 'BEGIN', 'END', 'ARCHITECTURE', 'BATCH', 'EPOCHS', 'OPTIMIZER', 'TRAIN LOSS', 'TRAIN ACC', 'TEST LOSS', 'TEST ACC', 'DATA FOLDER', 'LOSS FUNCTION', 'OPTIMIZER PARAMS', 'KERNEL REG', 'BIAS REG', 'ACTIV. REG', 'DECAY', 'DROPOUT')) start_str = date_format.format(train_start) end_str = date_format.format(train_end) data_folder = args.path.split('/')[-1 if args.path[-1] != '/' else -2] test_log.write(log_format.format(start_str, end_str, args.model.upper(), args.batch, args.epochs, args.optimizer.upper(), train_score[0], train_score[1], test_score[0], test_score[1], data_folder, losses_dict[args.loss], paramDictFormat( opt.get_config()), 'YES' if args.regularize_kernel else 'NO', 'YES' if args.regularize_bias else 'NO', 'YES' if args.regularize_activity else 'NO', args.weight_decay, args.dropout if args.dropout else 0.0)) # save the model and class file if an output filename was specified if args.output is not None: print(f'Saving model as {args.output}.h5') os.makedirs('/'.join(args.output.split('/')[:-1]), exist_ok=True) model.save(f'{args.output}.h5') with open(f'{args.output}.bin', 'wb') as fout: pickle.dump((args.model, lb), fout) subprocess.run(['notify-send', 'Entrenamiento completado', f'Se ha completado el entrenamiento del modelo {args.model}.'], check=False)
num_ims = len(all_imgs) indexes = np.arange(num_ims) #random.shuffle(indexes) num_val = 0 #num_ims//10 #valid_imgs = list(itemgetter(*indexes[:num_val].tolist())(all_imgs)) train_imgs = list(itemgetter(*indexes[num_val:].tolist())(all_imgs)) train_batch = BatchGenerator( instances=train_imgs, labels=LABELS, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 batch_size=BATCH_SIZE, min_net_size=IMAGE_H, max_net_size=IMAGE_H, shuffle=False, jitter=0.0, im_dir=train_image_folder) #sys.exit('bye') #train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize, jitter=False) #valid_batch = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False) # In[104]: # **Setup a few callbacks and start the training** # In[105]:
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### train_ints, valid_ints, labels, max_box_per_image = create_training_instances( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['train']['cache_name'], config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) print('\nTraining on: \t' + str(labels) + '\n') ############################### # Create the generators ############################### train_generator = BatchGenerator( instances=train_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.3, norm=normalize) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Create the model ############################### if os.path.exists(config['train']['saved_weights_name']): config['train']['warmup_epochs'] = 0 warmup_batches = config['train']['warmup_epochs'] * ( config['train']['train_times'] * len(train_generator)) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] multi_gpu = len(config['train']['gpus'].split(',')) train_model, infer_model = create_model( nb_class=len(labels), anchors=config['model']['anchors'], max_box_per_image=max_box_per_image, max_grid=[ config['model']['max_input_size'], config['model']['max_input_size'] ], batch_size=config['train']['batch_size'], warmup_batches=warmup_batches, ignore_thresh=config['train']['ignore_thresh'], multi_gpu=multi_gpu, saved_weights_name=config['train']['saved_weights_name'], lr=config['train']['learning_rate'], grid_scales=config['train']['grid_scales'], obj_scale=config['train']['obj_scale'], noobj_scale=config['train']['noobj_scale'], xywh_scale=config['train']['xywh_scale'], class_scale=config['train']['class_scale'], ) ############################### # Kick off the training ############################### callbacks = create_callbacks(config['train']['saved_weights_name'], config['train']['tensorboard_dir'], infer_model) train_model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * config['train']['train_times'], epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'], verbose=2 if config['train']['debug'] else 1, callbacks=callbacks, workers=4, max_queue_size=8) # make a GPU version of infer_model for evaluation if multi_gpu > 1: infer_model = load_model(config['train']['saved_weights_name']) ############################### # Run the evaluation ############################### # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score for label, average_precision in average_precisions.items(): print(labels[label] + ': {:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### train_ints, valid_ints, labels, max_box_per_image = create_training_instances( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['train']['cache_name'], config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels']) print('\nTraining on: \t' + str(labels) + '\n') ############################### # Create the generators ############################### train_generator = BatchGenerator( instances=train_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.3, norm=normalize) valid_generator = BatchGenerator( instances=valid_ints, anchors=config['model']['anchors'], labels=labels, downsample= 32, # ratio between network input's size and network output's size, 32 for YOLOv3 max_box_per_image=max_box_per_image, batch_size=config['train']['batch_size'], min_net_size=config['model']['min_input_size'], max_net_size=config['model']['max_input_size'], shuffle=True, jitter=0.0, norm=normalize) ############################### # Create the model ############################### if os.path.exists(config['train']['saved_weights_name']): config['train']['warmup_epochs'] = 0 warmup_batches = config['train']['warmup_epochs'] * ( config['train']['train_times'] * len(train_generator)) os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus'] multi_gpu = len(config['train']['gpus'].split(',')) print('multi_gpu:' + str(multi_gpu)) train_model, infer_model = create_model( nb_class=len(labels), anchors=config['model']['anchors'], max_box_per_image=max_box_per_image, max_grid=[ config['model']['max_input_size'], config['model']['max_input_size'] ], batch_size=config['train']['batch_size'], warmup_batches=warmup_batches, ignore_thresh=config['train']['ignore_thresh'], multi_gpu=multi_gpu, saved_weights_name=config['train']['saved_weights_name'], lr=config['train']['learning_rate'], grid_scales=config['train']['grid_scales'], obj_scale=config['train']['obj_scale'], noobj_scale=config['train']['noobj_scale'], xywh_scale=config['train']['xywh_scale'], class_scale=config['train']['class_scale'], backend=config['model']['backend']) ############################### # Kick off the training ############################### callbacks = create_callbacks(config['train']['saved_weights_name'], config['train']['tensorboard_dir'], infer_model) train_model.fit( x=train_generator, validation_data=valid_generator, steps_per_epoch=len(train_generator) * config['train']['train_times'], epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'], verbose=2 if config['train']['debug'] else 1, workers=4, max_queue_size=8, callbacks=callbacks) train_model.load_weights(config['train']['saved_weights_name']) infer_model.save(config['train']['saved_weights_name']) ############################### # Run the evaluation ############################### # compute mAP for all the classes average_precisions = evaluate(infer_model, valid_generator) # print the score total_instances = [] precisions = [] for label, (average_precision, num_annotations) in average_precisions.items(): print('{:.0f} instances of class'.format(num_annotations), labels[label], 'with average precision: {:.4f}'.format(average_precision)) total_instances.append(num_annotations) precisions.append(average_precision) if sum(total_instances) == 0: print('No test instances found.') return print('mAP using the weighted average of precisions among classes: {:.4f}'. format( sum([a * b for a, b in zip(total_instances, precisions)]) / sum(total_instances))) print('mAP: {:.4f}'.format( sum(precisions) / sum(x > 0 for x in total_instances)))