def next(self): if self.iter_next(): self.batch_counter += 1 batch, label = self._data_buffer.get(block=True) return io.DataBatch(data=[batch], label=[label], pad=0) else: raise StopIteration
def next(self): """Returns the next batch of data.""" batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: #pdb.set_trace() label, s = self.next_sample() data = self.imdecode(s) filepath = os.path.join( self.path_root, self.imglist[self.seq[self.cur - 1]][1]) data = cv2.imread(filepath, 1) data, label = self.aug_position(data, label.asnumpy()) data = cv2.cvtColor(data, cv2.COLOR_BGR2RGB) data = mx.nd.array(data).as_in_context(mx.cpu()) label = nd.array(label).as_in_context(mx.cpu()) try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue data = self.augmentation_transform(data) assert i < batch_size, 'Batch size must be multiples of augmenter output length' batch_data[i] = self.postprocess_data(data) batch_label[i] = label i += 1 except StopIteration: if not i: raise StopIteration return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) gender_label = nd.empty(self.provide_label[0][1]) age_label = nd.empty(self.provide_label[1][1]) i = 0 try: while i < batch_size: label, s, _, _ = self.next_sample() _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) if _data.shape[0] == 0: logging.debug('Invalid image,skipping') continue batch_data[i][:] = self.postprocess_data(_data) gender_label[i][:] = label[0] age_label[i][:] = label[1] i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], [gender_label, age_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch+=1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size * 2, c, h, w)) batch_margin = nd.empty((batch_size * 2,)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: dataset_idx = 0 while i < batch_size: batch_margin[i] = self.margin(self.iteration) _label, s, bbox, landmark = self.next_sample(dataset_idx) if(len(self.seq) > 1): label = np.ones([self.rec_num,]) * (-1) label[dataset_idx] = _label else: label = _label dataset_idx = (dataset_idx + 1) % self.rec_num _data = self.imdecode(s) #_data = self.augs.apply(_data) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i<batch_size: raise StopIteration for i in range(batch_size): batch_data[i + batch_size] = batch_data[i].copy() batch_data[i + batch_size][:, 56:, :] = 0 db = mx.io.DataBatch(data=(batch_data,)) self.mx_model.forward(db, is_train=False) net_out = self.mx_model.get_outputs() net_out[1] = net_out[1] / mx.nd.sqrt((net_out[1] * net_out[1]).sum(1).reshape([1, 1])) self.iteration += 1 return io.DataBatch([net_out[0][:batch_size, :, :, :], net_out[0][batch_size:, :, :, :], net_out[1][:batch_size, :], net_out[1][batch_size:, :]], [batch_label], batch_size - i)
def forward(self, data_batch, is_train=None): # g,x = self.get_params() # #print('{fc7_weight[0][0]}', self._iter, g['fc7_0_weight'].asnumpy()[0][0]) # #print('{pre_fc1_weight[0][0]}', self._iter, g['pre_fc1_weight'].asnumpy()[0][0]) # print('{fc7_weight[0][0]}', self._iter, np.max(g['fc7_0_weight'].asnumpy())) # print('{pre_fc1_weight[0][0]}', self._iter, np.max(g['pre_fc1_weight'].asnumpy())) # print('{fc7_weight min', self._iter, np.min(g['fc7_0_weight'].asnumpy())) # print('{pre_fc1_weight min', self._iter, np.min(g['pre_fc1_weight'].asnumpy())) # print('stn params locw', self._iter, np.max(g['locw'].asnumpy())) # print('stn params locb', self._iter, np.max(g['locb'].asnumpy())) assert self.binded and self.params_initialized self._curr_module.forward(data_batch, is_train=is_train) if is_train: self._iter+=1 fc1, label = self._curr_module.get_outputs(merge_multi_context=True) global_fc1 = fc1 self.global_label = label.as_in_context(self._ctx_cpu) # print('for debug, fc1 max', mx.nd.max(global_fc1)) # print('for debug, fc1 min', mx.nd.min(global_fc1)) for i, _module in enumerate(self._arcface_modules): _label = self.global_label - self._ctx_class_start[i] db_global_fc1 = io.DataBatch([global_fc1], [_label]) _module.forward(db_global_fc1) #fc7 with margin
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) #print("sample img shape ",np.shape(_data)) _data = self.resize_img(_data) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.nd_mean is not None: _data = _data.astype('float32') _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) _data = _data.astype('float32') #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 127.5 data = [_data] #print("next data shpe ",np.shape(_data)) try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch+=1 batch_size = self.batch_size i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() try: _data = self.imdecode(s) except Exception as e: logging.debug('Invalid decoding, skipping: %s', str(e)) continue if _data.shape[0]!=self.data_shape[1]: _data = mx.image.resize_short(_data, self.data_shape[1]) _data = _data.asnumpy().astype(np.float32) if self.rand_mirror and np.random.rand()<0.5: _data = _data[:,::-1,:] if self.color_jittering>0: if self.color_jittering>1: _rd = random.randint(0,1) if _rd==1: _data = self.compress_aug(_data) _data = self.color_aug(_data, 0.125) #if self.nd_mean is not None: # _data -= self.nd_mean # _data *= 0.0078125 if self.cutoff>0: _rd = random.randint(0,1) if _rd==1: #print('do cutoff aug', self.cutoff) centerh = random.randint(0, _data.shape[0]-1) centerw = random.randint(0, _data.shape[1]-1) half = self.cutoff//2 starth = max(0, centerh-half) endh = min(_data.shape[0], centerh+half) startw = max(0, centerw-half) endw = min(_data.shape[1], centerw+half) #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 128 #_data -= 127.5 #_data /= 128.0 #self.batch_data[i] = self.postprocess_data(_data) _data = _data.transpose( (2,0,1) ) self.batch_data[i] = _data self.batch_label[i] = label i += 1 except StopIteration: if i<batch_size: raise StopIteration batch_data = nd.array(self.batch_data) batch_label = nd.array(self.batch_label) return io.DataBatch([batch_data], [batch_label], batch_size - i)
def __call__(self, data): """Collate train data into batch.""" img_data = nd.stack(*[item[0] for item in data]) gt_bboxes = _pad_arrs_to_max_length([item[1] for item in data], self._max_gt_box_number, pad_axis=0, pad_val=-1) batch_data = io.DataBatch(data=[img_data], label=[gt_bboxes]) return batch_data
def next(self): """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) #self.nbatch+=1 batch_size = self.batch_size #c, h, w = self.data_shape batch_data = nd.empty(self.provide_data[0][1]) batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: item = self.next_sample() with open(item['image_path'], 'rb') as fin: img = fin.read() try: #if config.to_gray: # _data = mx.image.imdecode(img, flag=0) #to gray #else: # _data = mx.image.imdecode(img) #self.check_valid_image(_data) img = np.fromstring(img, np.uint8) if config.to_gray: _data = cv2.imdecode(img, cv2.IMREAD_GRAYSCALE) else: _data = cv2.imdecode(img, cv2.IMREAD_COLOR) _data = cv2.cvtColor(_data, cv2.COLOR_BGR2RGB) if _data.shape[0]!=config.img_height or _data.shape[1]!=config.img_width: _data = cv2.resize(_data, (config.img_width, config.img_height) ) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue _data = mx.nd.array(_data) #print(_data.shape) #if _data.shape[0]!=config.img_height or _data.shape[1]!=config.img_width: # _data = self.resize_aug(_data) #print(_data.shape) _data = _data.astype('float32') _data -= 127.5 _data *= 0.0078125 data = [_data] label = item['label'] for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i<batch_size: raise StopIteration data_all = [batch_data] if config.use_lstm: data_all += self.init_state_arrays return io.DataBatch(data_all, [batch_label], batch_size - i)
def forward(self, data_batch, is_train=None): assert self.binded and self.params_initialized self._backbone_module.forward(data_batch, is_train=is_train) if is_train: self._iter += 1 fc1, label = self._backbone_module.get_outputs( merge_multi_context=True) global_fc1 = fc1 self.global_label = label.as_in_context(self._ctx_single_gpu) for i, _module in enumerate(self._arcface_modules): _label = self.global_label - self._ctx_class_start[i] db_global_fc1 = io.DataBatch([global_fc1], [_label]) _module.forward(db_global_fc1) #fc7 with margin
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) _data = _data.astype('float32') _data = image.RandomGrayAug(.2)(_data) if random.random() < 0.2: _data = image.ColorJitterAug(0.2, 0.2, 0.2)(_data) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.nd_mean is not None: _data = _data.astype('float32') _data -= self.nd_mean _data *= 0.0078125 data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): data = self.iter.next() img = data['img'] # print(img) img = img.transpose(0, 3, 1, 2) batch_data = nd.array(img, dtype=np.uint8).astype(np.float32) # batch_data = nd.array(img) # print(batch_data.shape) # batch_data = nd.transpose(batch_data, axes=(0, 3, 1, 2)) batch_label = nd.array(data['label']) # .astype(np.int32) batch_index = None if 'index' in data: batch_index = nd.array(data['index']) # print('batch dtype {}'.format(batch_label.dtype)) return io.DataBatch([batch_data], [batch_label], index=batch_index)
def __call__(self, data): """Collate train data into batch.""" img_data = nd.stack(*[item[0] for item in data]) center_targets = nd.stack(*[item[1] for item in data]) scale_targets = nd.stack(*[item[2] for item in data]) weights = nd.stack(*[item[3] for item in data]) objectness = nd.stack(*[item[4] for item in data]) class_targets = nd.stack(*[item[5] for item in data]) gt_bboxes = _pad_arrs_to_max_length([item[6] for item in data], self._max_gt_box_number, pad_axis=0, pad_val=-1) batch_data = io.DataBatch(data=[img_data], label=[gt_bboxes, objectness, center_targets, scale_targets, weights, class_targets]) return batch_data
def next(self): """Yield the next datum for MXNet to run.""" batch_images = nd.empty((self.batch_size, *self.img_shape)) batch_labels = [] for i in range(self.batch_size): batch_images[i][:] = self.image_to_mx(self.read_image()) batch_labels.append(self.read_label()) if self.record: self.bytedata = self.record.read() batch_label_box, batch_label_class, batch_label_score = \ self.batch_label_to_mx(batch_labels) return io.DataBatch( [batch_images], [batch_label_box, batch_label_score, batch_label_class], self.batch_size - 1 - i)
def next(self): if not self.is_init: self.reset() self.is_init=True self.nbatch+=1 batch_size=self.batch_size c,h,w=self.data_shape batch_data=nd.empty((batch_size,c,h,w)) # gender_label=nd.empty((batch_size,self.provide_label[0][1])) age_label=nd.empty(self.provide_label[0][1]) i=0 try: while i<batch_size: label, s, _, _=self.next_sample() _data=mx.image.imdecode(s).asnumpy() #imdecode输入为opencv格式,输出会将bgr=>rgb # if True: # cv2.imshow('_data',_data[:,:,::-1]) # key = cv2.waitKey(1000) if np.random.random()>0.5: _data=_data[:,::-1] if np.random.random()>0.75: _data=self.random_rotation(x=_data,rg=20,row_axis=0,col_axis=1,channel_axis=2) if np.random.random()>0.75: _data=self.random_shear(x=_data,intensity=0.2,row_axis=0,col_axis=1,channel_axis=2) if np.random.random()>0.75: _data=self.random_shift(x=_data,wrg=0.2,hrg=0.2,row_axis=0,col_axis=1,channel_axis=2) if np.random.random()>0.75: _data=self.random_zoom(x=_data,zoom_range=[0.8,1.2],row_axis=0,col_axis=1,channel_axis=2) batch_data[i][:]=self.postprocess_data(mx.nd.array(_data)) # gender_label[i][:]=label[1] age_label[i][:]=label[0] i+=1 # if True: # cv2.imshow('aur_data',_data[:,:,::-1]) # cv2.waitKey(1000) except StopIteration: if i<batch_size: raise StopIteration return io.DataBatch([batch_data], [age_label], batch_size - i)
def get_input_shape(sym, proto_obj): """Helper function to obtain the shape of an array""" arg_params = proto_obj.arg_dict aux_params = proto_obj.aux_dict model_input_shape = [ data[1] for data in proto_obj.model_metadata.get('input_tensor_data') ] data_names = [ data[0] for data in proto_obj.model_metadata.get('input_tensor_data') ] # creating dummy inputs inputs = [] for in_shape in model_input_shape: inputs.append(nd.ones(shape=in_shape)) data_shapes = [] for idx, input_name in enumerate(data_names): data_shapes.append((input_name, inputs[idx].shape)) ctx = context.cpu() # create a module mod = module.Module(symbol=sym, data_names=data_names, context=ctx, label_names=None) mod.bind(for_training=False, data_shapes=data_shapes, label_shapes=None) mod.set_params(arg_params=arg_params, aux_params=aux_params) data_forward = [] for idx, input_name in enumerate(data_names): val = inputs[idx] data_forward.append(val) mod.forward(io.DataBatch(data_forward)) result = mod.get_outputs()[0].asnumpy() return result.shape
def forward(self, data_batch, is_train=None): #g,x = self.get_params() #print('{fc7_weight[0][0]}', self._iter, g['fc7_0_weight'].asnumpy()[0][0]) #print('{pre_fc1_weight[0][0]}', self._iter, g['pre_fc1_weight'].asnumpy()[0][0]) assert self.binded and self.params_initialized self._curr_module.forward(data_batch, is_train=is_train) if is_train: self._iter += 1 fc1, label = self._curr_module.get_outputs( merge_multi_context=True) global_fc1 = fc1 self.global_label = label.as_in_context(self._ctx_cpu).reshape([ -1, ]) for i, _module in enumerate(self._arcface_modules): _label = self.global_label - self._ctx_class_start[i] _label = _label.reshape([ -1, ]) db_global_fc1 = io.DataBatch([global_fc1], [_label]) _module.forward(db_global_fc1) #fc7 with margin
def next(self): if self.need_init: self.reset() self.need_init = False """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: _label, s, pos_flag, score = self.next_sample() label = pos_flag _data = self.imdecode(s) _data = self.augs.apply(_data) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration self.iteration += 1 return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: #print('XXXX', i) label, s, bbox, landmark = self.next_sample() gender = int(label[0]) age = int(label[1]) assert age >= 0 #assert gender==0 or gender==1 plabel = np.zeros(shape=(101, ), dtype=np.float32) plabel[0] = gender if age == 0: age = 1 if age > 100: age = 100 plabel[1:age + 1] = 1 label = plabel _data = self.imdecode(s) if _data.shape[0] != self.data_shape[1]: _data = mx.image.resize_short(_data, self.data_shape[1]) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.color_jittering > 0: if self.color_jittering > 1: _rd = random.randint(0, 1) if _rd == 1: _data = self.compress_aug(_data) #print('do color aug') _data = _data.astype('float32', copy=False) #print(_data.__class__) _data = self.color_aug(_data, 0.125) if self.nd_mean is not None: _data = _data.astype('float32', copy=False) _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: _rd = random.randint(0, 1) if _rd == 1: #print('do cutoff aug', self.cutoff) centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 128 data = [_data] for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" self.nbatch += 1 c, h, w = self.data_shape batch_data_srctar = nd.empty((2 * self.batch_size_src, c, h, w)) batch_data_t = nd.empty((2 * self.batch_size_src, c, h, w)) batch_label_srctar = nd.empty(self.provide_label_srctar[0][1]) batch_label_t = nd.empty(self.provide_label_srctar[0][1]) batch_data_tar = nd.empty((self.batch_size_src, c, h, w)) batch_data_adv = nd.empty((self.batch_size_src, c, h, w)) batch_data = nd.empty((3 * self.batch_size_src, c, h, w)) batch_label = nd.empty(self.provide_label[0][1]) arg_t, aux_t = self.model.get_params() self.model_adv.set_params(arg_t, aux_t) #print("update model_adv params") #time_now2 = datetime.datetime.now() #print("update params time", time_now2-time_now1) i = 0 try: while i < self.batch_size_src: label, img = self.next_sample1() batch_data_srctar[i][:] = img batch_label_srctar[i][:] = label i += 1 except StopIteration: if i < self.batch_size_src: raise StopIteration try: while i < 2 * self.batch_size_src: label, img = self.next_sample2() #print(img) #img_show = np.squeeze(img) #img_show = img_show.astype(np.uint8) #print("img.shape:", img_show.shape) #plt.imshow(img_show) #plt.show() batch_data_srctar[i][:] = img batch_label_srctar[i][:] = label i += 1 except StopIteration: if i < 2 * self.batch_size_src: raise StopIteration #print("batch_label_srctar:", batch_label_srctar) margin = self.batch_size_src // self.ctx_num #print("margin: ",margin) for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = batch_data_srctar[i * margin:(i + 1) * margin][:] batch_data_t[ (2 * i + 1) * margin:2 * (i + 1) * margin][:] = batch_data_srctar[self.batch_size_src + i * margin:self.batch_size_src + (i + 1) * margin][:] for i in xrange(self.ctx_num): batch_label_t[2 * i * margin:(2 * i + 1) * margin][:] = batch_label_srctar[i * margin:(i + 1) * margin][:] batch_label_t[ (2 * i + 1) * margin:2 * (i + 1) * margin][:] = batch_label_srctar[self.batch_size_src + i * margin:self.batch_size_src + (i + 1) * margin][:] #print("batch_data_t:", batch_data_t[0][:],batch_data_t) batch_data_t_o = batch_data_t db = mx.io.DataBatch([batch_data_t]) self.model_adv.forward(db, is_train=True) ori_out = self.model_adv.get_outputs()[-1].asnumpy() #print("ori_dis: ", ori_out) self.model_adv.backward() grad = self.model_adv.get_input_grads()[0] #print("grad: ", grad) grad = mx.nd.array(grad) #print("batch_data_t: ", batch_data_t.asnumpy().shape) for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] -= 1 / 255 * mx.nd.sign( grad[2 * i * margin:(2 * i + 1) * margin][:]) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.maximum( mx.nd.maximum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], batch_data_t_o[2 * i * margin:(2 * i + 1) * margin][:] - self.sigma), mx.nd.zeros_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:])) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.minimum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], mx.nd.minimum( batch_data_t_o[2 * i * margin:(2 * i + 1) * margin][:] + self.sigma, mx.nd.ones_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:]))) #print("first") for i in range(0, self.round - 1): db = mx.io.DataBatch([batch_data_t]) self.model_adv.forward(db, is_train=True) adv_out = self.model_adv.get_outputs()[-1].asnumpy() #print("adv_dis: ", i, adv_out, np.max(adv_out)) if np.max(adv_out) > self.thd: self.model_adv.backward() grad = self.model_adv.get_input_grads()[0] grad = mx.nd.array(grad) for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] -= 1 / 255 * mx.nd.sign( grad[2 * i * margin:(2 * i + 1) * margin][:]) batch_data_t[2 * i * margin:( 2 * i + 1) * margin][:] = mx.nd.maximum( mx.nd.maximum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], batch_data_t_o[2 * i * margin:(2 * i + 1) * margin][:] - self.sigma), mx.nd.zeros_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:])) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.minimum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], mx.nd.minimum( batch_data_t_o[2 * i * margin:(2 * i + 1) * margin][:] + self.sigma, mx.nd.ones_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:]))) else: #print("adv_dis: ", i) break db = mx.io.DataBatch([batch_data_t]) self.model_adv.forward(db, is_train=True) adv_out = self.model_adv.get_outputs()[-1].asnumpy() #print("adv_dis: ", adv_out) ''' for i in xrange(5): imgadv_show = np.squeeze(batch_data_t[i][0][:].asnumpy()) imgadv_show = imgadv_show.astype(np.uint8) print("imgadv_show.type: ", imgadv_show.astype) #imgadv_show = np.transpose(imgadv_show, (1, 2, 0)) plt.imshow(imgadv_show) plt.show() ''' for i in xrange(self.ctx_num): batch_data_adv[i * margin:(i + 1) * margin][:] = batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] batch_data_src = batch_data_srctar[0:self.batch_size_src][:] batch_data_tar = batch_data_srctar[self.batch_size_src:2 * self.batch_size_src][:] #for i in xrange(self.ctx_num): # batch_data_tar[i * margin: (i + 1) * margin][:] = batch_data_t[(2 * i + 1) * margin:2 * (i + 1) * margin][:] batch_label_src = batch_label_srctar[0:self.batch_size_src][:] batch_label_tar = batch_label_srctar[self.batch_size_src:2 * self.batch_size_src][:] #print("labels: " , batch_label_src , batch_label_tar) margin = self.batch_size_src // self.main_ctx_num # 30 for i in xrange(self.main_ctx_num): # 0 1 2 3 batch_data[margin * 3 * i:margin * 3 * i + margin][:] = batch_data_src[margin * i:margin * i + margin][:] batch_data[margin * 3 * i + margin:margin * 3 * i + 2 * margin][:] = batch_data_tar[margin * i:margin * i + margin][:] batch_data[margin * 3 * i + 2 * margin:margin * 3 * i + 3 * margin][:] = batch_data_adv[margin * i:margin * i + margin][:] for i in xrange(self.main_ctx_num): batch_label[margin * 3 * i:margin * 3 * i + margin][:] = batch_label_src[margin * i:margin * i + margin][:] batch_label[margin * 3 * i + margin:margin * 3 * i + 2 * margin][:] = batch_label_tar[margin * i:margin * i + margin][:] batch_label[margin * 3 * i + 2 * margin:margin * 3 * i + 3 * margin][:] = batch_label_src[margin * i:margin * i + margin][:] #print('batch_label: ', batch_label) ''' for i in xrange(2): imgadv_show = np.squeeze(batch_data[i][0][:].asnumpy()) print(imgadv_show) #imgadv_show = imgadv_show.astype(np.uint8) print(imgadv_show) print("imgadv_show.type: ", imgadv_show.astype) #imgadv_show = np.transpose(imgadv_show, (1, 2, 0)) plt.imshow(imgadv_show) plt.show() ''' return io.DataBatch([batch_data], [batch_label])
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch+=1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) if self.rand_mirror: _rd = random.randint(0,1) if _rd==1: _data = mx.ndarray.flip(data=_data, axis=1) if self.cutoff>0: centerh = random.randint(0, _data.shape[0]-1) centerw = random.randint(0, _data.shape[1]-1) half = self.cutoff//2 starth = max(0, centerh-half) endh = min(_data.shape[0], centerh+half) startw = max(0, centerw-half) endw = min(_data.shape[1], centerw+half) _data = _data.astype('float32') #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 127.5 #_npdata = _data.asnumpy() #if landmark is not None: # _npdata = face_preprocess.preprocess(_npdata, bbox = bbox, landmark=landmark, image_size=self.image_size) #if self.rand_mirror: # _npdata = self.mirror_aug(_npdata) #if self.mean is not None: # _npdata = _npdata.astype(np.float32) # _npdata -= self.mean # _npdata *= 0.0078125 #nimg = np.zeros(_npdata.shape, dtype=np.float32) #nimg[self.patch[1]:self.patch[3],self.patch[0]:self.patch[2],:] = _npdata[self.patch[1]:self.patch[3], self.patch[0]:self.patch[2], :] #_data = mx.nd.array(nimg) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) if self.provide_label is not None: batch_label[i][:] = label i += 1 except StopIteration: if i<batch_size: raise StopIteration #print('next end', batch_size, i) _label = None if self.provide_label is not None: _label = [batch_label] return io.DataBatch([batch_data], _label, batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) if _data.shape[0] != self.data_shape[1]: _data = mx.image.resize_short(_data, self.data_shape[1]) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.blur: aug_blur = iaa.Sequential([ iaa.OneOf([ iaa.GaussianBlur(sigma=(0.5, 2.5)), iaa.AverageBlur(k=(2, 5)), iaa.MotionBlur(k=(5, 7)), iaa.BilateralBlur(d=(3, 4), sigma_color=(10, 250), sigma_space=(10, 250)), iaa.imgcorruptlike.DefocusBlur(severity=1), iaa.imgcorruptlike.GlassBlur(severity=1), iaa.imgcorruptlike.Pixelate(severity=(1, 3)), iaa.Pepper(0.01), iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255), per_channel=True), iaa.imgcorruptlike.SpeckleNoise(severity=1), iaa.imgcorruptlike.JpegCompression(severity=(1, 4)), ]) ]) _rd = random.randint(0, 1) if _rd == 1: _data = aug_blur(images=_data) if self.maxpooling: maxpool_aug = iaa.MaxPooling(2) _rd = random.randint(0, 1) if _rd == 1: _data = maxpool_aug(images=_data) if self.color_jittering > 0: if self.color_jittering > 1: _rd = random.randint(0, 1) if _rd == 1: _data = self.compress_aug(_data) #print('do color aug') _data = _data.astype('float32', copy=False) #print(_data.__class__) _data = self.color_aug(_data, 0.125) if self.nd_mean is not None: _data = _data.astype('float32', copy=False) _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: _rd = random.randint(0, 1) if _rd == 1: #print('do cutoff aug', self.cutoff) centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 128 data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) features_data = np.zeros((batch_size, 512)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) features_data[i, :] = self.train_features[self.seq[self.cur - 1] - 1, :] if _data.shape[0] != self.data_shape[1]: _data = mx.image.resize_short(_data, self.data_shape[1]) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) features_data[i, :] = self.train_features_flip[ self.seq[self.cur - 1] - 1, :] if self.color_jittering > 0: if self.color_jittering > 1: _rd = random.randint(0, 1) if _rd == 1: _data = self.compress_aug(_data) #print('do color aug') _data = _data.astype('float32', copy=False) #print(_data.__class__) _data = self.color_aug(_data, 0.125) if self.nd_mean is not None: _data = _data.astype('float32', copy=False) _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: _rd = random.randint(0, 1) if _rd == 1: #print('do cutoff aug', self.cutoff) centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 128 data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], ), features_data
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) #例如10个 3*5*5,的shape if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) #一维 mix_lab = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) if _data.shape[0] != self.data_shape[1]: _data = mx.image.resize_short(_data, self.data_shape[1]) ### differ resize if self.rand_resize: inputResize = mx.image.ForceResizeAug(size=(112, 112)) _r = random.randint(0, 6) # random 0 1 2 3 4 5 #resolution is 30 40 50 60 if _r < 3: # 20 26 32 38 resolutionResize = mx.image.ForceResizeAug( size=(20 + 6 * _r, 20 + 6 * _r)) _data = resolutionResize(_data) _data = inputResize(_data) else: # 24 34 44 54, rr = _r resolutionResize = mx.image.ForceResizeAug( size=(24 + 10 * rr, 24 + 10 * rr)) _data = resolutionResize(_data) _data = inputResize(_data) ############################################### ## all_ low resize # if self.rand_resize: # inputResize = mx.image.ForceResizeAug(size=(112,112)) # _r=random.randint(0,6) # random 0 1 2 3 4 5 # #resolution is 30 40 50 60 # if _r<3:# 28 34 40 # resolutionResize = mx.image.ForceResizeAug(size=(28+6*_r,28+6*_r)) # _data = resolutionResize(_data) # _data = inputResize(_data) # else: # 30 40 50 60 # rr=_r # resolutionResize = mx.image.ForceResizeAug(size=(30+10*(rr-3),30+10*(rr-3))) # _data = resolutionResize(_data) # _data = inputResize(_data) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.color_jittering > 0: if self.color_jittering > 1: _rd = random.randint(0, 1) if _rd == 1: _data = self.compress_aug(_data) #print('do color aug') _data = _data.astype('float32', copy=False) #print(_data.__class__) _data = self.color_aug(_data, 0.125) if self.nd_mean is not None: _data = _data.astype('float32', copy=False) _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: _rd = random.randint(0, 1) if _rd == 1: #print('do cutoff aug', self.cutoff) centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 128 data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data( datum) #hwc,to chw一个一个填充到batch 大小的图片label batch_label[ i][:] = label #[2.0 108.0......] #batch 个label i += 1 except StopIteration: if i < batch_size: raise StopIteration # add SamplePairing not mixup # if self.mix_up: #True alpha=0.2 alpha = 0.4 #0.2增大到0.4 lam = 0.4 SP_mixup = False if SP_mixup and random.randint(0, 1): # 随机一个batch mixup if alpha > 0.: #lam 设置0.2中间值很少,接近0 或者1 的随机值,适合人脸混叠 lam = np.random.beta(alpha, alpha, [batch_size, 1]) # 产生batch个随机值, # ...[9.98583138e-08] # [9.99157586e-01] # [2.03985548e-02] # [2.86226043e-01]] else: lam = np.ones((batch_size, 1)) lam_nd = nd.array(np.tile(lam[..., None, None], [1, 3, 112, 112])) #img size chw index = np.random.permutation( batch_size) #打乱一个batch ,和原始batch 相当于两个batch mix_img = batch_data * lam_nd + batch_data[index] * ( 1 - lam_nd) #(batch, 3, 112, 112) mix_img = (mix_img.astype('int', copy=False)).astype('float32', copy=False) ####label, batch_label batch_label[] # batch_label[index] for ind in range(batch_size): if lam[ind] < 0.5: #数据大于0.5 标签是a mix_lab[ind][:] = batch_label[index][ ind] #batch B(改变索引顺序的标签) else: #>=0.5 if lam[ind] > 0.5: mix_lab[ind][:] = batch_label[ind] #batch a 的标签 else: #=0.5 随机标签 if random.randint(0, 1) == 0: mix_lab[ind][:] = batch_label[ind] else: mix_lab[ind][:] = batch_label[index][ind] # print(mix_lab) # print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%>=0.5") # print (batch_label) # print("%****************************************") # print(mix_lab.shape) # print (batch_label.shape) return io.DataBatch([mix_img], [mix_lab], batch_size - i) else: return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True self.nbatch += 1 batch_size1 = self.batch_size1 interclass_size = self.batchsize_id c, h, w = self.data_shape batch_data = nd.empty((batch_size1 + interclass_size, c, h, w)) batch_data_t = nd.empty((batch_size1 + interclass_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) batch_label_t = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size1: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) _data = _data.astype('float32') _data = image.RandomGrayAug(.2)(_data) if random.random() < 0.2: _data = image.ColorJitterAug(0.2, 0.2, 0.2)(_data) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue for datum in data: assert i < batch_size1, 'Batch size must be multiples of augmenter output length' # print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size1: raise StopIteration try: while i < interclass_size + batch_size1: label, s, bbox, landmark = self.next_sample2() _data = self.imdecode(s) _data = _data.astype('float32') _data = image.RandomGrayAug(.2)(_data) if random.random() < 0.2: _data = image.ColorJitterAug(0.2, 0.2, 0.2)(_data) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue for datum in data: assert i < interclass_size + batch_size1, 'Batch size must be multiples of augmenter output length' # print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < interclass_size + batch_size1: raise StopIteration margin = batch_size1 // self.ctx_num for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = batch_data[i * margin:(i + 1) * margin][:] batch_data_t[(2 * i + 1) * margin:2 * (i + 1) * margin][:] = batch_data[batch_size1 + i * margin:batch_size1 + (i + 1) * margin][:] for i in xrange(self.ctx_num): batch_label_t[2 * i * margin:(2 * i + 1) * margin][:] = batch_label[i * margin:(i + 1) * margin][:] batch_label_t[(2 * i + 1) * margin:2 * (i + 1) * margin][:] = batch_label[batch_size1 + i * margin:batch_size1 + (i + 1) * margin][:] return io.DataBatch([batch_data_t], [batch_label_t])
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" self.nbatch += 1 c, h, w = self.data_shape batch_data_srctar = nd.empty((2 * self.batch_size_src, c, h, w)) batch_data_t = nd.empty((2 * self.batch_size_src, c, h, w)) batch_label_srctar = nd.empty(self.provide_label_srctar[0][1]) batch_label_t = nd.empty(self.provide_label_srctar[0][1]) batch_data_tar = nd.empty((self.batch_size_src, c, h, w)) batch_data_adv = nd.empty((self.batch_size_src, c, h, w)) batch_data = nd.empty((3 * self.batch_size_src, c, h, w)) batch_label = nd.empty(self.provide_label[0][1]) #time_now1 = datetime.datetime.now() arg_t, aux_t = self.model.get_params() self.model_adv.set_params(arg_t, aux_t) #print("update model_adv params") #time_now2 = datetime.datetime.now() #print("update params time", time_now2-time_now1) i = 0 try: while i < self.batch_size_src: label, s, bbox, landmark = self.next_sample1() _data = self.imdecode(s) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.nd_mean is not None: _data = _data.astype('float32') _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) _data = _data.astype('float32') _data[starth:endh, startw:endw, :] = 127.5 data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue for datum in data: assert i < self.batch_size_src, 'Batch size must be multiples of augmenter output length' batch_data_srctar[i][:] = self.postprocess_data(datum) batch_label_srctar[i][:] = label i += 1 except StopIteration: if i < self.batch_size_src: raise StopIteration try: while i < 2 * self.batch_size_src: label, s, bbox, landmark = self.next_sample2() _data = self.imdecode(s) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.nd_mean is not None: _data = _data.astype('float32') _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) _data = _data.astype('float32') _data[starth:endh, startw:endw, :] = 127.5 data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue for datum in data: assert i < 2 * self.batch_size_src, 'Batch size must be multiples of augmenter output length' batch_data_srctar[i][:] = self.postprocess_data(datum) batch_label_srctar[i][:] = label i += 1 except StopIteration: if i < 2 * self.batch_size_src: raise StopIteration #print("batch_label_srctar:", batch_label_srctar) margin = self.batch_size_src // self.ctx_num #print("margin: ",margin) for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = batch_data_srctar[i * margin:(i + 1) * margin][:] batch_data_t[ (2 * i + 1) * margin:2 * (i + 1) * margin][:] = batch_data_srctar[self.batch_size_src + i * margin:self.batch_size_src + (i + 1) * margin][:] for i in xrange(self.ctx_num): batch_label_t[2 * i * margin:(2 * i + 1) * margin][:] = batch_label_srctar[i * margin:(i + 1) * margin][:] batch_label_t[ (2 * i + 1) * margin:2 * (i + 1) * margin][:] = batch_label_srctar[self.batch_size_src + i * margin:self.batch_size_src + (i + 1) * margin][:] #print("batch_label_t:", batch_label_t) db = mx.io.DataBatch([batch_data_t]) self.model_adv.forward(db, is_train=True) ori_out = self.model_adv.get_outputs()[-1].asnumpy() #print("ori_dis: ", ori_out) self.model_adv.backward() grad = self.model_adv.get_input_grads()[0] #print("grad: ", grad) grad = mx.nd.array(grad) #print("batch_data_t: ", batch_data_t.asnumpy().shape) for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] -= self.sigma * mx.nd.sign( grad[2 * i * margin:(2 * i + 1) * margin][:]) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.maximum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], mx.nd.zeros_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:])) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.minimum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], 255 * mx.nd.ones_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:])) #print("first") for i in range(0, self.round - 1): db = mx.io.DataBatch([batch_data_t]) self.model_adv.forward(db, is_train=True) adv_out = self.model_adv.get_outputs()[-1].asnumpy() #print("adv_dis: ", i, adv_out, np.max(adv_out)) if np.max(adv_out) > self.thd: self.model_adv.backward() grad = self.model_adv.get_input_grads()[0] grad = mx.nd.array(grad) for i in xrange(self.ctx_num): batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] -= self.sigma * mx.nd.sign( grad[2 * i * margin:(2 * i + 1) * margin][:]) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.maximum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], mx.nd.zeros_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:])) batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] = mx.nd.minimum( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:], 255 * mx.nd.ones_like( batch_data_t[2 * i * margin:(2 * i + 1) * margin][:])) else: #print("adv_dis: ", i) break db = mx.io.DataBatch([batch_data_t]) self.model_adv.forward(db, is_train=True) adv_out = self.model_adv.get_outputs()[-1].asnumpy() #print("adv_dis: ", adv_out) #imgadv_show = np.squeeze(batch_data_t[0][:].asnumpy()) #imgadv_show = imgadv_show.astype(np.uint8) # print("imgadv_show.type: ", imgadv_show.astype) #imgadv_show = np.transpose(imgadv_show, (1, 2, 0)) #plt.imshow(imgadv_show) #plt.show() for i in xrange(self.ctx_num): batch_data_adv[i * margin:(i + 1) * margin][:] = batch_data_t[2 * i * margin:(2 * i + 1) * margin][:] batch_data_src = batch_data_srctar[0:self.batch_size_src][:] batch_data_tar = batch_data_srctar[self.batch_size_src:2 * self.batch_size_src][:] #for i in xrange(self.ctx_num): # batch_data_tar[i * margin: (i + 1) * margin][:] = batch_data_t[(2 * i + 1) * margin:2 * (i + 1) * margin][:] batch_label_src = batch_label_srctar[0:self.batch_size_src][:] batch_label_tar = batch_label_srctar[self.batch_size_src:2 * self.batch_size_src][:] #print("labels: " , batch_label_src , batch_label_tar) margin = self.batch_size_src // self.main_ctx_num # 30 for i in xrange(self.main_ctx_num): # 0 1 2 3 batch_data[margin * 3 * i:margin * 3 * i + margin][:] = batch_data_src[margin * i:margin * i + margin][:] batch_data[margin * 3 * i + margin:margin * 3 * i + 2 * margin][:] = batch_data_tar[margin * i:margin * i + margin][:] batch_data[margin * 3 * i + 2 * margin:margin * 3 * i + 3 * margin][:] = batch_data_adv[margin * i:margin * i + margin][:] for i in xrange(self.main_ctx_num): batch_label[margin * 3 * i:margin * 3 * i + margin][:] = batch_label_src[margin * i:margin * i + margin][:] batch_label[margin * 3 * i + margin:margin * 3 * i + 2 * margin][:] = batch_label_tar[margin * i:margin * i + margin][:] batch_label[margin * 3 * i + 2 * margin:margin * 3 * i + 3 * margin][:] = batch_label_src[margin * i:margin * i + margin][:] #print("batch labels: ", batch_label) return io.DataBatch([batch_data], [batch_label])
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.nd_mean is not None: _data = _data.astype('float32') _data -= self.nd_mean _data *= 0.0078125 #_npdata = _data.asnumpy() #if landmark is not None: # _npdata = face_preprocess.preprocess(_npdata, bbox = bbox, landmark=landmark, image_size=self.image_size) #if self.rand_mirror: # _npdata = self.mirror_aug(_npdata) #if self.mean is not None: # _npdata = _npdata.astype(np.float32) # _npdata -= self.mean # _npdata *= 0.0078125 #nimg = np.zeros(_npdata.shape, dtype=np.float32) #nimg[self.patch[1]:self.patch[3],self.patch[0]:self.patch[2],:] = _npdata[self.patch[1]:self.patch[3], self.patch[0]:self.patch[2], :] #_data = mx.nd.array(nimg) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) if self.provide_label is not None: if not self.coco_mode: if len(batch_label.shape) == 1: batch_label[i][:] = label else: for ll in xrange(batch_label.shape[1]): v = label[ll] if ll > 0: c2c = v #m = min(0.55, max(0.3,math.log(c2c+1)*4-1.85)) #v = math.cos(m) #v = v*v #_param = [0.5, 0.3, 0.85, 0.7] _param = [0.5, 0.4, 0.85, 0.75] #_param = [0.55, 0.4, 0.9, 0.75] _a = (_param[1] - _param[0]) / ( _param[3] - _param[2]) m = _param[1] + _a * (c2c - _param[3]) m = min(_param[0], max(_param[1], m)) #m = 0.5 #if c2c<0.77: # m = 0.3 #elif c2c<0.82: # m = 0.4 #elif c2c>0.88: # m = 0.55 v = math.cos(m) v = v * v #print('c2c', i,c2c,m,v) batch_label[i][ll] = v else: batch_label[i][:] = (i % self.per_batch_size ) // self.images_per_identity i += 1 except StopIteration: if i < batch_size: raise StopIteration #print('next end', batch_size, i) _label = None if self.provide_label is not None: _label = [batch_label] if self.data_extra is not None: return io.DataBatch([batch_data, self.data_extra], _label, batch_size - i) else: return io.DataBatch([batch_data], _label, batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" # print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) if _data.shape[0] != self.data_shape[1]: _data = mx.image.resize_short(_data, self.data_shape[1]) if self.rand_mirror: _rd = random.randint(0, 5) # change sai if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.color_jittering > 0: if self.color_jittering > 1: _rd = random.randint(0, 1) if _rd == 1: _data = self.compress_aug(_data) _rd = random.randint(0, 5) # change sai if _rd == 1: _data = _data.astype('float32', copy=False) _data = self.color_aug(_data, 0.125) if self.nd_mean is not None: _data = _data.astype('float32', copy=False) _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: _rd = random.randint(0, 10) # change sai if _rd == 1: rate = random.randint(1, 5) xmin = rate ymin = rate xmax = int(self.data_shape[1]) - rate ymax = int(self.data_shape[2]) - rate _data = _data[ymin:ymax, xmin:xmax, :] _data = mx.image.resize_short(_data, self.data_shape[1]) if self.shelter: _rd = random.randint(0, 10) # change sai if _rd == 1: # change sai xmin = random.randint(15, 100) ymin = random.randint(15, 100) xmax = xmin + random.randint(5, 10) ymax = ymin + random.randint(5, 10) _data = _data.astype('float32') _data[ymin:ymax, xmin:xmax, :] = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)) data = [_data] try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue # print('aa',data[0].shape) # data = self.augmentation_transform(data) # print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' # print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label i += 1 except StopIteration: if i < batch_size: raise StopIteration return io.DataBatch([batch_data], [batch_label], batch_size - i)
def next(self): if not self.is_init: self.reset() self.is_init = True pass self.n_batch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, image_str = self.next_sample() # image_str ---> NDArray 112x112x3 # 可以 image_arr.asnumpy() ---> numpy array type # plt.imshow() 来展示 image_arr = mx.image.imdecode(image_str) if image_arr.shape[0] != image_arr.shape[1]: image_arr = mx.image.resize_short(image_arr, self.data_shape[1]) pass # 镜像翻转 if self.rand_mirror: rand_int = np.random.randint(0, 2) if rand_int == 1: image_arr = mx.ndarray.flip(data=image_arr, axis=1) pass pass if self.color_jitter > 0: if self.color_jitter > 1: rand_int = np.random.randint(0, 2) if rand_int == 1: # 精简增强 image_arr = self.compress_aug(image_arr) pass pass # 将 像素转为 float32 image_arr = image_arr.astype("float32", copy=False) # 颜色增强 image_arr = self.color_jitter_aug(image_arr) pass if self.nd_mean is not None: image_arr = image_arr.astype('float32', copy=False) image_arr -= self.nd_mean image_arr *= 0.0078125 pass # 随机裁剪 if self.cutoff > 0: rand_int = np.random.randint(0, 2) if rand_int == 1: center_h = np.random.randint(0, image_arr.shape[0]) center_w = np.random.randint(0, image_arr.shape[1]) half = self.cutoff // 2 start_h = max(0, center_h - half) end_h = min(image_arr.shape[0], center_h + half) start_w = max(0, center_w - half) end_w = min(image_arr.shape[1], center_w + half) image_arr[start_h:end_h, start_w:end_w, :] = 128 pass pass image_data = [image_arr] try: # 检测图像数据 self.check_valid_image(image_data) pass except RuntimeError as e: print("Invalid image, skipping: {}".format(e)) continue pass for image_info in image_data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' # [height, width, channel] ---> [channel, height, width] batch_data[i][:] = self.post_process_data(image_info) batch_label[i][:] = label i += 1 pass pass pass except StopIteration: if i < batch_size: raise StopIteration pass return io.DataBatch([batch_data], [batch_label], batch_size - i) pass
def next(self): if not self.is_init: self.reset() self.is_init = True """Returns the next batch of data.""" #print('in next', self.cur, self.labelcur) self.nbatch += 1 batch_size = self.batch_size c, h, w = self.data_shape batch_data = nd.empty((batch_size, c, h, w)) if self.provide_label is not None: batch_label = nd.empty(self.provide_label[0][1]) i = 0 try: while i < batch_size: label, s, bbox, landmark = self.next_sample() _data = self.imdecode(s) # if _data.shape[0]!=self.data_shape[1]: # _data = mx.image.resize_short(_data, self.data_shape[1]) # add by yan, 1127 _data, _ = mx.image.random_crop(_data, (w, h)) if self.rand_mirror: _rd = random.randint(0, 1) if _rd == 1: _data = mx.ndarray.flip(data=_data, axis=1) if self.color_jittering > 0: if self.color_jittering > 1: _rd = random.randint(0, 1) if _rd == 1: _data = self.compress_aug(_data) #print('do color aug') _data = _data.astype('float32', copy=False) #print(_data.__class__) _data = self.color_aug(_data, 0.125) if self.nd_mean is not None: # print('mean is not none') _data = _data.astype('float32', copy=False) _data -= self.nd_mean _data *= 0.0078125 if self.cutoff > 0: _rd = random.randint(0, 1) if _rd == 1: #print('do cutoff aug', self.cutoff) centerh = random.randint(0, _data.shape[0] - 1) centerw = random.randint(0, _data.shape[1] - 1) half = self.cutoff // 2 starth = max(0, centerh - half) endh = min(_data.shape[0], centerh + half) startw = max(0, centerw - half) endw = min(_data.shape[1], centerw + half) #print(starth, endh, startw, endw, _data.shape) _data[starth:endh, startw:endw, :] = 128 data = [_data] # print ('data is :', data) try: self.check_valid_image(data) except RuntimeError as e: logging.debug('Invalid image, skipping: %s', str(e)) continue #print('aa',data[0].shape) #data = self.augmentation_transform(data) #print('bb',data[0].shape) for datum in data: assert i < batch_size, 'Batch size must be multiples of augmenter output length' #print(datum.shape) batch_data[i][:] = self.postprocess_data(datum) batch_label[i][:] = label[0] i += 1 except StopIteration: if i < batch_size: raise StopIteration # for i in range(len(batch_label)): # # print('for debug , batch label is :{}, shape is {}'.format(batch_label, batch_label.shape)) # if 0 < batch_label[i][0] and batch_label[i][0] < 20: # print('in the middle') # #return nd.transpose(datum, axes=(2, 0, 1)) # print('image tmp: ', batch_data[i].shape) # tmp_data = nd.transpose(batch_data[i], axes=(2, 1, 0)) # print('image data shape is: ', tmp_data.shape) # if not os.path.exists('./debug-rec/{}'.format(str(i))): # os.mkdir('./debug-rec/{}'.format(str(i))) # # from numpy import random # img_name = random.randint(0, 10000) # tmp_img = cv2.imwrite('./debug-rec/{}/{}.jpg'.format(str(i), img_name), tmp_data.asnumpy()) return io.DataBatch([batch_data], [batch_label], batch_size - i)