def __init__(self, path, mode='train', image_size=224, resize_short_size=256): super(ImageNetDataset, self).__init__(path) self.mode = mode self.samples = [] list_file = "train_list.txt" if self.mode == "train" else "val_list.txt" with open(os.path.join([path, list_file]), 'r') as f: for line in f: _image, _label = line.strip().split(" ") self.samples.append((_image, int(_label))) normalize = transforms.Normalize(mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375]) if self.mode == 'train': self.transform = transforms.Compose([ transforms.RandomResizedCrop(image_size), transforms.RandomHorizontalFlip(), transforms.Transpose(), normalize ]) else: self.transform = transforms.Compose([ transforms.Resize(resize_short_size), transforms.CenterCrop(image_size), transforms.Transpose(), normalize ])
def test_exception(self): trans = transforms.Compose([transforms.Resize(-1)]) trans_batch = transforms.Compose([transforms.Resize(-1)]) with self.assertRaises(Exception): self.do_transform(trans) with self.assertRaises(Exception): self.do_transform(trans_batch) with self.assertRaises(ValueError): transforms.Pad([1.0, 2.0, 3.0]) with self.assertRaises(TypeError): fake_img = self.create_image((100, 120, 3)) F.pad(fake_img, '1') with self.assertRaises(TypeError): fake_img = self.create_image((100, 120, 3)) F.pad(fake_img, 1, {}) with self.assertRaises(TypeError): fake_img = self.create_image((100, 120, 3)) F.pad(fake_img, 1, padding_mode=-1) with self.assertRaises(ValueError): fake_img = self.create_image((100, 120, 3)) F.pad(fake_img, [1.0, 2.0, 3.0]) with self.assertRaises(TypeError): tensor_img = paddle.rand((3, 100, 100)) F.pad(tensor_img, '1') with self.assertRaises(TypeError): tensor_img = paddle.rand((3, 100, 100)) F.pad(tensor_img, 1, {}) with self.assertRaises(TypeError): tensor_img = paddle.rand((3, 100, 100)) F.pad(tensor_img, 1, padding_mode=-1) with self.assertRaises(ValueError): tensor_img = paddle.rand((3, 100, 100)) F.pad(tensor_img, [1.0, 2.0, 3.0]) with self.assertRaises(ValueError): transforms.RandomRotation(-2) with self.assertRaises(ValueError): transforms.RandomRotation([1, 2, 3]) with self.assertRaises(ValueError): trans_gray = transforms.Grayscale(5) fake_img = self.create_image((100, 120, 3)) trans_gray(fake_img) with self.assertRaises(TypeError): transform = transforms.RandomResizedCrop(64) transform(1)
def build_model(self): """ DataLoader """ pad = int(30 * self.img_size // 256) train_transform = T.Compose([ T.RandomHorizontalFlip(), T.Resize((self.img_size + pad, self.img_size + pad)), T.RandomCrop(self.img_size), T.ToTensor(), T.Normalize(mean=0.5, std=0.5), ]) test_transform = T.Compose([ T.Resize((self.img_size, self.img_size)), T.ToTensor(), T.Normalize(mean=0.5, std=0.5) ]) self.trainA = ImageFolder('dataset/photo2cartoon/trainA', self.img_size, train_transform) self.trainB = ImageFolder('dataset/photo2cartoon/trainB', self.img_size, train_transform) self.testA = ImageFolder('dataset/photo2cartoon/testA', self.img_size, test_transform) self.testB = ImageFolder('dataset/photo2cartoon/testB', self.img_size, test_transform) self.trainA_loader = DataLoader(self.trainA, batch_size=self.batch_size, shuffle=True) self.trainB_loader = DataLoader(self.trainB, batch_size=self.batch_size, shuffle=True) self.testA_loader = DataLoader(self.testA, batch_size=1, shuffle=False) self.testB_loader = DataLoader(self.testB, batch_size=1, shuffle=False) """ Define Generator, Discriminator """ self.genA2B = ResnetGenerator(ngf=self.ch, img_size=self.img_size, light=self.light) self.genB2A = ResnetGenerator(ngf=self.ch, img_size=self.img_size, light=self.light) self.disGA = Discriminator(input_nc=3, ndf=self.ch, n_layers=7) self.disGB = Discriminator(input_nc=3, ndf=self.ch, n_layers=7) self.disLA = Discriminator(input_nc=3, ndf=self.ch, n_layers=5) self.disLB = Discriminator(input_nc=3, ndf=self.ch, n_layers=5) """ Define Loss """ self.L1_loss = nn.loss.L1Loss() self.MSE_loss = nn.loss.MSELoss() self.BCE_loss = nn.loss.BCEWithLogitsLoss() self.G_optim = paddle.optimizer.Adam( learning_rate=self.lr, beta1=0.5, beta2=0.999, weight_decay=0.0001, parameters=self.genA2B.parameters()+self.genB2A.parameters() ) self.D_optim = paddle.optimizer.Adam( learning_rate=self.lr, beta1=0.5, beta2=0.999, weight_decay=0.0001, parameters=self.disGA.parameters()+self.disGB.parameters()+self.disLA.parameters()+self.disLB.parameters() ) self.Rho_clipper = RhoClipper(0, self.rho_clipper) self.W_clipper = WClipper(0, self.w_clipper)
def test_pad(self): trans = transforms.Compose([transforms.Pad(2)]) self.do_transform(trans) fake_img = self.create_image((200, 150, 3)) trans_pad = transforms.Compose([transforms.Pad(10)]) fake_img_padded = trans_pad(fake_img) np.testing.assert_equal(self.get_shape(fake_img_padded), (3, 220, 170)) trans_pad1 = transforms.Pad([1, 2]) trans_pad2 = transforms.Pad([1, 2, 3, 4]) trans_pad4 = transforms.Pad(1, padding_mode='edge') img = trans_pad1(fake_img) img = trans_pad2(img) img = trans_pad4(img)
def __init__(self, data_dir, mode='train', image_size=224, resize_short_size=256): super(ImageNetDataset, self).__init__() train_file_list = os.path.join(data_dir, 'train_list.txt') val_file_list = os.path.join(data_dir, 'val_list.txt') test_file_list = os.path.join(data_dir, 'test_list.txt') self.data_dir = data_dir self.mode = mode normalize = transforms.Normalize( mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375]) if self.mode == 'train': self.transform = transforms.Compose([ transforms.RandomResizedCrop(image_size), transforms.RandomHorizontalFlip(), transforms.Transpose(), normalize ]) else: self.transform = transforms.Compose([ transforms.Resize(resize_short_size), transforms.CenterCrop(image_size), transforms.Transpose(), normalize ]) if mode == 'train': with open(train_file_list) as flist: full_lines = [line.strip() for line in flist] np.random.shuffle(full_lines) if os.getenv('PADDLE_TRAINING_ROLE'): # distributed mode if the env var `PADDLE_TRAINING_ROLE` exits trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0")) trainer_count = int(os.getenv("PADDLE_TRAINERS_NUM", "1")) per_node_lines = len(full_lines) // trainer_count lines = full_lines[trainer_id * per_node_lines:( trainer_id + 1) * per_node_lines] print( "read images from %d, length: %d, lines length: %d, total: %d" % (trainer_id * per_node_lines, per_node_lines, len(lines), len(full_lines))) else: lines = full_lines self.data = [line.split() for line in lines] else: with open(val_file_list) as flist: lines = [line.strip() for line in flist] self.data = [line.split() for line in lines]
def test_random_crop(self): trans = transforms.Compose([ transforms.RandomCrop(200), transforms.RandomCrop((140, 160)), ]) self.do_transform(trans) trans_random_crop1 = transforms.RandomCrop(224) trans_random_crop2 = transforms.RandomCrop((140, 160)) fake_img = self.create_image((500, 400, 3)) fake_img_crop1 = trans_random_crop1(fake_img) fake_img_crop2 = trans_random_crop2(fake_img_crop1) np.testing.assert_equal(self.get_shape(fake_img_crop1), (3, 224, 224)) np.testing.assert_equal(self.get_shape(fake_img_crop2), (3, 140, 160)) trans_random_crop_same = transforms.RandomCrop((140, 160)) img = trans_random_crop_same(fake_img_crop2) trans_random_crop_bigger = transforms.RandomCrop((180, 200), pad_if_needed=True) img = trans_random_crop_bigger(img) trans_random_crop_pad = transforms.RandomCrop((224, 256), 2, True) img = trans_random_crop_pad(img)
def test_random_crop(self): trans = transforms.Compose([ transforms.RandomCrop(200), transforms.RandomCrop((140, 160)), ]) self.do_transform(trans) trans_random_crop1 = transforms.RandomCrop(224) trans_random_crop2 = transforms.RandomCrop((140, 160)) fake_img = np.random.rand(500, 400, 3).astype('float32') fake_img_crop1 = trans_random_crop1(fake_img) fake_img_crop2 = trans_random_crop2(fake_img_crop1) np.testing.assert_equal(fake_img_crop1.shape, (224, 224, 3)) np.testing.assert_equal(fake_img_crop2.shape, (140, 160, 3)) trans_random_crop_same = transforms.RandomCrop((140, 160)) img = trans_random_crop_same(fake_img_crop2) trans_random_crop_bigger = transforms.RandomCrop((180, 200)) img = trans_random_crop_bigger(img) trans_random_crop_pad = transforms.RandomCrop((224, 256), 2, True) img = trans_random_crop_pad(img)
def test_affine(self): trans = transforms.Compose([ transforms.RandomAffine(90), transforms.RandomAffine([-10, 10], translate=[0.1, 0.3]), transforms.RandomAffine(45, translate=[0.2, 0.2], scale=[0.2, 0.5]), transforms.RandomAffine(10, translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 10]), transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40]), transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40], interpolation='bilinear'), transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40], interpolation='bilinear', fill=114), transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40], interpolation='bilinear', fill=114, center=(60, 80)), ]) self.do_transform(trans)
def test_color_jitter(self): trans = transforms.Compose([ transforms.BrightnessTransform(0.0), transforms.HueTransform(0.0), transforms.SaturationTransform(0.0), transforms.ContrastTransform(0.0), ]) self.do_transform(trans)
def test_flip(self): trans = transforms.Compose([ transforms.RandomHorizontalFlip(1.0), transforms.RandomHorizontalFlip(0.0), transforms.RandomVerticalFlip(0.0), transforms.RandomVerticalFlip(1.0), ]) self.do_transform(trans)
def test_tranpose(self): trans = transforms.Compose([transforms.Transpose()]) self.do_transform(trans) fake_img = self.create_image((50, 100, 3)) converted_img = trans(fake_img) np.testing.assert_equal(self.get_shape(converted_img), (3, 50, 100))
def test_to_tensor(self): trans = transforms.Compose([transforms.ToTensor()]) fake_img = self.create_image((50, 100, 3)) tensor = trans(fake_img) assert isinstance(tensor, paddle.Tensor) np.testing.assert_equal(tensor.shape, (3, 50, 100))
def test_color_jitter(self): trans = transforms.Compose( [transforms.ColorJitter(1.1, 2.2, 0.8, 0.1)]) self.do_transform(trans) color_jitter_trans = transforms.ColorJitter(1.2, 0.2, 0.5, 0.2) batch_input = paddle.rand((2, 3, 4, 4), dtype=paddle.float32) result = color_jitter_trans(batch_input)
def test_rotate(self): trans = transforms.Compose([ transforms.RandomRotation(90), transforms.RandomRotation([-10, 10]), transforms.RandomRotation(45, expand=True), transforms.RandomRotation(10, expand=True, center=(60, 80)), ]) self.do_transform(trans)
def test_trans_all(self): normalize = transforms.Normalize( mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375], ) trans = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), normalize, ]) self.do_transform(trans)
def test_erase(self): trans = transforms.Compose([ transforms.RandomErasing(value=(0.5, )), transforms.RandomErasing(value="random") ]) self.do_transform(trans) erase_trans = transforms.RandomErasing(value=(0.5, 0.2, 0.01)) batch_input = paddle.rand((2, 3, 4, 4), dtype=paddle.float32) result = erase_trans(batch_input)
def test_trans_resize(self): trans = transforms.Compose([ transforms.Resize(300), transforms.RandomResizedCrop((280, 280)), transforms.Resize(280), transforms.Resize((256, 200)), transforms.Resize((180, 160)), transforms.CenterCrop(128), transforms.CenterCrop((128, 128)), ]) self.do_transform(trans)
def test_trans_all(self): normalize = transforms.Normalize( mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375]) trans = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.GaussianNoise(), transforms.ColorJitter( brightness=0.4, contrast=0.4, saturation=0.4, hue=0.4), transforms.RandomHorizontalFlip(), transforms.Permute(mode='CHW'), normalize ]) self.do_transform(trans)
def test_pad(self): trans = transforms.Compose([transforms.Pad(2)]) self.do_transform(trans) fake_img = np.random.rand(200, 150, 3).astype('float32') trans_pad = transforms.Pad(10) fake_img_padded = trans_pad(fake_img) np.testing.assert_equal(fake_img_padded.shape, (220, 170, 3)) trans_pad1 = transforms.Pad([1, 2]) trans_pad2 = transforms.Pad([1, 2, 3, 4]) img = trans_pad1(fake_img) img = trans_pad2(img)
def test_exception(self): trans = transforms.Compose([transforms.Resize(-1)]) trans_batch = transforms.BatchCompose([transforms.Resize(-1)]) with self.assertRaises(Exception): self.do_transform(trans) with self.assertRaises(Exception): self.do_transform(trans_batch) with self.assertRaises(ValueError): transforms.ContrastTransform(-1.0) with self.assertRaises(ValueError): transforms.SaturationTransform(-1.0), with self.assertRaises(ValueError): transforms.HueTransform(-1.0) with self.assertRaises(ValueError): transforms.BrightnessTransform(-1.0) with self.assertRaises(ValueError): transforms.Pad([1.0, 2.0, 3.0]) with self.assertRaises(TypeError): fake_img = np.random.rand(100, 120, 3).astype('float32') F.pad(fake_img, '1') with self.assertRaises(TypeError): fake_img = np.random.rand(100, 120, 3).astype('float32') F.pad(fake_img, 1, {}) with self.assertRaises(TypeError): fake_img = np.random.rand(100, 120, 3).astype('float32') F.pad(fake_img, 1, padding_mode=-1) with self.assertRaises(ValueError): fake_img = np.random.rand(100, 120, 3).astype('float32') F.pad(fake_img, [1.0, 2.0, 3.0]) with self.assertRaises(ValueError): transforms.RandomRotate(-2) with self.assertRaises(ValueError): transforms.RandomRotate([1, 2, 3]) with self.assertRaises(ValueError): trans_gray = transforms.Grayscale(5) fake_img = np.random.rand(100, 120, 3).astype('float32') trans_gray(fake_img)
def __init__(self, path, mode='train', image_size=224, resize_short_size=256): super(ImageNetDataset, self).__init__(path) self.mode = mode normalize = transforms.Normalize(mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375]) if self.mode == 'train': self.transform = transforms.Compose([ transforms.RandomResizedCrop(image_size), transforms.RandomHorizontalFlip(), transforms.Transpose(), normalize ]) else: self.transform = transforms.Compose([ transforms.Resize(resize_short_size), transforms.CenterCrop(image_size), transforms.Transpose(), normalize ])
def test_grayscale(self): trans = transforms.Compose([transforms.Grayscale()]) self.do_transform(trans) trans_gray = transforms.Grayscale() fake_img = self.create_image((500, 400, 3)) fake_img_gray = trans_gray(fake_img) np.testing.assert_equal(self.get_shape(fake_img_gray)[1], 500) np.testing.assert_equal(self.get_shape(fake_img_gray)[2], 400) trans_gray3 = transforms.Grayscale(3) fake_img = self.create_image((500, 400, 3)) fake_img_gray = trans_gray3(fake_img)
def load_image(image_path, max_size=400, shape=None): image = cv2.imread(image_path) image = image.astype('float32') / 255.0 size = shape if shape is not None else max_size if max( image.shape[:2]) > max_size else max(image.shape[:2]) transform = transforms.Compose([ transforms.Resize(size), transforms.Permute(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) image = transform(image)[np.newaxis, :3, :, :] image = paddle.to_tensor(image) return image
def test_grayscale(self): trans = transforms.Compose([transforms.Grayscale()]) self.do_transform(trans) trans_gray = transforms.Grayscale() fake_img = np.random.rand(500, 400, 3).astype('float32') fake_img_gray = trans_gray(fake_img) np.testing.assert_equal(len(fake_img_gray.shape), 3) np.testing.assert_equal(fake_img_gray.shape[0], 500) np.testing.assert_equal(fake_img_gray.shape[1], 400) trans_gray3 = transforms.Grayscale(3) fake_img = np.random.rand(500, 400, 3).astype('float32') fake_img_gray = trans_gray3(fake_img)
def load_image(image_path, max_size=400, shape=None): image = Image.open(image_path).convert('RGB') size = shape if shape is not None else max_size if max( image.size) > max_size else max(image.size) transform = transforms.Compose([ transforms.Resize(size), transforms.Transpose(), transforms.Normalize([123.675, 116.28, 103.53], [58.395, 57.120, 57.375]) ]) image = transform(image)[np.newaxis, :3, :, :] image = paddle.to_tensor(image) return image
def __init__(self, data_dir, image_size=224, resize_short_size=256): super(ImageNetValDataset, self).__init__() val_file_list = os.path.join(data_dir, 'val_list.txt') test_file_list = os.path.join(data_dir, 'test_list.txt') self.data_dir = data_dir normalize = transforms.Normalize(mean=[123.675, 116.28, 103.53], std=[58.395, 57.120, 57.375]) self.transform = transforms.Compose([ transforms.Resize(resize_short_size), transforms.CenterCrop(image_size), transforms.Transpose(), normalize ]) with open(val_file_list) as flist: lines = [line.strip() for line in flist] self.data = [line.split() for line in lines]
def __init__(self, data_path, mode='train', val_split=0.2): self.mode = mode assert self.mode in ['train', 'val', 'test'], \ "mode should be 'train' or 'test', but got {}".format(self.mode) self.data_source = pd.read_csv(data_path) # 清洗数据, 数据集中有很多样本只标注了部分关键点, 这里有两种策略 # 第一种, 将未标注的位置从上一个样本对应的关键点复制过来 # self.data_source.fillna(method = 'ffill',inplace = True) # 第二种, 将包含有未标注的样本从数据集中移除 self.data_source.dropna(how="any", inplace=True) self.data_label_all = self.data_source.drop('Image', axis=1) # 划分训练集和验证集合 if self.mode in ['train', 'val']: np.random.seed(43) data_len = len(self.data_source) # 随机划分 shuffled_indices = np.random.permutation(data_len) # 顺序划分 # shuffled_indices = np.arange(data_len) self.shuffled_indices = shuffled_indices val_set_size = int(data_len * val_split) if self.mode == 'val': val_indices = shuffled_indices[:val_set_size] self.data_img = self.data_source.reindex().iloc[val_indices] self.data_label = self.data_label_all.reindex( ).iloc[val_indices] elif self.mode == 'train': train_indices = shuffled_indices[val_set_size:] self.data_img = self.data_source.reindex().iloc[train_indices] self.data_label = self.data_label_all.reindex( ).iloc[train_indices] elif self.mode == 'test': self.data_img = self.data_source self.data_label = self.data_label_all self.transforms = transforms.Compose([ImgTransforms((2, 0, 1))])
def test_det( opt, batch_size=12, img_size=(1088, 608), iou_thres=0.5, print_interval=40, ): data_cfg = opt.data_cfg f = open(data_cfg) data_cfg_dict = json.load(f) f.close() nC = 1 test_path = data_cfg_dict['test'] dataset_root = data_cfg_dict['root'] if opt.gpus[0] >= 0: # opt.device = torch.device('cuda') opt.device = 'gpu' else: # opt.device = torch.device('cpu') opt.device = 'cpu' paddle.set_device(opt.device) print('Creating model...') model = create_model(opt.arch, opt.heads, opt.head_conv) model = load_model(model, opt.load_model) #model = torch.nn.DataParallel(model) # model = model.to(opt.device) model.eval() # Get dataloader transforms = T.Compose([T.ToTensor()]) dataset = DetDataset(dataset_root, test_path, img_size, augment=False, transforms=transforms) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=8, drop_last=False, collate_fn=collate_fn) mean_mAP, mean_R, mean_P, seen = 0.0, 0.0, 0.0, 0 print('%11s' * 5 % ('Image', 'Total', 'P', 'R', 'mAP')) outputs, mAPs, mR, mP, TP, confidence, pred_class, target_class, jdict = \ [], [], [], [], [], [], [], [], [] AP_accum, AP_accum_count = np.zeros(nC), np.zeros(nC) for batch_i, (imgs, targets, paths, shapes, targets_len) in enumerate(dataloader): t = time.time() #seen += batch_size output = model(imgs.cuda())[-1] origin_shape = shapes[0] width = origin_shape[1] height = origin_shape[0] inp_height = img_size[1] inp_width = img_size[0] c = np.array([width / 2., height / 2.], dtype=np.float32) s = max(float(inp_width) / float(inp_height) * height, width) * 1.0 meta = {'c': c, 's': s, 'out_height': inp_height // opt.down_ratio, 'out_width': inp_width // opt.down_ratio} hm = output['hm'].sigmoid_() wh = output['wh'] reg = output['reg'] if opt.reg_offset else None opt.K = 200 detections, inds = mot_decode(hm, wh, reg=reg, ltrb=opt.ltrb, K=opt.K) # Compute average precision for each sample targets = [targets[i][:int(l)] for i, l in enumerate(targets_len)] for si, labels in enumerate(targets): seen += 1 #path = paths[si] #img0 = cv2.imread(path) dets = detections[si] dets = dets.unsqueeze(0) dets = post_process(opt, dets, meta) dets = merge_outputs(opt, [dets])[1] #remain_inds = dets[:, 4] > opt.det_thres #dets = dets[remain_inds] if dets is None: # If there are labels but no detections mark as zero AP if labels.size(0) != 0: mAPs.append(0), mR.append(0), mP.append(0) continue # If no labels add number of detections as incorrect correct = [] if labels.size(0) == 0: # correct.extend([0 for _ in range(len(detections))]) mAPs.append(0), mR.append(0), mP.append(0) continue else: target_cls = labels[:, 0] # Extract target boxes as (x1, y1, x2, y2) target_boxes = xywh2xyxy(labels[:, 2:6]) target_boxes[:, 0] *= width target_boxes[:, 2] *= width target_boxes[:, 1] *= height target_boxes[:, 3] *= height ''' path = paths[si] img0 = cv2.imread(path) img1 = cv2.imread(path) for t in range(len(target_boxes)): x1 = target_boxes[t, 0] y1 = target_boxes[t, 1] x2 = target_boxes[t, 2] y2 = target_boxes[t, 3] cv2.rectangle(img0, (x1, y1), (x2, y2), (0, 255, 0), 4) cv2.imwrite('gt.jpg', img0) for t in range(len(dets)): x1 = dets[t, 0] y1 = dets[t, 1] x2 = dets[t, 2] y2 = dets[t, 3] cv2.rectangle(img1, (x1, y1), (x2, y2), (0, 255, 0), 4) cv2.imwrite('pred.jpg', img1) abc = ace ''' detected = [] for *pred_bbox, conf in dets: obj_pred = 0 pred_bbox = torch.FloatTensor(pred_bbox).view(1, -1) # Compute iou with target boxes iou = bbox_iou(pred_bbox, target_boxes, x1y1x2y2=True)[0] # Extract index of largest overlap best_i = np.argmax(iou) # If overlap exceeds threshold and classification is correct mark as correct if iou[best_i] > iou_thres and obj_pred == labels[best_i, 0] and best_i not in detected: correct.append(1) detected.append(best_i) else: correct.append(0) # Compute Average Precision (AP) per class AP, AP_class, R, P = ap_per_class(tp=correct, conf=dets[:, 4], pred_cls=np.zeros_like(dets[:, 4]), # detections[:, 6] target_cls=target_cls) # Accumulate AP per class AP_accum_count += np.bincount(AP_class, minlength=nC) AP_accum += np.bincount(AP_class, minlength=nC, weights=AP) # Compute mean AP across all classes in this image, and append to image list mAPs.append(AP.mean()) mR.append(R.mean()) mP.append(P.mean()) # Means of all images mean_mAP = np.sum(mAPs) / (AP_accum_count + 1E-16) mean_R = np.sum(mR) / (AP_accum_count + 1E-16) mean_P = np.sum(mP) / (AP_accum_count + 1E-16) if batch_i % print_interval == 0: # Print image mAP and running mean mAP print(('%11s%11s' + '%11.3g' * 4 + 's') % (seen, dataloader.dataset.nF, mean_P, mean_R, mean_mAP, time.time() - t)) # Print mAP per class print('%11s' * 5 % ('Image', 'Total', 'P', 'R', 'mAP')) print('AP: %-.4f\n\n' % (AP_accum[0] / (AP_accum_count[0] + 1E-16))) # Return mAP return mean_mAP, mean_R, mean_P
def __len__(self): return len(self.img_names) if __name__ == '__main__': from paddle.vision.transforms import transforms as T from paddle.io import DataLoader img_size = 256 pad = 30 train_transform = T.Compose([ T.RandomHorizontalFlip(), T.Resize((img_size + pad, img_size + pad)), T.RandomCrop(img_size), T.ToTensor(), T.Normalize(mean=0.5, std=0.5) ]) dataloader = ImageFolder('dataset/photo2cartoon/trainB', transform=train_transform) train_loader = DataLoader(dataloader, batch_size=1, shuffle=True) print('num: ', len(train_loader)) for i in range(300): print(i) try: real_A, _ = next(trainA_iter) except: trainA_iter = iter(train_loader())
def test_normalize(self): normalize = transforms.Normalize(mean=0.5, std=0.5) trans = transforms.Compose([transforms.Transpose(), normalize]) self.do_transform(trans)