def main(): ########### 读取配置文件 ########## ch = config.ConfigHandler("./config.ini") ch.load_config() ########### 读取参数 ########## train_batch_size = int(ch.config["model"]["train_batch_size"]) val_batch_size = int(ch.config["model"]["val_batch_size"]) num_epochs = int(ch.config["model"]["num_epochs"]) learning_rate = float(ch.config["model"]["learning_rate"]) class_size = int(ch.config["model"]["class_size"]) log_interval = int(ch.config["log"]["log_interval"]) ########### 获取数据loader ########## data_loader = dataset.MyDataset(train_batch_size, val_batch_size) data_loader_train =data_loader.load_train_data() data_loader_test = data_loader.load_test_data() ########### 训练和评价 ########## train.train_and_test(num_epochs, learning_rate, class_size, data_loader_train, data_loader_test, log_interval).train_epoch()
def load_data(image_dir, label_dir): # Prepare dataset # data loader for easy mini-batch return in testing data = dataset.MyDataset(image_dir=image_dir, label_dir=label_dir, transform=True) loader = Data.DataLoader(dataset=data, batch_size=BATCH_SIZE, shuffle=False) return loader
def load_data(image_dir, label_dir): ''' data loader for every mini-batch return in the training/validation/test set ''' data = dataset.MyDataset(image_dir=image_dir, label_dir=label_dir, transform=True) loader = Data.DataLoader(dataset=data, batch_size=opt.batch_size, shuffle=True) return loader
def main(): if not torch.cuda.is_available(): logging.info('no gpu device available') sys.exit(1) np.random.seed(args.seed) torch.cuda.set_device(args.gpu) cudnn.benchmark = True torch.manual_seed(args.seed) cudnn.enabled=True torch.cuda.manual_seed(args.seed) logging.info('gpu device = %d' % args.gpu) logging.info("args = %s", args) genotype = eval("genotypes.%s" % args.arch) model = Network(args.init_channels, ntu_CLASSES, args.layers, args.auxiliary, genotype) model = model.cuda() utils.load(model, args.model_path) logging.info("param size = %fMB", utils.count_parameters_in_MB(model)) criterion = nn.CrossEntropyLoss() criterion = criterion.cuda() validset = dataset.MyDataset('/media/lab540/79eff75a-f78c-42f2-8902-9358e88bf654/lab540/Neura_auto_search/datasets/kinetics_convert/test.txt', transform = transform.ToTensor()) valid_queue = torch.utils.data.DataLoader(validset, batch_size=args.batch_size, shuffle=False, num_workers=1) # _, test_transform = utils._data_transforms_cifar10(args) # test_data = dset.CIFAR10(root=args.data, train=False, download=True, transform=test_transform) # # test_queue = torch.utils.data.DataLoader( # test_data, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=2) model.drop_path_prob = args.drop_path_prob test_acc, test_obj = infer(valid_queue, model, criterion) logging.info('test_acc %f', test_acc)
output = output.permute(0, 2, 3, 1) output = output.reshape(output.size(0), output.size(1), output.size(2), 3, -1) mask_obj = target[..., 0] > 0 mask_noobj = target[..., 0] == 0 loss_obj = torch.mean((output[mask_obj] - target[mask_obj])**2) loss_noobj = torch.mean((output[mask_noobj][0] - target[mask_noobj][0])**2) loss = alpha * loss_obj + (1 - alpha) * loss_noobj return loss if __name__ == '__main__': myDataset = dataset.MyDataset() train_loader = torch.utils.data.DataLoader(myDataset, batch_size=2, shuffle=True) net = Darknet53() net.train() opt = torch.optim.Adam(net.parameters()) for target_13, target_26, target_52, img_data in train_loader: output_13, output_26, output_52 = net(img_data) loss_13 = loss_fn(output_13, target_13, 0.9) loss_26 = loss_fn(output_26, target_26, 0.9) loss_52 = loss_fn(output_52, target_52, 0.9)
def main(): train_dir = r'F:\Lab408\jinzhengu\root\shuffled_divided\train' eval_dir = r'F:\Lab408\jinzhengu\root\shuffled_divided\eval' log_dir = r'F:\Lab408\jinzhengu\root\monitored_sess_log' ckpt_dir = path.join(log_dir, 'ckpts') # model_dir = r'F:\Lab408\jinzhengu\root\monitored_sess_log' eval_interval = 20 save_summary_steps = 5 save_ckpts_steps = 100 train_batchsz = 20 eval_batchsz = 50 # eval_steps = 40 epoch = 900 img_num = 870 * 2 max_steps = (img_num * epoch) // train_batchsz # ------------------------------ prepare input ------------------------------ dset = dataset.MyDataset(train_dir, eval_dir) prefetch_batch = None iter_dict = { 'train': dset.train(train_batchsz, prefetch_batch), 'eval': dset.eval(eval_batchsz, prefetch_batch) } # train_iter = dset.train(train_batchsz, prefetch_batch) # eval_iter = dset.eval(eval_batchsz, prefetch_batch) # dict_tsr_handle = { # 'train': train_iter.string_handle(), # 'eval': eval_iter.string_handle() # } holder_handle = tf.placeholder(tf.string, []) iter = tf.data.Iterator.from_string_handle( holder_handle, iter_dict['train'].output_types) # next_elem = iter.get_next() inputx, labels, filename = iter.get_next() inputx = tf.reshape(inputx, [-1, 200, 250, 3]) inputx = tf.transpose(inputx, [0, 3, 1, 2]) # nchw # eval_x.set_shape([eval_batchsz, 200, 250, 3]) # train_x, train_y, train_fname = dset.train(train_batchsz, prefetch_batch) # train_x.set_shape([train_batchsz, 200, 250, 3]) # eval_x, eval_y, eval_fname = dset.eval(eval_batchsz, prefetch_batch) # eval_x.set_shape([eval_batchsz, 200, 250, 3]) # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ build graph \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ model = smodel.Simplest('NCHW') # model = smodel.Simplest('NHWC') logits = model(inputx) with tf.name_scope('cross_entropy'): loss = tf.losses.sparse_softmax_cross_entropy(labels, logits) with tf.name_scope('accuracy'): _pred = tf.argmax(logits, axis=1, output_type=tf.int32) acc_vec = tf.equal(labels, _pred) acc = tf.reduce_mean(tf.cast(acc_vec, tf.float32)) with tf.name_scope('optimizer'): optimizer = tf.train.AdamOptimizer(1e-4) train_op = optimizer.minimize(loss, tf.train.get_or_create_global_step()) # |||||||||||||||||||||||||||||| hooks |||||||||||||||||||||||||||||| # >>> logging tf.logging.set_verbosity(tf.logging.INFO) # global_step = tf.train.get_or_create_global_step() # tf.identity(global_step, 'g_step') # tf.identity(loss, 'cross_entropy') # tf.identity(acc, 'accuracy') # tensor_lr = optimizer._lr_t tensors = { 'step': tf.train.get_or_create_global_step().name, 'loss': loss.name, 'accuracy': acc.name } logging_hook = tf.train.LoggingTensorHook( tensors= tensors, every_n_iter=10 ) # >>> summary summary_conf = { 'dir': log_dir, 'saved_steps': save_summary_steps } summary_protobuf = { 'loss': tf.summary.scalar('cross_entropy', loss), 'accuracy': tf.summary.scalar('accuracy', acc) } # print(list(summary_protobuf.values())) # summary_loss = tf.summary.scalar('cross_entropy', loss) # summary_acc = tf.summary.scalar('accuracy', acc) # summary_lr = tf.summary.scalar('lr', optimizer._lr_t) # global_step = # merged_op = tf.summary.merge_all() # summary_hook = tf.train.SummarySaverHook( # save_steps=1, # output_dir= ckpt_dir, # summary_op= merged_op # ) # >>> main run hook eval_hook = runhooks.RunHook( iter_dict= iter_dict, eval_steps= eval_interval, train_op= train_op, training= model.training, holder_handle= holder_handle, summary_conf= summary_conf, summary_protobuf= summary_protobuf, ) # >>> checkpoit saver ckpt_saver_hook = runhooks.CkptSaverHook( ckpt_dir, save_steps= save_ckpts_steps ) # ckpt_saver_hook = tf.train.CheckpointSaverHook( # checkpoint_dir= ckpt_dir, # save_steps= save_ckpts_steps, # ) all_hooks = [ # logging_hook, # summary_hook, eval_hook, ckpt_saver_hook, # tf.train.StopAtStepHook(max_steps), # tf.train.NanTensorHook(loss) ] # ////////////////////////////// session config ////////////////////////////// sess_conf = tf.ConfigProto() sess_conf.gpu_options.allow_growth = True sess_conf.gpu_options.per_process_gpu_memory_fraction = 0.75 sess_creator = tf.train.ChiefSessionCreator( # scaffold=scaffold, # master='', config=sess_conf, checkpoint_dir=ckpt_dir ) # print('end') # return # ------------------------------ start ------------------------------ with tf.train.MonitoredSession( session_creator= sess_creator, hooks= all_hooks, stop_grace_period_secs= 3600 ) as mon_sess: while not mon_sess.should_stop(): step = mon_sess.run(tf.train.get_global_step()) # arg from retval of _EvalHook before_run() # training, step = mon_sess.run([model.training, tf.train.get_global_step()]) # arg from retval of _EvalHook before_run() # if not training: # print('step {}: eval xxxxxxxxx'.format(step)) # print(lr) return
torch.manual_seed(seed) if use_cuda: os.environ['CUDA_VISIBLE_DEVICES'] = gpus torch.cuda.manual_seed(seed) model = Darknet(cfgfile) model.print_network() init_width = model.width init_height = model.height kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {} test_loader = torch.utils.data.DataLoader(dataset.MyDataset( trainlist, shape=(init_width, init_height), shuffle=False, transform=transforms.Compose([ transforms.ToTensor(), ]), train=False), batch_size=batch_size, shuffle=False, **kwargs) if use_cuda: model = torch.nn.DataParallel(model).cuda() model.module.load_weights(weightfile) def test(): def truths_length(truths):
torch.argmax(target_obj[:, 5:], dim=1)) loss_obj = loss_obj_conf + loss_obj_crood + loss_obj_cls mask_noobj = target[..., 0] == 0 output_noobj = output[mask_noobj] target_noobj = target[mask_noobj] loss_noobj = conf_loss_fn(output_noobj[:, 0], target_noobj[:, 0]) loss = alpha * loss_obj + (1 - alpha) * loss_noobj return loss if __name__ == '__main__': save_path = "models/net_yolo6.pth" train_label_path = r"data/train_label.txt" train_data = dataset.MyDataset(train_label_path) train_loader = DataLoader(train_data, batch_size=4, shuffle=True) # validate_label_path = r"data/validate_label.txt" # validate_data = dataset.MyDataset(validate_label_path) # validate_loader = DataLoader(validate_data, batch_size=2, shuffle=True) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net = MainNet().to(device) if os.path.exists(save_path): net.load_state_dict(torch.load(save_path)) else: print("NO Param") net.train() opt = torch.optim.Adam(net.parameters())
torch.manual_seed(seed) if use_cuda: os.environ['CUDA_VISIBLE_DEVICES'] = gpus torch.cuda.manual_seed(seed) model = Darknet(cfgfile) model.print_network() init_width = model.width init_height = model.height kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {} test_loader = torch.utils.data.DataLoader( dataset.MyDataset(trainlist, labelpath,shape=(init_width, init_height), shuffle=False, transform=transforms.Compose([ transforms.ToTensor(), ]), train=False), batch_size=batch_size, shuffle=False, **kwargs) if use_cuda: model = torch.nn.DataParallel(model).cuda() def test(): def truths_length(truths): for i in range(50): if truths[i][1] == 0: return i model.eval() print('model---------',model)
loss = alpha * loss_obj + ( 1 - alpha) * loss_noobj #加到一起优化,负样本比例比较高,加个alpha系数均衡正负样本 return loss #返回总损失 save_path = r"model\YOLO_net.pth" #模型路径 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") corr_loss = nn.CrossEntropyLoss() cls_loss = nn.BCELoss() # writer = SummaryWriter() if __name__ == '__main__': myDataset = dataset.MyDataset() #加载数据集 train_loader = torch.utils.data.DataLoader(myDataset, batch_size=10, shuffle=True) net = MainNet() #实例化网络 if os.path.exists(save_path): net.load_state_dict(torch.load(save_path)) #加载网络模型 net.train().to(device) opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9, weight_decay=0.0005) #优化器 scheduler = lr_scheduler.StepLR(opt, 10, gamma=0.8) #学习率调整
def main(): # Load parameters args = params.args() # Load train, valid, and test data print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Loading dataset') train_dataset = dt.MyDataset(args.train_filename, args.mode) valid_dataset = dt.MyDataset(args.valid_filename, args.mode) test_dataset = dt.MyDataset(args.test_filename, args.mode) gold_dataset = dt.MyDataset(args.gold_filename, args.mode) print('train, valid, test num:', len(train_dataset), len(valid_dataset), len(test_dataset)) # Load dataset to DataLoader train_loader = DataLoader(dataset=train_dataset, batch_size=args.BATCH_SIZE, shuffle=True) valid_loader = DataLoader(dataset=valid_dataset, batch_size=args.BATCH_SIZE, shuffle=False) test_loader = DataLoader(dataset=test_dataset, batch_size=args.BATCH_SIZE, shuffle=False) gold_loader = DataLoader(dataset=gold_dataset, batch_size=args.BATCH_SIZE, shuffle=False) # Initialize model model = siamese.SiameseNetwork(args) model.to(device) # Train model print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Start training') try: train(model, train_loader, valid_loader, args) except KeyboardInterrupt: print('\n' + '-' * 89) print('Exit from training early') # Save final model save(model, args.save_dir, args.model_filename, -1) print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Training finished') # Test model print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Start prediction') predict = test(test_loader, model, args) pred_filename = args.predict_dir + '/predict_result.tsv' with open(pred_filename, 'w') as f: for item in predict: f.write(item[0] + '\t' + item[1] + '\t' + str(item[2]) + '\t' + str(item[3]) + '\n') f.closed print('Successfully save prediction result to', pred_filename) with open(args.predict_dir + '/rel_embed_vector.tsv', 'w') as f: for item in predict: out1 = item[5].cpu().numpy().tolist() f.write('\t'.join(str(x) for x in out1)) f.write('\n') f.closed with open(args.predict_dir + '/rel_embed_label.tsv', 'w') as f: for item in predict: f.write(item[1]) f.write('\n') f.closed print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Prediction finished') # Gold Prediction print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Start gold prediction') predict = test(gold_loader, model, args) pred_filename = args.gold_dir + '/predict_result.tsv' with open(pred_filename, 'w') as f: for item in predict: f.write(item[0] + '\t' + item[1] + '\t' + str(item[2]) + '\t' + str(item[3]) + '\n') f.closed print('Successfully save prediction result to', pred_filename) with open(args.gold_dir + '/rel_embed_vector.tsv', 'w') as f: for item in predict: out1 = item[5].cpu().numpy().tolist() f.write('\t'.join(str(x) for x in out1)) f.write('\n') f.closed with open(args.gold_dir + '/rel_embed_label.tsv', 'w') as f: for item in predict: f.write(item[1]) f.write('\n') f.closed print('[' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') + '] Gold prediction finished')
ls += loss.data optimizer.zero_grad() loss.backward() optimizer.step() ls /= sum mse /= sum loss_list.append(ls) print(f'[{epoch}/{epochs}] Loss: {ls:.5f} | mse: {mse: .5f}') if epoch % every_epochs_save == 0: model_file_path = f'{model_save_dir}/{machine_type}/model_{machine_type}_{epoch}.pkl' torch.save(ae_net, model_file_path) if __name__ == '__main__': os.makedirs(param['model_dir'], exist_ok=True) dirs = utils.select_dirs(param) process_mt_list = ['pump', 'a_fan', 'slider', 'valve'] for target_dir in dirs: machine_type = os.path.split(target_dir)[-1] if machine_type not in process_mt_list: continue pre_data_path = param['pre_data_dir'] + f'/{machine_type}.db' print(f'loading dataset [{machine_type}] ......') my_dataset = dataset.MyDataset(pre_data_path, keys=['log_mel']) train_loader = DataLoader(my_dataset, batch_size=param['batch_size'], shuffle=True) print('training ......') train(train_loader, machine_type, model_name='AE')
def main(): train_dir = r'\train' eval_dir = r'\eval' log_dir = r'\session_log' ckpt_dir = path.join(log_dir, 'ckpts') # model_dir = r'\monitored_sess_log' eval_interval = 20 save_summary_steps = 5 save_ckpts_steps = 20 train_batchsz = 20 eval_batchsz = 50 eval_times = 10 # eval_steps = 40 epoch = 900 img_num = 870 * 2 max_steps = (img_num * epoch) // train_batchsz # ------------------------------ prepare input ------------------------------ dset = dataset.MyDataset(train_dir, eval_dir) prefetch_batch = None iter_dict = { 'train': dset.train(train_batchsz, prefetch_batch), 'eval': dset.eval(eval_batchsz, prefetch_batch) } # train_iter = dset.train(train_batchsz, prefetch_batch) # eval_iter = dset.eval(eval_batchsz, prefetch_batch) # dict_tsr_handle = { # 'train': train_iter.string_handle(), # 'eval': eval_iter.string_handle() # } holder_handle = tf.placeholder(tf.string, []) iter = tf.data.Iterator.from_string_handle( holder_handle, dset.output_types) # next_elem = iter.get_next() inputx, labels, filename = iter.get_next() inputx = tf.reshape(inputx, [-1, 200, 250, 3]) # eval_x.set_shape([eval_batchsz, 200, 250, 3]) # train_x, train_y, train_fname = dset.train(train_batchsz, prefetch_batch) # train_x.set_shape([train_batchsz, 200, 250, 3]) # eval_x, eval_y, eval_fname = dset.eval(eval_batchsz, prefetch_batch) # eval_x.set_shape([eval_batchsz, 200, 250, 3]) # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ build graph \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ model = cnn.CNN(data_format = 'NHWC') logits = model(inputx) with tf.name_scope('cross_entropy'): loss = tf.losses.sparse_softmax_cross_entropy(labels, logits) with tf.name_scope('accuracy'): _pred = tf.argmax(logits, axis=1, output_type=tf.int32) acc_vec = tf.equal(labels, _pred) acc = tf.reduce_mean(tf.cast(acc_vec, tf.float32)) # float with tf.name_scope('optimizer'): optimizer = tf.train.AdamOptimizer(1e-4) train_op = optimizer.minimize(loss, tf.train.get_or_create_global_step()) # >>> summary summary_conf = { 'dir': log_dir, 'saved_steps': save_summary_steps } summary_protobuf = { 'loss': tf.summary.scalar('cross_entropy', loss), 'accuracy': tf.summary.scalar('accuracy', acc) } # print(list(summary_protobuf.values())) # summary_loss = tf.summary.scalar('cross_entropy', loss) # summary_acc = tf.summary.scalar('accuracy', acc) # summary_lr = tf.summary.scalar('lr', optimizer._lr_t) # global_step = merged_op = tf.summary.merge_all() # summary_hook = tf.train.SummarySaverHook( # save_steps=1, # output_dir= ckpt_dir, # summary_op= merged_op # ) # >>> eval op_init1 = tf.variables_initializer(tf.global_variables()) op_init2 = tf.variables_initializer(tf.local_variables()) op_group = tf.group(op_init1, op_init2) # ////////////////////////////// session config ////////////////////////////// sess_conf = tf.ConfigProto() sess_conf.gpu_options.allow_growth = True sess_conf.gpu_options.per_process_gpu_memory_fraction = 0.75 train_writer = tf.summary.FileWriter(path.join(summary_conf['dir'], 'train')) eval_writer = tf.summary.FileWriter(path.join(summary_conf['dir'], 'eval')) summary_timer = tf.train.SecondOrStepTimer(every_steps=save_summary_steps) eval_timer = tf.train.SecondOrStepTimer(every_steps=eval_interval) with tf.Session(config= sess_conf) as sess: train_handle = sess.run(iter_dict['train'].string_handle()) eval_handle = sess.run(iter_dict['eval'].string_handle()) feature2rnn = sess.run(model.feature2rnn, feed_dict= { holder_handle: eval_handle, model.is_training: False }) np.save(filename+'.pny', feature2rnn) # sess.run(op_group) # for _step in range(max_steps): # if eval_timer.should_trigger_for_step(_step): # for i in range(eval_times): # pass # summary_str = sess.run(merged_op, feed_dict= { # holder_handle: eval_handle, # model.is_training: False # }) # eval_writer.add_summary(summary_str, _step) # eval_timer.update_last_triggered_step(_step) # summary_str, _ = sess.run([merged_op, train_op, acc], feed_dict={ # holder_handle: train_handle, # model.is_training: True # }) # if summary_timer.should_trigger_for_step(_step): # train_writer.add_summary(summary_str, _step) # summary_timer.update_last_triggered_step(_step) print('end') return
mask_zero = label[..., 0] == 0 label_zero = label[mask_zero].float() out_zero = out[mask_zero].cpu() loss_zero_conf = loss_fn1(out_zero[:, 0], label_zero[:, 0]) loss = a * loss_nonzero + (1 - a) * loss_zero_conf return loss if __name__ == '__main__': net = MainNet() if torch.cuda.is_available(): net = net.cuda() mydata = dataset.MyDataset() label_data = data.DataLoader(mydata, batch_size=2, shuffle=True, num_workers=6) # net.load_state_dict(torch.load(os.path.join(save_path,save_param))) optimizer = torch.optim.Adam((net.parameters())) for epoch in range(20000): for label_13, label_26, label_52, img_data in label_data: # print('label_13',label_13[:,:,0,0]) if torch.cuda.is_available(): img_data = img_data.cuda() out_13, out_26, out_52 = net(img_data) # print('out',out_13[:,:,0,0]) loss_fn1 = nn.BCEWithLogitsLoss()
def main(): transform = transforms.Compose([ transforms.Resize((448, 448)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) grid_num = 7 if args.command == "basic" else 14 trainset = dataset.MyDataset(root="hw2_train_val/train15000", grid_num=grid_num, train=args.augment, transform=transform) testset = dataset.MyDataset(grid_num=grid_num, root="hw2_train_val/val1500", train=False, transform=transform) trainLoader = DataLoader(trainset, batch_size=args.batchs, shuffle=True, num_workers=args.worker) testLoader = DataLoader(testset, batch_size=1, shuffle=False, num_workers=args.worker) device = utils.selectDevice(show=True) if args.command == "basic": model = models.Yolov1_vgg16bn(pretrained=True).to(device) criterion = models.YoloLoss(7., 2., 5., 0.5, device).to(device) optimizer = optim.SGD(model.parameters(), lr=args.lr, weight_decay=1e-4) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, [20, 45, 55], gamma=0.1) start_epoch = 0 if args.load: model, optimizer, start_epoch, scheduler = utils.loadCheckpoint( args.load, model, optimizer, scheduler) model = train(model, criterion, optimizer, scheduler, trainLoader, testLoader, start_epoch, args.epochs, device, lr=args.lr, grid_num=7) elif args.command == "improve": model_improve = models.Yolov1_vgg16bn_Improve( pretrained=True).to(device) criterion = models.YoloLoss(14., 2., 5, 0.5, device).to(device) optimizer = optim.SGD(model_improve.parameters(), lr=args.lr, weight_decay=1e-4) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, [20, 40, 70], gamma=0.1) start_epoch = 0 if args.load: model_improve, optimizer, start_epoch, scheduler = utils.loadCheckpoint( args.load, model, optimizer, scheduler) model_improve = train(model_improve, criterion, optimizer, scheduler, trainLoader, testLoader, start_epoch, args.epochs, device, lr=args.lr, grid_num=7, save_name="Yolov1-Improve")