def run(): step = int(config.get('BASIC_INFO', 'MODEL_STEP')) print('*' * 50) print('step {}'.format(step)) ''' define parameters ''' mal_dir = config.get('PATH', 'MAL_DIR') ben_dir = config.get('PATH', 'BEN_DIR') label_file = config.get('PATH', 'LABEL_FILE') batch_size = int(config.get('CLASSIFIER', 'BATCH_SIZE')) k_fold_value = int(config.get('BASIC_INFO', 'K_FOLD_VALUE')) ''' seperate data using K-fold cross validation ''' mal_data = np.array(walk_dir(mal_dir)) ben_data = np.array(walk_dir(ben_dir)) cv = KFold(n_splits=k_fold_value, shuffle=True, random_state=0) for (train_mal_idx, eval_mal_idx), (train_ben_idx, eval_ben_idx) in zip(cv.split(mal_data), cv.split(ben_data)): ''' load data ''' print('load data') train_data = data.DataLoader(mal_data[train_mal_idx], ben_data[train_ben_idx], batch_size=batch_size, mode='train') eval_data = data.DataLoader(mal_data[eval_mal_idx], ben_data[eval_ben_idx], batch_size=batch_size, mode='evaluate') print('load model') model_dic = { 'epoch': int(config.get('CLASSIFIER', 'EPOCH')), 'gpu_num': int(config.get('CLASSIFIER', 'GPU_NUM')), 'keep_prob': float(1 - float(config.get('CLASSIFIER', 'DROPOUT_PROB'))), 'learning_rate': float(config.get('CLASSIFIER', 'LEARNING_RATE')), 'model_storage': config.get('CLASSIFIER', 'MODEL_STORAGE'), 'model_network': config.get('CLASSIFIER', 'NETWORK'), 'net_input_size': int(config.get('CLASSIFIER', 'INPUT_SIZE')), 'net_output_size': int(config.get('CLASSIFIER', 'OUTPUT_SIZE')), 'net_type': config.get('CLASSIFIER', 'NETWORK') } classifier = model.KISNet(model_num=step, train_data=train_data, eval_data=eval_data, model_dic=model_dic) classifier.train() classifier.evaluate() pass
def train_epoch(epoch, model, optimizer, args): losses = 0.0 dataset = VOCdetection(root=VOC_ROOT) dataloader = data.DataLoader(dataset, args.batch_size, shuffle=False) criteria = myloss(batch_size=args.batch_size) i = 0 batch_num = 0 for (img, gt, width, height) in dataloader: img = Variable(img) labels = Variable(gt) optimizer.zero_grad() # 优化器零梯度 y_pred = model(img) # 数据输入模型得输出 l, a, b, c, d = criteria(y_pred, labels) # 输出与真实值算损失 l.backward() # 损失反向传 optimizer.step() # 优化器走起来 losses += l.data[0] batch_num += 1 writer.add_scalar('loss', l.data.numpy(), batch_num) if l.data.numpy() < 1e-4: break print('No.{} batch || loss is {}'.format(batch_num, l.data[0])) print("Epoch: {}, Ave loss: {}".format(epoch, losses / batch_num)) writer.close() return losses / batch_num
def val(net, criterion): dataset = VOCDetection(None, transform=SSDAugmentation(cfg['min_dim'],MEANS,'val'),phase='val') data_loader = data.DataLoader(dataset, 1,num_workers=1,collate_fn=detection_collate,pin_memory=True) data_size = len(dataset) batch_iterator = iter(data_loader) loss_all = 0 with torch.no_grad(): for step in range(0, data_size): images, targets = next(batch_iterator) images = Variable(images.cuda()) with torch.no_grad(): targets = [ann.cuda() for ann in targets] out = net(images) loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss_all = loss_all + loss.data progress_bar(step, data_size, ' avg loss %.4f' % (loss_all/step)) return loss_all/data_size
def preds_targets_batch(net, dataset, cuda, num_images, batch_size): batch_iterator = iter( data.DataLoader(dataset, batch_size, shuffle=False, collate_fn=detection_collate)) # dump predictions and assoc. ground truth to text file for now #num_images = len(dataset) targs = [] dets = [] for i in trange(num_images): #print('Testing image {:d}/{:d}....'.format(i+1, num_images)) iid, xx, yy = get_iidxy(dataset.ids[i]) images, targets = next(batch_iterator) #print(targets) if len(targets[0]) != 0: t = torch.cat(targets.copy(), 0) t = torch.cat([t[:, 4:], t[:, :4]], 1) t = add_col2(t, 1.0, 1) t = addxy(t, iid, xx, yy).int() targs.append(t) #print(t) x = Variable(images) if cuda: x = x.cuda() y = net(x) # forward pass detections = y.data # scale each detection back up to the image dets.append(get_dets(detections[0], iid, xx, yy)) dets = torch.cat(dets) targs = torch.cat(targs) return dets, targs
def create_dataset(): if args.dataset == 'COCO': if args.dataset_root == VOC_ROOT: if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') print("WARNING: Using default COCO dataset_root because " + "--dataset_root was not specified.") args.dataset_root = COCO_ROOT cfg = coco dataset = COCODetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'VOC': if args.dataset_root == COCO_ROOT: parser.error('Must specify dataset if specifying dataset_root') cfg = voc dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) print('Loading the dataset...') print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) return cfg, data_loader
def print_all_stats(): dl = data.DataLoader(window_size=100, threshold=1.0, algo_name='enhanced', features='comprehensive') for trial_id in trial_sets.top_ids: print("\nStats for trial: {}".format(trial_id)) print_stats(trial_id, dl)
def train(): torch.backends.cudnn.deterministic = True random.seed(1) torch.manual_seed(1) torch.cuda.manual_seed(1) np.random.seed(1) dataset = COCODetection(image_path=cfg.dataset.train_images, info_file=cfg.dataset.train_info, transform=SSDAugmentation(MEANS)) setup_eval() val_dataset = COCODetection(image_path=cfg.dataset.valid_images, info_file=cfg.dataset.valid_info, transform=BaseTransform(MEANS)) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) val_loader = data.DataLoader(val_dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # Parallel wraps the underlying module, but when saving and loading we don't want that # I don't use the timer during training (I use a different timing method). # Apparently there's a race condition with multiple GPUs, so disable it just to be safe. timer.disable_all() criterion = MultiBoxLoss(num_classes=cfg.num_classes, pos_threshold=cfg.positive_iou_threshold, neg_threshold=cfg.negative_iou_threshold, negpos_ratio=cfg.ohem_negpos_ratio) if not os.path.exists('logs'): os.mkdir('logs') compute_validation_loss(data_loader, val_loader, criterion)
def test4(self): cfg = wider dataset = wf.WiderDetection( root="/media/bigtree/DATA/data_ubuntu/wider_face", transform=SSDWiderAugmentation(cfg['min_dim'], MEANS)) epoch_size = len(dataset) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=1, shuffle=True, collate_fn=detection_collate, pin_memory=True) # print(list(map(lambda x: len(x), dataset._bboxes))) batch_iterator = iter(data_loader) ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes']) net = ssd_net if args.cuda: # net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True net = net.cuda() if not args.resume: print('Initializing weights...') ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) ''' run one batch of batch to see if things work ''' images, targets = next(batch_iterator) # targets.data[0] = torch.tensor() if args.cuda: images = Variable(images.cuda()) targets = [Variable(ann.cuda(), volatile=True)\ for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) \ for ann in targets] t0 = time.time() out = net(images) optimizer.zero_grad() # print(out[0].shape, out[1].shape, out[2].shape) loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() print("timer: {} seconds loss {} loc loss {}" " conf loss {}".format(t1 - t0, loss.data[0], loss_l.data[0], loss_c.data[0]))
def main(): # Set up a parser for command line arguments parser = argparse.ArgumentParser("Visualize AFLW dataset (COCO-style annotations)") parser.add_argument('-v', '--verbose', action='store_true', help="increase output verbosity") parser.add_argument('--dataset_root', type=str, required=True, help='AFLW root directory') parser.add_argument('--json', type=str, default='aflw_annotations.json', help="COCO json annotation file") parser.add_argument('--batch_size', type=int, default=4, help="set batch size") parser.add_argument('--dim', type=int, default=300, help="input image dimension") parser.add_argument('-a', '--augment', action='store_true', help="apply augmentations") args = parser.parse_args() # Load AFLW dataset if args.augment: transform = Augmentor(size=args.dim, mean=(92, 101, 113)) else: transform = BaseTransform(size=args.dim, mean=(0, 0, 0)) dataset = AFLW(root=args.dataset_root, json=args.json, transform=transform) # Build data loader data_loader = data.DataLoader(dataset=dataset, batch_size=args.batch_size, num_workers=1, shuffle=True, collate_fn=detection_collate, pin_memory=True) # Build batch iterator batch_iterator = iter(data_loader) try: images, bbox_targets = next(batch_iterator) except StopIteration: batch_iterator = iter(data_loader) images, bbox_targets = next(batch_iterator) # Get images widths and heights and compute scale height = images.size(2) width = images.size(3) scale = torch.Tensor([width, height, width, height]) for i in range(args.batch_size): if args.verbose: print("Image: %d" % i) print("===================================================") img = images[i].numpy().transpose(1, 2, 0).astype(np.uint8).copy() for j in range(len(bbox_targets[i])): # Get object's bounding box and label bbox = bbox_targets[i][j][:4] label = int(bbox_targets[i][j][-1]) pt = (bbox * scale).numpy() cv2.rectangle(img, pt1=(pt[0], pt[1]), pt2=(pt[2], pt[3]), color=(255, 0, 255), thickness=2) if args.verbose: print("\tbbox = ({}, {}, {}, {}) (label = {})".format(int(pt[0]), int(pt[1]), int(pt[2]), int(pt[3]), label)) cv2.imshow("AFLW: {}".format(i), img) cv2.waitKey()
def validate(args, net, criterion, cfg): validation_batch_size = 1 try: # Turn off learning. Go to testing phase net.eval() dataset = GTDBDetection(args, args.validation_data, split='validate', transform=SSDAugmentation(cfg['min_dim'], mean=MEANS)) data_loader = data.DataLoader(dataset, validation_batch_size, num_workers=args.num_workers, shuffle=False, collate_fn=detection_collate, pin_memory=True) total = len(dataset) done = 0 loc_loss = 0 conf_loss = 0 start = time.time() for batch_idx, (images, targets, ids) in enumerate(data_loader): done = done + len(images) logging.debug('processing {}/{}'.format(done, total)) if args.cuda: images = images.cuda() targets = [ann.cuda() for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] y = net(images) # forward pass loss_l, loss_c = criterion(y, targets) loc_loss += loss_l.item() # data[0] conf_loss += loss_c.item() # data[0] end = time.time() logging.debug('Time taken for validation ' + str(datetime.timedelta(seconds=end - start))) return (loc_loss + conf_loss) / (total / validation_batch_size) except Exception as e: logging.error("Could not validate", exc_info=True) return 0
def main(): ssd_net = build_face_ssd('val') net = ssd_net net.load_state_dict( torch.load('./checkpoints/SSD_wFace_matching_0.6_128.pth')) net.eval() dataset = WiderFaceDetection(root='/data00/kangyang/datasets/WIDER_FACE', transform=SimpleTestAugmentation()) data_loader = data.DataLoader(dataset, 1, num_workers=0, shuffle=False, collate_fn=detection_collate, pin_memory=True) cpu = False if not cpu: net = net.cuda() for i_batch, (images, targets) in enumerate(data_loader): if cpu: pass else: with torch.no_grad(): blob = Variable(images.cuda()) targets = [Variable(ann) for ann in targets] y = net(blob) face_detections = y.data[0][1] num_boxes = face_detections.shape[0] count = 0 im = np.transpose(images[0], (1, 2, 0)).numpy().astype(np.uint8) + 128 im = im[:, :, ::-1] im = np.ascontiguousarray(im) im_height, im_width, _ = im.shape for b in range(num_boxes): if face_detections[b, 0] >= 0.3: box = face_detections[b, 1:] x1 = min(im_width, max(0, box[0] * im_width)) y1 = min(im_height, max(0, box[1] * im_height)) x2 = min(im_width, max(0, box[2] * im_width)) y2 = min(im_height, max(0, box[3] * im_height)) im = cv2.rectangle(im, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0)) count += 1 print 'get fgboxes: {}'.format(count) cv2.imwrite('test_{}.png'.format(i_batch), im) if i_batch > 100: break
def __init__(self, args, domain_path): if args.data_aug: augmentation = PitchAugmentation(args) else: augmentation = None self.train_dataset = H5Dataset(args, domain_path / 'train', augmentation=augmentation) self.train_loader = data.DataLoader(self.train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, pin_memory=True) self.train_iter = iter(self.train_loader) self.valid_dataset = H5Dataset(args, domain_path / 'val', augmentation=augmentation) self.valid_loader = data.DataLoader(self.valid_dataset, batch_size=args.batch_size, num_workers=args.num_workers // 10 + 1, pin_memory=True) self.valid_iter = iter(self.valid_loader)
def data_creator(config): # Within a machine, this code runs synchronously. args = config["args"] cfg = config["args"] dataset = get_dataset(config, "train") # cfg["num_classes"] = num_classes data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) data_loader_test = get_dataset(config, "val") return data_loader, data_loader_test
def _load(self): """ Loads the data and model objects """ args = self._args _, self._params = utils.decide_config(args.root, args.name) self._args.name = self._args.name.split("-")[0] data_ = data.Data(args=args) self.num_dev_samples = data_.dev_partition.shape[0] self._device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") dataset = data.InputDataset(input_data=data_, num_neg=data_.num_neg) dev_dataset = data.InputDataset(input_data=data_, num_neg=data_.num_neg, partition="dev") test_dataset = data.InputDataset(input_data=data_, num_neg=data_.num_neg, partition="test") self._loader = data.DataLoader( dataset=dataset, batch_size=self._args.batch) # used for node clustering self._dev_loader = data.DataLoader( dataset=dev_dataset, batch_size=self._args.batch) # used for link prediction self._test_loader = data.DataLoader( dataset=test_dataset, batch_size=self._args.batch ) # used for link prediction and attention visualization self._negative_pairs = data_.negative_pairs self._neighborhood = data_.neighborhood self._mask = data_.neighborhood_mask self._y = None if hasattr(data_, "y"): self._y = data_.y self._model = model.Goat(num_nodes=data_.num_nodes, dim=data_.dim) self._model.to(self._device)
def visualize_all_classifier_results(): trial_ids = trial_sets.top_ids dl = data.DataLoader(window_size=100, threshold=2.0, algo_name='enhanced', features='comprehensive') for trial_id in trial_ids: print("Trial {}".format(trial_id)) training_ids = trial_ids.copy() training_ids.remove(trial_id) visualize_classifier_results(training_ids, trial_id, dl)
def train(): dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation(512, MEANS)) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=0, shuffle=True, collate_fn=detection_collate, pin_memory=False) model = EfficientDet(num_classes=21) model = model.cuda() optimizer = optim.AdamW(model.parameters(), lr=args.lr) criterion = FocalLoss() model.train() iteration = 0 for epoch in range(args.num_epoch): print('Start epoch: {} ...'.format(epoch)) total_loss = [] for idx, sample in enumerate(data_loader): images = sample['img'].cuda() classification, regression, anchors = model(images) classification_loss, regression_loss = criterion( classification, regression, anchors, sample['annot']) classification_loss = classification_loss.mean() regression_loss = regression_loss.mean() loss = classification_loss + regression_loss if bool(loss == 0): continue optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1) optimizer.step() total_loss.append(loss.item()) if (iteration % 100 == 0): print( 'Epoch/Iteration: {}/{}, classification: {}, regression: {}, totol_loss: {}' .format(epoch, iteration, classification_loss.item(), regression_loss.item(), np.mean(total_loss))) iteration += 1 torch.save(model.state_dict(), './weights/checkpoint_{}.pth'.format(epoch))
def create_fingertip_cdf(): THRESHOLD = 2.0 dl = data.DataLoader(window_size=100, threshold=THRESHOLD, algo_name='enhanced', features='comprehensive') fingertip_error = [] csv_file = open(data.GRAPH_CACHE + 'csv-fingertip.csv', 'w') csvwriter = csv.writer(csv_file, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) csvwriter.writerow(['reflective', 'transitive']) for trial_id in trial_sets.top_ids: wrist_oxygen, fingertip_oxygen, transitive_oxygen = dl.load_all_oxygen( trial_id) for oF, oT in zip(fingertip_oxygen, transitive_oxygen): csvwriter.writerow([oF, oT]) fingertip_error.append(np.square(np.subtract(oF, oT))) fingertip_error = np.array(fingertip_error) fingertip_error = fingertip_error[~np.isnan(fingertip_error)] plt.figure() sorted_data = np.sort(fingertip_error) yvals = np.arange(len(sorted_data)) / float(len(sorted_data) - 1) plt.plot(sorted_data, yvals) # plt.legend(['Baseline', 'Enhanced']) plt.ylim(0.0, 1.0) plt.xlabel('RMSE') plt.savefig(data.GRAPH_CACHE + 'cdf-fingertip.pdf') csv_file.close()
def train(): # if args.dataset == 'COCO': # if args.dataset_root == VOC_ROOT: # if not os.path.exists(COCO_ROOT): # parser.error('Must specify dataset_root if specifying dataset') # print("WARNING: Using default COCO dataset_root because " + # "--dataset_root was not specified.") # args.dataset_root = COCO_ROOT # cfg = coco # dataset = COCODetection(root=args.dataset_root, # transform=SSDAugmentation(cfg['min_dim'], # MEANS)) # elif args.dataset == 'VOC': # if args.dataset_root == COCO_ROOT: # parser.error('Must specify dataset if specifying dataset_root') cfg = voc dataset = VOCDetection(root=VOC_ROOT, transform=SSDAugmentation(cfg['min_dim'], MEANS)) epoch_size = len(dataset) // 32 print("epoch size: ", epoch_size) data_loader = data.DataLoader(dataset, 32, num_workers=6, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(data_loader) epoch = 0 for iteration in range(0, 22): if iteration != 0 and (iteration % epoch_size == 0): print("\nepoch: ", epoch) epoch += 1 print("\riteration : %d \t, epoch: %d" % (iteration, epoch), end=' ') # load train data images, targets = next(batch_iterator)
def val(args, net, val_set, optimizer): net.eval() val_loader = data.DataLoader(val_set, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(val_loader) eval_results = [] start_time = time.time() for iteration in range(args.start_iter + args.ft_iter, args.max_iter): try: images, targets, _shape = next(batch_iterator) except StopIteration: batch_iterator = iter(val_loader) images, targets, _shape = next(batch_iterator) images = Variable(images.cuda()) targets = [Variable(ann.cuda(), volatile=True) for ann in targets] out1, out2 = net(images, deform_map=False, test=False) detections, reg_boxes = out1 eval_result = evaluate(images, detections.data, targets, iteration, 0.1, visualize=False, post_combine=True) eval_results.append(eval_result) eval_results = list(map(list, zip(*eval_results))) print( " --- accuracy=%.4f, precision=%.4f, recall=%.4f, f1-score=%.4f, cost %.2f seconds ---" % (avg(eval_results[0]), avg(eval_results[1]), avg( eval_results[2]), avg(eval_results[3]), time.time() - start_time))
def test2(self): cfg = wider dataset = wf.WiderDetection( root="/media/bigtree/DATA/data_ubuntu/wider_face", transform=SSDWiderAugmentation(cfg['min_dim'], MEANS)) epoch_size = len(dataset) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=1, shuffle=True, collate_fn=detection_collate, pin_memory=True) batch_iterator = iter(data_loader) img, targets = next(batch_iterator) img1 = img[0].numpy() # print(targets[0].numpy()) # print(img1.shape) img1 = np.transpose(img1, (1, 2, 0)) img1 = (img1 / 122 + 1.0) / 2 cv2.imshow('img', img1) cv2.waitKey(0) # print(img1.shape) # img1 = (img1/122 + 1.0) / 2 show_img_ = np.ascontiguousarray(img1) print(targets[0].numpy() * 300) for box in targets[0].numpy(): box = box * 300 xlb, ylb = box[0], box[1] xrt, yrt = box[2], box[3] cv2.rectangle(show_img_, (int(xlb), int(ylb)), (int(xrt), int(yrt)), (0, 0, 0), thickness=1) cv2.imshow('show_img', show_img_) cv2.waitKey(0) print(img.shape)
def train(): if args.dataset == 'VOC': cfg = voc dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation(cfg['min_dim'], MEANS)) print("Minimum number of dimensions", cfg['min_dim']) print("Number of classes", cfg['num_classes']) if args.visdom: import visdom viz = visdom.Visdom() ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes']) net = ssd_net if args.cuda: net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume: print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume) ssd_net.conf.apply(weights_init) else: vgg_weights = torch.load(args.save_folder + args.basenet) print('Loading base network...') ssd_net.vgg.load_state_dict(vgg_weights) if args.cuda: net = net.cuda() if not args.resume: print('Initializing weights...') # initialize newly added layers' weights with xavier method ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) net.train() # loss counters loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading the dataset...') epoch_size = len(dataset) // args.batch_size print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) step_index = 0 if args.visdom: vis_title = 'SSD.PyTorch on ' + dataset.name vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss'] iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend) epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(data_loader) for iteration in range(args.start_iter, cfg['max_iter']): if args.visdom and iteration != 0 and (iteration % epoch_size == 0): update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None, 'append', epoch_size) # reset epoch loss counters loc_loss = 0 conf_loss = 0 epoch += 1 if iteration in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) # load train data try: images, targets = next(batch_iterator) except StopIteration: batch_iterator = iter(data_loader) images, targets = next(batch_iterator) if args.cuda: images = Variable(images.cuda()) targets = [Variable(ann.cuda(), volatile=True) for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] # forward t0 = time.time() out = net(images) # backprop optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() loc_loss += loss_l.item() conf_loss += loss_c.item() if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.item()), end=' ') if args.visdom: update_vis_plot(iteration, loss_l.item(), loss_c.item(), iter_plot, epoch_plot, 'append') if iteration != 0 and iteration % 50 == 0: print('Saving state, iter:', iteration) torch.save(ssd_net.state_dict(), 'weights/ssd300_COCO_' + repr(iteration) + '.pth') torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): # #torch.cuda.set_device(1) if args.dataset == 'COCO': if args.dataset_root == VOC_ROOT: if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') print("WARNING: Using default COCO dataset_root because " + "--dataset_root was not specified.") args.dataset_root = COCO_ROOT cfg = coco dataset = COCODetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'VOC': #if args.dataset_root == VOC_ROOT: # parser.error('Must specify dataset if specifying dataset_root') cfg = voc dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'SSDD': print('root is SSDD') cfg = ssdd dataset = SSDDDetection(root=args.dataset_root, split='train', transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'GFPlane': print('root is GFPlane') cfg = gfplane dataset = GFPlaneDetection(root=args.dataset_root, split='train', transform=GFPlaneAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'CasiaShip': print('root is CasiaShip') cfg = casiaship dataset = ShipDetection(root=args.dataset_root, split='train', transform=GFPlaneAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'BigShip': print('root is Bigship') cfg = casiaBigship dataset = BigShipDetection(root=args.dataset_root, split='train', transform=GFPlaneAugmentation( cfg['min_dim'], MEANS)) if args.visdom: import visdom viz = visdom.Visdom() ssd_net = build_ssd('train', cfg, cfg['min_dim'], cfg['num_classes']) #ssd_net = build_ssd('train',cfg, cfg['min_dim'], cfg['num_classes']) #import pdb;pdb.set_trace() net = ssd_net if args.cuda: net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume: print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume) else: vgg_weights = torch.load(args.save_folder + args.basenet) #import pdb;pdb.set_trace() print('Loading base network...') ssd_net.vgg.load_state_dict(vgg_weights) if args.cuda: net = net.cuda() #import pdb;pdb.set_trace() if not args.resume: print('Initializing weights...') # initialize newly added layers' weights with xavier method ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) criterion = MultiBoxLoss_noobj(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) net.train() # loss counters loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading the dataset...') epoch_size = len(dataset) // args.batch_size print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) step_index = 0 if args.visdom: vis_title = 'SSD.PyTorch on ' + dataset.name vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss'] iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend) epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(data_loader) epoch = 0 epoch_iter = 0 for iteration in range(args.start_iter, cfg['max_iter']): if args.visdom and iteration != 0 and (iteration % epoch_size == 0): update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None, 'append', epoch_size) # reset epoch loss counters loc_loss = 0 conf_loss = 0 epoch_iter = 0 epoch += 1 if iteration in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) #import pdb;pdb.set_trace() # load train data try: images, targets = next(batch_iterator) except StopIteration: print('next batch') print('batch local loss: {}\nbatch conf loss:{}\n'.format( loc_loss, conf_loss)) batch_iterator = iter(data_loader) images, targets = next(batch_iterator) loc_loss = 0 conf_loss = 0 epoch = epoch + 1 epoch_iter = 0 print('\nepoch: {} ,dataset trained finished!'.format(epoch)) #import pdb;pdb.set_trace() if args.cuda: images = Variable(images.to("cuda")) targets = [Variable(ann.cuda(), volatile=True) for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] #import pdb;pdb.set_trace() # forward #import pdb;pdb.set_trace() epoch_iter += 1 t0 = time.time() out = net(images) # backprop optimizer.zero_grad() #import pdb;pdb.set_trace() loss_l, loss_c = criterion(out, targets) #import pdb;pdb.set_trace() loss = loss_l + loss_c #print('') loss.backward() optimizer.step() t1 = time.time() loc_loss += loss_l.item() conf_loss += loss_c.item() #print('iter ' + repr(iteration) + ' || Loss: %.4f ||' %(loss.item())+\ # ' || Loss_l: %.4f' %(loss_l.item())+' || Loss_c: %.4f'%(loss_c.item())) if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) print('epoch: %d || '%(epoch),' iter ' + repr(iteration) + ' || '+str(epoch_iter)+'/'+str(len(batch_iterator))+' || Loss: %.4f ||' %(loss.item())+\ ' || Loss_l: %.4f' %(loss_l.item())+' || Loss_c: %.4f'%(loss_c.item()), end=' ') if args.visdom: update_vis_plot(iteration, loss_l.data[0], loss_c.data[0], iter_plot, epoch_plot, 'append') if iteration != 0 and iteration % 5000 == 0: print('Saving state, iter:', iteration) save_path = 'weights/ssd512_Airbus512_' + repr(iteration) + '.pth' torch.save(ssd_net.state_dict(), save_path) test_online(save_path, cfg, loss, 'cut') torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): ''' get the dataset and dataloader ''' print(args.dataset) if args.dataset == 'COCO': if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') cfg = coco dataset = COCODetection(root=COCO_ROOT, transform=SSDAugmentation( cfg['min_dim'], MEANS), filename='train.txt') elif args.dataset == 'VOC': if not os.path.exists(VOC_ROOT): parser.error('Must specify dataset_root if specifying dataset') cfg = voc dataset = VOCDetection(root=VOC_ROOT, transform=SSDAugmentation(cfg['min_dim'], mean=cfg['mean'], std=cfg['std'])) print(len(dataset)) elif args.dataset == 'LAJI': if not os.path.exists(LAJI_ROOT): parser.error('Must specify dataset_root if specifying dataset') cfg = laji_se_resnext101_32x4d dataset = LAJIDetection(root=LAJI_ROOT, transform=SSDAugmentation(cfg['min_dim'], mean=cfg['mean'], std=cfg['std'])) print(len(dataset)) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # build, load, the net ssd_net = build_ssd('train', size=cfg['min_dim'], cfg=cfg) ''' for name,param in ssd_net.named_parameters(): if param.requires_grad: print(name) ''' start_iter = args.start_iter if args.resume: print('Resuming training, loading {}...'.format(args.resume)) data_tmp = torch.load(args.resume) data_tmp = {k.lstrip("module."): v for k, v in data_tmp.items()} ssd_net.load_state_dict(data_tmp) start_iter = int(args.resume.split("/")[-1].split("_")[-2]) print("start_iter is {}".format(start_iter)) if args.cuda: net = ssd_net.cuda() # net = torch.nn.DataParallel(net) net.train() #optimizer optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optimizer = torch.optim.AdamW(net.parameters(), args.lr) #loss:SmoothL1\Iou\Giou\Diou\Ciou print(cfg['losstype']) criterion = MultiBoxLoss(cfg=cfg, overlap_thresh=0.5, prior_for_matching=True, bkg_label=0, neg_mining=True, neg_pos=3, neg_overlap=0.5, encode_target=False, use_gpu=args.cuda, loss_name=cfg['losstype']) project_name = "_".join([args.net_name, args.config]) pth_path = os.path.join(args.save_path, project_name) log_path = os.path.join(pth_path, 'tensorboard') os.makedirs(pth_path, exist_ok=True) os.makedirs(log_path, exist_ok=True) writer = SummaryWriter( log_path + f'/{datetime.datetime.now().strftime("%Y%m%d-%H%M%S")}/') epoch_size = len(dataset) // args.batch_size print('Training SSD on:', dataset.name, epoch_size) iteration = args.start_iter step_index = 0 loc_loss = 0 conf_loss = 0 step = 0 num_iter_per_epoch = len(data_loader) lr_need_steps = list(cfg['lr_steps']) for epoch in range(start_iter, args.max_epoch): progress_bar = tqdm(data_loader) for ii, batch_iterator in enumerate(progress_bar): iteration += 1 if step in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, epoch, step_index, iteration, num_iter_per_epoch) # load train data images, targets = batch_iterator # print(images,targets) if args.cuda: images = images.cuda() targets = [ann.cuda() for ann in targets] else: images = images targets = [ann for ann in targets] t0 = time.time() out = net(images, 'train') optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = weight * loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() loc_loss += loss_l.item() conf_loss += loss_c.item() progress_bar.set_description( 'Step: {}. Epoch: {}/{}. Iteration: {}/{}. Cls loss: {:.5f}. Reg loss: {:.5f}. Total loss: {:.5f}' .format(step, epoch, args.max_epoch, ii + 1, num_iter_per_epoch, loss_c.item(), loss_l.item(), loss.item())) writer.add_scalars('Loss', {'train': loss}, step) writer.add_scalars('Regression_loss', {'train': loss_l.item()}, step) writer.add_scalars('Classfication_loss', {'train': loss_c.item()}, step) current_lr = optimizer.param_groups[0]['lr'] writer.add_scalar('learning_rate', current_lr, step) # print(iteration) # if iteration % 10 == 0: # print('timer: %.4f sec.' % (t1 - t0)) # print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.item()), end=' ') step += 1 # if epoch % 10 == 0 and epoch >60: # # epoch>1000 and epoch % 50 == 0: # print('Saving state, iter:', iteration) # #print('loss_l:'+weight * loss_l+', loss_c:'+'loss_c') # save_folder = args.work_dir+cfg['work_name'] # if not os.path.exists(save_folder): # os.mkdir(save_folder) # torch.save(net.state_dict(),args.work_dir+cfg['work_name']+'/ssd'+ # repr(epoch)+'_.pth') if step != 0 and step % 4000 == 0: torch.save( net.state_dict(), os.path.join(pth_path, f'{args.net_name}_{epoch}_{step}.pth')) loc_loss = 0 conf_loss = 0 torch.save(net.state_dict(), os.path.join(pth_path, f'{args.net_name}_{epoch}_{step}.pth'))
def train(): if args.dataset == 'COCO': if args.dataset_root == VOC_ROOT: if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') print("WARNING: Using default COCO dataset_root because " + "--dataset_root was not specified.") args.dataset_root = COCO_ROOT cfg = coco dataset = COCODetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'VOC': if args.dataset_root == COCO_ROOT: parser.error('Must specify dataset if specifying dataset_root') cfg = voc dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'OPIXray': print('\nXray\n') cfg = OPIXray dataset = OPIXrayDetection(root=args.dataset_root, image_sets=args.image_sets, phase='train') ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes']) #ssd_net = build_ssd('train', cfg['min_dim'], 21) net = ssd_net print(ssd_net) if args.cuda: net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume: print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume) else: if not args.transfer: vgg_weights = torch.load(args.save_folder + args.basenet) print('Loading base network...') ssd_net.vgg.load_state_dict(vgg_weights) else: print('Transfer learning...') ssd_net.load_weights(args.transfer, isStrict=False) ssd_net._conf.apply(weights_init) ssd_net._modules['vgg'][0] = nn.Conv2d(4, 64, kernel_size=3, padding=1) ''' pretrained_dict = torch.load(args.transfer) model_dict = ssd_net.state_dict() pretrained_dict = transfer_state_dict(pretrained_dict, model_dict) model_dict.update(pretrained_dict) # 更新(合并)模型的参数 ssd_net = ssd_net.load_state_dict(model_dict) ''' ''' pretrained_dict = torch.load(args.transfer) model_dict = ssd_net.state_dict() pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict and (k != 'vgg.33.weight') and (k != 'extras.0.weight') and (k != 'extras.2.weight') and (k != 'extras.4.weight') and (k != 'extras.6.weight')} # filter out unnecessary keys model_dict.update(pretrained_dict) ssd_net.load_state_dict(model_dict) nn.init.xavier_uniform_(ssd_net.vgg[33].weight) ''' #ssd_net.vgg[33] if args.cuda: net = net.cuda() if (not args.resume) & (not args.transfer): print('Initializing weights...') # initialize newly added layers' weights with xavier method ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net._conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) net.train() # loss counters loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading the dataset...') epoch_size = len(dataset) // args.batch_size print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) step_index = 0 if args.visdom: vis_title = 'SSD on ' + dataset.name + '\n' + start_time vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss'] iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend) epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(data_loader) for iteration in range(args.start_iter, cfg['max_iter']): if iteration != 0 and (iteration % epoch_size == 0): epoch += 1 #update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None, # 'append', epoch_size) # reset epoch loss counters loc_loss = 0 conf_loss = 0 if epoch % 5 == 0: print('Saving state, epoch:', epoch) #torch.save(ssd_net.state_dict(), args.save_folder + '/ssd300_SIXray_' + # repr(epoch) + '.pth') torch.save( ssd_net.state_dict(), args.save_folder + '/ssd300_Xray_knife_' + repr(epoch) + '.pth') if iteration in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) # load train data print('iteration:', iteration) try: images, targets = next(batch_iterator) except: batch_iterator = iter(data_loader) images, targets = next(batch_iterator) print('Reload!') if args.cuda: images = Variable(images.cuda()) targets = [Variable(ann.cuda(), volatile=True) for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] # forward images = images.type(torch.FloatTensor) t0 = time.time() out = net(images) # backprop optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() loc_loss += loss_l.item() conf_loss += loss_c.item() if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.item()), end=' ') if args.visdom: update_vis_plot(iteration, loss_l.item(), loss_c.item(), iter_plot, epoch_plot, 'append') torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): if args.dataset == 'COCO': if args.dataset_root == VOC_ROOT: if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') print("WARNING: Using default COCO dataset_root because " + "--dataset_root was not specified.") args.dataset_root = COCO_ROOT cfg = coco dataset = COCODetection(root=args.dataset_root, transform=SSDAugmentation(cfg['min_dim'], MEANS)) elif args.dataset == 'VOC': if args.dataset_root == COCO_ROOT: parser.error('Must specify dataset if specifying dataset_root') cfg = voc dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation(cfg['min_dim'], MEANS)) if args.visdom: import visdom viz = visdom.Visdom() ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes']) net = ssd_net if args.cuda: net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume: print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume) else: vgg_weights = torch.load(args.save_folder + args.basenet) print('Loading base network...') ssd_net.vgg.load_state_dict(vgg_weights) if args.cuda: net = net.cuda() if not args.resume: print('Initializing weights...') # initialize newly added layers' weights with xavier method ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) now_time = (datetime.datetime.now() + datetime.timedelta(hours=8)).strftime('%Y-%m-%d-%H-%M') writer = SummaryWriter("runs/" + now_time[5:]) print('Loading the dataset...') epoch_size = len(dataset) // args.batch_size print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) net.train() # loss counters loc_loss = 0 conf_loss = 0 loc_loss_epoch = 0.0 conf_loss_epoch = 0.0 total_loss_epoch = 0.0 # create batch iterator step_index = 0 iteration = 0 max_epoches = int(cfg["max_iter"] / epoch_size) for epoch in range(int(max_epoches+1)): t0 = time.time() for images, targets in data_loader: iteration += 1 if iteration in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) if args.cuda: images = images.cuda() for i in range(len(targets)): targets[i] = targets[i].float().cuda() else: images = images targets = targets # forward out = net(images) # backprop optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() loc_loss += loss_l.item() conf_loss += loss_c.item() loc_loss_epoch += loss_l.item() conf_loss_epoch += loss_c.item() total_loss_epoch += loss.item() writer.add_scalar("loss/total_loss_iterations", loss.item(), iteration) if iteration % epoch_size == 0: writer.add_scalar("loss/loc_loss", loc_loss_epoch / len(dataset), epoch) writer.add_scalar("loss/conf_loss", conf_loss_epoch / len(dataset), epoch) writer.add_scalar("loss/total_loss", total_loss_epoch / len(dataset), epoch) loc_loss_epoch = 0.0 conf_loss_epoch = 0.0 total_loss_epoch = 0.0 if iteration % 10 == 0: t1 = time.time() print('Every 10 iterations timer: %.4f sec.' % (t1 - t0)) print('iter [' + repr(iteration + 1) + "/" + str(cfg["max_iter"]) + '] ||' + 'epoch [' + str(epoch+1) + "/" + str(max_epoches) + "] ||" + 'Batch-Loss: %.4f ||' % (loss.item()), end=' ') t0 = time.time() if iteration % 5000 == 0: print('Saving state, iter:', iteration) torch.save(ssd_net.state_dict(), 'weights/ssd300_voc_pf_' + repr(iteration+1) + '.pth') torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): args.dataset = 'VOC' args.resume = 'vocinit' args.batch_size = 16 args.num_workers = 2 ssd_net = build_ssd(cfg['min_dim'], cfg['num_classes']) net = ssd_net net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume == 'vocinit': args.resume = 'weights/base/ssd_300_VOC0712.pth' print('Resuming training, loading {}...'.format(args.resume)) ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) ssd_net.load_weights(args.resume, True) elif args.resume == 'ours': args.resume = 'weights/VOC.pth' print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume, False) else: #random init ssd_net.vgg.apply(weights_init) ssd_net.extras.apply(weights_init) ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) net = net.cuda() optimizer = optim.Adam(net.parameters(), lr=args.lr) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, 3) net.train() valloss = 10000000000 start_time = time.time() for epoch in range(0,4): dataset = VOCDetection(None, transform=SSDAugmentation(cfg['min_dim'],MEANS), phase = 'train') data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers,collate_fn=detection_collate, pin_memory=True) print('epoch ',epoch) loss_all = 0 if epoch <= 1: args.lr = 0.0001 set_lr(args.lr,optimizer) elif epoch == 2: args.lr = 0.00001 set_lr(args.lr,optimizer) print('learning rate:', args.lr) for iteration, (images,targets) in enumerate(data_loader): images, targets = remove_redudant(images,targets) images = Variable(images.cuda()) with torch.no_grad(): targets = [ann.cuda() for ann in targets] out = net(images) optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() loss_all = loss_all + loss.data if iteration % 500 == 0: print('iter %4d'%iteration, ' || Loss: %2.4f ||' % (loss.data)) if iteration % 2000 == 0 and iteration > 0: print("---total training time: %s seconds ---" % (time.time() - start_time)) curloss = val(net, criterion) if valloss > curloss: torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset +'.pth') valloss = curloss print('model saved')
def train(): if args.dataset == 'COCO': if args.dataset_root == VOC_ROOT: if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') print("WARNING: Using default COCO dataset_root because " + "--dataset_root was not specified.") args.dataset_root = COCO_ROOT cfg = coco dataset = COCODetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'VOC': if args.dataset_root == COCO_ROOT: parser.error('Must specify dataset if specifying dataset_root') cfg = voc_ssd7 dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) if args.visdom: import visdom viz = visdom.Visdom() ssd_net = build_ssd7('train', cfg['num_classes']) print(ssd_net) net = ssd_net if args.cuda: net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume: print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume) # else: # mobilenet_weights = torch.load(args.save_folder + args.basenet) # print('Loading base network...') # ssd_net.mobilenet.load_state_dict(mobilenet_weights) if args.cuda: net = net.cuda() if not args.resume: print('Initializing weights...') # initialize newly added layers' weights with xavier method ssd_net.loc.apply(weights_init) ssd_net.conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optimizer = optim.Adam(net.parameters(), lr=args.lr) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) net.train() # loss counters loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading the dataset...') # args.batch_size = 64 epoch_size = len(dataset) // args.batch_size print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) step_index = 0 if args.visdom: vis_title = 'SSD.PyTorch on ' + dataset.name vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss'] iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend) epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(data_loader) for iteration in range(args.start_iter, cfg['max_iter']): if args.visdom and iteration != 0 and (iteration % epoch_size == 0): update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None, 'append', epoch_size) # reset epoch loss counters loc_loss = 0 conf_loss = 0 epoch += 1 if iteration in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) # load train data # images, targets = next(batch_iterator) try: images, targets = next(batch_iterator) except StopIteration: batch_iterator = iter(data_loader) images, targets = next(batch_iterator) if args.cuda: # images = Variable(images.cuda()) # targets = [Variable(ann.cuda(), volatile=True) for ann in targets] images = images.cuda() targets = [ann.cuda() for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] # forward t0 = time.time() # print(images) out = net(images) # backprop optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() # loc_loss += loss_l.data[0] # conf_loss += loss_c.data[0] loc_loss += loss_l.data conf_loss += loss_c.data if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) # print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.data[0]), end=' ') print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.data), end=' ') if args.visdom: # update_vis_plot(iteration, loss_l.data[0], loss_c.data[0], # iter_plot, epoch_plot, 'append') update_vis_plot(iteration, loss_l.data, loss_c.data, iter_plot, epoch_plot, 'append') if iteration != 0 and iteration % 5000 == 0: print('Saving state, iter:', iteration) torch.save(ssd_net.state_dict(), 'weights/ssd7_VOC_' + repr(iteration) + '.pth') torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): if args.dataset == 'COCO': if args.dataset_root == VOC_ROOT: if not os.path.exists(COCO_ROOT): parser.error('Must specify dataset_root if specifying dataset') print("WARNING: Using default COCO dataset_root because " + "--dataset_root was not specified.") args.dataset_root = COCO_ROOT cfg = coco dataset = COCODetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) elif args.dataset == 'VOC': if args.dataset_root == COCO_ROOT: parser.error('Must specify dataset if specifying dataset_root') cfg = voc dataset = VOCDetection(root=args.dataset_root, transform=SSDAugmentation( cfg['min_dim'], MEANS)) net = EfficientDet(num_class=cfg['num_classes']) if args.cuda: net = net.cuda() # if args.cuda: # net = torch.nn.DataParallel(net) # cudnn.benchmark = True optimizer = optim.AdamW(net.parameters(), lr=args.lr) criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) net.train() iteration = 0 for epoch in range(args.num_epoch): print('\n Start epoch: {} ...'.format(epoch)) for idx, (images, targets) in enumerate(data_loader): if args.cuda: images = Variable(images.cuda()) targets = [ Variable(ann.cuda(), volatile=True) for ann in targets ] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] # forward t0 = time.time() out = net(images) optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss), end=' ') if iteration != 0 and iteration % 5000 == 0: print('Saving state, iteration:', iteration) torch.save(net.state_dict(), 'weights/Effi' + repr(idx) + '.pth') iteration += 1 torch.save(net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): #加载icdar数据 dataset = icdar_dataset.ICDARData(root=DATAROOT, img_path=IMG_PATH, txt_path=TXT_PATH) # if args.visdom: # import visdom # viz = visdom.Visdom() tb_net = build_tb('train') net = tb_net if args.cuda: net = torch.nn.DataParallel(tb_net) cudnn.benchmark = True #是否从上次训练的断点处继续训练 if args.resume: print('Resuming training, loading {}...'.format(args.resume)) tb_net.load_weights(args.resume) else: vgg_weights = torch.load(args.save_folder + args.basenet) print('Loading base network...') tb_net.vgg.load_state_dict(vgg_weights) if args.cuda: net = net.cuda() if not args.resume: print('Initializing weights...') # initialize newly added layers' weights with xavier method tb_net.extras.apply(weights_init) tb_net.loc.apply(weights_init) tb_net.conf.apply(weights_init) optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) criterion = MultiBoxLoss(cfg['num_class'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) net.train() # loss counters loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading the dataset...') epoch_size = len(dataset) // args.batch_size # print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) step_index = 0 # if args.visdom: # vis_title = 'SSD.PyTorch on ' + dataset.name # vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss'] # iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend) # epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend) data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=True, collate_fn=detection_collate, pin_memory=True) # create batch iterator batch_iterator = iter(data_loader) for iteration in range(args.start_iter, cfg['max_iter']): # if args.visdom and iteration != 0 and (iteration % epoch_size == 0): # update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None, # 'append', epoch_size) # # reset epoch loss counters # loc_loss = 0 # conf_loss = 0 # epoch += 1 if iteration in cfg['lr_steps']: step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) # load train data #images, targets = next(batch_iterator) #print('images:', images) try: images, targets = next(batch_iterator) except StopIteration: batch_iterator = iter(data_loader) images, targets = next(batch_iterator) except Exception as e: print("loading dta exception", e) #print(images.type()) if args.cuda: images = Variable(images.cuda()) with torch.no_grad(): targets = [Variable(ann.cuda()) for ann in targets] else: images = Variable(images) with torch.no_grad(): targets = [Variable(ann) for ann in targets] # forward t0 = time.time() #print(images.type()) out = net(images) # backprop optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() # print('loss_l:', loss_l) # print('loss_c:', loss_c) # loc_loss += loss_l.data.item() # conf_loss += loss_c.data.item() loc_loss += loss_l conf_loss += loss_c if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.data.item()), end=' ') # if args.visdom: # update_vis_plot(iteration, loss_l.data[0], loss_c.data[0], # iter_plot, epoch_plot, 'append') if iteration != 0 and iteration % 5000 == 0: print('Saving state, iter:', iteration) torch.save(tb_net.state_dict(), 'weights/tb_ICDAR_' + repr(iteration) + '.pth') torch.save(tb_net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train(): cfg = voc # voc是一个字典 里面包括网络的一系列参数信息 dataset = VOCDetection( # 是一个VOC数据的类 root=args.dataset_root, # 数据集的根目录 transform=SSDAugmentation( cfg['min_dim'], MEANS)) # 图片的预处理方法(输入图片的尺寸和均值) 原本类中定义为None 后面的MEANS我人为可以删除 if args.visdom: # 这里是可视化工具,不用管################### import visdom viz = visdom.Visdom() ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes']) # 阶段【train or test】 输入图片尺寸大小 类别数 # build_ssd是一个放在ssd.py的函数 # return是一个类的对象,也就是class SSD(nn.Module),ssd_net也就是SSD类的一个对象 # ssd_net拥有所有class SSD继承于nn.Module以及作者增加方法的所有属性 # 在SSD这个类中就定义了网络的base部分(修改全连接层后的VGG16)和extras部分(论文作者加入的多尺度feature map)和head部分 # 对选定的6个尺度下的feature map进行卷积操作得到的每个default box 的每一个分类类别的confidence以及位置坐标的信息 net = ssd_net # 到这里class类SSD只完成了__init__()并没有执行__forward__() net是一个类 if args.cuda: # 是否将模型放到多个个GPU上运行{我认为在我的任务中不要放在多线程GPU中} net = torch.nn.DataParallel(ssd_net) cudnn.benchmark = True if args.resume: # 【resume】的默认值是None,表示不是接着某个断点来继续训练这个模型 【其实checkpoint里面最好还要加上优化器的保存】 # 【model_state_dict,optimizer_state_dict,epoch】 见深度之眼 print('Resuming training, loading {}...'.format(args.resume)) ssd_net.load_weights(args.resume) else: # 那么就从weights文件夹下面直接加载预训练好vgg基础网络预训练权重 vgg_weights = torch.load(args.save_folder + args.basenet) # 整个ssd_net中vgg基础网络的权重 print('Loading base network...') ssd_net.vgg.load_state_dict( vgg_weights ) # 只在整个ssd_net中的vgg模块中加载预训练好的权重,其余的extra,特征融合,CBAM模块没有加载预训练权重 if args.cuda: # 将模型结构放在GPU上训练 net = net.cuda() if not args.resume: # ###################################################################### print('Initializing weights...' ) # 如果不是接着某个断点接着训练,那么其余extras loc con都会xavier方法初始化 # initialize newly added layers' weights with xavier method ssd_net.extras.apply( weights_init) # extras 模块由 xavier 方法默认初始化data和bias ssd_net.loc.apply(weights_init) # loc 模块由 xavier 方法默认初始化data和bias ssd_net.conf.apply(weights_init) # conf 模块由 xavier 方法默认初始化data和bias # 【优化器】net.parameters()是网络结构中的参数,学习率,动量,权重衰减率 optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # 定义损失函数部分【MultiBoxesLoss是一个类用于计算网络的损失,criterion是一个对象】 # 【损失函数】 关键!!! criterion是个nn.Moudule的形式 里面包括两部分loss_c 和 loss_l criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5, False, args.cuda) # 前向传播 net.train() # loss counters loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading the dataset...') epoch_size = len(dataset) // args.batch_size # 每个epoch中有多少个batch print('Training SSD on:', dataset.name) print('Using the specified args:') print(args) # 讲设定的参数打印出来 step_index = 0 # 可视化部分 if args.visdom: # 默认值为False vis_title = 'SSD.PyTorch on ' + dataset.name vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss'] iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend) epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend) data_loader = data.DataLoader( dataset, args.batch_size, num_workers=args.num_workers, # 默认值我修改成了0 shuffle=True, collate_fn=detection_collate, # collate_fn将一个batch_size数目的图片进行合并成batch pin_memory=True) batch_iterator = iter(data_loader) # batch迭代器 依次迭代batch for iteration in range(args.start_iter, cfg['max_iter']): # 由最大迭代次数来迭代训练 if args.visdom and iteration != 0 and ( iteration % epoch_size == 0): # 因为args.visdom一直设置为False因此没有被调用 update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None, 'append', epoch_size) # reset epoch loss counters loc_loss = 0 conf_loss = 0 epoch += 1 if iteration in cfg['lr_steps']: # 通过多少次epoch调节一次学习率 step_index += 1 adjust_learning_rate(optimizer, args.gamma, step_index) # load train data try: images, targets = next(batch_iterator) # targets 和image都是读取的训练数据 except StopIteration: bath_iterator = iter(data_loader) images, targets = next(bath_iterator) # images=【batch_size,3,300,300】 # targets=【batch_size,num_object,5】 # num_object代表一张图里面有几个ground truth,5代表四个位置信息和一个label if args.cuda: # 将数据放在cuda上 images = Variable(images.cuda()) targets = [Variable(ann.cuda(), volatile=True) for ann in targets] else: images = Variable(images) targets = [Variable(ann, volatile=True) for ann in targets] # forward t0 = time.time() # ##out是netforward的输出:是个元组,里面包括3个部分[loc conf priors] out = net(images) # ## backprop 优化器梯度清零 optimizer.zero_grad() # ## criterion是nn.Module形式,下面是调用它的forward模式【重点看,里面包括难例挖掘的内容】 # ###################################【【【训练阶段的损失!!!】】】###################################### # ##输入参数1:网络结构net输出的out:[loc conf priors] # ##输入参数2:targets:真实目标的位置标签值 loss_l, loss_c = criterion( out, targets ) # criterion就是MultiBoxLoss类定义的对象,forward前传播返回的结果是【loss_l, loss_c】 loss = loss_l + loss_c # 总loss loss.backward() optimizer.step() t1 = time.time() # 下面两行好像没有使用 loc_loss += loss_l.data # ###到底是改成item()还是data conf_loss += loss_c.data # ###到底是改成item()还是data if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % loss.data, end=' ') # 到底是改成item()还是data if args.visdom: update_vis_plot(iteration, loss_l.data, loss_c.data, iter_plot, epoch_plot, 'append') if iteration != 0 and iteration % 500 == 0: # 迭代多少次保存一次模型。 在尝试阶段,为了节省时间,建议将根据迭代次数保存模型的参数调低,例如调节到500 print('Saving state, iter:', iteration) # 保存的checkpoint torch.save(ssd_net.state_dict(), 'weights/ssd300_VOC_' + repr(iteration) + '.pth') # 保存模型的路径 torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset + '.pth') # 最后的保存:不是保存整个模型,只是保存了参数