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)
