示例#1
0
test_loader = DataLoader(test_dataset,
                         batch_size=config_map['batch_size'],
                         shuffle=False)  #, num_workers=4)
data_len = int(len(test_dataset) / config_map['batch_size'])
logger.info('the dataset has %d images' % (len(train_dataset)))
logger.info('the batch_size is %d' % (config_map['batch_size']))

criterion = nn.BCEWithLogitsLoss()

num_iter = 0
best_mAP = 0.0
train_len = len(train_dataset)
train_iter = config_map['resume_epoch'] * len(train_loader)
last_little_mAP = 0.0

my_vis.img('label colors', get_class_color_img())

for epoch in range(config_map['resume_epoch'], config_map['epoch_num']):
    backbone_net_p.train()

    logger.info('\n\nStarting epoch %d / %d' %
                (epoch + 1, config_map['epoch_num']))
    logger.info('Learning Rate for this epoch: {}'.format(
        optimizer.param_groups[0]['lr']))

    epoch_start_time = time.clock()

    total_loss = 0.
    avg_loss = 0.

    for i, (images, mask_label) in enumerate(train_loader):
示例#2
0
        if my_vis and i % train_config['show_img_iter_during_train'] == 0:
            yolo_p.eval()
            # img, label_bboxes = next(test_iter)
            pred, _ = yolo_p(img[0].unsqueeze(0))
            detect_tensor = non_max_suppression(pred.to('cpu'),
                                                conf_thres=0.5,
                                                nms_thres=0.1)
            detect_tensor = detect_tensor[0]
            show_img = unorm(img[0])
            if detect_tensor is not None:
                # print(show_img.shape)
                show_img = draw_debug_rect(show_img.permute(1, 2, 0),
                                           detect_tensor[..., 1:5],
                                           detect_tensor[..., -1],
                                           detect_tensor[..., -2], name_list)
            my_vis.img('detect bboxes show', show_img)

            yolo_p.train()

        optimizer.zero_grad()
        now_loss.backward()
        optimizer.step()
        it_ed_time = time.clock()
        it_cost_time = it_ed_time - it_st_time
        if (i + 1) % 5 == 0:
            avg_loss = total_loss / (i + 1)
            logger.info(
                'Epoch [%d/%d], Iter [%d/%d] expect end in %.2f min. Loss: %.4f, average_loss: %.4f'
                % (epoch + 1, train_config['epoch_num'], i + 1,
                   len(train_loader), it_cost_time *
                   (len(train_loader) - i + 1) // 60,