def next_sample(self):
"""Helper function for reading in next sample."""
#set total batch size, for example, 1800, and maximum size for each people, for example 45
if self.seq is not None:
while True:
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, None, None
else:
label, fname, bbox, landmark = self.imglist[idx]
return label, self.read_image(fname), bbox, landmark
else:
s = self.imgrec.read()
if s is None:
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img, None, None
def __init__(self, batch_size, data_shape,
path_imgrec = None,
shuffle=False, aug_list=None, mean = None,
rand_mirror = False, cutoff = 0,
data_name='data', label_name='softmax_label', **kwargs):
super(FaceImageIter, self).__init__()
assert path_imgrec
if path_imgrec:
logging.info('loading recordio %s...',
path_imgrec)
path_imgidx = path_imgrec[0:-4]+".idx"
self.imgrec = recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r') # pylint: disable=redefined-variable-type
s = self.imgrec.read_idx(0)
header, _ = recordio.unpack(s)
if header.flag>0:
print('header0 label', header.label)
self.header0 = (int(header.label[0]), int(header.label[1]))
#assert(header.flag==1)
self.imgidx = range(1, int(header.label[0]))
self.id2range = {}
self.seq_identity = range(int(header.label[0]), int(header.label[1]))
for identity in self.seq_identity:
s = self.imgrec.read_idx(identity)
header, _ = recordio.unpack(s)
a,b = int(header.label[0]), int(header.label[1])
self.id2range[identity] = (a,b)
count = b-a
print('id2range', len(self.id2range))
else:
self.imgidx = list(self.imgrec.keys)
if shuffle:
self.seq = self.imgidx
self.oseq = self.imgidx
print(len(self.seq))
else:
self.seq = None
self.mean = mean
self.nd_mean = None
if self.mean:
self.mean = np.array(self.mean, dtype=np.float32).reshape(1,1,3)
self.nd_mean = mx.nd.array(self.mean).reshape((1,1,3))
self.check_data_shape(data_shape)
self.provide_data = [(data_name, (batch_size,) + data_shape)]
self.batch_size = batch_size
self.data_shape = data_shape
self.shuffle = shuffle
self.image_size = '%d,%d'%(data_shape[1],data_shape[2])
self.rand_mirror = rand_mirror
print('rand_mirror', rand_mirror)
self.cutoff = cutoff
self.provide_label = [(label_name, (batch_size,))]
#print(self.provide_label[0][1])
self.cur = 0
self.nbatch = 0
self.is_init = False
def next_sample(self):
"""Helper function for reading in next sample."""
#set total batch size, for example, 1800, and maximum size for each people, for example 45
if self.seq is not None:
while True:
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if self.output_c2c:
count = self.idx2flag[idx]
if self.output_c2c==1:
v = np.random.uniform(0.4, 0.5)
elif self.output_c2c==2:
v = np.random.uniform(0.4, 0.5)
if count>=self.output_c2c:
v = np.random.uniform(0.3, 0.4)
elif self.output_c2c==3:
v = (9.5 - math.log(2.0+count))/10.0
v = min(max(v, 0.3), 0.5)
elif self.output_c2c==4:
mu = 0.0
sigma = 0.1
mrange = [0.4,0.5]
v = numpy.random.normal(mu, sigma)
v = math.abs(v)*-1.0+mrange[1]
v = max(v, mrange[0])
elif self.output_c2c==5:
v = np.random.uniform(0.41, 0.51)
if count>=175:
v = np.random.uniform(0.37, 0.47)
elif self.output_c2c==6:
v = np.random.uniform(0.41, 0.51)
if count>=175:
v = np.random.uniform(0.38, 0.48)
else:
assert False
label = [label, v]
else:
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, None, None
else:
label, fname, bbox, landmark = self.imglist[idx]
return label, self.read_image(fname), bbox, landmark
else:
s = self.imgrec.read()
if s is None:
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img, None, None
def push_record(self, recname):
print('Pushing file: %s ...'%recname)
imgrec = recordio.MXIndexedRecordIO(recname+'.idx', recname+'.rec', 'r')
s = imgrec.read_idx(0)
header,_ = recordio.unpack(s)
header0 = (int(header.label[0]), int(header.label[1]))
for idd in tqdm(range(header0[0], header0[1])):
idxbuff = [self.idx]
s = imgrec.read_idx(idd)
header, _ = recordio.unpack(s)
imgrange = range(int(header.label[0]), int(header.label[1]))
for imgidx in imgrange:
s = imgrec.read_idx(imgidx)
hdd, img = recordio.unpack(s)
hdd = mx.recordio.IRHeader(0, float(self.idnum), 0, 0)
s = recordio.pack(hdd, img)
self.recout.write_idx( self.idx, s)
self.idx += 1
idxbuff.append(self.idx)
self.ID_idx.append(idxbuff)
self.idnum += 1
def __getitem__(self, idx):
r = self.rec.read_idx(idx)
h, im = recordio.unpack(r)
im = image.imdecode(im, self._flag)
l = h.label
pseudo_l = self.labels[idx]
if self.tform is not None:
im = self.tform(im)
return im, l, pseudo_l
def next_sample(self):
"""Helper function for reading in next sample."""
#set total batch size, for example, 1800, and maximum size for each people, for example 45
if self.seq is not None:
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
return header.label, img, None, None
else:
label, fname, bbox, landmark = self.imglist[idx]
return label, self.read_image(fname), bbox, landmark
else:
s = self.imgrec.read()
if s is None:
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img, None, None
def next_sample(self):
while True:
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, None, None
def __init__(self,
batch_size,
data_shape,
path_imgrec=None,
task='age',
shuffle=False,
aug_list=None,
mean=None,
rand_mirror=False,
cutoff=0,
data_name='data',
label_name='softmax_label',
**kwargs):
super(FaceImageIter, self).__init__()
assert path_imgrec
if path_imgrec:
logging.info('loading recordio %s...', path_imgrec)
path_imgidx = path_imgrec[0:-4] + ".idx"
self.imgrec = recordio.MXIndexedRecordIO(path_imgidx, path_imgrec,
'r') # pylint: disable=redefined-variable-type
s = self.imgrec.read_idx(0)
header, _ = recordio.unpack(s)
self.imgidx = list(self.imgrec.keys)
if shuffle:
self.seq = self.imgidx
self.oseq = self.imgidx
print(len(self.seq))
else:
self.seq = None
self.mean = mean
self.nd_mean = None
if self.mean:
self.mean = np.array(self.mean, dtype=np.float32).reshape(1, 1, 3)
self.nd_mean = mx.nd.array(self.mean).reshape((1, 1, 3))
self.check_data_shape(data_shape)
self.provide_data = [(data_name, (batch_size, ) + data_shape)]
self.batch_size = batch_size
self.data_shape = data_shape
self.shuffle = shuffle
self.image_size = '%d,%d' % (data_shape[1], data_shape[2])
self.rand_mirror = rand_mirror
print('rand_mirror', rand_mirror)
self.cutoff = cutoff
if task == 'age':
self.provide_label = [(label_name, (batch_size, 100))]
else:
self.provide_label = [(label_name, (batch_size, ))]
#print(self.provide_label[0][1])
self.cur = 0
self.nbatch = 0
self.is_init = False
def next_sample(self):
"""Helper function for reading in next sample."""
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
img = mx.image.imdecode(img).asnumpy()
#label = np.zeros( (self.num_classes, self.record_img_size, self.record_img_size), dtype=np.uint8)
hlabel = np.array(header.label).reshape( (self.num_classes,2) )
return img, hlabel
def next_sample(self):
"""Helper function for reading in next sample."""
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
img = mx.image.imdecode(img).asnumpy()
# label = np.zeros( (self.num_classes, self.record_img_size, self.record_img_size), dtype=np.uint8)
hlabel = np.array(header.label).reshape((self.num_classes, 2))
return img, hlabel
def __getitem__(self, idx):
while True:
record = super().__getitem__(idx)
header, img = recordio.unpack(record)
if _check_valid_image(img):
decoded_img = image.imdecode(img, self._flag)
else:
idx = np.random.randint(low=0, high=len(self))
continue
if self._transform is not None:
return self._transform(decoded_img, header.label)
return decoded_img, header.label
def __getitem__(self, idx):
idx = self.seq[idx]
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
img = mx.image.imdecode(img)
if self.augs is not None:
img = mx.nd.array(self.augs(image=img.asnumpy())['image'])
img = img.transpose((2, 0, 1)).astype(np.float32)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return img, label
def push_mxrecord(self, recname):
from mxnet import recordio
print('Pushing mxrec:', recname)
imgrec = recordio.MXIndexedRecordIO(recname + '.idx', recname + '.rec',
'r')
header, _ = recordio.unpack(imgrec.read_idx(0))
header0 = (int(header.label[0]), int(header.label[1]))
print('datalen', header0[1] - header0[0])
bar = tqdm(range(header0[0], header0[1]))
for idd in bar:
s = imgrec.read_idx(idd)
header, _ = recordio.unpack(s)
imgrange = (int(header.label[0]), int(header.label[1]))
meta = [self.pos]
for idx in range(imgrange[0], imgrange[1]):
s = imgrec.read_idx(idx)
hdd, img = recordio.unpack(s)
self.ioout.write_idx(self.pos, img)
self.pos += 1
meta.append(self.pos)
self.class_metas.append(meta)
def get_msceleb_images(records_dir):
imgidx_path = os.path.join(records_dir, "train.idx")
imgrec_path = os.path.join(records_dir, "train.rec")
images_dir = os.path.join(records_dir, "images")
imgrec = recordio.MXIndexedRecordIO(imgidx_path, imgrec_path, 'r')
s = imgrec.read_idx(0)
header, _ = recordio.unpack(s)
tot_images = int(header.label[0]) - 1
print("Total images", tot_images)
for i in range(tot_images):
print("Reading ", i)
s = imgrec.read()
header, img = recordio.unpack(s)
img = mx.image.imdecode(img).asnumpy()
label = int(header.label)
img = Image.fromarray(np.uint8(img), "RGB")
images_subdir = os.path.join(images_dir, "identity_%d" % label)
if not os.path.exists(images_subdir):
os.makedirs(images_subdir)
image_path = os.path.join(images_subdir, "image_%d.jpg" % i)
img.save(image_path)
def __getitem__(self, idx):
if self.use1 and not self.use2:
record = self.rec1.read_idx(self.idx1[idx])
h, im = recordio.unpack(record)
im = image.imdecode(im, self._flag)
l = h.label
if self.tform1 is not None:
im = self.tform1(im)
return im, l
elif self.use2 and not self.use1:
record = self.rec1.read_idx(self.idx2[idx])
h, im = recordio.unpack(record)
im = image.imdecode(im, self._flag)
l = h.label
if self.tform2 is not None:
im = self.tform2(im)
return im, l
else:
# online sample pairs generation
r1 = self.rec1.read_idx(self.idx1[idx[0]])
h1, im1 = recordio.unpack(r1)
im1 = image.imdecode(im1, self._flag)
l1 = h1.label
if self.tform1 is not None:
im1 = self.tform1(im1)
r2 = self.rec2.read_idx(self.idx2[idx[1]])
h2, im2 = recordio.unpack(r2)
im2 = image.imdecode(im2, self._flag)
l2 = h2.label
if self.tform2 is not None:
im2 = self.tform2(im2)
yc = 1 if l1 == l2 else 0
return im1, l1, im2, l2, yc
def next_sample(self):
"""Helper function for reading in next sample."""
#set total batch size, for example, 1800, and maximum size for each people, for example 45
if self.seq1 is not None:
while True:
if self.cur1 >= len(self.seq1):
raise StopIteration
idx = self.seq1[self.cur1]
self.cur1 += 1
if self.imgrec1 is not None:
s = self.imgrec1.read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, None, None
else: #no
s = self.imgrec1.read()
if s is None:
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img, None, None
def __init__(self,
batch_size,
data_shape,
path_imgrec=None,
shuffle=False,
aug_list=None,
mean=None,
rand_mirror=False,
cutoff=0,
data_name='data',
label_name='sigmoid_label',
num_class=21,
**kwargs):
super(FaceImageIter, self).__init__()
if path_imgrec:
logging.info('loading record %s...', path_imgrec)
path_imgidx = path_imgrec[0:-4] + ".idx"
self.imgrec = recordio.MXIndexedRecordIO(path_imgidx, path_imgrec,
'r')
s_dataset = self.imgrec.read_idx(0)
header, _ = recordio.unpack(s_dataset)
if header.flag == 2:
#print('header0 label', header.label)
self.header0 = (int(header.label[0]), int(header.label[1]))
#assert(header.flag==1)
self.imgidx = range(1, int(header.label[0]))
else:
print("header flag is not 2 for dataset ", header.flag)
#self.imgidx = list(self.imgrec.keys)
if shuffle:
self.seq = self.imgidx
#print("init shutffle",len(self.seq))
else:
self.seq = None
self.mean = mean
if self.mean:
self.mean = np.ones([1, 1, 3], dtype=np.float32) * self.mean
self.nd_mean = mx.nd.array(self.mean).reshape((1, 1, 3))
self.check_data_shape(data_shape)
self.provide_data = [(data_name, (batch_size, ) + data_shape)]
self.batch_size = batch_size
self.data_shape = data_shape
self.shuffle = shuffle
self.image_size = '%d,%d' % (data_shape[1], data_shape[2])
self.rand_mirror = rand_mirror
self.cutoff = cutoff
self.provide_label = [(label_name, (batch_size, num_class))]
#print(self.provide_label[0][1])
self.cur = 0
self.nbatch = 0
self.is_init = False
def __getitem__(self, idx):
s = self.imgrec.read_idx(self.seq[idx])
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
img = mx.image.imdecode(img)
#print(img.__class__)
#if np.random.rand()<0.5:
# img = img[:,::-1,:]
if self.transform is not None:
img = self.transform(img)
img = 2*img-1.0
return img, float(label)
def next_sample2(self):
if self.oseq2 is not None:
while True:
if self.cur2 >= len(self.oseq2):
raise StopIteration
idx2 = self.oseq2[self.cur2]
self.cur2 += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx2)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, None, None
def extract_ms1m_info():
self = edict()
path_ms1m = lz.share_path2 + 'faces_ms1m_112x112/'
path_imgrec = lz.share_path2 + 'faces_ms1m_112x112/train.rec'
path_imgidx = path_imgrec[0:-4] + ".idx"
self.imgrec = recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')
s = self.imgrec.read_idx(0)
header, _ = recordio.unpack(s)
self.header0 = (int(header.label[0]), int(header.label[1]))
# assert(header.flag==1)
self.imgidx = list(range(1, int(header.label[0])))
id2range = dict()
self.seq_identity = list(range(int(header.label[0]), int(header.label[1])))
for identity in self.seq_identity:
s = self.imgrec.read_idx(identity)
header, _ = recordio.unpack(s)
a, b = int(header.label[0]), int(header.label[1])
id2range[(identity - 3804847)] = (a, b)
count = b - a
self.seq = self.imgidx
self.seq_identity = [int(t) - 3804847 for t in self.seq_identity]
lz.msgpack_dump([self.imgidx, self.seq_identity, id2range],
path_ms1m + '/info.pk')
def load_train_data(data_dir):
path_imgrec = os.path.join(data_dir, "train.rec")
path_imgidx = path_imgrec[0:-4] + ".idx"
print("Loading recordio {}\n\
Corresponding record idx is {}".format(path_imgrec, path_imgidx))
imgrec = recordio.MXIndexedRecordIO(path_imgidx,
path_imgrec,
"r",
key_type=int)
# Read header0 to get some info.
identity_key_start = 0
identity_key_end = 0
imgidx_list = []
id2range = {}
rec0 = imgrec.read_idx(0)
header0, img_str = recordio.unpack(rec0)
if header0.flag > 0:
identity_key_start = int(header0.label[0])
identity_key_end = int(header0.label[1])
imgidx_list = range(1, identity_key_start)
# Read identity id range
for identity in range(identity_key_start, identity_key_end):
rec = imgrec.read_idx(identity)
header, s = recordio.unpack(rec)
a, b = int(header.label[0]), int(header.label[1])
id2range[identity] = (a, b)
else:
imgidx_list = imgrec.keys
return imgrec, imgidx_list
def get_image_idx(self):
image_rec_idx = self.image_rec.read_idx(0)
header, _ = recordio.unpack(image_rec_idx)
assert header.flag > 0, "header.flag is not more than zero....header: {}".format(
header)
header_0 = (int(header.label[0]), int(header.label[1]))
image_idx = range(1, int(header.label[0]))
identity_2_range_dict = {}
seq_identity = range(int(header.label[0]), int(header.label[1]))
for identity in seq_identity:
image_rec_idx = self.image_rec.read_idx(identity)
header, _ = recordio.unpack(image_rec_idx)
start_label = int(header.label[0])
end_label = int(header.label[1])
identity_2_range_dict[identity] = (start_label, end_label)
pass
return header_0, image_idx, identity_2_range_dict
pass
def get_image_idx(self, images_filter):
image_rec_idx = self.image_rec.read_idx(0)
header, _ = recordio.unpack(image_rec_idx)
if header.flag > 0:
image_idx = []
seq_identity = range(int(header.label[0]), int(header.label[1]))
for identity in seq_identity:
image_rec_idx = self.image_rec.read_idx(identity)
header, _ = recordio.unpack(image_rec_idx)
start_label = int(header.label[0])
end_label = int(header.label[1])
count = end_label - start_label
if count < images_filter:
continue
pass
image_idx += range(start_label, end_label)
pass
pass
else:
image_idx = list(self.image_rec.keys)
pass
return image_idx
pass
def next_sample(self):
if self.seq is not None:
while True:
if self.cur >= self.num_samples_per_gpu:
raise StopIteration
idx = self.seq[self.num_samples_per_gpu * self.context +
self.cur]
self.cur += 1
if self.imgrec is not None:
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return int(label), img, None, None
else:
label, fname, bbox, landmark = self.imglist[idx]
return label, self.read_image(fname), bbox, landmark
else:
s = self.imgrec.read()
if s is None:
raise StopIteration
header, img = recordio.unpack(s)
return header.label, img, None, None
def select_fairfaces(self):
'''
select faces with fair rules
'''
self.seq = []
self.time_reset()
batch_size = self.batch_size
tag = []
print('triplet time stat', self.times)
self.times[0] += self.time_elapsed()
self.time_reset()
for k in range(len(self.triplet_seq)):
_idx = self.triplet_seq[k]
s = self.imgrec.read_idx(_idx)
header, img = recordio.unpack(s)
_label = header.label
if not isinstance(_label, numbers.Number):
_label = _label[0]
tag.append((int(_label), _idx))
self.times[1] += self.time_elapsed()
self.time_reset()
nrof_images_per_class = [1]
for i in range(1, bag_size):
if tag[i][0] == tag[i - 1][0]:
nrof_images_per_class[-1] += 1
else:
nrof_images_per_class.append(1)
# random pick triplets
triplets = self.pick_random_triplets(
nrof_images_per_class) # shape=(T,3)
print('found triplets', len(triplets))
ba = 0
while True:
bb = ba + self.per_batch_size // 3
if bb > len(triplets):
break
_triplets = triplets[ba:bb]
for i in range(3):
for triplet in _triplets:
_pos = triplet[i]
_idx = tag[_pos][1]
self.seq.append(_idx)
ba = bb
self.times[2] += self.time_elapsed()
def load_or_gen_list(rec_f, rec):
idx_cls_lst_f = os.path.splitext(rec_f)[0] + '-lst.json'
if os.path.exists(idx_cls_lst_f):
idx_cls_lst = load_json(idx_cls_lst_f)
idx_cls_lst = [int(l) for l in idx_cls_lst]
return idx_cls_lst
else:
idx_cls_lst = []
for idx in rec.idx.keys():
record = rec.read_idx(idx)
h, _ = recordio.unpack(record)
idx_cls_lst.append(int(h.label))
save_json(idx_cls_lst, idx_cls_lst_f)
return idx_cls_lst
def main(args):
ds = args.input
path_imgrec = osp.join(ds, 'train.rec')
path_imgidx = osp.join(ds, 'train.idx')
imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r') # pylint: disable=redefined-variable-type
if not osp.exists(args.output):
os.makedirs(args.output)
writer = mx.recordio.MXRecordIO(osp.join(args.output, 'train.rec'), 'w')
s = imgrec.read_idx(0)
header, _ = recordio.unpack(s)
if header.flag > 0:
print('header0 label', header.label)
header0 = (int(header.label[0]), int(header.label[1]))
imgidx = list(range(1, int(header.label[0])))
else:
imgidx = list(imgrec.keys)
random.shuffle(imgidx)
label_stat = None
print('total images:', len(imgidx))
for i, idx in enumerate(imgidx):
if i % 10000 == 0:
print('processing', i, idx)
s = imgrec.read_idx(idx)
header, img = mx.recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
if label_stat is None:
label_stat = [label, label]
else:
label_stat[0] = min(label, label_stat[0])
label_stat[1] = max(label, label_stat[1])
wheader = mx.recordio.IRHeader(0, label, i, 0)
ws = mx.recordio.pack(wheader, img)
writer.write(ws)
print('label_stat:', label_stat)
writer.close()
if args.copy_vers:
for binfile in glob.glob(osp.join(args.input, '*.bin')):
target_file = osp.join(args.output, binfile.split('/')[-1])
shutil.copyfile(binfile, target_file)
with open(osp.join(args.output, 'property'), 'w') as f:
f.write("%d,112,112\n" % (int(label_stat[1]) + 1))
f.write("%d\n" % len(imgidx))
f.write("shuffled\n")
f.write("%s\n" % (datetime.datetime.now()))
def __init__(self, filename, gray_scale=False, transform=None, classes=None):
flag = 0 if gray_scale else 1
# retrieve number of classes without decoding images
td = RecordFileDataset(filename)
s = set([recordio.unpack(td.__getitem__(i))[0].label[0] for i in range(len(td))])
self._num_classes = len(s)
if not classes:
self._classes = [str(i) for i in range(self._num_classes)]
else:
if len(self._num_classes) != len(classes):
warnings.warn('Provided class names do not match data, expected "num_class" is {} '
'vs. provided: {}'.format(self._num_classes, len(classes)))
self._classes = list(classes) + \
[str(i) for i in range(len(classes), self._num_classes)]
self._dataset = ImageRecordDataset(filename, flag=flag)
if transform:
self._dataset = self._dataset.transform_first(transform)
def __getitem__(self, idx):
i, j = self.orig_idx[idx]
item = self.records[i].read_idx(j)
header, s = recordio.unpack(item)
img = mx.image.imdecode(s, 1)
label = header.label
if self.transform:
img, label = self.transform(img, label)
need_flip = self.horizontal_flip and random.random() > 0.5
img = mx.nd.flip(img, axis=2) if need_flip else img
if self.with_landmark:
landmark = mx.nd.array(self.landmark_dicts[i][j])
landmark = landmark[17 * 2:-8 * 2]
landmark = mx.nd.clip(landmark, 0, 224)
if need_flip:
landmark[::2] = 224 - landmark[::2]
return img, label, landmark
return img, label
def extract_asian_celeb_images(args):
imgrec = recordio.MXIndexedRecordIO(args.idx_path, args.rec_path, 'r')
last = 0
cnt = 0
for i in range(2830146):
header, s = recordio.unpack(imgrec.read_idx(i + 1))
img = mx.image.imdecode(s).asnumpy()
dst = os.path.join(args.write_path, str(int(header.label[0])))
if not os.path.exists(dst):
os.makedirs(dst)
last = int(header.label[0])
cnt = 0
cv2.imwrite(os.path.join(dst, f'{cnt}.jpg'),
cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
cnt += 1
def __getitem__(self, index):
idx = self.seq[index]
s = self.imgrec.read_idx(idx)
header, s = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
_data = mx.image.imdecode(s)
if self.rand_mirror:
_rd = random.randint(0, 1)
if _rd == 1:
_data = mx.ndarray.flip(data=_data, axis=1)
_data = nd.transpose(_data, axes=(2, 0, 1))
_data = _data.asnumpy()
img = torch.from_numpy(_data)
return img, label
def next_sample(self):
while True:
if self.cur >= len(self.seq_image_idx):
raise StopIteration
pass
identity = self.seq_image_idx[self.cur]
self.cur += 1
image_rec_idx = self.image_rec.read_idx(identity)
header, image_str = recordio.unpack(image_rec_idx)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
pass
return label, image_str
pass
pass
def next_sample2(self):
"""Helper function for reading in next sample."""
#set total batch size, for example, 1800, and maximum size for each people, for example 45
if self.seq2 is not None:
#print("self.seq2: ",self.seq2)
while True:
if self.cur2 >= len(self.seq2):
raise StopIteration
idx = self.seq2[self.cur2]
#print("cur2: ", self.seq2,idx)
self.cur2 += 1
if self.imgrec2 is not None:
s = self.imgrec2.read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, None, None
def next_sample(self):
"""Helper function for reading in next sample."""
#set total batch size, for example, 1800, and maximum size for each people, for example 45
while True:
if self.cur >= len(self.seq):
self.cur = 0
self.seq = []
self.select_pairs()
rec_name, idx, pos_flag, score = self.seq[self.cur]
#print(rec_name, idx, pos_flag, score)
self.cur += 1
s = self.imgrec[rec_name].read_idx(idx)
header, img = recordio.unpack(s)
label = header.label
if not isinstance(label, numbers.Number):
label = label[0]
return label, img, pos_flag, score
def __init__(self, batch_size, data_shape,
path_imgrec = None,
shuffle=False, aug_list=None, mean = None,
rand_mirror = False,
c2c_threshold = 0.0, output_c2c = 0,
ctx_num = 0, images_per_identity = 0, data_extra = None, hard_mining = False,
triplet_params = None, coco_mode = False,
mx_model = None,
data_name='data', label_name='softmax_label', **kwargs):
super(FaceImageIter, self).__init__()
assert path_imgrec
if path_imgrec:
logging.info('loading recordio %s...',
path_imgrec)
path_imgidx = path_imgrec[0:-4]+".idx"
self.imgrec = recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r') # pylint: disable=redefined-variable-type
s = self.imgrec.read_idx(0)
header, _ = recordio.unpack(s)
self.idx2cos = {}
self.idx2meancos = {}
self.c2c_auto = False
if output_c2c or c2c_threshold>0.0:
path_c2c = os.path.join(os.path.dirname(path_imgrec), 'c2c')
print(path_c2c)
if os.path.exists(path_c2c):
for line in open(path_c2c, 'r'):
vec = line.strip().split(',')
self.idx2cos[int(vec[0])] = float(vec[1])
else:
self.c2c_auto = True
self.c2c_step = 10000
if header.flag>0:
print('header0 label', header.label)
self.header0 = (int(header.label[0]), int(header.label[1]))
#assert(header.flag==1)
self.imgidx = range(1, int(header.label[0]))
if c2c_threshold>0.0:
imgidx2 = []
for idx in self.imgidx:
c = self.idx2cos[idx]
if c<c2c_threshold:
continue
imgidx2.append(idx)
print(len(self.imgidx), len(imgidx2))
self.imgidx = imgidx2
self.id2range = {}
self.seq_identity = range(int(header.label[0]), int(header.label[1]))
for identity in self.seq_identity:
s = self.imgrec.read_idx(identity)
header, _ = recordio.unpack(s)
a,b = int(header.label[0]), int(header.label[1])
#print('flag', header.flag)
#print(header.label)
#assert(header.flag==2)
self.id2range[identity] = (a,b)
if len(self.idx2cos)>0:
m = 0.0
for ii in xrange(a,b):
m+=self.idx2cos[ii]
m/=(b-a)
for ii in xrange(a,b):
self.idx2meancos[ii] = m
#self.idx2meancos[identity] = m
print('id2range', len(self.id2range))
print(len(self.idx2cos), len(self.idx2meancos))
else:
self.imgidx = list(self.imgrec.keys)
if shuffle:
self.seq = self.imgidx
self.oseq = self.imgidx
print(len(self.seq))
else:
self.seq = None
self.mean = mean
self.nd_mean = None
if self.mean:
self.mean = np.array(self.mean, dtype=np.float32).reshape(1,1,3)
self.nd_mean = mx.nd.array(self.mean).reshape((1,1,3))
self.check_data_shape(data_shape)
self.provide_data = [(data_name, (batch_size,) + data_shape)]
self.batch_size = batch_size
self.data_shape = data_shape
self.shuffle = shuffle
self.image_size = '%d,%d'%(data_shape[1],data_shape[2])
self.rand_mirror = rand_mirror
print('rand_mirror', rand_mirror)
#self.cast_aug = mx.image.CastAug()
#self.color_aug = mx.image.ColorJitterAug(0.4, 0.4, 0.4)
self.ctx_num = ctx_num
self.c2c_threshold = c2c_threshold
self.output_c2c = output_c2c
self.per_batch_size = int(self.batch_size/self.ctx_num)
self.images_per_identity = images_per_identity
if self.images_per_identity>0:
self.identities = int(self.per_batch_size/self.images_per_identity)
self.per_identities = self.identities
self.repeat = 3000000.0/(self.images_per_identity*len(self.id2range))
self.repeat = int(self.repeat)
print(self.images_per_identity, self.identities, self.repeat)
self.data_extra = None
if data_extra is not None:
self.data_extra = nd.array(data_extra)
self.provide_data = [(data_name, (batch_size,) + data_shape), ('extra', data_extra.shape)]
self.hard_mining = hard_mining
self.mx_model = mx_model
if self.hard_mining:
assert self.images_per_identity>0
assert self.mx_model is not None
self.triplet_params = triplet_params
self.triplet_mode = False
self.coco_mode = coco_mode
if len(label_name)>0:
if output_c2c:
self.provide_label = [(label_name, (batch_size,2))]
else:
self.provide_label = [(label_name, (batch_size,))]
else:
self.provide_label = []
print(self.provide_label[0][1])
if self.coco_mode:
assert self.triplet_params is None
assert self.images_per_identity>0
if self.triplet_params is not None:
assert self.images_per_identity>0
assert self.mx_model is not None
self.triplet_bag_size = self.triplet_params[0]
self.triplet_alpha = self.triplet_params[1]
self.triplet_max_ap = self.triplet_params[2]
assert self.triplet_bag_size>0
assert self.triplet_alpha>=0.0
assert self.triplet_alpha<=1.0
self.triplet_mode = True
self.triplet_oseq_cur = 0
self.triplet_oseq_reset()
self.seq_min_size = self.batch_size*2
self.cur = 0
self.nbatch = 0
self.is_init = False
self.times = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
def hard_mining_reset(self):
#import faiss
from annoy import AnnoyIndex
data = nd.zeros( self.provide_data[0][1] )
label = nd.zeros( self.provide_label[0][1] )
#label = np.zeros( self.provide_label[0][1] )
X = None
ba = 0
batch_num = 0
while ba<len(self.oseq):
batch_num+=1
if batch_num%10==0:
print('loading batch',batch_num, ba)
bb = min(ba+self.batch_size, len(self.oseq))
_count = bb-ba
for i in xrange(_count):
idx = self.oseq[i+ba]
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
img = self.imdecode(img)
data[i][:] = self.postprocess_data(img)
label[i][:] = header.label
db = mx.io.DataBatch(data=(data,self.data_extra), label=(label,))
self.mx_model.forward(db, is_train=False)
net_out = self.mx_model.get_outputs()
embedding = net_out[0].asnumpy()
nembedding = sklearn.preprocessing.normalize(embedding)
if _count<self.batch_size:
nembedding = nembedding[0:_count,:]
if X is None:
X = np.zeros( (len(self.id2range), nembedding.shape[1]), dtype=np.float32 )
nplabel = label.asnumpy()
for i in xrange(_count):
ilabel = int(nplabel[i])
#print(ilabel, ilabel.__class__)
X[ilabel] += nembedding[i]
ba = bb
X = sklearn.preprocessing.normalize(X)
d = X.shape[1]
t = AnnoyIndex(d, metric='euclidean')
for i in xrange(X.shape[0]):
t.add_item(i, X[i])
print('start to build index')
t.build(20)
print(X.shape)
k = self.per_identities
self.seq = []
for i in xrange(X.shape[0]):
nnlist = t.get_nns_by_item(i, k)
assert nnlist[0]==i
for _label in nnlist:
assert _label<len(self.id2range)
_id = self.header0[0]+_label
v = self.id2range[_id]
_list = range(*v)
if len(_list)<self.images_per_identity:
random.shuffle(_list)
else:
_list = np.random.choice(_list, self.images_per_identity, replace=False)
for i in xrange(self.images_per_identity):
_idx = _list[i%len(_list)]
self.seq.append(_idx)
def select_triplets(self):
self.seq = []
while len(self.seq)<self.seq_min_size:
self.time_reset()
embeddings = None
bag_size = self.triplet_bag_size
batch_size = self.batch_size
#data = np.zeros( (bag_size,)+self.data_shape )
#label = np.zeros( (bag_size,) )
tag = []
#idx = np.zeros( (bag_size,) )
print('eval %d images..'%bag_size, self.triplet_oseq_cur)
print('triplet time stat', self.times)
if self.triplet_oseq_cur+bag_size>len(self.oseq):
self.triplet_oseq_reset()
print('eval %d images..'%bag_size, self.triplet_oseq_cur)
self.times[0] += self.time_elapsed()
self.time_reset()
#print(data.shape)
data = nd.zeros( self.provide_data[0][1] )
label = nd.zeros( self.provide_label[0][1] )
ba = 0
while True:
bb = min(ba+batch_size, bag_size)
if ba>=bb:
break
#_batch = self.data_iter.next()
#_data = _batch.data[0].asnumpy()
#print(_data.shape)
#_label = _batch.label[0].asnumpy()
#data[ba:bb,:,:,:] = _data
#label[ba:bb] = _label
for i in xrange(ba, bb):
_idx = self.oseq[i+self.triplet_oseq_cur]
s = self.imgrec.read_idx(_idx)
header, img = recordio.unpack(s)
img = self.imdecode(img)
data[i-ba][:] = self.postprocess_data(img)
label[i-ba][:] = header.label
tag.append( ( int(header.label), _idx) )
#idx[i] = _idx
db = mx.io.DataBatch(data=(data,), label=(label,))
self.mx_model.forward(db, is_train=False)
net_out = self.mx_model.get_outputs()
#print('eval for selecting triplets',ba,bb)
#print(net_out)
#print(len(net_out))
#print(net_out[0].asnumpy())
net_out = net_out[0].asnumpy()
#print(net_out)
#print('net_out', net_out.shape)
if embeddings is None:
embeddings = np.zeros( (bag_size, net_out.shape[1]))
embeddings[ba:bb,:] = net_out
ba = bb
assert len(tag)==bag_size
self.triplet_oseq_cur+=bag_size
embeddings = sklearn.preprocessing.normalize(embeddings)
self.times[1] += self.time_elapsed()
self.time_reset()
nrof_images_per_class = [1]
for i in xrange(1, bag_size):
if tag[i][0]==tag[i-1][0]:
nrof_images_per_class[-1]+=1
else:
nrof_images_per_class.append(1)
triplets = self.pick_triplets(embeddings, nrof_images_per_class) # shape=(T,3)
print('found triplets', len(triplets))
ba = 0
while True:
bb = ba+self.per_batch_size//3
if bb>len(triplets):
break
_triplets = triplets[ba:bb]
for i in xrange(3):
for triplet in _triplets:
_pos = triplet[i]
_idx = tag[_pos][1]
self.seq.append(_idx)
ba = bb
self.times[2] += self.time_elapsed()
def __init__(self, batch_size, data_shape,
path_imgrec = None,
shuffle=False, aug_list=None, mean = None,
rand_mirror = False, cutoff = 0,
c2c_threshold = 0.0, output_c2c = 0, c2c_mode = -10, limit = 0,
ctx_num = 0, images_per_identity = 0, data_extra = None, hard_mining = False,
triplet_params = None, coco_mode = False,
mx_model = None,
data_name='data', label_name='softmax_label', **kwargs):
super(FaceImageIter, self).__init__()
assert path_imgrec
if path_imgrec:
logging.info('loading recordio %s...',
path_imgrec)
path_imgidx = path_imgrec[0:-4]+".idx"
self.imgrec = recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r') # pylint: disable=redefined-variable-type
s = self.imgrec.read_idx(0)
header, _ = recordio.unpack(s)
self.idx2cos = {}
self.idx2flag = {}
self.idx2meancos = {}
self.c2c_auto = False
#if output_c2c or c2c_threshold>0.0 or c2c_mode>=-5:
# path_c2c = os.path.join(os.path.dirname(path_imgrec), 'c2c')
# print(path_c2c)
# if os.path.exists(path_c2c):
# for line in open(path_c2c, 'r'):
# vec = line.strip().split(',')
# idx = int(vec[0])
# self.idx2cos[idx] = float(vec[1])
# self.idx2flag[idx] = 1
# if len(vec)>2:
# self.idx2flag[idx] = int(vec[2])
# else:
# self.c2c_auto = True
# self.c2c_step = 10000
if header.flag>0:
print('header0 label', header.label)
self.header0 = (int(header.label[0]), int(header.label[1]))
#assert(header.flag==1)
self.imgidx = range(1, int(header.label[0]))
if c2c_mode==0:
imgidx2 = []
for idx in self.imgidx:
c = self.idx2cos[idx]
f = self.idx2flag[idx]
if f!=1:
continue
imgidx2.append(idx)
print('idx count', len(self.imgidx), len(imgidx2))
self.imgidx = imgidx2
elif c2c_mode==1:
imgidx2 = []
tmp = []
for idx in self.imgidx:
c = self.idx2cos[idx]
f = self.idx2flag[idx]
if f==1:
imgidx2.append(idx)
else:
tmp.append( (idx, c) )
tmp = sorted(tmp, key = lambda x:x[1])
tmp = tmp[250000:300000]
for _t in tmp:
imgidx2.append(_t[0])
print('idx count', len(self.imgidx), len(imgidx2))
self.imgidx = imgidx2
elif c2c_mode==2:
imgidx2 = []
tmp = []
for idx in self.imgidx:
c = self.idx2cos[idx]
f = self.idx2flag[idx]
if f==1:
imgidx2.append(idx)
else:
tmp.append( (idx, c) )
tmp = sorted(tmp, key = lambda x:x[1])
tmp = tmp[200000:300000]
for _t in tmp:
imgidx2.append(_t[0])
print('idx count', len(self.imgidx), len(imgidx2))
self.imgidx = imgidx2
elif c2c_mode==-2:
imgidx2 = []
for idx in self.imgidx:
c = self.idx2cos[idx]
f = self.idx2flag[idx]
if f==2:
continue
if c<0.73:
continue
imgidx2.append(idx)
print('idx count', len(self.imgidx), len(imgidx2))
self.imgidx = imgidx2
elif c2c_threshold>0.0:
imgidx2 = []
for idx in self.imgidx:
c = self.idx2cos[idx]
f = self.idx2flag[idx]
if c<c2c_threshold:
continue
imgidx2.append(idx)
print(len(self.imgidx), len(imgidx2))
self.imgidx = imgidx2
self.id2range = {}
self.seq_identity = range(int(header.label[0]), int(header.label[1]))
c2c_stat = [0,0]
for identity in self.seq_identity:
s = self.imgrec.read_idx(identity)
header, _ = recordio.unpack(s)
a,b = int(header.label[0]), int(header.label[1])
self.id2range[identity] = (a,b)
count = b-a
if count>=output_c2c:
c2c_stat[1]+=1
else:
c2c_stat[0]+=1
for ii in xrange(a,b):
self.idx2flag[ii] = count
if len(self.idx2cos)>0:
m = 0.0
for ii in xrange(a,b):
m+=self.idx2cos[ii]
m/=(b-a)
for ii in xrange(a,b):
self.idx2meancos[ii] = m
#self.idx2meancos[identity] = m
print('id2range', len(self.id2range))
print(len(self.idx2cos), len(self.idx2meancos), len(self.idx2flag))
print('c2c_stat', c2c_stat)
if limit>0 and limit<len(self.imgidx):
random.seed(727)
prob = float(limit)/len(self.imgidx)
new_imgidx = []
new_ids = 0
for identity in self.seq_identity:
s = self.imgrec.read_idx(identity)
header, _ = recordio.unpack(s)
a,b = int(header.label[0]), int(header.label[1])
found = False
for _idx in xrange(a,b):
if random.random()<prob:
found = True
new_imgidx.append(_idx)
if found:
new_ids+=1
self.imgidx = new_imgidx
print('new ids', new_ids)
random.seed(None)
#random.Random(727).shuffle(self.imgidx)
#self.imgidx = self.imgidx[0:limit]
else:
self.imgidx = list(self.imgrec.keys)
if shuffle:
self.seq = self.imgidx
self.oseq = self.imgidx
print(len(self.seq))
else:
self.seq = None
self.mean = mean
self.nd_mean = None
if self.mean:
self.mean = np.array(self.mean, dtype=np.float32).reshape(1,1,3)
self.nd_mean = mx.nd.array(self.mean).reshape((1,1,3))
self.check_data_shape(data_shape)
self.provide_data = [(data_name, (batch_size,) + data_shape)]
self.batch_size = batch_size
self.data_shape = data_shape
self.shuffle = shuffle
self.image_size = '%d,%d'%(data_shape[1],data_shape[2])
self.rand_mirror = rand_mirror
print('rand_mirror', rand_mirror)
self.cutoff = cutoff
#self.cast_aug = mx.image.CastAug()
#self.color_aug = mx.image.ColorJitterAug(0.4, 0.4, 0.4)
self.ctx_num = ctx_num
self.c2c_threshold = c2c_threshold
self.output_c2c = output_c2c
self.per_batch_size = int(self.batch_size/self.ctx_num)
self.images_per_identity = images_per_identity
if self.images_per_identity>0:
self.identities = int(self.per_batch_size/self.images_per_identity)
self.per_identities = self.identities
self.repeat = 3000000.0/(self.images_per_identity*len(self.id2range))
self.repeat = int(self.repeat)
print(self.images_per_identity, self.identities, self.repeat)
self.data_extra = None
if data_extra is not None:
self.data_extra = nd.array(data_extra)
self.provide_data = [(data_name, (batch_size,) + data_shape), ('extra', data_extra.shape)]
self.hard_mining = hard_mining
self.mx_model = mx_model
if self.hard_mining:
assert self.images_per_identity>0
assert self.mx_model is not None
self.triplet_params = triplet_params
self.triplet_mode = False
self.coco_mode = coco_mode
if len(label_name)>0:
if output_c2c:
self.provide_label = [(label_name, (batch_size,2))]
else:
self.provide_label = [(label_name, (batch_size,))]
else:
self.provide_label = []
print(self.provide_label[0][1])
if self.coco_mode:
assert self.triplet_params is None
assert self.images_per_identity>0
if self.triplet_params is not None:
assert self.images_per_identity>0
assert self.mx_model is not None
self.triplet_bag_size = self.triplet_params[0]
self.triplet_alpha = self.triplet_params[1]
self.triplet_max_ap = self.triplet_params[2]
assert self.triplet_bag_size>0
assert self.triplet_alpha>=0.0
assert self.triplet_alpha<=1.0
self.triplet_mode = True
self.triplet_oseq_cur = 0
self.triplet_oseq_reset()
self.seq_min_size = self.batch_size*2
self.cur = 0
self.nbatch = 0
self.is_init = False
self.times = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
def next_sample(self):
"""Helper function for reading in next sample."""
if self.cur >= len(self.seq):
raise StopIteration
idx = self.seq[self.cur]
self.cur += 1
s = self.imgrec.read_idx(idx)
header, img = recordio.unpack(s)
img = mx.image.imdecode(img).asnumpy()
#label = np.zeros( (self.num_classes, self.record_img_size, self.record_img_size), dtype=np.uint8)
hlabel = np.array(header.label).reshape( (self.num_classes,2) )
annot = {}
ul = np.array( (50000,50000), dtype=np.int32)
br = np.array( (0,0), dtype=np.int32)
for i in xrange(hlabel.shape[0]):
#hlabel[i] = hlabel[i][::-1]
h = int(hlabel[i][0])
w = int(hlabel[i][1])
key = np.array((h,w))
#print(key.shape, ul.shape, br.shape)
ul = np.minimum(key, ul)
br = np.maximum(key, br)
#label[h][w] = i+1
#label[i][h][w] = 1.0
#print(h,w,i+1)
if self.mode==0:
ul_margin = np.array( (60,30) )
br_margin = np.array( (30,30) )
crop_ul = ul
crop_ul = ul-ul_margin
crop_ul = np.maximum(crop_ul, np.array( (0,0), dtype=np.int32) )
crop_br = br
crop_br = br+br_margin
crop_br = np.minimum(crop_br, np.array( (img.shape[0],img.shape[1]), dtype=np.int32 ) )
elif self.mode==1:
#mm = (self.record_img_size - 256)//2
#crop_ul = (mm, mm)
#crop_br = (self.record_img_size-mm, self.record_img_size-mm)
crop_ul = (0,0)
crop_br = (self.record_img_size, self.record_img_size)
annot['scale'] = 256
#annot['center'] = np.array( (self.record_img_size/2+10, self.record_img_size/2) )
else:
mm = (48, 64)
#mm = (64, 80)
crop_ul = mm
crop_br = (self.record_img_size-mm[0], self.record_img_size-mm[1])
crop_ul = np.array(crop_ul)
crop_br = np.array(crop_br)
img = img[crop_ul[0]:crop_br[0],crop_ul[1]:crop_br[1],:]
#print(img.shape, crop_ul, crop_br)
invalid = False
for i in xrange(hlabel.shape[0]):
if (hlabel[i]<crop_ul).any() or (hlabel[i] >= crop_br).any():
invalid = True
hlabel[i] -= crop_ul
#mm = np.amin(ul)
#mm2 = self.record_img_size - br
#mm2 = np.amin(mm2)
#mm = min(mm, mm2)
#print('mm',mm, ul, br)
#print('invalid', invalid)
if invalid:
self.invalid_num+=1
annot['invalid'] = invalid
#annot['scale'] = (self.record_img_size - mm*2)*1.1
#if self.mode==1:
# annot['scale'] = 256
#print(annot)
#center = ul+br
#center /= 2.0
#annot['center'] = center
#img = img[ul[0]:br[0],ul[1]:br[1],:]
#scale = br-ul
#scale = max(scale[0], scale[1])
#print(img.shape)
return img, hlabel, annot
