def main(): # Set save path save_path = args.save_path if not os.path.exists(save_path): os.makedirs(save_path) # Save configuration with open(save_path+'/configuration.json', 'w') as f: json.dump(args.__dict__, f, indent=2) # Load dataset path = args.data_path train_df, test_df, train_ng_pool, test_negative, num_user, num_item, feature = D.load_data(path) train_dataset = D.CustomDataset(train_df, feature, negative=train_ng_pool, num_neg = args.num_neg, istrain=True) test_dataset = D.CustomDataset(test_df, feature, negative=test_negative, num_neg = None, istrain=False) # test_dataset = D.CustomDataset(train_df, feature, negative=train_ng_pool, num_neg = None, istrain=False) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=4, collate_fn=my_collate_trn) test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=4, collate_fn=my_collate_tst) # Model model = MAML(num_user, num_item, args.embed_dim, args.dropout_rate).cuda() print(model) if args.load_path is not None: checkpoint = torch.load(args.load_path) model.load_state_dict(checkpoint) print("Pretrained Model Loaded") # Optimizer optimizer = torch.optim.Adam(model.parameters(),lr=args.lr) # Loss embedding_loss = Embedding_loss(margin=args.margin, num_item = num_item).cuda() feature_loss = Feature_loss().cuda() covariance_loss = Covariance_loss().cuda() # Logger train_logger = Logger(f'{save_path}/train.log') test_logger = Logger(f'{save_path}/test.log') # Train & Eval for epoch in range(args.epoch): train_loader.dataset.train_ng_sampling() train(model, embedding_loss, feature_loss, covariance_loss, optimizer, train_loader, train_logger, epoch) if (epoch+1) % 100 == 0 or epoch==0: test(model, test_loader, test_logger, epoch) # Save Model every 100 epoch torch.save(model.state_dict(), f"{save_path}/model_{epoch+1}.pth")
def train(model): """Train the model.""" epoch_count = 0 # training cross-validation with 5 fold for i in range(5): # Training dataset. print("Training fold", i) dataset_train = dataset.CustomDataset() dataset_train.load_custom_K_fold(dataset_path, "train", i) dataset_train.prepare() # Validation dataset dataset_val = dataset.CustomDataset() dataset_val.load_custom_K_fold(dataset_path, "val", i) dataset_val.prepare() augmentation = imgaug.augmenters.Sometimes(0.5, [ imgaug.augmenters.Fliplr(0.5), imgaug.augmenters.Flipud(0.5)]) model_inference = modellib.MaskRCNN(mode="inference", config=config,model_dir=logs) mAP_callback = modellib.MeanAveragePrecisionCallback(model, model_inference, dataset_val, calculate_at_every_X_epoch=25, dataset_limit=500, verbose=1) # Training - Stage 1 epoch_count += 20 print("Training network heads") model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE *2, epochs= epoch_count, layers='heads', custom_callbacks=[mAP_callback]) #augmentation=augmentation) epoch_count += 10 print("Fine tune Resnet stage 4 and up") model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE, epochs= epoch_count, layers='4+', custom_callbacks=[mAP_callback], augmentation=augmentation)
def train(model): # Training set. dataset_train = dataset.CustomDataset() dataset_train.load_custom(dataset_path, "train") dataset_train.prepare() print("Images: {}\nClasses: {}".format(len(dataset_train.image_ids), dataset_train.class_names)) # Validation set dataset_val = dataset.CustomDataset() dataset_val.load_custom(dataset_path, "val") dataset_val.prepare() print("Images: {}\nClasses: {}".format(len(dataset_val.image_ids), dataset_val.class_names)) augmentation = imgaug.augmenters.Sometimes( 0.5, [imgaug.augmenters.Fliplr(0.5), imgaug.augmenters.Flipud(0.5)]) model_inference = modellib.MaskRCNN(mode="inference", config=config, model_dir=logs) #calculating COCO-mAP after every 5 epoch, limited to the first 1000 images mAP_callback = modellib.MeanAveragePrecisionCallback( model, model_inference, dataset_val, calculate_at_every_X_epoch=5, dataset_limit=1000, verbose=1) # Training - Stage 1 print("Training network heads") model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE, epochs=20, layers='heads', custom_callbacks=[mAP_callback], augmentation=augmentation)
# Run detection on one image at a time GPU_COUNT = 1 IMAGES_PER_GPU = 1 config = InferenceConfig() config.display() # Device to load the neural network on. # Useful if you're training a model on the same # machine, in which case use CPU and leave the # GPU for training. #DEVICE = "/gpu:0" # /cpu:0 or /gpu:0 # Load validation dataset dataset = dataset.CustomDataset() dataset.load_custom(dataset_dir, "val") dataset.prepare() print("Images: {}\nClasses: {}".format(len(dataset.image_ids), dataset.class_names)) model = modellib.MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=config) print("Loading weights ", weight_path) model.load_weights(weight_path, by_name=True) n = 0 count_porn = 0 count_non = 0
'-s', type=str, help='source model file') parser.add_argument('--dst-model', '-d', type=str, help='destination model file') parser.add_argument('--num-classes', type=int, default=1, help='number of classes') parser.add_argument('--dataset', type=str, default='', help='dataset path') args = parser.parse_args() print(args) dataset = dataset.CustomDataset(args.dataset, 'train') num_ids = dataset.max_id + 2 print(num_ids) if '0.5x' in args.src_model: model_size = '0.5x' elif '1.0x' in args.src_model: model_size = '1.0x' elif '1.5x' in args.src_model: model_size = '1.5x' elif '2.0x' in args.src_model: model_size = '2.0x' anchors = np.random.randint(low=10, high=150, size=(12, 2)) model = shufflenetv2.ShuffleNetV2(anchors, num_classes=args.num_classes,
# Data preprocessing df = pd.read_csv("../input/data/train.csv") df['list'] = df[df.columns[3:]].values.tolist() new_df = df[['TITLE', 'ABSTRACT', 'list']].copy() # Creating Dataset and Dataloaders train_size = 0.8 train_dataset = new_df.sample(frac=train_size, random_state=200) test_dataset = new_df.drop(train_dataset.index).reset_index(drop=True) train_dataset = train_dataset.reset_index(drop=True) print("FULL Dataset: {}".format(new_df.shape)) print("TRAIN Dataset: {}".format(train_dataset.shape)) print("TEST Dataset: {}".format(test_dataset.shape)) training_set = dataset.CustomDataset(train_dataset, config.TOKENIZER, config.MAX_LEN) testing_set = dataset.CustomDataset(test_dataset, config.TOKENIZER, config.MAX_LEN) train_params = { 'batch_size': config.TRAIN_BATCH_SIZE, 'shuffle': True, 'num_workers': 0 } test_params = { 'batch_size': config.VALID_BATCH_SIZE, 'shuffle': True, 'num_workers': 0 }
def main(): #Hyperparameter parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--batch-size', type=int, default=128, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=500, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.0001, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--lrlist', default=[0.001, 0.0001], help="list for adjust learning rate") parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--weight-decay', type=float, default=0.00000001, help='weight decay parameter') #Data sampling method parser.add_argument( '--new_version', default=True, type=bool, help= "True : longer input length, False : input length + prediction length = 31" ) parser.add_argument( '--random-length', default=[False, True], type=bool, help="if you want to use randomized sample length, True.") parser.add_argument('--before_lim', default=120, type=int, help='initialize batchs input length') parser.add_argument('--after_lim', default=30, type=int, help='initialize batchs prediction length') # Mode Configure parser.add_argument('--test', default=False, help='use for testing(trained model)') parser.add_argument( '--save-model', action='store_true', default=True, # False~>True help='For Saving the current Model') parser.add_argument('--name', type=str, default='LSTM_20_2') parser.add_argument('--log-pass', type=int, default=10000) parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=2, metavar='S', help='random seed (default: 1)') parser.add_argument( '--log-interval', type=int, default=500, metavar='N', # 10~>50 help='how many batches to wait before logging training status') parser.add_argument('--isweather', default=False, help='key of using weather information') parser.add_argument('--isMSEweighted', default=False, help='key for using weighted MSE') #Path # parser.add_argument('--resume', default='./model/LSTM_20_1/76001checkpoint_lstm_std.pth.tar', type=str, metavar='PATH', # help='path to latest checkpoint (default: none)') parser.add_argument('--resume', default='', type=str) parser.add_argument("--data-root", default="./data/03_merge/v06_divide_train_test/") parser.add_argument("--normalize-factor-path", type=str, default='./data/etc/normalize_factor.csv') parser.add_argument("--usable-idx-path", type=str, default="./data/etc/") # Cuda Configureration args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") cudnn.benchmark = True cudnn.deterministic = True kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} # Normalize factor load fr = open(args.normalize_factor_path, 'r', encoding='cp949', newline='') normalize_factor = list(csv.reader(fr)) if args.test: train_loss_dataset = dataset.CustomDataset(args, args.data_root, "v05_trainset.csv", "idx_train_loss.csv", for_test=True) train_loss_sampler = sampler.BatchSampler( sampler.SequentialSampler(train_loss_dataset), batch_size=2000, drop_last=False, random_length=args.random_length, for_test=True, before_lim=args.before_lim, after_lim=args.after_lim, new_version_sampler=args.new_version) train_loss_loader = torch.utils.data.DataLoader( train_loss_dataset, batch_sampler=train_loss_sampler, **kwargs) test_dataset = dataset.CustomDataset(args, args.data_root, "v05_testset.csv", "idx_test.csv", for_test=True) test_sampler = sampler.BatchSampler( sampler.SequentialSampler(test_dataset), batch_size=2000, drop_last=False, random_length=args.random_length, for_test=True, before_lim=args.before_lim, after_lim=args.after_lim, new_version_sampler=args.new_version) test_loader = torch.utils.data.DataLoader(test_dataset, batch_sampler=test_sampler, **kwargs) else: train_dataset = dataset.CustomDataset(args, args.data_root, "v05_trainset.csv", "idx_train.csv") # BatchSampler Parameter : (sampler, batch_size, drop_last,random_length = False,for_test=False,new_type_sampler=True,before_lim=-1,after_lim=-1) train_sampler = sampler.BatchSampler( sampler.RandomSampler(train_dataset), batch_size=args.batch_size, drop_last=False, random_length=args.random_length, before_lim=args.before_lim, after_lim=args.after_lim, new_version_sampler=args.new_version) train_loader = torch.utils.data.DataLoader(train_dataset, batch_sampler=train_sampler, **kwargs) train_loss_dataset = dataset.CustomDataset(args, args.data_root, "v05_trainset.csv", "idx_train_loss.csv", for_test=True) train_loss_sampler = sampler.BatchSampler( sampler.RandomSampler(train_loss_dataset), batch_size=args.test_batch_size, drop_last=False, random_length=args.random_length, for_test=True, before_lim=args.before_lim, after_lim=args.after_lim, new_version_sampler=args.new_version) train_loss_loader = torch.utils.data.DataLoader( train_loss_dataset, batch_sampler=train_loss_sampler, **kwargs) test_dataset = dataset.CustomDataset(args, args.data_root, "v05_testset.csv", "idx_test.csv", for_test=True) test_sampler = sampler.BatchSampler( sampler.RandomSampler(test_dataset), batch_size=args.test_batch_size, drop_last=False, random_length=args.random_length, for_test=True, before_lim=args.before_lim, after_lim=args.after_lim, new_version_sampler=args.new_version) test_loader = torch.utils.data.DataLoader(test_dataset, batch_sampler=test_sampler, **kwargs) #Training Configuration writer = SummaryWriter('./log/' + args.name + '/') print(device) model = Model.LSTM(args).to(device) if args.isMSEweighted: criterion = weighted_mse_loss else: criterion = nn.MSELoss().to(device) optimizer = optim.Adam(model.parameters(), lr=args.lr) training = Train.Training(model) steps = 0 best_loss = 1000000 start_epoch = 1 #Load Trained Model if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) steps = checkpoint['steps'] best_loss = checkpoint['best_loss'] start_epoch = checkpoint['epoch'] else: print("=> no checkpoint found at '{}'".format(args.resume)) if not args.test: #학습용 for param_group in optimizer.param_groups: param_group['lr'] = args.lr for epoch in range(start_epoch, args.epochs): print(epoch) adjust_learning_rate(optimizer, steps, args) steps, best_loss = training.train(args, model, criterion, device, train_loader, test_loader, train_loss_loader, optimizer, epoch, writer, normalize_factor, steps, best_loss) else: #검증용 print("activate test code!!!!") args.random_length[0] = False test_mse, test_mae, test_won_sum_mae, test_won_mae, test_mae_list, test_var = training.eval( args, test_loader, model, criterion, device, normalize_factor, teacher_forcing=False) writer.add_scalars('Loss_test', {'test loss': test_mae}, 1) writer.add_scalars('Won mae_test', {'test_won_mae': test_won_sum_mae}, 1) writer.add_scalars( 'energy_prediction_mae_test', { 'elec': test_won_mae[0], 'water': test_won_mae[1], 'gas': test_won_mae[2] }, 1) print("mae_won={}".format(test_won_sum_mae)) for i in range(30): writer.add_scalars('예측 길이에 따른 오차_test', {'test won': test_mae_list[i]}, i + 1)
def train(epoch): global processed_batches t0 = time.time() if ngpus > 1: cur_model = model.module else: cur_model = model train_loader = torch.utils.data.DataLoader(dataset.CustomDataset(), batch_size=batch_size, shuffle=False, **kwargs) lr = adjust_learning_rate(optimizer, processed_batches) logging('epoch %d, processed %d samples, lr %f' % (epoch, epoch * len(train_loader.dataset), lr)) model.train() t1 = time.time() avg_time = torch.zeros(9) for batch_idx, (data, target) in enumerate(train_loader): t2 = time.time() adjust_learning_rate(optimizer, processed_batches) processed_batches = processed_batches + 1 #if (batch_idx+1) % dot_interval == 0: # sys.stdout.write('.') if use_cuda: data = data.cuda() #target= target.cuda() t3 = time.time() data, target = Variable(data), Variable(target) t4 = time.time() optimizer.zero_grad() t5 = time.time() output = model(data) t6 = time.time() region_loss.seen = region_loss.seen + data.data.size(0) loss = region_loss(output, target) t7 = time.time() loss.backward() t8 = time.time() optimizer.step() t9 = time.time() if False and batch_idx > 1: avg_time[0] = avg_time[0] + (t2 - t1) avg_time[1] = avg_time[1] + (t3 - t2) avg_time[2] = avg_time[2] + (t4 - t3) avg_time[3] = avg_time[3] + (t5 - t4) avg_time[4] = avg_time[4] + (t6 - t5) avg_time[5] = avg_time[5] + (t7 - t6) avg_time[6] = avg_time[6] + (t8 - t7) avg_time[7] = avg_time[7] + (t9 - t8) avg_time[8] = avg_time[8] + (t9 - t1) print('-------------------------------') print(' load data : %f' % (avg_time[0] / (batch_idx))) print(' cpu to cuda : %f' % (avg_time[1] / (batch_idx))) print('cuda to variable : %f' % (avg_time[2] / (batch_idx))) print(' zero_grad : %f' % (avg_time[3] / (batch_idx))) print(' forward feature : %f' % (avg_time[4] / (batch_idx))) print(' forward loss : %f' % (avg_time[5] / (batch_idx))) print(' backward : %f' % (avg_time[6] / (batch_idx))) print(' step : %f' % (avg_time[7] / (batch_idx))) print(' total : %f' % (avg_time[8] / (batch_idx))) t1 = time.time() print('') t1 = time.time() logging('training with %f samples/s' % (len(train_loader.dataset) / (t1 - t0))) if (epoch + 1) % save_interval == 0: logging('save weights to %s/%06d.weights' % (backupdir, epoch + 1)) cur_model.seen = (epoch + 1) * len(train_loader.dataset) cur_model.save_weights('%s/%06d.weights' % (backupdir, epoch + 1))
import options import dataset import functions import train import network import save_results import os if __name__ == '__main__': opt = options.Options().parser.parse_args() ratio_A = opt.ratio_A dataset_A = dataset.CustomDataset(ratio=ratio_A, train=True, dataset=opt.dataset) dataloader_A = dataset.DataLoader(dataset_A, batch_size=opt.batch_size_A, shuffle=True) ratio_B = opt.ratio_B dataset_B = dataset.CustomDataset(ratio=ratio_B, train=True, dataset=opt.dataset) dataloader_B = dataset.DataLoader(dataset_B, batch_size=opt.batch_size_B, shuffle=True) sampled_batch_size = opt.sampled_batch_size testset_A = dataset.CustomDataset(ratio=ratio_A, train=False)
################################################################################ # Dividing Dataset #################################################################################### train_dataset, valid_dataset = train_test_split(new_df, test_size=.2, random_state=42) print("Shape of train_dataset is :{} Shape of valid_dataset is :{}".format( train_dataset.shape, valid_dataset.shape)) ############################################################## # Defining Tokenizer ################################################################ tokenizer = config_file.tokenizer # Creating the Training and Validation dataset for further creation of Dataloader training_set = dataset.CustomDataset(train_dataset, tokenizer, config.MAX_LEN, config.SUMMARY_LEN) val_set = dataset.CustomDataset(valid_dataset, tokenizer, config.MAX_LEN, config.SUMMARY_LEN) # Defining the parameters for creation of dataloaders train_params = { 'batch_size': config.TRAIN_BATCH_SIZE, 'shuffle': True, 'num_workers': 8 } val_params = { 'batch_size': config.VALID_BATCH_SIZE, 'shuffle': False, 'num_workers': 4 }
# make pixel indexes 0-based x1 = int(bbox.find('xmin').text) - 1 y1 = int(bbox.find('ymin').text) - 1 x2 = int(bbox.find('xmax').text) - 1 y2 = int(bbox.find('ymax').text) - 1 bboxes.append([x1, y1, x2, y2]) testgt_bboxes_dict[ind] = bboxes # data loader for training data # use a custon sampler to load all positive samples and random sample negative samples # so that number size of negative sample is 10% of positive sample sampler = dataset.CustomSampler(len(pos_indexes), len(neg_indexes), 0.1) train_indexes = np.concatenate([pos_indexes, neg_indexes], axis=0) catdata = dataset.CustomDataset(train_indexes, H, W, data_dir, gt_bboxes_dict, aug=True) trainloader = data.DataLoader(dataset=catdata, batch_size=32, sampler=sampler, num_workers=4) # data loader for testing data testdata = dataset.CustomDataset(testimg_indexes, H, W, testdata_dir, testgt_bboxes_dict, aug=False) testloader = data.DataLoader(dataset=testdata,
def train(args): utils.make_workspace_dirs(args.workspace) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') anchors = np.loadtxt(os.path.join(args.dataset, 'anchors.txt')) scale_sampler = utils.TrainScaleSampler(args.in_size, args.scale_step, args.rescale_freq) shared_size = torch.IntTensor(args.in_size).share_memory_() logger = utils.get_logger(path=os.path.join(args.workspace, 'log.txt')) torch.backends.cudnn.benchmark = True dataset = ds.CustomDataset(args.dataset, 'train') collate_fn = partial(ds.collate_fn, in_size=shared_size, train=True) data_loader = torch.utils.data.DataLoader(dataset, args.batch_size, True, num_workers=args.workers, collate_fn=collate_fn, pin_memory=args.pin, drop_last=True) num_ids = dataset.max_id + 2 if args.backbone == 'darknet': model = darknet.DarkNet(anchors, num_classes=args.num_classes, num_ids=num_ids).to(device) elif args.backbone == 'shufflenetv2': model = shufflenetv2.ShuffleNetV2(anchors, num_classes=args.num_classes, num_ids=num_ids, model_size=args.thin).to(device) else: print('unknown backbone architecture!') sys.exit(0) if args.checkpoint: model.load_state_dict(torch.load(args.checkpoint)) params = [p for p in model.parameters() if p.requires_grad] if args.optim == 'sgd': optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) else: optimizer = torch.optim.Adam(params, lr=args.lr, weight_decay=args.weight_decay) if args.freeze_bn: for name, param in model.named_parameters(): if 'norm' in name: param.requires_grad = False logger.info('freeze {}'.format(name)) else: param.requires_grad = True trainer = f'{args.workspace}/checkpoint/trainer-ckpt.pth' if args.resume: trainer_state = torch.load(trainer) optimizer.load_state_dict(trainer_state['optimizer']) if -1 in args.milestones: args.milestones = [int(args.epochs * 0.5), int(args.epochs * 0.75)] lr_scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, milestones=args.milestones, gamma=args.lr_gamma) start_epoch = 0 if args.resume: start_epoch = trainer_state['epoch'] + 1 lr_scheduler.load_state_dict(trainer_state['lr_scheduler']) logger.info(args) logger.info('Start training from epoch {}'.format(start_epoch)) model_path = f'{args.workspace}/checkpoint/{args.savename}-ckpt-%03d.pth' size = shared_size.numpy().tolist() for epoch in range(start_epoch, args.epochs): model.train() logger.info(('%8s%10s%10s' + '%10s' * 8) % ('Epoch', 'Batch', 'SIZE', 'LBOX', 'LCLS', 'LIDE', 'LOSS', 'SB', 'SC', 'SI', 'LR')) rmetrics = defaultdict(float) optimizer.zero_grad() for batch, (images, targets) in enumerate(data_loader): warmup = min(args.warmup, len(data_loader)) if epoch == 0 and batch <= warmup: lr = args.lr * (batch / warmup)**4 for g in optimizer.param_groups: g['lr'] = lr loss, metrics = model(images.to(device), targets.to(device), size) loss.backward() if args.sparsity: model.correct_bn_grad(args.lamb) num_batches = epoch * len(data_loader) + batch + 1 if ((batch + 1) % args.accumulated_batches == 0) or (batch == len(data_loader) - 1): optimizer.step() optimizer.zero_grad() for k, v in metrics.items(): rmetrics[k] = (rmetrics[k] * batch + metrics[k]) / (batch + 1) fmt = tuple([('%g/%g') % (epoch, args.epochs), ('%g/%g') % (batch, len(data_loader)), ('%gx%g') % (size[0], size[1])] + \ list(rmetrics.values()) + [optimizer.param_groups[0]['lr']]) if batch % args.print_interval == 0: logger.info(('%8s%10s%10s' + '%10.3g' * (len(rmetrics.values()) + 1)) % fmt) size = scale_sampler(num_batches) shared_size[0], shared_size[1] = size[0], size[1] torch.save(model.state_dict(), f"{model_path}" % epoch) torch.save( { 'epoch': epoch, 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict() }, trainer) if epoch >= args.eval_epoch: pass lr_scheduler.step()
def main(): wandb.init(project="AttCF") parser = argparse.ArgumentParser() parser.add_argument('--data_path', type=str, default='/daintlab/data/recommend/Amazon-office-raw', help='path') parser.add_argument('--top_k', type=int, default=10, help='top_k') parser.add_argument('--optim', type=str, default='adam', help='optimizer') parser.add_argument('--epochs', type=int, default=5, help='epoch') parser.add_argument('--batch_size', type=int, default=256, help='batch size') parser.add_argument('--dim', type=int, default=128, help='dimension') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--gpu', type=str, default='0', help='gpu number') parser.add_argument('--num_sam', type=int, default=4, help='num of pos sample') parser.add_argument('--feature_type', default='all', type=str, help='Type of feature to use. [all, img, txt]') parser.add_argument( '--eval_type', default='leave-one-out', type=str, help='Evaluation protocol. [ratio-split, leave-one-out]') global args global sd global train_len global test_len args = parser.parse_args() wandb.config.update(args) args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu # Load dataset print("Loading Dataset") data_path = os.path.join(args.data_path, args.eval_type) train_df, test_df, train_ng_pool, test_negative, num_user, num_item, images = D.load_data( data_path, args.feature_type) train_len = len(train_df) test_len = num_user train_dataset = D.CustomDataset(train_df, test_df, images, negative=train_ng_pool, istrain=True, feature_type=args.feature_type, num_sam=args.num_sam) test_dataset = D.CustomDataset(train_df, test_df, images, negative=test_negative, istrain=False, feature_type=args.feature_type, num_sam=args.num_sam) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, collate_fn=my_collate, pin_memory=True) test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, collate_fn=my_collate_tst, pin_memory=True) # Model acf = ACF(num_user, num_item, images, args.dim) acf = torch.nn.DataParallel(acf) acf = acf.cuda() print(acf) # Optimizer optim = optimizer(optim=args.optim, lr=args.lr, model=acf) # Train & Eval for epoch in range(args.epochs): sd = np.random.randint(2021) start = time.time() train(acf, train_loader, epoch, optim) end = time.time() print("{}/{} Train Time : {}".format(epoch + 1, args.epochs, end - start)) if (epoch + 1) == args.epochs: start = time.time() test(acf, test_loader, epoch) end = time.time() print("{}/{} Evaluate Time : {}".format(epoch + 1, args.epochs, end - start))
# Data print('==> Preparing data..') transform_train = transforms.Compose([ transforms.Resize((320, 160)), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) # trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) train_data_path = 'data_training' trainset = dataset.CustomDataset(train_data_path, transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True) # testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test) # testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2) # Model print('==> Building model..') # net = VGG('VGG16') net = skynet.SkyNet() net = net.to(device) if args.resume: # Load checkpoint.
def main(args): try: mp.set_start_method('spawn') except RuntimeError: pass utils.make_workspace_dirs(args.workspace) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') in_size = [int(insz) for insz in args.in_size.split(',')] scale_step = [int(ss) for ss in args.scale_step.split(',')] anchors = np.loadtxt(os.path.join(args.dataset, 'anchors.txt')) scale_sampler = utils.TrainScaleSampler(scale_step, args.rescale_freq) shared_size = torch.IntTensor(in_size).share_memory_() dataset_train = ds.CustomDataset(args.dataset, 'train') data_loader = torch.utils.data.DataLoader( dataset=dataset_train, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, collate_fn=partial(ds.collate_fn, in_size=shared_size, train=True), pin_memory=args.pin) dataset_valid = ds.CustomDataset(args.dataset, 'test') data_loader_valid = torch.utils.data.DataLoader( dataset=dataset_valid, batch_size=1, shuffle=False, num_workers=1, collate_fn=partial(ds.collate_fn, in_size=torch.IntTensor(in_size), train=False), pin_memory=args.pin) if args.checkpoint: print(f'load {args.checkpoint}') model = torch.load(args.checkpoint).to(device) else: print('please set fine tune model first!') return criterion = yolov3.YOLOv3Loss(args.num_classes, anchors) decoder = yolov3.YOLOv3EvalDecoder(in_size, args.num_classes, anchors) if args.test_only: mAP = eval.evaluate(model, data_loader_valid, device, args.num_classes) print(f'mAP of current model on validation dataset:%.2f%%' % (mAP * 100)) return params = [p for p in model.parameters() if p.requires_grad] if args.optim == 'sgd': optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) else: optimizer = torch.optim.Adam(params, lr=args.lr, weight_decay=args.weight_decay) if args.resume: trainer_state = torch.load(f'{args.workspace}/checkpoint/trainer-ckpt.pth') optimizer.load_state_dict(trainer_state['optimizer']) milestones = [int(ms) for ms in args.milestones.split(',')] def lr_lambda(iter): if iter < args.warmup: return pow(iter / args.warmup, 4) factor = 1 for i in milestones: factor *= pow(args.lr_gamma, int(iter > i)) return factor lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda) if args.resume: start_epoch = trainer_state['epoch'] + 1 lr_scheduler.load_state_dict(trainer_state['lr_scheduler']) else: start_epoch = 0 print(f'Start training from epoch {start_epoch}') best_mAP = 0 for epoch in range(start_epoch, args.epochs): msgs = train_one_epoch(model, criterion, optimizer, lr_scheduler, data_loader, epoch, args.interval, shared_size, scale_sampler, device, args.sparsity, args.lamb) utils.print_training_message(epoch + 1, msgs, args.batch_size) torch.save(model, f"{args.workspace}/checkpoint/{args.savename}-ckpt-%03d.pth" % epoch) torch.save({ 'epoch' : epoch, 'optimizer' : optimizer.state_dict(), 'lr_scheduler' : lr_scheduler.state_dict()}, f'{args.workspace}/checkpoint/trainer-ckpt.pth') if epoch >= args.eval_epoch: mAP = eval.evaluate(model, decoder, data_loader_valid, device, args.num_classes) with open(f'{args.workspace}/log/mAP.txt', 'a') as file: file.write(f'{epoch} {mAP}\n') file.close() print(f'Current mAP:%.2f%%' % (mAP * 100))
def main(args): try: mp.set_start_method('spawn') except RuntimeError: pass utils.make_workspace_dirs(args.workspace) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') in_size = [int(s) for s in args.in_size.split(',')] scale_step = [int(ss) for ss in args.scale_step.split(',')] anchors = np.loadtxt(os.path.join(args.dataset, 'anchors.txt')) scale_sampler = utils.TrainScaleSampler(scale_step, args.rescale_freq) shared_size = torch.IntTensor(in_size).share_memory_() dataset = ds.CustomDataset(args.dataset, 'train') collate_fn = partial(ds.collate_fn, in_size=shared_size, train=True) data_loader = torch.utils.data.DataLoader(dataset, args.batch_size, True, num_workers=args.workers, collate_fn=collate_fn, pin_memory=args.pin) model = darknet.DarkNet(anchors, in_size, num_classes=args.num_classes).to(device) if args.checkpoint: print(f'load {args.checkpoint}') model.load_state_dict(torch.load(args.checkpoint)) if args.sparsity: model.load_prune_permit('model/prune_permit.json') criterion = yolov3.YOLOv3Loss(args.num_classes, anchors) decoder = yolov3.YOLOv3EvalDecoder(in_size, args.num_classes, anchors) params = [p for p in model.parameters() if p.requires_grad] if args.optim == 'sgd': optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) else: optimizer = torch.optim.Adam(params, lr=args.lr, weight_decay=args.weight_decay) trainer = f'{args.workspace}/checkpoint/trainer-ckpt.pth' if args.resume: trainer_state = torch.load(trainer) optimizer.load_state_dict(trainer_state['optimizer']) milestones = [int(ms) for ms in args.milestones.split(',')] def lr_lambda(iter): if iter < args.warmup: return pow(iter / args.warmup, 4) factor = 1 for i in milestones: factor *= pow(args.lr_gamma, int(iter > i)) return factor lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda) if args.resume: start_epoch = trainer_state['epoch'] + 1 lr_scheduler.load_state_dict(trainer_state['lr_scheduler']) else: start_epoch = 0 print(f'Start training from epoch {start_epoch}') for epoch in range(start_epoch, args.epochs): msgs = train_one_epoch(model, criterion, optimizer, lr_scheduler, data_loader, epoch, args.interval, shared_size, scale_sampler, device, args.sparsity, args.lamb) utils.print_training_message(args.workspace, epoch + 1, msgs, args.batch_size) torch.save( model.state_dict(), f"{args.workspace}/checkpoint/{args.savename}-ckpt-%03d.pth" % epoch) torch.save( { 'epoch': epoch, 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict() }, trainer) if epoch >= args.eval_epoch: pass