def reconstruct(self, images=None, paths=None, use_gpu=False, visualization=False, output_dir="dcscn_output"): """ API for super resolution. Args: images (list(numpy.ndarray)): images data, shape of each is [H, W, C], the color space is BGR. paths (list[str]): The paths of images. use_gpu (bool): Whether to use gpu. visualization (bool): Whether to save image or not. output_dir (str): The path to store output images. Returns: res (list[dict]): each element in the list is a dict, the keys and values are: save_path (str, optional): the path to save images. (Exists only if visualization is True) data (numpy.ndarray): data of post processed image. """ if use_gpu: try: _places = os.environ["CUDA_VISIBLE_DEVICES"] int(_places[0]) except: raise RuntimeError( "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id." ) all_data = list() for yield_data in reader(images, paths): all_data.append(yield_data) total_num = len(all_data) res = list() for i in range(total_num): image_x = np.array([all_data[i]['img_x']]) image_x2 = np.array([all_data[i]['img_x2']]) dropout = np.array([0]) image_x = PaddleTensor(image_x.copy()) image_x2 = PaddleTensor(image_x2.copy()) drop_out = PaddleTensor(dropout.copy()) output = self.gpu_predictor.run([ image_x, image_x2 ]) if use_gpu else self.cpu_predictor.run([image_x, image_x2]) output = np.expand_dims(output[0].as_ndarray(), axis=1) out = postprocess(data_out=output, org_im=all_data[i]['org_im'], org_im_shape=all_data[i]['org_im_shape'], org_im_path=all_data[i]['org_im_path'], output_dir=output_dir, visualization=visualization) res.append(out) return res
def classification(self, images=None, paths=None, batch_size=1, use_gpu=False, top_k=1): """ API for image classification. Args: images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR. paths (list[str]): The paths of images. batch_size (int): batch size. use_gpu (bool): Whether to use gpu. top_k (int): Return top k results. Returns: res (list[dict]): The classfication results. """ if not self.predictor_set: self._set_config() self.predictor_set = True if use_gpu: try: _places = os.environ["CUDA_VISIBLE_DEVICES"] int(_places[0]) except: raise RuntimeError( "Attempt to use GPU for prediction, but environment variable CUDA_VISIBLE_DEVICES was not set correctly." ) all_data = list() for yield_data in reader(images, paths): all_data.append(yield_data) total_num = len(all_data) loop_num = int(np.ceil(total_num / batch_size)) res = list() for iter_id in range(loop_num): batch_data = list() handle_id = iter_id * batch_size for image_id in range(batch_size): try: batch_data.append(all_data[handle_id + image_id]) except: pass # feed batch image batch_image = np.array([data['image'] for data in batch_data]) batch_image = PaddleTensor(batch_image.copy()) predictor_output = self.gpu_predictor.run([ batch_image ]) if use_gpu else self.cpu_predictor.run([batch_image]) out = postprocess( data_out=predictor_output[0].as_ndarray(), label_list=self.label_list, top_k=top_k) res += out return res
def keypoint_detection(self, images=None, paths=None, batch_size=1, use_gpu=False, output_dir=None, visualization=False): """ API for human pose estimation and tracking. Args: images (list(numpy.ndarray)): images data, shape of each is [H, W, C]. paths (list[str]): The paths of images. batch_size (int): batch size. use_gpu (bool): Whether to use gpu. output_dir (str): The path to store output images. visualization (bool): Whether to save image or not. Returns: res (list[collections.OrderedDict]): The key points of human pose. """ # create output directory output_dir = output_dir if output_dir else os.path.join( os.getcwd(), 'keypoint_detection_result') all_data = list() for yield_data in reader(images, paths): all_data.append(yield_data) total_num = len(all_data) loop_num = int(np.ceil(total_num / batch_size)) res = list() for iter_id in range(loop_num): batch_data = list() handle_id = iter_id * batch_size for image_id in range(batch_size): try: batch_data.append(all_data[handle_id + image_id]) except: pass # feed batch image batch_image = np.array([data['image'] for data in batch_data]) batch_image = PaddleTensor(batch_image.copy()) output = self.gpu_predictor.run([ batch_image ]) if use_gpu else self.cpu_predictor.run([batch_image]) output = np.expand_dims(output[0].as_ndarray(), axis=1) # postprocess one by one for i in range(len(batch_data)): out = postprocess(out_heatmaps=output[i], org_im=batch_data[i]['org_im'], org_im_shape=batch_data[i]['org_im_shape'], org_im_path=batch_data[i]['org_im_path'], output_dir=output_dir, visualization=visualization) res.append(out) return res
def style_transfer(self, images=None, paths=None, alpha=1, use_gpu=False, output_dir='transfer_result', visualization=False): """ API for image style transfer. Args: images (list): list of dict objects, each dict contains key: content(str): value is a numpy.ndarry with shape [H, W, C], content data. styles(str): value is a list of numpy.ndarray with shape [H, W, C], styles data. weights(str, optional): value is the interpolation weights correspond to styles. paths (list): list of dict objects, each dict contains key: content(str): value is the path to content. styles(str): value is the paths to styles. weights(str, optional): value is the interpolation weights correspond to styles. alpha (float): The weight that controls the degree of stylization. Should be between 0 and 1. use_gpu (bool): whether to use gpu. output_dir (str): the path to store output images. visualization (bool): whether to save image or not. Returns: im_output (list[dict()]): list of output images and save path of images. """ if use_gpu: try: _places = os.environ["CUDA_VISIBLE_DEVICES"] int(_places[0]) except: raise RuntimeError( "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id." ) im_output = [] for component, w, h in reader(images, paths): content = PaddleTensor(component['content_arr'].copy()) content_feats = self.gpu_predictor_enc.run([content]) if use_gpu else self.cpu_predictor_enc.run([content]) accumulate = np.zeros((3, 512, 512)) for idx, style_arr in enumerate(component['styles_arr_list']): style = PaddleTensor(style_arr.copy()) # encode style_feats = self.gpu_predictor_enc.run([style]) if use_gpu else self.cpu_predictor_enc.run([style]) fr_feats = fr(content_feats[0].as_ndarray(), style_feats[0].as_ndarray(), alpha) fr_feats = PaddleTensor(fr_feats.copy()) # decode predict_outputs = self.gpu_predictor_dec.run([fr_feats]) if use_gpu else self.cpu_predictor_dec.run( [fr_feats]) # interpolation accumulate += predict_outputs[0].as_ndarray()[0] * component['style_interpolation_weights'][idx] # postprocess save_im_name = 'ndarray_{}.jpg'.format(time.time()) result = postprocess(accumulate, output_dir, save_im_name, visualization, size=(w, h)) im_output.append(result) return im_output
def stgraph_output(): module = hub.Module(name='resnet50_vd_imagenet_ssld') gpu_config = AnalysisConfig(module.default_pretrained_model_path) gpu_config.disable_glog_info() gpu_config.enable_use_gpu(memory_pool_init_size_mb=1000, device_id=0) gpu_predictor = create_paddle_predictor(gpu_config) img = cv2.imread('pandas.jpg') data = process_image(img)[np.newaxis, :, :, :] data = PaddleTensor(data.copy()) result = gpu_predictor.run([data]) return np.sum(result[0].as_ndarray())
def classification(self, images=None, paths=None, batch_size=1, use_gpu=False, top_k=1): """ API for image classification. Args: images (numpy.ndarray): data of images, shape of each is [H, W, C], color space must be BGR. paths (list[str]): The paths of images. batch_size (int): batch size. use_gpu (bool): Whether to use gpu. top_k (int): Return top k results. Returns: res (list[dict]): The classfication results. """ all_data = list() for yield_data in reader(images, paths): all_data.append(yield_data) total_num = len(all_data) loop_num = int(np.ceil(total_num / batch_size)) res = list() for iter_id in range(loop_num): batch_data = list() handle_id = iter_id * batch_size for image_id in range(batch_size): try: batch_data.append(all_data[handle_id + image_id]) except: pass # feed batch image batch_image = np.array([data['image'] for data in batch_data]) batch_image = PaddleTensor(batch_image.copy()) predictor_output = self.gpu_predictor.run([ batch_image ]) if use_gpu else self.cpu_predictor.run([batch_image]) out = postprocess( data_out=predictor_output[0].as_ndarray(), label_list=self.label_list, top_k=top_k) res += out return res
def segment(self, images=None, paths=None, batch_size=1, use_gpu=False, visualization=False, output_dir='humanseg_server_output'): """ API for human segmentation. Args: images (list(numpy.ndarray)): images data, shape of each is [H, W, C], the color space is BGR. paths (list[str]): The paths of images. batch_size (int): batch size. use_gpu (bool): Whether to use gpu. visualization (bool): Whether to save image or not. output_dir (str): The path to store output images. Returns: res (list[dict]): each element in the list is a dict, the keys and values are: save_path (str, optional): the path to save images. (Exists only if visualization is True) data (numpy.ndarray): data of post processed image. """ if use_gpu: try: _places = os.environ["CUDA_VISIBLE_DEVICES"] int(_places[0]) except: raise RuntimeError( "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id." ) # compatibility with older versions all_data = list() for yield_data in reader(images, paths): all_data.append(yield_data) total_num = len(all_data) loop_num = int(np.ceil(total_num / batch_size)) res = list() for iter_id in range(loop_num): batch_data = list() handle_id = iter_id * batch_size for image_id in range(batch_size): try: batch_data.append(all_data[handle_id + image_id]) except: pass # feed batch image batch_image = np.array([data['image'] for data in batch_data]) batch_image = PaddleTensor(batch_image.copy()) output = self.gpu_predictor.run([ batch_image ]) if use_gpu else self.cpu_predictor.run([batch_image]) output = output[1].as_ndarray() output = np.expand_dims(output[:, 1, :, :], axis=1) # postprocess one by one for i in range(len(batch_data)): out = postprocess(data_out=output[i], org_im=batch_data[i]['org_im'], org_im_shape=batch_data[i]['org_im_shape'], org_im_path=batch_data[i]['org_im_path'], output_dir=output_dir, visualization=visualization) res.append(out) return res
def predict_det(self, inputs): inputs = PaddleTensor(inputs.copy()) result = self.predictor.run([inputs]) output_data = result[0].as_ndarray() return output_data