def next(self): crop_size = (self.data_shape[3], self.data_shape[2]) batch_data = mx.ndarray.empty(self.data_shape) i = 0 if self.pic_cnt < NUM_TEST_PICS: for prod in self.bff_iter: str_image = io.BytesIO(prod['pic']).read() picture = mx.img.imdecode(str_image) picture = mx.img.CenterCropAug(crop_size, 2)(picture) picture = mx.ndarray.transpose(picture, axes=(2, 0, 1)) batch_data[i] = picture i += 1 self.pic_cnt += 1 if self.pic_cnt % 1000 == 0 or self.pic_cnt == NUM_TEST_PICS: logger.info("converted {} images".format(self.pic_cnt)) if self.pic_cnt % self.batch_size == 0: return DataBatch(data=[batch_data], pad=0, index=None, provide_data=self.provide_data) elif self.pic_cnt == NUM_TEST_PICS: return DataBatch(data=[batch_data], pad=self.batch_size - i, index=None, provide_data=self.provide_data) else: raise StopIteration
def _produce_data(self): while True: images = mx.nd.zeros((self.batch_size, 3, self.crop_size, self.crop_size)) mask_dim = int(self.crop_size * self.label_shrink_scale) masks = mx.nd.zeros((self.batch_size, mask_dim * mask_dim)) if self.provide_g_labels: g_labels = mx.nd.zeros((self.batch_size, self.class_num, 1, 1)) sub_list = self.flist_item_queue.get() batch_images = [] for image_path in list(sub_list): buf = mx.nd.array( np.frombuffer(open(os.path.join(self.im_root, image_path+".jpg"), 'rb').read(), dtype=np.uint8), dtype=np.uint8, ctx=mx.cpu()) batch_images.append(mx.image.imdecode(buf)) batch_labels = [] for ind, label_path in enumerate(sub_list): mask = Image.open(os.path.join(self.mask_root, label_path+".png")) mask_arr = np.array(mask, dtype=np.uint8) if self.provide_g_labels: g_l_arr = np.zeros(self.class_num, dtype=np.uint8) ul = np.unique(mask_arr) ul = ul[ul != 255] g_l_arr[ul] = 1 g_l_arr = g_l_arr.reshape(-1, 1, 1) g_labels[ind][:] = g_l_arr batch_labels.append(mask_arr) for ind in range(len(batch_images)): im_arr = batch_images[ind] l_arr = batch_labels[ind] r_start, c_start, new_crop_size = preprocessing.calc_crop_params(im_arr, self.scale_range, self.crop_size) if self.random_flip: im_arr, l_arr = preprocessing.random_flip(im_arr, l_arr) im_arr, l_arr = preprocessing.pad_image(im_arr, l_arr, new_crop_size, self.rgb_mean, ignored_label=255) im_arr = im_arr[r_start:r_start + new_crop_size, c_start:c_start + new_crop_size, :] l_arr = l_arr[r_start:r_start + new_crop_size, c_start:c_start + new_crop_size] batch_images[ind] = im_arr batch_labels[ind] = l_arr l_dim = int(self.crop_size * self.label_shrink_scale) batch_images = [mx.image.imresize(im, self.crop_size, self.crop_size, interp=1) for im in batch_images] for ind in range(len(batch_labels)): mask_arr = batch_labels[ind] mask_arr = Image.fromarray(mask_arr).resize((l_dim, l_dim), Image.NEAREST) mask_arr = np.array(mask_arr, dtype=np.uint8) batch_labels[ind] = mask_arr for i in range(len(sub_list)): images[i][:] = mx.nd.transpose(batch_images[i], (2, 0, 1)) masks[i][:] = batch_labels[i].reshape(-1) images -= mx.nd.reshape(self.rgb_mean, (1, 3, 1, 1)).astype(np.float32) if self.provide_g_labels: self.data_queue.put(DataBatch(data=[images], label=[masks, g_labels], pad=None, index=None)) else: self.data_queue.put(DataBatch(data=[images], label=[masks], pad=None, index=None))
def test_DataBatch(): from mxnet.io import DataBatch import re batch = DataBatch(data=[mx.nd.ones((2, 3))]) assert re.match( r'DataBatch: data shapes: \[\(2L?, 3L?\)\] label shapes: None', str(batch)) batch = DataBatch(data=[mx.nd.ones((2, 3)), mx.nd.ones( (7, 8))], label=[mx.nd.ones((4, 5))]) assert re.match( r'DataBatch: data shapes: \[\(2L?, 3L?\), \(7L?, 8L?\)\] label shapes: \[\(4L?, 5L?\)\]', str(batch))
def _inference(self, data): """Internal inference methods for MXNet. Run forward computation and return output. Parameters ---------- data : list of NDArray Preprocessed inputs in NDArray format. Returns ------- list of NDArray Inference output. """ # Check input shape check_input_shape(data, self.signature) data = [item.as_in_context(self.ctx) for item in data] self.mx_model.forward(DataBatch(data)) data = self.mx_model.get_outputs() # by pass lazy evaluation get_outputs either returns a list of nd arrays # a list of list of ndarrays for d in data: if isinstance(d, list): for n in data: if isinstance(n, mx.ndarray.ndarray.NDArray): n.wait_to_read() elif isinstance(d, mx.ndarray.ndarray.NDArray): d.wait_to_read() return data
def next(self): if self.curr_idx == len(self.idx): raise StopIteration i, j = self.idx[self.curr_idx] self.curr_idx += 1 # print('sample iter: ', i, j) step = self.batch_size if self.major_axis == 1: data = self.nddata[i][j:j+step].T #NTL -> TNL label = ndarray.transpose(data=self.ndlabel[i][j:j+step], axes=(1,0,2)) label_weight = ndarray.transpose(data=self.ndlabel_weight[i][j:j+step], axes=(1,0,2)) else: data = self.nddata[i][j:j+step] label = self.ndlabel[i][j:j+step] label_weight = self.ndlabel_weight[i][j:j+step] return DataBatch([data], [label, label_weight], pad=0, bucket_key=self.buckets[i], provide_data=[(self.data_name, data.shape)], provide_label=[ (self.label_name, label.shape), (self.label_weight_name, label_weight.shape) ])
def next(self): """Returns the next batch of data.""" if self.curr_idx == len(self.idx): raise StopIteration i, j = self.idx[self.curr_idx] self.curr_idx += 1 if self.major_axis == 1: data = self.nddata[i][j:j + self.batch_size].T label = self.ndlabel[i][j:j + self.batch_size].T else: data = self.nddata[i][j:j + self.batch_size] label = self.ndlabel[i][j:j + self.batch_size] return DataBatch([data], [label], pad=0, bucket_key=self.buckets[i], provide_data=[ DataDesc(name=self.data_name, shape=data.shape, layout=self.layout) ], provide_label=[ DataDesc(name=self.label_name, shape=label.shape, layout=self.layout) ])
def next(self): """Returns the next batch of data.""" if self.curr_idx == len(self.idx): raise StopIteration #i = batches index, j = starting record i, j = self.idx[self.curr_idx] self.curr_idx += 1 indices = self.ndindex[i][j:j + self.batch_size] sentences = self.ndsent[i][j:j + self.batch_size] characters = self.ndchar[i][j:j + self.batch_size] label = self.ndlabel[i][j:j + self.batch_size] return DataBatch([sentences, characters], [label], pad=0, index=indices, bucket_key=self.buckets[i], provide_data=[ DataDesc(name=self.data_names[0], shape=sentences.shape, layout=self.layout), DataDesc(name=self.data_names[1], shape=characters.shape, layout=self.layout) ], provide_label=[ DataDesc(name=self.label_name, shape=label.shape, layout=self.layout) ])
def next(self): try: batch1 = self.iter1.next() except StopIteration: raise StopIteration while True: try: batch2 = self.iter2.next() break except StopIteration: self.iter2.reset() data1 = batch1.data[0] data2 = batch2.data[0] label1 = batch1.label[0] label2 = batch2.label[0] data_parts = [] label_parts = [] for i in xrange(self.ctx_num): a1 = i * self.per_size1 b1 = (i + 1) * self.per_size1 a2 = i * self.per_size2 b2 = (i + 1) * self.per_size2 _data1 = self.part_slice(data1, a1, b1) _data2 = self.part_slice(data2, a2, b2) _label1 = self.part_slice(label1, a1, b1) _label2 = self.part_slice(label2, a2, b2) #_target_label = mx.ndarray.ones_like(_target_label)*9999 data_parts.append(_data1) data_parts.append(_data2) label_parts.append(_label1) label_parts.append(_label2) data = mx.ndarray.concat(*data_parts, dim=0) label = mx.ndarray.concat(*label_parts, dim=0) return DataBatch(data=(data, ), label=(label, ))
def inference(self, model_input): """ Internal inference methods for MXNet. Run forward computation and return output. :param model_input: list of NDArray Preprocessed inputs in NDArray format. :return: list of NDArray Inference output. """ if self.error is not None: return None # Check input shape check_input_shape(model_input, self.signature) model_input = [item.as_in_context(self.mxnet_ctx) for item in model_input] self.mx_model.forward(DataBatch(model_input)) model_input = self.mx_model.get_outputs() # by pass lazy evaluation get_outputs either returns a list of nd arrays # a list of list of NDArray for d in model_input: if isinstance(d, list): for n in model_input: if isinstance(n, mx.ndarray.ndarray.NDArray): n.wait_to_read() elif isinstance(d, mx.ndarray.ndarray.NDArray): d.wait_to_read() return model_input
def next(self): if self.iter_next(): return DataBatch(data=self.getdata(), label=self.getlabel(), pad=self.getpad()) else: raise StopIteration
def next(self): """Get next data batch from iterator. Returns ------- DataBatch The data of next batch. Raises ------ StopIteration If the end of the data is reached. """ if self.iter_next(): with self.lock: data, label = next(self.itr) data = np.transpose(data, (0, 3, 1, 2)) # NCHW label = label[:, :, :, None] label = np.transpose(label, (0, 3, 1, 2)) # NCHW data = [[ mx.nd.array(data[self.batch_size * i:self.batch_size * (i + 1)]) ] for i in range(self.gpu_nums) ] # multi-gpu distribute data, time-consuming!!! label = [[ mx.nd.array(label[self.batch_size * i:self.batch_size * (i + 1)]) ] for i in range(self.gpu_nums)] return DataBatch(data=data, label=label, \ pad=0, index= None, provide_data=self.provide_data,provide_label=self.provide_label) else: raise StopIteration
def next(self): if self._cur_pointer + self._batch_size < len(self._name_id): cur_images = np.zeros( (self._batch_size, 3, self._crop_h, self._crop_w)) cur_labels = np.zeros( (self._batch_size, 1, self._crop_h / self._label_stride, self._crop_w / self._label_stride)) for i in range(self._batch_size): image_path, label_path = self.parse_lst( self._name_list[self._name_id[i + self._cur_pointer]]) ori_image = np.array(Image.open(image_path)) ori_label = np.array(Image.open(label_path)) if self._use_flip: do_flip = np.random.randint(2) == 0 if do_flip: ori_image = ori_image[:, ::-1, :] ori_label = ori_label[:, ::-1] crop_image, crop_label = self.random_crop(image=ori_image, label=ori_label) cur_images[i, ...] = crop_image cur_labels[i, ...] = crop_label else: raise StopIteration self._cur_pointer += self._batch_size return DataBatch(data=[mx.nd.array(cur_images)], label=[mx.nd.array(cur_labels)])
def next(self): if self.iter_next(): while True: data, label = self.get_data_label() return DataBatch(data=data, label=label, pad=self.getpad(), index=self.getindex()) else: raise StopIteration
def predict(url): # global net start_time = time.time() img = get_image(url, show=False) # compute the predict probabilities net.forward(DataBatch([mx.nd.array(img)])) # net.forward(list([mx.nd.array(img)])) prob = net.get_outputs()[0].asnumpy() # print the top-2 prob = np.squeeze(prob) classes = np.argsort(prob)[::-1] # print("Total size of the features = %s" %(len(classes))) index, value = max(enumerate(prob), key=operator.itemgetter(1)) # for i in classes: # print('probability=%f, label=%s' % (prob[i], labels[i])) end_time = time.time() # print("Total execution time: {} seconds".format(end_time - start_time)) # with open(("errors/classification_time.csv"),"a") as f: # f.write(','.join([url, str(end_time - start_time),"\n"])) return labels[index], value,prob[0],prob[1],(end_time - start_time)
def next(self): """return one dict which contains "data" and "label" """ if self.iter_next(): # self.data, self.label,\ start = time.time() self.batch_image, self.batch_label, self.batch_img_size, self.batch_original_img_size, \ self.batch_image_name, self.batch_label_name = self.getdata() # end = time.time() # print 'load data: %s' % (end - start) # print self.batch_image_name self.cursor += self.batch_size # return DataBatch(self.batch_image, # label=self.batch_label, # ) # print mx.nd.concatenate(self.batch_image) # print self.batch_label # return { # self.data_name: mx.nd.array(self.batch_image), # self.label_name: mx.nd.array(self.batch_label), # } return DataBatch(data=[mx.nd.array(self.batch_image)], label=[mx.nd.array(self.batch_label)], ) else: raise StopIteration
def next(self): source_batch = self.source_iter.next() target_batch = self.target_iter.next() source_data = source_batch.data[0] target_data = target_batch.data[0] source_label = source_batch.label[0] target_label = target_batch.label[0] data_parts = [] label_parts = [] for i in xrange(self.gpu_num): _source_data = self.part_slice(source_data, i) _target_data = self.part_slice(target_data, i) _source_label = self.part_slice(source_label, i) _target_label = self.part_slice(target_label, i) #_target_label = mx.ndarray.ones_like(_target_label)*9999 data_parts.append(_source_data) data_parts.append(_target_data) label_parts.append(_source_label) label_parts.append(_target_label) self.data = mx.ndarray.concat(*data_parts, dim=0) self.label = mx.ndarray.concat(*label_parts, dim=0) #self.data = mx.ndarray.concat( source_data, target_data, dim=0) #print(self.data.shape) #self.label = mx.ndarray.concat(source_batch.label[0], target_batch.label[0], dim=0) #provide_data = [(self.data_name, self.data.shape)] #provide_label = [(self.label_name, self.label.shape)] #print(self.label.shape) #return {self.data_name : [self.data], # self.label_name : [self.label]} return DataBatch(data=(self.data, ), label=(self.label, ))
def next(self): batches = self.iters.next() #for idx,label in enumerate(self.label_list): # print(batches.label[0].shape) split_label_reshape = [] split_label = mx.nd.split(batches.label[0], axis=1, num_outputs=len(self.label_list_origin)) batch_size = split_label[0].size #for split in split_label: index = np.random.permutation(batch_size) lam = 0.8 mixed_x = batches.data[0] * lam + (1.0 - lam) * batches.data[0][index, :] batches.data[0] = mixed_x split_label_reshape = [split.reshape([ 0, ]) for split in split_label] split_label_reshape_mixup = [ split.reshape([ 0, ])[index] for split in split_label ] split_label_reshape = split_label_reshape + split_label_reshape_mixup #print(batches.data[0].shape) if self.summary_writer is not None: self.summary_writer.add_image('image', (batches.data[0] + 123.68) / 274.740997314) return DataBatch(data=batches.data, label=split_label_reshape)
def get_next(self): """in zoo, each DataBatch has pic of one time step of sample of #batch_size """ assert (self.cursor < self.num_data), "DataIter needs reset." if self.cursor + self.batch_size <= self.num_data: data = [ array(d[1][self.cursor:self.cursor + self.batch_size]) for d in self.data ] label = [ array(l[1][self.cursor:self.cursor + self.batch_size]) for l in self.label ] else: pad = self.batch_size - self.num_data + self.cursor data = [ array(np.concatenate((d[1][self.cursor:], d[1][:pad]), axis=0)) for d in self.data ] label = [ array(np.concatenate((l[1][self.cursor:], l[1][:pad]), axis=0)) for l in self.label ] batch = DataBatch(data=data, label=label, pad=self.getpad(), index=None) return batch
def create_batch(): length = input_shape[0] * input_shape[1] * input_shape[2] * input_shape[3] frame = np.zeros(length, dtype=np.float32) frame[:] = 1.0 batch_frame = [mx.nd.array(frame.reshape(input_shape))] batch_shape = [DataDesc('data', batch_frame[0].shape)] batch = DataBatch(data=batch_frame, provide_data=batch_shape) return batch
def next(self): if self.iter_next(): #print("return batch") return DataBatch(self.getdata(), self.getlabel()) else: # print("raise StopIteration") # self.reset() raise StopIteration
def _produce_data(self): while True: mask_dim = int(self.im_size * self.label_shrink_scale) images = mx.nd.zeros( (self.batch_size, 3, self.im_size, self.im_size), ctx=mx.cpu()) labels = mx.nd.zeros((self.batch_size, 1, 1, self.class_num), ctx=mx.cpu()) cues = mx.nd.zeros( (self.batch_size, self.class_num, mask_dim, mask_dim), ctx=mx.cpu()) small_ims = mx.nd.zeros((self.batch_size, mask_dim, mask_dim, 3), ctx=mx.cpu()) sub_list = self.flist_item_queue.get() batch_images = [] for ind, item_name in enumerate(sub_list): buf = mx.nd.array(np.frombuffer(open( os.path.join(self.im_root, item_name + ".jpg"), 'rb').read(), dtype=np.uint8), dtype=np.uint8, ctx=mx.cpu()) im = mx.image.imdecode(buf) tmp = self.cue_dict[item_name + "_cues"] cue = np.zeros((self.class_num, mask_dim, mask_dim)) cue[tmp[0], tmp[1], tmp[2]] = 1 if self.random_flip and np.random.rand() > 0.5: im = mx.nd.flip(im, axis=1) cue = cue[:, :, ::-1] batch_images.append(im) label = np.zeros(self.class_num) label[self.cue_dict[item_name + "_labels"]] = 1 labels[ind][:] = label.reshape(1, 1, -1) cues[ind][:] = cue batch_images = [ mx.image.imresize(im, self.im_size, self.im_size, interp=1) for im in batch_images ] sm_images = [ mx.image.imresize(im, mask_dim, mask_dim, interp=1) for im in batch_images ] for i in range(len(sub_list)): images[i][:] = mx.nd.transpose(batch_images[i], (2, 0, 1)) small_ims[i][:] = sm_images[i] images -= self.rgb_mean self.data_queue.put( DataBatch(data=[images, small_ims], label=[labels, cues], pad=None, index=None))
def next(self): """return one dict which contains "data" and "label" """ if self.iter_next(): self.data, self.label = self._read() res = DataBatch(data=[mx.nd.array(self.data[0][1])], label=[mx.nd.array(self.label[0][1])], index=None) return res else: raise StopIteration
def next(self): if self._fetcher.iter_next(): tic = time.time() data_batch = self._fetcher.get() print 'Waited for {} seconds'.format(time.time() - tic) else: raise StopIteration return DataBatch(data=[array(data_batch[0])], label=[array(data_batch[1])])
def next(self): if (self.regenerate): self.regenerate = False self._generate_next() # This can raise StopIteration if self.iter_next(): return DataBatch(data=self.getdata(), label=self.getlabel(), \ pad=self.getpad(), index=None) else: self.regenerate = True return self.next()
def next(self): """For DataBatch definition, see this page: https://mxnet.incubator.apache.org/api/python/io.html#mxnet.io.DataBatch """ return DataBatch(data=(self.data, ), label=(self.label, ), pad=0, index=None, provide_data=self.provide_data, provide_label=self.provide_label)
def next(self): self.cur_iter += 1 if self.cur_iter <= self.max_iter: return DataBatch(data=(self.data, ), label=(self.label, ), pad=0, index=None, provide_data=self.provide_data, provide_label=self.provide_label) else: raise StopIteration
def next(self): batches = self.iters.next() #for idx,label in enumerate(self.label_list): # print(batches.label[0].shape) split_label_reshape =[] split_label = mx.nd.split(batches.label[0], axis=1, num_outputs=len(self.label_list)) split_label_reshape = [split.reshape([0,]) for split in split_label] return DataBatch(data=batches.data, label=split_label_reshape)
def next(self): try: if self.iter_next(): data, label = self.imgs_queue.get(block=True) return DataBatch(data=[data], label=[label], pad=self.getpad(), index=self.getindex()) else: raise StopIteration except Exception as ex: print str(ex)
def next(self): if self.cursor >= self.size: raise StopIteration data, label = self.result_queue.get() self.cursor += 1 return DataBatch(data=data, label=label, provide_data=self.provide_data, provide_label=self.provide_label)
def next(self): if self.cursor + self.pair_batch_size >= self.num_data: raise StopIteration data, label = self._fetch_data() self.cursor += self.pair_batch_size return DataBatch(data=data, label=label, pad=0, index=None, provide_data=self.provide_data, provide_label=self.provide_label)