def Img_transform(self, name, size, split='train'): # if len(args.crop_size) == 1: # crop_size = (args.crop_size[0] , args.crop_size[0]) ## W x H # else: # crop_size = (args.crop_size[1] , args.crop_size[0]) assert (isinstance(size, tuple) and len(size) == 2) if name in ['CS', 'IDD']: if split == 'train': t = [ transforms.Resize(size), transforms.RandomCrop((512, 512)), transforms.RandomHorizontalFlip(), transforms.ToTensor() ] else: t = [transforms.Resize(size), transforms.ToTensor()] return transforms.Compose(t) if split == 'train': t = [ transforms.Resize(size), transforms.RandomHorizontalFlip(), transforms.ToTensor() ] else: t = [transforms.Resize(size), transforms.ToTensor()] return transforms.Compose(t)
def __init__(self, data, labels, is_train=True): super(Cifar10, self).__init__() self.data, self.labels = data, labels self.is_train = is_train assert len(self.data) == len(self.labels) mean, std = (0.4914, 0.4822, 0.4465), (0.2471, 0.2435, 0.2616) if is_train: self.trans_weak = T.Compose([ T.Resize((32, 32)), T.PadandRandomCrop(border=4, cropsize=(32, 32)), T.RandomHorizontalFlip(p=0.5), T.Normalize(mean, std), T.ToTensor(), ]) self.trans_strong = T.Compose([ T.Resize((32, 32)), T.PadandRandomCrop(border=4, cropsize=(32, 32)), T.RandomHorizontalFlip(p=0.5), RandomAugment(2, 10), T.Normalize(mean, std), T.ToTensor(), ]) else: self.trans = T.Compose([ T.Resize((32, 32)), T.Normalize(mean, std), T.ToTensor(), ])
def Img_transform(self, name, size, split='train'): assert (isinstance(size, tuple) and len(size) == 2) if name in ['CS', 'IDD', 'MAP', 'ADE', 'IDD20K']: if split == 'train': t = [ #transforms.RandomScale(1.1), #transforms.RandomRotate(3), #transforms.Resize((640,640)), #RandomAffine(1,(0.04,0.04),None,1,resample=Image.NEAREST,fillcolor=255), #Resize((512,512),Image.NEAREST), #RandomHorizontalFlip(), #ToTensor() transforms.Resize(size), #transforms.RandomCrop((512,512)), transforms.RandomHorizontalFlip(), transforms.ToTensor() ] else: t = [transforms.Resize(size), transforms.ToTensor()] return transforms.Compose(t) if split == 'train': t = [ transforms.Resize(size), transforms.RandomHorizontalFlip(), transforms.ToTensor() ] else: t = [transforms.Resize(size), transforms.ToTensor()] return transforms.Compose(t)
def __init__(self, root, mode='train'): self.samples = [] lines = os.listdir(os.path.join(root, 'GT')) for line in lines: rgbpath = os.path.join(root, 'RGB', line[:-4] + '.jpg') tpath = os.path.join(root, 'T', line[:-4] + '.jpg') maskpath = os.path.join(root, 'GT', line) self.samples.append([rgbpath, tpath, maskpath]) if mode == 'train': self.transform = transform.Compose( transform.Normalize(mean1=mean_rgb, mean2=mean_t, std1=std_rgb, std2=std_t), transform.Resize(400, 400), transform.RandomHorizontalFlip(), transform.ToTensor()) elif mode == 'test': self.transform = transform.Compose( transform.Normalize(mean1=mean_rgb, mean2=mean_t, std1=std_rgb, std2=std_t), transform.Resize(400, 400), transform.ToTensor()) else: raise ValueError
def get_transform(train): transforms = [] transforms.append(T.ToTensor()) if train: transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
def __init__(self, cfg): self.cfg = cfg if self.cfg.mode == 'train': self.transform = transform.Compose( transform.Normalize(mean=cfg.mean, std=cfg.std), transform.Resize(size=448), transform.RandomHorizontalFlip(), transform.ToTensor()) elif self.cfg.mode == 'test' or self.cfg.mode == 'val': self.transform = transform.Compose( transform.Normalize(mean=cfg.mean, std=cfg.std), transform.ToTensor()) else: raise ValueError
def __init__(self, data, labels, is_train=True): super(Cifar10, self).__init__() self.data, self.labels = data, labels self.is_train = is_train assert len(self.data) == len(self.labels) mean, std = (0.4914, 0.4822, 0.4465), (0.2471, 0.2435, 0.2616) # mean, std = (-0.0172, -0.0356, -0.1069), (0.4940, 0.4869, 0.5231) # [-1, 1] if is_train: self.trans_reg = transforms.Compose([ transforms.RandomResizedCrop(32), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply( [transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8), transforms.RandomGrayscale(p=0.2), transforms.ToTensor(), transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]) ]) self.trans_weak = T.Compose([ T.Resize((32, 32)), T.PadandRandomCrop(border=4, cropsize=(32, 32)), T.RandomHorizontalFlip(p=0.5), T.Normalize(mean, std), T.ToTensor(), ]) self.trans_strong = T.Compose([ T.Resize((32, 32)), T.PadandRandomCrop(border=4, cropsize=(32, 32)), T.RandomHorizontalFlip(p=0.5), RandomAugment(2, 10), T.Normalize(mean, std), T.ToTensor(), ]) else: self.trans = T.Compose([ T.Resize((32, 32)), T.Normalize(mean, std), T.ToTensor(), ])
def __init__(self, cfg): with open(cfg.datapath + '/' + cfg.mode + '.txt', 'r') as lines: self.samples = [] for line in lines: imagepath = cfg.datapath + '/image/' + line.strip() + '.jpg' maskpath = cfg.datapath + '/scribble/' + line.strip() + '.png' self.samples.append([imagepath, maskpath]) if cfg.mode == 'train': self.transform = transform.Compose( transform.Normalize(mean=cfg.mean, std=cfg.std), transform.Resize(320, 320), transform.RandomHorizontalFlip(), transform.RandomCrop(320, 320), transform.ToTensor()) elif cfg.mode == 'test': self.transform = transform.Compose( transform.Normalize(mean=cfg.mean, std=cfg.std), transform.Resize(320, 320), transform.ToTensor()) else: raise ValueError
def __init__(self, cfg): with open(os.path.join(cfg.datapath, cfg.mode + '.txt'), 'r') as lines: self.samples = [] for line in lines: imagepath = os.path.join(cfg.datapath, 'image', line.strip() + '.jpg') maskpath = os.path.join(cfg.datapath, 'mask', line.strip() + '.png') self.samples.append([imagepath, maskpath]) if cfg.mode == 'train': self.transform = transform.Compose( transform.Normalize(mean=cfg.mean, std=cfg.std), transform.Resize(320, 320), transform.RandomHorizontalFlip(), transform.RandomCrop(288, 288), transform.ToTensor()) elif cfg.mode == 'test': self.transform = transform.Compose( transform.Normalize(mean=cfg.mean, std=cfg.std), transform.Resize(320, 320), transform.ToTensor()) else: raise ValueError
def __init__(self, root, mode='train'): self.samples = [] lines = os.listdir(os.path.join(root, mode + '_images')) self.mode = mode for line in lines: rgbpath = os.path.join(root, mode + '_images', line) tpath = os.path.join(root, mode + '_depth', line[:-4] + '.png') maskpath = os.path.join(root, mode + '_masks', line[:-4] + '.png') self.samples.append([rgbpath, tpath, maskpath]) if mode == 'train': self.transform = transform.Compose( transform.Normalize(mean1=mean_rgb, std1=std_rgb), transform.Resize(256, 256), transform.RandomHorizontalFlip(), transform.ToTensor()) elif mode == 'test': self.transform = transform.Compose( transform.Normalize(mean1=mean_rgb, std1=std_rgb), transform.Resize(256, 256), transform.ToTensor()) else: raise ValueError
def __init__(self, data, labels, n_guesses=1, is_train=True): super(Cifar10, self).__init__() self.data, self.labels = data, labels self.n_guesses = n_guesses assert len(self.data) == len(self.labels) assert self.n_guesses >= 1 # mean, std = (0.4914, 0.4822, 0.4465), (0.2471, 0.2435, 0.2616) # [0, 1] mean, std = (-0.0172, -0.0356, -0.1069), (0.4940, 0.4869, 0.5231 ) # [-1, 1] if is_train: self.trans = T.Compose([ T.Resize((32, 32)), T.PadandRandomCrop(border=4, cropsize=(32, 32)), T.RandomHorizontalFlip(p=0.5), T.Normalize(mean, std), T.ToTensor(), ]) else: self.trans = T.Compose([ T.Resize((32, 32)), T.Normalize(mean, std), T.ToTensor(), ])
def main(): #数据集加载 dataset = Market1501() #训练数据处理器 transform_train = T.Compose([ T.Random2DTransform(height, width), #尺度统一,随机裁剪 T.RandomHorizontalFlip(), #水平翻转 T.ToTensor(), #图片转张量 T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), #归一化,参数固定 ]) #测试数据处理器 transform_test = T.Compose([ T.Resize((height, width)), #尺度统一 T.ToTensor(), #图片转张量 T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), #归一化,参数固定 ]) #train数据集吞吐器 train_data_loader = DataLoader( ImageDataset(dataset.train, transform=transform_train), #自定义的数据集,使用训练数据处理器 batch_size=train_batch_size, #一个批次的大小(一个批次有多少个图片张量) drop_last=True, #丢弃最后无法称为一整个批次的数据 ) print("train_data_loader inited") #query数据集吞吐器 query_data_loader = DataLoader( ImageDataset(dataset.query, transform=transform_test), #自定义的数据集,使用测试数据处理器 batch_size=test_batch_size, #一个批次的大小(一个批次有多少个图片张量) shuffle=False, #不重排 drop_last=True, #丢弃最后无法称为一整个批次的数据 ) print("query_data_loader inited") #gallery数据集吞吐器 gallery_data_loader = DataLoader( ImageDataset(dataset.gallery, transform=transform_test), #自定义的数据集,使用测试数据处理器 batch_size=test_batch_size, #一个批次的大小(一个批次有多少个图片张量) shuffle=False, #不重排 drop_last=True, #丢弃最后无法称为一整个批次的数据 ) print("gallery_data_loader inited\n") #加载模型 model = ReIDNet(num_classes=751, loss={'softmax'}) #指定分类的数量,与使用的损失函数以便决定模型输出何种计算结果 print("=>ReIDNet loaded") print("Model size: {:.5f}M\n".format( sum(p.numel() for p in model.parameters()) / 1000000.0)) #损失函数 criterion_class = nn.CrossEntropyLoss() """ 优化器 参数1,待优化的参数 参数2,学习率 参数3,权重衰减 """ optimizer = torch.optim.SGD(model.parameters(), lr=train_lr, weight_decay=5e-04) """ 动态学习率 参数1,指定使用的优化器 参数2,mode,可选择‘min’(min表示当监控量停止下降的时候,学习率将减小)或者‘max’(max表示当监控量停止上升的时候,学习率将减小) 参数3,factor,代表学习率每次降低多少 参数4,patience,容忍网路的性能不提升的次数,高于这个次数就降低学习率 参数5,min_lr,学习率的下限 """ scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=dy_step_gamma, patience=10, min_lr=0.0001) #如果是测试 if evaluate: test(model, query_data_loader, gallery_data_loader) return 0 #如果是训练 print('————model start training————\n') bt = time.time() #训练的开始时间 for epoch in range(start_epoch, end_epoch): model.train(True) train(epoch, model, criterion_class, optimizer, scheduler, train_data_loader) et = time.time() #训练的结束时间 print('**模型训练结束, 保存最终参数到{}**\n'.format(final_model_path)) torch.save(model.state_dict(), final_model_path) print('————训练总用时{:.2f}小时————'.format((et - bt) / 3600.0))
def main(parser_data): device = torch.device( parser_data.device if torch.cuda.is_available() else "cpu") print("Using {} device training.".format(device.type)) if not os.path.exists("save_weights"): os.mkdir("save_weights") data_transform = { "train": transform.Compose([ transform.SSDCropping(), transform.Resize(), transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox() ]), "val": transform.Compose([ transform.Resize(), transform.ToTensor(), transform.Normalization() ]) } VOC_root = parser_data.data_path # check voc root if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False: raise FileNotFoundError( "VOCdevkit dose not in path:'{}'.".format(VOC_root)) train_dataset = VOC2012DataSet(VOC_root, data_transform['train'], train_set='train.txt') # 注意训练时,batch_size必须大于1 batch_size = parser_data.batch_size assert batch_size > 1, "batch size must be greater than 1" nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using %g dataloader workers' % nw) train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw, collate_fn=train_dataset.collate_fn) val_dataset = VOC2012DataSet(VOC_root, data_transform['val'], train_set='val.txt') val_data_loader = torch.utils.data.DataLoader( val_dataset, batch_size=batch_size, shuffle=False, num_workers=nw, collate_fn=train_dataset.collate_fn) model = create_model(num_classes=21, device=device) model.to(device) # define optimizer params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.0005, momentum=0.9, weight_decay=0.0005) # learning rate scheduler lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.3) # 如果指定了上次训练保存的权重文件地址,则接着上次结果接着训练 if parser_data.resume != "": checkpoint = torch.load(parser_data.resume) model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) parser_data.start_epoch = checkpoint['epoch'] + 1 print("the training process from epoch{}...".format( parser_data.start_epoch)) train_loss = [] learning_rate = [] val_map = [] val_data = None # 如果电脑内存充裕,可提前加载验证集数据,以免每次验证时都要重新加载一次数据,节省时间 # val_data = get_coco_api_from_dataset(val_data_loader.dataset) for epoch in range(parser_data.start_epoch, parser_data.epochs): utils.train_one_epoch(model=model, optimizer=optimizer, data_loader=train_data_loader, device=device, epoch=epoch, print_freq=50, train_loss=train_loss, train_lr=learning_rate) lr_scheduler.step() utils.evaluate(model=model, data_loader=val_data_loader, device=device, data_set=val_data, mAP_list=val_map) # save weights save_files = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch } torch.save(save_files, "./save_weights/ssd300-{}.pth".format(epoch)) # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) if not os.path.exists("save_weights"): os.mkdir("save_weights") data_transform = { "train": transform.Compose([transform.SSDCropping(), transform.Resize(), transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox()]), "val": transform.Compose([transform.Resize(), transform.ToTensor(), transform.Normalization()]) } voc_path = "../" train_dataset = VOC2012DataSet(voc_path, data_transform['train'], True) # 注意训练时,batch_size必须大于1 train_data_loader = torch.utils.data.DataLoader(train_dataset, batch_size=8, shuffle=True, num_workers=0, collate_fn=utils.collate_fn) val_dataset = VOC2012DataSet(voc_path, data_transform['val'], False) val_data_loader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=0, collate_fn=utils.collate_fn) model = create_model(num_classes=21, device=device) model.to(device) # define optimizer params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.002, momentum=0.9, weight_decay=0.0005) # learning rate scheduler lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.3) train_loss = [] learning_rate = [] val_map = [] val_data = None # 如果电脑内存充裕,可提前加载验证集数据,以免每次验证时都要重新加载一次数据,节省时间 # val_data = get_coco_api_from_dataset(val_data_loader.dataset) for epoch in range(20): utils.train_one_epoch(model=model, optimizer=optimizer, data_loader=train_data_loader, device=device, epoch=epoch, print_freq=50, train_loss=train_loss, train_lr=learning_rate, warmup=True) lr_scheduler.step() utils.evaluate(model=model, data_loader=val_data_loader, device=device, data_set=val_data, mAP_list=val_map) # save weights save_files = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch} torch.save(save_files, "./save_weights/ssd300-{}.pth".format(epoch)) # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
def main(args): print(args) # mp.spawn(main_worker, args=(args,), nprocs=args.world_size, join=True) init_distributed_mode(args) device = torch.device(args.device) results_file = "results{}.txt".format( datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) # Data loading code print("Loading data") data_transform = { "train": transform.Compose([ transform.SSDCropping(), transform.Resize(), transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox() ]), "val": transform.Compose([ transform.Resize(), transform.ToTensor(), transform.Normalization() ]) } VOC_root = args.data_path # check voc root if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False: raise FileNotFoundError( "VOCdevkit dose not in path:'{}'.".format(VOC_root)) # load train data set train_data_set = VOC2012DataSet(VOC_root, data_transform["train"], train_set='train.txt') # load validation data set val_data_set = VOC2012DataSet(VOC_root, data_transform["val"], train_set='val.txt') print("Creating data loaders") if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_data_set) test_sampler = torch.utils.data.distributed.DistributedSampler( val_data_set) else: train_sampler = torch.utils.data.RandomSampler(train_data_set) test_sampler = torch.utils.data.SequentialSampler(val_data_set) if args.aspect_ratio_group_factor >= 0: # 统计所有图像比例在bins区间中的位置索引 group_ids = create_aspect_ratio_groups( train_data_set, k=args.aspect_ratio_group_factor) train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids, args.batch_size) else: train_batch_sampler = torch.utils.data.BatchSampler(train_sampler, args.batch_size, drop_last=True) data_loader = torch.utils.data.DataLoader( train_data_set, batch_sampler=train_batch_sampler, num_workers=args.workers, collate_fn=train_data_set.collate_fn) data_loader_test = torch.utils.data.DataLoader( val_data_set, batch_size=1, sampler=test_sampler, num_workers=args.workers, collate_fn=train_data_set.collate_fn) print("Creating model") model = create_model(num_classes=args.num_classes + 1, device=device) model_without_ddp = model if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu]) model_without_ddp = model.module params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma) # lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma) # 如果传入resume参数,即上次训练的权重地址,则接着上次的参数训练 if args.resume: # If map_location is missing, torch.load will first load the module to CPU # and then copy each parameter to where it was saved, # which would result in all processes on the same machine using the same set of devices. checkpoint = torch.load( args.resume, map_location='cpu') # 读取之前保存的权重文件(包括优化器以及学习率策略) model_without_ddp.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) args.start_epoch = checkpoint['epoch'] + 1 if args.test_only: utils.evaluate(model, data_loader_test, device=device) return train_loss = [] learning_rate = [] val_map = [] print("Start training") start_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) mean_loss, lr = utils.train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq) # only first process to save training info if args.rank in [-1, 0]: train_loss.append(mean_loss.item()) learning_rate.append(lr) # update learning rate lr_scheduler.step() # evaluate after every epoch coco_info = utils.evaluate(model, data_loader_test, device=device) if args.rank in [-1, 0]: # write into txt with open(results_file, "a") as f: result_info = [ str(round(i, 4)) for i in coco_info + [mean_loss.item(), lr] ] txt = "epoch:{} {}".format(epoch, ' '.join(result_info)) f.write(txt + "\n") val_map.append(coco_info[1]) # pascal mAP if args.output_dir: # 只在主节点上执行保存权重操作 save_on_master( { 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'args': args, 'epoch': epoch }, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch))) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str)) if args.rank in [-1, 0]: # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
def main(parser_data): device = torch.device( parser_data.device if torch.cuda.is_available() else "cpu") print(device) if not os.path.exists("save_weights"): os.mkdir("save_weights") data_transform = { "train": transform.Compose([ transform.SSDCropping(), transform.Resize(), transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox() ]), "val": transform.Compose([ transform.Resize(), transform.ToTensor(), transform.Normalization() ]) } night_root = parser_data.data_path train_dataset = NightDataSet(night_root, data_transform['train'], train_set='train.txt') # aa = train_dataset[1] # 注意训练时,batch_size必须大于1 train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=8, shuffle=True, num_workers=4, collate_fn=utils.collate_fn) val_dataset = NightDataSet(night_root, data_transform['val'], train_set='val.txt') # bb = val_dataset[2] val_data_loader = torch.utils.data.DataLoader(val_dataset, batch_size=4, shuffle=False, num_workers=0, collate_fn=utils.collate_fn) model = create_model(num_classes=3, device=device) print(model) model.to(device) # define optimizer params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005) # learning rate scheduler lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5) # 如果指定了上次训练保存的权重文件地址,则接着上次结果接着训练 if parser_data.resume != "": checkpoint = torch.load(parser_data.resume) model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) parser_data.start_epoch = checkpoint['epoch'] + 1 print("the training process from epoch{}...".format( parser_data.start_epoch)) train_loss = [] learning_rate = [] val_map = [] train_val_map = [] val_data = None # 如果电脑内存充裕,可提前加载验证集数据,以免每次验证时都要重新加载一次数据,节省时间 # val_data = get_coco_api_from_dataset(val_data_loader.dataset) for epoch in range(parser_data.start_epoch, parser_data.epochs): utils.train_one_epoch(model=model, optimizer=optimizer, data_loader=train_data_loader, device=device, epoch=epoch, print_freq=50, train_loss=train_loss, train_lr=learning_rate) lr_scheduler.step() if epoch >= 20 or epoch == 10: utils.evaluate(model=model, data_loader=val_data_loader, device=device, data_set=val_data, mAP_list=val_map) # save weights save_files = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch } torch.save(save_files, "./save_weights/ssd512-{}.pth".format(epoch)) # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
import numpy as np import torchvision import torch print(torch.__version__) print(torchvision.__version__) normalize = T.Normalize(mean=[0.43216, 0.394666, 0.37645], std=[0.22803, 0.22145, 0.216989]) # def normalize(tensor): # # Subtract the mean, and scale to the interval [-1,1] # tensor_minusmean = tensor - tensor.mean() # return tensor_minusmean/tensor_minusmean.abs().max() transform_video = torchvision.transforms.Compose([ T.ToFloatTensorInZeroOne(), T.Resize((128, 171)), T.RandomHorizontalFlip(), normalize, T.RandomCrop((112, 112)) ]) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") root = ET.parse( '/root/yangsen-data/LIRIS-ACCEDE-movies/ACCEDEmovies.xml').getroot() movie_length = {} def get_sec(time_str: str) -> int: """Get Seconds from time.""" h, m, s = time_str.split(':') return int(h) * 3600 + int(m) * 60 + int(s)
def main(parser_data): device = torch.device( parser_data.device if torch.cuda.is_available() else "cpu") print("Using {} device training.".format(device.type)) if not os.path.exists("save_weights"): os.mkdir("save_weights") results_file = "results{}.txt".format( datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) data_transform = { "train": transform.Compose([ transform.SSDCropping(), transform.Resize(), transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox() ]), "val": transform.Compose([ transform.Resize(), transform.ToTensor(), transform.Normalization() ]) } VOC_root = parser_data.data_path # check voc root if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False: raise FileNotFoundError( "VOCdevkit dose not in path:'{}'.".format(VOC_root)) train_dataset = VOC2012DataSet(VOC_root, data_transform['train'], train_set='train.txt') # 注意训练时,batch_size必须大于1 batch_size = parser_data.batch_size assert batch_size > 1, "batch size must be greater than 1" # 防止最后一个batch_size=1,如果最后一个batch_size=1就舍去 drop_last = True if len(train_dataset) % batch_size == 1 else False nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using %g dataloader workers' % nw) train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw, collate_fn=train_dataset.collate_fn, drop_last=drop_last) val_dataset = VOC2012DataSet(VOC_root, data_transform['val'], train_set='val.txt') val_data_loader = torch.utils.data.DataLoader( val_dataset, batch_size=batch_size, shuffle=False, num_workers=nw, collate_fn=train_dataset.collate_fn) model = create_model(num_classes=args.num_classes + 1, device=device) # define optimizer params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.0005, momentum=0.9, weight_decay=0.0005) # learning rate scheduler lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.3) # 如果指定了上次训练保存的权重文件地址,则接着上次结果接着训练 if parser_data.resume != "": checkpoint = torch.load(parser_data.resume) model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) parser_data.start_epoch = checkpoint['epoch'] + 1 print("the training process from epoch{}...".format( parser_data.start_epoch)) train_loss = [] learning_rate = [] val_map = [] # 提前加载验证集数据,以免每次验证时都要重新加载一次数据,节省时间 val_data = get_coco_api_from_dataset(val_data_loader.dataset) for epoch in range(parser_data.start_epoch, parser_data.epochs): mean_loss, lr = utils.train_one_epoch(model=model, optimizer=optimizer, data_loader=train_data_loader, device=device, epoch=epoch, print_freq=50) train_loss.append(mean_loss.item()) learning_rate.append(lr) # update learning rate lr_scheduler.step() coco_info = utils.evaluate(model=model, data_loader=val_data_loader, device=device, data_set=val_data) # write into txt with open(results_file, "a") as f: result_info = [ str(round(i, 4)) for i in coco_info + [mean_loss.item(), lr] ] txt = "epoch:{} {}".format(epoch, ' '.join(result_info)) f.write(txt + "\n") val_map.append(coco_info[1]) # pascal mAP # save weights save_files = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch } torch.save(save_files, "./save_weights/ssd300-{}.pth".format(epoch)) # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
def main(parser_data): device = torch.device( parser_data.device if torch.cuda.is_available() else "cpu") print(device) if not os.path.exists("save_weights"): os.mkdir("save_weights") data_transform = { "train": transform.Compose([ transform.SSDCropping(), transform.Resize(), transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox() ]), "val": transform.Compose([ transform.Resize(), transform.ToTensor(), transform.Normalization() ]) } XRay_root = parser_data.data_path train_dataset = XRayDataset(XRay_root, data_transform['train'], train_set='train.txt') # Note that the batch_size must be greater than 1 train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=8, shuffle=True, num_workers=4, collate_fn=utils.collate_fn) val_dataset = XRayDataset(XRay_root, data_transform['val'], train_set='val.txt') val_data_loader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=0, collate_fn=utils.collate_fn) model = create_model(num_classes=6, device=device) model.to(device) # define optimizer params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.0005, momentum=0.9, weight_decay=0.0005) # learning rate scheduler lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.3) # If the address of the weight file saved by the last training is specified, the training continues with the last result if parser_data.resume != "": checkpoint = torch.load(parser_data.resume) model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) parser_data.start_epoch = checkpoint['epoch'] + 1 print("the training process from epoch{}...".format( parser_data.start_epoch)) train_loss = [] learning_rate = [] val_map = [] val_data = None # If your computer has sufficient memory, you can save time by loading the validation set data in advance to avoid having to reload the data each time you validate # val_data = get_coco_api_from_dataset(val_data_loader.dataset) for epoch in range(parser_data.start_epoch, parser_data.epochs): utils.train_one_epoch(model=model, optimizer=optimizer, data_loader=train_data_loader, device=device, epoch=epoch, print_freq=50, train_loss=train_loss, train_lr=learning_rate) lr_scheduler.step() utils.evaluate(model=model, data_loader=val_data_loader, device=device, data_set=val_data, mAP_list=val_map) # save weights save_files = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch } torch.save(save_files, "./save_weights/ssd300-{}.pth".format(epoch)) # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
import pandas as pd import traceback import transform as T import numpy as np import torchvision import torch from tensorboardX import SummaryWriter print(torch.__version__) print(torchvision.__version__) normalize = T.Normalize(mean=[0.43216, 0.394666, 0.37645], std=[0.22803, 0.22145, 0.216989]) transform_video = torchvision.transforms.Compose([ T.ToFloatTensorInZeroOne(), T.Resize((128, 171)), T.RandomHorizontalFlip(), normalize, T.RandomCrop((112, 112)) ]) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(torchaudio.__version__) trainIter = 0 evalIter = 0 def normalize(tensor): # Subtract the mean, and scale to the interval [-1,1] tensor_minusmean = tensor - tensor.mean() return tensor_minusmean/tensor_minusmean.abs().max() class LIRIS_ACCEDE(torch.utils.data.Dataset):
def main(): print("------------------------------") print("START") print("------------------------------") composed_transforms_tr = standard_transforms.Compose([ tr.RandomHorizontalFlip(), tr.ScaleNRotate(rots=(-15, 15), scales=(.75, 1.5)), # tr.RandomResizedCrop(img_size), tr.FixedResize(img_size), tr.Normalize(mean=mean, std=std), tr.ToTensor() ]) # data pocessing and data augumentation voc_train_dataset = VOCSegmentation( base_dir=data_dir, split='train', transform=composed_transforms_tr) # get data #return {'image': _img, 'gt': _target} print("Data loaded...") print("Dataset:{}".format(dataset)) print("------------------------------") voc_train_loader = DataLoader(voc_train_dataset, batch_size=batch_size, shuffle=True, num_workers=1) iter_dataset = iter(voc_train_loader) train = next(iter_dataset) print("Input size {}".format(train['image'].shape)) print("Output size {}".format(train['gt'].shape)) print("Model start training...") print("------------------------------") print("Model info:") print("If use CUDA : {}".format(use_gpu)) print('Initial learning rate {} | batch size {} | epoch num {}'.format( 0.0001, batch_size, epoches)) print("------------------------------") model = fpn_unet(input_bands=input_bands, n_classes=num_class) model_id = 0 # load model if find_new_file(model_dir) is not None: model.load_state_dict(torch.load(find_new_file(model_dir))) # model.load_state_dict(torch.load('./pth/best2.pth')) print('load the model %s' % find_new_file(model_dir)) model_id = re.findall(r'\d+', find_new_file(model_dir)) model_id = int(model_id[0]) print('Current model ID {}'.format(model_id)) model.cuda() criterion = torch.nn.CrossEntropyLoss() #define loss optimizer = torch.optim.Adam(model.parameters(), lr=0.0001) #define optimizer model.cuda() model.train() f = open('log.txt', 'w') for epoch in range(epoches): cur_log = '' running_loss = 0.0 start = time.time() lr = adjust_learning_rate(base_lr, optimizer, epoch, model_id, power) print("Current learning rate : {}".format(lr)) for i, batch_data in tqdm.tqdm(enumerate(voc_train_loader)): #get data images, labels = batch_data['image'], batch_data['gt'] labels = labels.view(images.size()[0], img_size, img_size).long() i += images.size()[0] images = Variable(images).cuda() labels = Variable(labels).cuda() optimizer.zero_grad() outputs = model(images) losses = criterion(outputs, labels) # calculate loss losses.backward() optimizer.step() running_loss += losses print("Epoch [%d] all Loss: %.4f" % (epoch + 1 + model_id, running_loss / i)) cur_log += 'epoch:{}, '.format(str(epoch)) + 'learning_rate:{}'.format( str(lr)) + ', ' + 'train_loss:{}'.format( str(running_loss.item() / i)) + ', ' torch.save(model.state_dict(), os.path.join(model_dir, '%d.pth' % (model_id + epoch + 1))) print("Model Saved") # iou, acc, recall, precision = test_my(input_bands, model_name, model_dir, img_size, num_class) # cur_log += 'iou:{}'.format(str(iou)) + ', ' + 'acc:{}'.format(str(acc))+'\n' + ', ' + 'recall:{}'.format(str(recall))+'\n' + ', ' + 'precision:{}'.format(str(precision)) end = time.time() time_cha = end - start left_steps = epoches - epoch - model_id print('the left time is %d hours, and %d minutes' % (int(left_steps * time_cha) / 3600, (int(left_steps * time_cha) % 3600) / 60)) print(cur_log) f.writelines(str(cur_log))
current_pos + batch_size) if self.transform: samples = self.transform(samples) yield samples, labels if __name__ == '__main__': # just for debug the dataset tic = time.time() background = np.ones(18, ) background = -9999 * background counts = 0 mean = unpickle('mean_channal.pkl') tfs = T.Compose([ T.Normalize(mean=mean), T.RandomHorizontalFlip(0.5), ]) datasets = CustomDataset('training.h5', transform=None) for samples, labels in datasets.load_data(batch_size=256, shuffle=False): # background += np.sum(samples, axis = (0,1,2)) counts += labels.shape[0] print("counts:", counts) # compute mean,std by channel print("len:", len(datasets)) # mean = background / len(datasets) # print("mean:", mean.shape) toc = time.time() print("elasped time is %.3f" % (toc - tic)) # pdb.set_trace() # all_data = np.concatenate([datasets.s1,datasets.s2], axis=3) # with open("mean_channal.pkl", 'wb') as f:
save_best_only=False, save_weights_only=False, mode='auto', period=1) #model = resnet.ResnetBuilder.build_resnet_18((18, 32, 32), nb_classes) network = model.create_model('resnet50', input_shape=(18, 32, 32), num_outputs=nb_classes) network.compile(loss='sparse_categorical_crossentropy', optimizer=optimizers.SGD(lr=0.1, momentum=0.9, nesterov=True), metrics=['accuracy']) mean = unpickle("mean_channal.pkl") trfs = T.Compose([T.Normalize(mean), T.RandomHorizontalFlip(0.5)]) training_data = CustomDataset('/mnt/img1/yangqh/Germany_cloud/training.h5', transform=None) validation_data = CustomDataset('/mnt/img1/yangqh/Germany_cloud/training.h5', transform=None) ##############此处改成train set 的目录 network.fit_generator( training_data.load_data(batch_size=batch_size), steps_per_epoch=len(training_data) // batch_size, validation_data=validation_data.load_data(batch_size=batch_size), validation_steps=len(validation_data) // batch_size, epochs=nb_epoch, verbose=1, max_q_size=100, callbacks=[checkpoint, lr_reducer, early_stopper, csv_logger]) network.save('final.h5')
def main(args): print(args) # mp.spawn(main_worker, args=(args,), nprocs=args.world_size, join=True) utils.init_distributed_mode(args) device = torch.device(args.device) # Data loading code print("Loading data") data_transform = { "train": transform.Compose([ transform.SSDCropping(), transform.Resize(), # transform.ColorJitter(), transform.ToTensor(), transform.RandomHorizontalFlip(), transform.Normalization(), transform.AssignGTtoDefaultBox() ]), "val": transform.Compose([ transform.Resize(), transform.ToTensor(), transform.Normalization() ]) } VOC_root = args.data_path # load train data set train_data_set = VOC2012DataSet(VOC_root, data_transform["train"], True) # load validation data set val_data_set = VOC2012DataSet(VOC_root, data_transform["val"], False) print("Creating data loaders") if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_data_set) test_sampler = torch.utils.data.distributed.DistributedSampler( val_data_set) else: train_sampler = torch.utils.data.RandomSampler(train_data_set) test_sampler = torch.utils.data.SequentialSampler(val_data_set) if args.aspect_ratio_group_factor >= 0: # 统计所有图像比例在bins区间中的位置索引 group_ids = create_aspect_ratio_groups( train_data_set, k=args.aspect_ratio_group_factor) train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids, args.batch_size) else: train_batch_sampler = torch.utils.data.BatchSampler(train_sampler, args.batch_size, drop_last=True) data_loader = torch.utils.data.DataLoader( train_data_set, batch_sampler=train_batch_sampler, num_workers=args.workers, collate_fn=utils.collate_fn) data_loader_test = torch.utils.data.DataLoader(val_data_set, batch_size=4, sampler=test_sampler, num_workers=args.workers, collate_fn=utils.collate_fn) print("Creating model") model = create_model(num_classes=21) model.to(device) model_without_ddp = model if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu]) model_without_ddp = model.module params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma) # lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma) # 如果传入resume参数,即上次训练的权重地址,则接着上次的参数训练 if args.resume: # If map_location is missing, torch.load will first load the module to CPU # and then copy each parameter to where it was saved, # which would result in all processes on the same machine using the same set of devices. checkpoint = torch.load( args.resume, map_location='cpu') # 读取之前保存的权重文件(包括优化器以及学习率策略) model_without_ddp.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) args.start_epoch = checkpoint['epoch'] + 1 if args.test_only: utils.evaluate(model, data_loader_test, device=device) return print("Start training") start_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) utils.train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq) lr_scheduler.step() if args.output_dir: # 只在主节点上执行保存权重操作 utils.save_on_master( { 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'args': args, 'epoch': epoch }, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch))) # evaluate after every epoch utils.evaluate(model, data_loader_test, device=device) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str))
if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend='nccl', init_method='env://') synchronize() img_mean = [0.485, 0.456, 0.406] img_std = [0.229, 0.224, 0.225] device = 'cuda' # torch.backends.cudnn.deterministic = True train_trans = transform.Compose( [ transform.RandomScale(0.5, 2.0), # transform.Resize(args.size, None), transform.RandomHorizontalFlip(), transform.RandomCrop(args.size), transform.RandomBrightness(0.04), transform.ToTensor(), transform.Normalize(img_mean, img_std), transform.Pad(args.size) ] ) valid_trans = transform.Compose( [transform.ToTensor(), transform.Normalize(img_mean, img_std)] ) train_set = ADE20K(args.path, 'train', train_trans) valid_set = ADE20K(args.path, 'valid', valid_trans)