add a model PLSC-ViT (#5697) (#5706)

* add a model and app for VisionTransformer Co-authored-by: liuTINA0907 <65896652+liuTINA0907@users.noreply.github.com> Co-authored-by: qizhaoaoe <2285142981@qq.com> Co-authored-by: liuTINA0907 <65896652+liuTINA0907@users.noreply.github.com>

Author: 3 people

modelcenter/PLSC-ViT/APP/__init__.py

@@ -0,0 +1,47 @@
+import gradio as gr
+from predictor import Predictor
+
+model_path = "paddlecv://models/vit/v2.4/imagenet2012-ViT-B_16-224_infer.pdmodel"
+params_path = "paddlecv://models/vit/v2.4/imagenet2012-ViT-B_16-224_infer.pdiparams"
+label_path = "paddlecv://dataset/imagenet2012_labels.txt"
+
+predictor = None
+
+
+def model_inference(image):
+ global predictor
+ if predictor is None:
+ predictor = Predictor(
+ model_path=model_path,
+ params_path=params_path,
+ label_path=label_path)
+ scores, labels = predictor.predict(image)
+ json_out = {"scores": scores.tolist(), "labels": labels.tolist()}
+ return image, json_out
+
+
+def clear_all():
+ return None, None, None
+
+
+with gr.Blocks() as demo:
+ gr.Markdown("Classification based on ViT")
+
+ with gr.Column(scale=1, min_width=100):
+
+ img_in = gr.Image(
+ value="https://plsc.bj.bcebos.com/dataset/test_images/cat.jpg",
+ label="Input")
+
+ with gr.Row():
+ btn1 = gr.Button("Clear")
+ btn2 = gr.Button("Submit")
+
+ img_out = gr.Image(label="Output")
+ json_out = gr.JSON(label="jsonOutput")
+
+ btn2.click(fn=model_inference, inputs=img_in, outputs=[img_out, json_out])
+ btn1.click(fn=clear_all, inputs=None, outputs=[img_in, img_out, json_out])
+ gr.Button.style(1)
+
+demo.launch()

modelcenter/PLSC-ViT/APP/app.py

@@ -0,0 +1,11 @@
+【PLSC-ViT-App-YAML】
+
+APP_Info:
+ title: PLSC-ViT-App
+ colorFrom: blue
+ colorTo: yellow
+ sdk: gradio
+ sdk_version: 3.9.1
+ app_file: app.py
+ license: apache-2.0
+ device: cpu

modelcenter/PLSC-ViT/APP/app.yaml

@@ -0,0 +1,229 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import os.path as osp
+import sys
+import yaml
+import time
+import shutil
+import requests
+import tqdm
+import hashlib
+import base64
+import binascii
+import tarfile
+import zipfile
+
+__all__ = [
+ 'get_model_path',
+ 'get_config_path',
+ 'get_dict_path',
+ 'get_data_path',
+]
+
+WEIGHTS_HOME = osp.expanduser("~/.cache/paddlecv/models/plsc")
+CONFIGS_HOME = osp.expanduser("~/.cache/paddlecv/configs/plsc")
+DICTS_HOME = osp.expanduser("~/.cache/paddlecv/dicts/plsc/")
+DATA_HOME = osp.expanduser("~/.cache/paddlecv/dataset/plsc")
+# dict of {dataset_name: (download_info, sub_dirs)}
+# download info: [(url, md5sum)]
+
+DOWNLOAD_RETRY_LIMIT = 3
+
+PMP_DOWNLOAD_URL_PREFIX = 'https://plsc.bj.bcebos.com/'
+
+
+def is_url(path):
+ """
+ Whether path is URL.
+ Args:
+ path (string): URL string or not.
+ """
+ return path.startswith('http://') \
+ or path.startswith('https://') \
+ or path.startswith('paddlecv://')
+
+
+def parse_url(url):
+ url = url.replace("paddlecv://", PMP_DOWNLOAD_URL_PREFIX)
+ return url
+
+
+def get_model_path(path):
+ """Get model path from WEIGHTS_HOME, if not exists,
+ download it from url.
+ """
+ if not is_url(path):
+ return path
+ url = parse_url(path)
+ path, _ = get_path(url, WEIGHTS_HOME, path_depth=3)
+ return path
+
+
+def get_data_path(path):
+ """Get model path from DATA_HOME, if not exists,
+ download it from url.
+ """
+ if not is_url(path):
+ return path
+ url = parse_url(path)
+ path, _ = get_path(url, DATA_HOME, path_depth=1)
+ return path
+
+
+def get_config_path(path):
+ """Get config path from CONFIGS_HOME, if not exists,
+ download it from url.
+ """
+ if not is_url(path):
+ return path
+ url = parse_url(path)
+ path, _ = get_path(url, CONFIGS_HOME)
+ return path
+
+
+def get_dict_path(path):
+ """Get config path from CONFIGS_HOME, if not exists,
+ download it from url.
+ """
+ if not is_url(path):
+ return path
+ url = parse_url(path)
+ path, _ = get_path(url, DICTS_HOME)
+ return path
+
+
+def map_path(url, root_dir, path_depth=1):
+ # parse path after download to decompress under root_dir
+ assert path_depth > 0, "path_depth should be a positive integer"
+ dirname = url
+ for _ in range(path_depth):
+ dirname = osp.dirname(dirname)
+ fpath = osp.relpath(url, dirname)
+ path = osp.join(root_dir, fpath)
+ dirname = osp.dirname(path)
+ return path, dirname
+
+
+def get_path(url, root_dir, md5sum=None, check_exist=True, path_depth=1):
+ """ Download from given url to root_dir.
+ if file or directory specified by url is exists under
+ root_dir, return the path directly, otherwise download
+ from url, return the path.
+ url (str): download url
+ root_dir (str): root dir for downloading, it should be
+ WEIGHTS_HOME
+ md5sum (str): md5 sum of download package
+ """
+ # parse path after download to decompress under root_dir
+ fullpath, dirname = map_path(url, root_dir, path_depth)
+
+ if osp.exists(fullpath) and check_exist:
+ if not osp.isfile(fullpath) or \
+ _check_exist_file_md5(fullpath, md5sum, url):
+ return fullpath, True
+ else:
+ os.remove(fullpath)
+
+ fullname = _download(url, dirname, md5sum)
+ return fullpath, False
+
+
+def _download(url, path, md5sum=None):
+ """
+ Download from url, save to path.
+ url (str): download url
+ path (str): download to given path
+ """
+ if not osp.exists(path):
+ os.makedirs(path)
+
+ fname = osp.split(url)[-1]
+ fullname = osp.join(path, fname)
+ retry_cnt = 0
+
+ while not (osp.exists(fullname) and _check_exist_file_md5(fullname, md5sum,
+ url)):
+ if retry_cnt < DOWNLOAD_RETRY_LIMIT:
+ retry_cnt += 1
+ else:
+ raise RuntimeError("Download from {} failed. "
+ "Retry limit reached".format(url))
+
+ # NOTE: windows path join may incur \, which is invalid in url
+ if sys.platform == "win32":
+ url = url.replace('\\', '/')
+
+ req = requests.get(url, stream=True)
+ if req.status_code != 200:
+ raise RuntimeError("Downloading from {} failed with code "
+ "{}!".format(url, req.status_code))
+
+ # For protecting download interupted, download to
+ # tmp_fullname firstly, move tmp_fullname to fullname
+ # after download finished
+ tmp_fullname = fullname + "_tmp"
+ total_size = req.headers.get('content-length')
+ with open(tmp_fullname, 'wb') as f:
+ if total_size:
+ for chunk in tqdm.tqdm(
+ req.iter_content(chunk_size=1024),
+ total=(int(total_size) + 1023) // 1024,
+ unit='KB'):
+ f.write(chunk)
+ else:
+ for chunk in req.iter_content(chunk_size=1024):
+ if chunk:
+ f.write(chunk)
+ shutil.move(tmp_fullname, fullname)
+ return fullname
+
+
+def _check_exist_file_md5(filename, md5sum, url):
+ # if md5sum is None, and file to check is model file, 
+ # read md5um from url and check, else check md5sum directly
+ return _md5check_from_url(filename, url) if md5sum is None \
+ and filename.endswith('pdparams') \
+ else _md5check(filename, md5sum)
+
+
+def _md5check_from_url(filename, url):
+ # For model in bcebos URLs, MD5 value is contained
+ # in request header as 'content_md5'
+ req = requests.get(url, stream=True)
+ content_md5 = req.headers.get('content-md5')
+ req.close()
+ if not content_md5 or _md5check(
+ filename,
+ binascii.hexlify(base64.b64decode(content_md5.strip('"'))).decode(
+ )):
+ return True
+ else:
+ return False
+
+
+def _md5check(fullname, md5sum=None):
+ if md5sum is None:
+ return True
+
+ md5 = hashlib.md5()
+ with open(fullname, 'rb') as f:
+ for chunk in iter(lambda: f.read(4096), b""):
+ md5.update(chunk)
+ calc_md5sum = md5.hexdigest()
+
+ if calc_md5sum != md5sum:
+ return False
+ return True

modelcenter/PLSC-ViT/APP/download.py

@@ -0,0 +1,88 @@
+import os
+import cv2
+import numpy as np
+import paddle
+from download import get_model_path, get_data_path
+
+class Predictor(object):
+ def __init__(self,
+ model_type="paddle",
+ model_path=None,
+ params_path=None,
+ label_path=None):
+ '''
+ model_path: str, http url
+ params_path: str, http url, could be downloaded
+ '''
+ assert model_type in ["paddle"]
+ assert model_path is not None and os.path.splitext(model_path)[
+ 1] == '.pdmodel'
+ assert params_path is not None and os.path.splitext(params_path)[
+ 1] == '.pdiparams'
+
+ import paddle.inference as paddle_infer
+ infer_model = get_model_path(model_path)
+ infer_params = get_model_path(params_path)
+ config = paddle_infer.Config(infer_model, infer_params)
+ self.predictor = paddle_infer.create_predictor(config)
+ self.input_names = self.predictor.get_input_names()
+ self.output_names = self.predictor.get_output_names()
+ self.labels = self.parse_labes(get_data_path(label_path))
+ self.model_type = model_type
+
+ def predict(self, img):
+
+ if self.preprocess is not None:
+ inputs = self.preprocess(img)
+ else:
+ inputs = img
+ for input_name in self.input_names:
+ input_tensor = self.predictor.get_input_handle(input_name)
+ input_tensor.copy_from_cpu(inputs[input_name])
+ self.predictor.run()
+ outputs = []
+ for output_idx in range(len(self.output_names)):
+ output_tensor = self.predictor.get_output_handle(
+ self.output_names[output_idx])
+ outputs.append(output_tensor.copy_to_cpu())
+ if self.postprocess is not None:
+ output_data = self.postprocess(outputs)
+ else:
+ output_data = outputs
+
+ return output_data
+
+ def preprocess(self, img):
+ img = cv2.resize(img, (224, 224))
+ scale = 1.0 / 255.0
+ mean = 0.5
+ std = 0.5
+ img = (img.astype('float32') * scale - mean) / std
+ img = img[np.newaxis, :, :, :]
+ img = img.transpose((0, 3, 1, 2))
+ return {'x': img}
+
+ @staticmethod
+ def parse_labes(label_path):
+ with open(label_path, 'r') as f:
+ labels = []
+ for line in f:
+ if len(line) < 2:
+ continue
+ label = line.strip().split(',')[0].split(' ')[2]
+ labels.append(label)
+ return labels
+
+ @staticmethod
+ def softmax(x, epsilon=1e-6):
+ exp_x = np.exp(x)
+ sfm = (exp_x + epsilon) / (np.sum(exp_x) + epsilon)
+ return sfm
+
+ def postprocess(self, logits):
+ pred = np.array(logits).squeeze()
+ pred = self.softmax(pred)
+ class_idx = pred.argsort()[::-1]
+ return pred[class_idx[:5]], np.array(self.labels)[class_idx[:5]]
+
+

modelcenter/PLSC-ViT/APP/predictor.py

@@ -0,0 +1,11 @@
+gradio
+opencv-python
+paddlepaddle
+PyYAML
+shapely
+scipy
+Cython
+numpy
+setuptools
+pillow
+tqdm