def __init__(self, cfg_path): with open(cfg_path, 'r') as rf: self.cfg = yaml.safe_load(rf) self.data_cfg = self.cfg['data'] self.model_cfg = self.cfg['model'] self.optim_cfg = self.cfg['optim'] self.hyper_params = self.cfg['hyper_params'] self.val_cfg = self.cfg['val'] print(self.data_cfg) print(self.model_cfg) print(self.optim_cfg) print(self.hyper_params) print(self.val_cfg) os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus'] self.gpu_num = len(str(self.cfg['gpus']).split(",")) dist.init_process_group(backend='nccl') ########################################################################################### self.tdata = COCODataSets( img_root=self.data_cfg['train_img_root'], annotation_path=self.data_cfg['train_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=True, remove_blank=self.data_cfg['remove_blank']) self.tloader = DataLoader(dataset=self.tdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.tdata.collate_fn, sampler=DistributedSampler( dataset=self.tdata, shuffle=True)) self.vdata = COCODataSets( img_root=self.data_cfg['val_img_root'], annotation_path=self.data_cfg['val_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=False, remove_blank=False) self.vloader = DataLoader(dataset=self.vdata, batch_size=1, num_workers=1, collate_fn=self.vdata.collate_fn, sampler=DistributedSampler( dataset=self.vdata, shuffle=False)) print("train_data: ", len(self.tdata), " | ", "val_data: ", len(self.vdata), " | ", "empty_data: ", self.tdata.empty_images_len) print("train_iter: ", len(self.tloader), " | ", "val_iter: ", len(self.vloader)) ############################################################################################ model = CenterNet(num_cls=self.model_cfg['num_cls'], PIXEL_MEAN=self.model_cfg['PIXEL_MEAN'], PIXEL_STD=self.model_cfg['PIXEL_STD'], backbone=self.model_cfg['backbone'], cfg=self.model_cfg) self.best_map = 0. self.best_map50 = 0. optimizer = split_optimizer(model, self.optim_cfg) local_rank = dist.get_rank() self.local_rank = local_rank self.device = torch.device("cuda", local_rank) model.to(self.device) if self.optim_cfg['sync_bn']: model = nn.SyncBatchNorm.convert_sync_batchnorm(model) self.model = nn.parallel.distributed.DistributedDataParallel( model, device_ids=[local_rank], output_device=local_rank) self.optimizer = optimizer self.ema = ModelEMA(self.model) self.gt_generator = CenterNetGT( alpha=self.model_cfg['alpha'], beta=self.model_cfg['beta'], num_cls=self.model_cfg['num_cls'], wh_planes=self.model_cfg['wh_planes'], down_ratio=self.model_cfg['down_ratio'], wh_area_process=self.model_cfg['wh_area_process']) self.creterion = CenterNetLoss( hm_weight=self.hyper_params['hm_weight'], wh_weight=self.hyper_params['wh_weight'], down_ratio=self.model_cfg['down_ratio']) self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust( init_lr=self.optim_cfg['lr'], milestones=self.optim_cfg['milestones'], warm_up_epoch=self.optim_cfg['warm_up_epoch'], iter_per_epoch=len(self.tloader), epochs=self.optim_cfg['epochs'], cosine_weights=self.optim_cfg['cosine_weights'])
def __init__(self, cfg_path): with open(cfg_path, 'r') as rf: self.cfg = yaml.safe_load(rf) self.data_cfg = self.cfg['data'] self.model_cfg = self.cfg['model'] self.optim_cfg = self.cfg['optim'] self.hyper_params = self.cfg['hyper_params'] self.val_cfg = self.cfg['val'] print(self.data_cfg) print(self.model_cfg) print(self.optim_cfg) print(self.hyper_params) print(self.val_cfg) os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus'] dist.init_process_group(backend='nccl') self.tdata = COCODataSets( img_root=self.data_cfg['train_img_root'], annotation_path=self.data_cfg['train_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=True, remove_blank=self.data_cfg['remove_blank']) self.tloader = DataLoader(dataset=self.tdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.tdata.collate_fn, sampler=DistributedSampler( dataset=self.tdata, shuffle=True)) self.vdata = COCODataSets( img_root=self.data_cfg['val_img_root'], annotation_path=self.data_cfg['val_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=False, remove_blank=False) self.vloader = DataLoader(dataset=self.vdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.vdata.collate_fn, sampler=DistributedSampler( dataset=self.vdata, shuffle=False)) print("train_data: ", len(self.tdata), " | ", "val_data: ", len(self.vdata), " | ", "empty_data: ", self.tdata.empty_images_len) print("train_iter: ", len(self.tloader), " | ", "val_iter: ", len(self.vloader)) model = RetinaNet( num_cls=self.model_cfg['num_cls'], anchor_sizes=self.model_cfg['anchor_sizes'], strides=self.model_cfg['strides'], backbone=self.model_cfg['backbone'], ) self.scaler = amp.GradScaler(enabled=True) # if self.model_cfg.get("backbone_weight", None): # weights = torch.load(self.model_cfg['backbone_weight']) # model.load_backbone_weighs(weights) self.best_map = 0. self.best_map50 = 0. optimizer = split_optimizer(model, self.optim_cfg) local_rank = dist.get_rank() self.local_rank = local_rank self.device = torch.device("cuda", local_rank) model.to(self.device) if self.optim_cfg['sync_bn']: model = nn.SyncBatchNorm.convert_sync_batchnorm(model) self.model = nn.parallel.distributed.DistributedDataParallel( model, device_ids=[local_rank], output_device=local_rank) self.optimizer = optimizer self.ema = ModelEMA(self.model) self.creterion = RetinaLoss( iou_thresh=self.hyper_params['iou_thresh'], ignore_thresh=self.hyper_params['ignore_thresh'], alpha=self.hyper_params['alpha'], gamma=self.hyper_params['gamma'], iou_type=self.hyper_params['iou_type'], ) self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust( init_lr=self.optim_cfg['lr'], milestones=self.optim_cfg['milestones'], warm_up_epoch=self.optim_cfg['warm_up_epoch'], iter_per_epoch=len(self.tloader), epochs=self.optim_cfg['epochs'], cosine_weights=self.optim_cfg['cosine_weights'])
import torch from nets.fcos import FCOS from losses.fcos_loss import FCOSLoss from datasets.coco import COCODataSets from torch.utils.data.dataloader import DataLoader if __name__ == '__main__': dataset = COCODataSets(img_root="/home/huffman/data/val2017", annotation_path="/home/huffman/data/annotations/instances_val2017.json", use_crowd=True, augments=True, remove_blank=True, img_size=640 ) dataloader = DataLoader(dataset=dataset, batch_size=4, shuffle=True, num_workers=4, collate_fn=dataset.collate_fn) net = FCOS( backbone="resnet18" ) creterion = FCOSLoss() for img_input, targets, _ in dataloader: _, _, h, w = img_input.shape targets[:, 3:] = targets[:, 3:] * torch.tensor(data=[w, h, w, h]) cls_outputs, reg_outputs, center_outputs, grids = net(img_input) total_loss, detail_loss = creterion(cls_outputs, reg_outputs, center_outputs, grids, targets) cls_loss, reg_loss, center_loss = detail_loss print(total_loss) print(cls_loss, reg_loss, center_loss) break
def __init__(self, cfg_path): with open(cfg_path, 'r') as rf: self.cfg = yaml.safe_load(rf) self.data_cfg = self.cfg['data'] self.model_cfg = self.cfg['model'] self.optim_cfg = self.cfg['optim'] self.val_cfg = self.cfg['val'] print(self.data_cfg) print(self.model_cfg) print(self.optim_cfg) print(self.val_cfg) os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus'] self.gpu_num = len(self.cfg['gpus'].split(',')) dist.init_process_group(backend='nccl') self.tdata = COCODataSets( img_root=self.data_cfg['train_img_root'], annotation_path=self.data_cfg['train_annotation_path'], max_thresh=self.data_cfg['max_thresh'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=True, remove_blank=self.data_cfg['remove_blank']) self.tloader = DataLoader(dataset=self.tdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.tdata.collect_fn, sampler=DistributedSampler( dataset=self.tdata, shuffle=True)) self.vdata = COCODataSets( img_root=self.data_cfg['val_img_root'], annotation_path=self.data_cfg['val_annotation_path'], max_thresh=self.data_cfg['max_thresh'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=False, remove_blank=False) self.vloader = DataLoader(dataset=self.vdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.vdata.collect_fn, sampler=DistributedSampler( dataset=self.vdata, shuffle=False)) print("train_data: ", len(self.tdata), " | ", "val_data: ", len(self.vdata), " | ", "empty_data: ", self.tdata.empty_images_len) print("train_iter: ", len(self.tloader), " | ", "val_iter: ", len(self.vloader)) model = SparseRCNN(**self.model_cfg) self.best_map = 0. optimizer = split_optimizer_v2(model, self.optim_cfg) local_rank = dist.get_rank() self.local_rank = local_rank self.device = torch.device("cuda", local_rank) model.to(self.device) if self.optim_cfg['sync_bn']: model = nn.SyncBatchNorm.convert_sync_batchnorm(model) self.model = nn.parallel.distributed.DistributedDataParallel( model, device_ids=[local_rank], output_device=local_rank) self.scaler = amp.GradScaler( enabled=True) if self.optim_cfg['amp'] else None self.optimizer = optimizer self.ema = ModelEMA(self.model) self.lr_adjuster = IterWarmUpMultiStepDecay( init_lr=self.optim_cfg['lr'], milestones=self.optim_cfg['milestones'], warm_up_iter=self.optim_cfg['warm_up_iter'], iter_per_epoch=len(self.tloader), epochs=self.optim_cfg['epochs'], alpha=self.optim_cfg['alpha'], warm_up_factor=self.optim_cfg['warm_up_factor']) self.cls_loss_logger = AverageLogger() self.l1_loss_logger = AverageLogger() self.iou_loss_logger = AverageLogger() self.match_num_logger = AverageLogger() self.loss_logger = AverageLogger()
def __init__(self, cfg_path): with open(cfg_path, 'r') as rf: self.cfg = yaml.safe_load(rf) self.data_cfg = self.cfg['data'] self.model_cfg = self.cfg['model'] self.optim_cfg = self.cfg['optim'] self.hyper_params = self.cfg['hyper_params'] self.val_cfg = self.cfg['val'] print(self.data_cfg) print(self.model_cfg) print(self.optim_cfg) print(self.hyper_params) print(self.val_cfg) os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus'] dist.init_process_group(backend='nccl') self.tdata = COCODataSets(img_root=self.data_cfg['train_img_root'], annotation_path=self.data_cfg['train_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=True, remove_blank=self.data_cfg['remove_blank'] ) self.tloader = DataLoader(dataset=self.tdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.tdata.collate_fn, sampler=DistributedSampler(dataset=self.tdata, shuffle=True)) self.vdata = COCODataSets(img_root=self.data_cfg['val_img_root'], annotation_path=self.data_cfg['val_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=False, remove_blank=False ) self.vloader = DataLoader(dataset=self.vdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.vdata.collate_fn, sampler=DistributedSampler(dataset=self.vdata, shuffle=False)) print("train_data: ", len(self.tdata), " | ", "val_data: ", len(self.vdata), " | ", "empty_data: ", self.tdata.empty_images_len) print("train_iter: ", len(self.tloader), " | ", "val_iter: ", len(self.vloader)) model = RetinaNet(num_cls=self.model_cfg['num_cls'], anchor_ratios=self.model_cfg['anchor_ratios'], anchor_scales=self.model_cfg['anchor_scales'], anchor_sizes=self.model_cfg['anchor_sizes'], strides=self.model_cfg['strides'], backbone=self.model_cfg['backbone'], ) if self.model_cfg.get("backbone_weight", None): weights = torch.load(self.model_cfg['backbone_weight']) model.load_backbone_weighs(weights) self.best_map = 0. self.best_map50 = 0. optimizer = split_optimizer(model, self.optim_cfg) local_rank = dist.get_rank() self.local_rank = local_rank self.device = torch.device("cuda", local_rank) model.to(self.device) model, optimizer = amp.initialize(model, optimizer, opt_level='O1', verbosity=0) if self.optim_cfg['sync_bn']: model = nn.SyncBatchNorm.convert_sync_batchnorm(model) self.model = nn.parallel.distributed.DistributedDataParallel(model, device_ids=[local_rank], output_device=local_rank) self.optimizer = optimizer self.ema = ModelEMA(self.model) beta = eval(self.hyper_params['beta']) if isinstance(self.hyper_params['beta'], str) \ else self.hyper_params['beta'] self.creterion = ATSSRetinaLoss(top_k=self.hyper_params['top_k'], anchor_per_loc=len(self.model_cfg['anchor_ratios']) * len(self.model_cfg[ 'anchor_scales']), alpha=self.hyper_params['alpha'], gamma=self.hyper_params['gamma'], beta=beta, ) self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust(init_lr=self.optim_cfg['lr'], milestones=self.optim_cfg['milestones'], warm_up_epoch=self.optim_cfg['warm_up_epoch'], iter_per_epoch=len(self.tloader), epochs=self.optim_cfg['epochs'], cosine_weights=self.optim_cfg['cosine_weights'] ) self.tb_writer = None if self.local_rank == 0: log_dir = 'runs/' print('Start Tensorboard with "tensorboard --logdir %s", view at http://localhost:6006/' % log_dir) self.tb_writer = SummaryWriter(log_dir=log_dir)
def __init__(self, cfg_path): with open(cfg_path, 'r') as rf: self.cfg = yaml.safe_load(rf) self.data_cfg = self.cfg['data'] self.model_cfg = self.cfg['model'] self.optim_cfg = self.cfg['optim'] self.val_cfg = self.cfg['val'] print(self.data_cfg) print(self.model_cfg) print(self.optim_cfg) print(self.val_cfg) os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus'] self.gpu_num = len(str(self.cfg['gpus']).split(",")) dist.init_process_group(backend='nccl') self.tdata = COCODataSets( img_root=self.data_cfg['train_img_root'], annotation_path=self.data_cfg['train_annotation_path'], min_thresh=self.data_cfg['min_thresh'], max_thresh=self.data_cfg['max_thresh'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=True, remove_blank=self.data_cfg['remove_blank']) self.tloader = DataLoader(dataset=self.tdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.tdata.collate_fn, sampler=DistributedSampler( dataset=self.tdata, shuffle=True)) self.vdata = COCODataSets( img_root=self.data_cfg['val_img_root'], annotation_path=self.data_cfg['val_annotation_path'], min_thresh=self.data_cfg['min_thresh'], max_thresh=self.data_cfg['max_thresh'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=False, remove_blank=False) self.vloader = DataLoader(dataset=self.vdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.vdata.collate_fn, sampler=DistributedSampler( dataset=self.vdata, shuffle=False)) print("train_data: ", len(self.tdata), " | ", "val_data: ", len(self.vdata), " | ", "empty_data: ", self.tdata.empty_images_len) print("train_iter: ", len(self.tloader), " | ", "val_iter: ", len(self.vloader)) model = DETR(self.model_cfg) self.scaler = amp.GradScaler(enabled=True) self.best_map = 0. self.best_map50 = 0. param_dicts = [ { "params": [ p for n, p in model.named_parameters() if "backbone" not in n and p.requires_grad ] }, { "params": [ p for n, p in model.named_parameters() if "backbone" in n and p.requires_grad ], "lr": self.optim_cfg['backbone_lr'], }, ] optimizer = torch.optim.AdamW( param_dicts, lr=self.optim_cfg['lr'], weight_decay=self.optim_cfg['weight_decay']) local_rank = dist.get_rank() self.local_rank = local_rank self.device = torch.device("cuda", local_rank) model.to(self.device) self.model = nn.parallel.distributed.DistributedDataParallel( model, device_ids=[local_rank], output_device=local_rank) self.optimizer = optimizer self.ema = ModelEMA(self.model) self.lr_adjuster = torch.optim.lr_scheduler.StepLR( optimizer, self.optim_cfg['decay_steps'])
import torch from nets.yolov4 import YOLOV4 from datasets.coco import COCODataSets from torch.utils.data.dataloader import DataLoader from utils.boxs_utils import kmean_anchors if __name__ == '__main__': dataset = COCODataSets( img_root="/home/huffman/data/val2017", annotation_path="/home/huffman/data/annotations/instances_val2017.json", use_crowd=False, augments=True, remove_blank=True, max_thresh=640) dataset.data_list = dataset.box_info_list kmean_anchors(dataset) # 9,14, 26,19, 20,44, 50,39, 45,90, 97,81, 96,195, 204,152, 325,344 # 11,12, 15,34, 36,25, 35,61, 80,56, 66,136, 160,121, 159,269, 394,312 # dataloader = DataLoader(dataset=dataset, batch_size=2, shuffle=True, num_workers=1, collate_fn=dataset.collect_fn) # net = YOLOV4() # for img_input, targets, target_len in dataloader: # out = net(img_input, targets) # break
import torch from nets.solov2 import SOLOv2 from datasets.coco import COCODataSets from torch.utils.data.dataloader import DataLoader from tqdm import tqdm if __name__ == '__main__': dataset = COCODataSets( img_root="/home/huffman/data/coco/val2017", annotation_path= "/home/huffman/data/coco/annotations/instances_val2017.json", use_crowd=True, augments=True, remove_blank=True, max_thresh=768, ) dataloader = DataLoader(dataset=dataset, batch_size=4, shuffle=True, num_workers=1, collate_fn=dataset.collect_fn) net = SOLOv2().eval() for img_input, valid_size, targets, mask, batch_len in dataloader: out = net(img_input, valid_size=valid_size, targets={ "target": targets, "batch_len": batch_len, 'mask': mask }) print(out)
def __init__(self, cfg_path): with open(cfg_path, 'r') as rf: self.cfg = yaml.safe_load(rf) self.data_cfg = self.cfg['data'] self.model_cfg = self.cfg['model'] self.optim_cfg = self.cfg['optim'] self.hyper_params = self.cfg['hyper_params'] self.val_cfg = self.cfg['val'] print(self.data_cfg) print(self.model_cfg) print(self.optim_cfg) print(self.hyper_params) print(self.val_cfg) self.tdata = COCODataSets(img_root=self.data_cfg['train_img_root'], annotation_path=self.data_cfg['train_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=True, remove_blank=self.data_cfg['remove_blank'] ) self.tloader = DataLoader(dataset=self.tdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.tdata.collate_fn, shuffle=True ) self.vdata = COCODataSets(img_root=self.data_cfg['val_img_root'], annotation_path=self.data_cfg['val_annotation_path'], img_size=self.data_cfg['img_size'], debug=self.data_cfg['debug'], use_crowd=self.data_cfg['use_crowd'], augments=False, remove_blank=False ) self.vloader = DataLoader(dataset=self.vdata, batch_size=self.data_cfg['batch_size'], num_workers=self.data_cfg['num_workers'], collate_fn=self.vdata.collate_fn, shuffle=False ) print("train_data: ", len(self.tdata), " | ", "val_data: ", len(self.vdata), " | ", "empty_data: ", self.tdata.empty_images_len) print("train_iter: ", len(self.tloader), " | ", "val_iter: ", len(self.vloader)) model = RetinaNet(num_cls=self.model_cfg['num_cls'], anchor_ratios=self.model_cfg['anchor_ratios'], anchor_scales=self.model_cfg['anchor_scales'], anchor_sizes=self.model_cfg['anchor_sizes'], strides=self.model_cfg['strides'], backbone=self.model_cfg['backbone'], ) # if self.model_cfg.get("backbone_weight", None): # weights = torch.load(self.model_cfg['backbone_weight']) # model.load_backbone_weighs(weights) self.best_map = 0. self.best_map50 = 0. optimizer = split_optimizer(model, self.optim_cfg) self.local_rank = 0 self.device = torch.device("cuda:0") model.to(self.device) self.model = model self.optimizer = optimizer self.ema = ModelEMA(self.model) beta = eval(self.hyper_params['beta']) if isinstance(self.hyper_params['beta'], str) \ else self.hyper_params['beta'] self.creterion = ATSSRetinaLoss(top_k=self.hyper_params['top_k'], anchor_per_loc=len(self.model_cfg['anchor_ratios']) * len(self.model_cfg[ 'anchor_scales']), alpha=self.hyper_params['alpha'], gamma=self.hyper_params['gamma'], beta=beta, ) self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust(init_lr=self.optim_cfg['lr'], milestones=self.optim_cfg['milestones'], warm_up_epoch=self.optim_cfg['warm_up_epoch'], iter_per_epoch=len(self.tloader), epochs=self.optim_cfg['epochs'], cosine_weights=self.optim_cfg['cosine_weights'] )