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