paddlex_cli.py 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457
  1. # copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
  2. #
  3. # Licensed under the Apache License, Version 2.0 (the "License");
  4. # you may not use this file except in compliance with the License.
  5. # You may obtain a copy of the License at
  6. #
  7. # http://www.apache.org/licenses/LICENSE-2.0
  8. #
  9. # Unless required by applicable law or agreed to in writing, software
  10. # distributed under the License is distributed on an "AS IS" BASIS,
  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. # See the License for the specific language governing permissions and
  13. # limitations under the License.
  14. import os
  15. import argparse
  16. import subprocess
  17. import sys
  18. import shutil
  19. from pathlib import Path
  20. from importlib_resources import files, as_file
  21. from . import create_pipeline
  22. from .inference.pipelines import load_pipeline_config
  23. from .repo_manager import setup, get_all_supported_repo_names
  24. from .utils.flags import FLAGS_json_format_model
  25. from .utils import logging
  26. from .utils.interactive_get_pipeline import interactive_get_pipeline
  27. from .utils.pipeline_arguments import PIPELINE_ARGUMENTS
  28. def args_cfg():
  29. """parse cli arguments"""
  30. def parse_str(s):
  31. """convert str type value
  32. to None type if it is "None",
  33. to bool type if it means True or False.
  34. """
  35. if s in ("None", "none", "NONE"):
  36. return None
  37. elif s in ("TRUE", "True", "true", "T", "t"):
  38. return True
  39. elif s in ("FALSE", "False", "false", "F", "f"):
  40. return False
  41. return s
  42. parser = argparse.ArgumentParser(
  43. "Command-line interface for PaddleX. Use the options below to install plugins, run pipeline predictions, or start the serving application."
  44. )
  45. install_group = parser.add_argument_group("Install PaddleX Options")
  46. pipeline_group = parser.add_argument_group("Pipeline Predict Options")
  47. serving_group = parser.add_argument_group("Serving Options")
  48. paddle2onnx_group = parser.add_argument_group("Paddle2ONNX Options")
  49. ################# install pdx #################
  50. install_group.add_argument(
  51. "--install",
  52. action="store_true",
  53. default=False,
  54. help="Install specified PaddleX plugins.",
  55. )
  56. install_group.add_argument(
  57. "plugins",
  58. nargs="*",
  59. default=[],
  60. help="Names of custom development plugins to install (space-separated).",
  61. )
  62. install_group.add_argument(
  63. "--no_deps",
  64. action="store_true",
  65. help="Install custom development plugins without their dependencies.",
  66. )
  67. install_group.add_argument(
  68. "--platform",
  69. type=str,
  70. choices=["github.com", "gitee.com"],
  71. default="github.com",
  72. help="Platform to use for installation (default: github.com).",
  73. )
  74. install_group.add_argument(
  75. "-y",
  76. "--yes",
  77. dest="update_repos",
  78. action="store_true",
  79. help="Automatically confirm prompts and update repositories.",
  80. )
  81. install_group.add_argument(
  82. "--use_local_repos",
  83. action="store_true",
  84. default=False,
  85. help="Use local repositories if they exist.",
  86. )
  87. ################# pipeline predict #################
  88. pipeline_group.add_argument(
  89. "--pipeline", type=str, help="Name of the pipeline to execute for prediction."
  90. )
  91. pipeline_group.add_argument(
  92. "--input",
  93. type=str,
  94. default=None,
  95. help="Input data or path for the pipeline, supports specific file and directory.",
  96. )
  97. pipeline_group.add_argument(
  98. "--save_path",
  99. type=str,
  100. default=None,
  101. help="Path to save the prediction results.",
  102. )
  103. pipeline_group.add_argument(
  104. "--device",
  105. type=str,
  106. default=None,
  107. help="Device to run the pipeline on (e.g., 'cpu', 'gpu:0').",
  108. )
  109. pipeline_group.add_argument(
  110. "--use_hpip", action="store_true", help="Enable HPIP acceleration if available."
  111. )
  112. pipeline_group.add_argument(
  113. "--get_pipeline_config",
  114. type=str,
  115. default=None,
  116. help="Retrieve the configuration for a specified pipeline.",
  117. )
  118. ################# serving #################
  119. serving_group.add_argument(
  120. "--serve",
  121. action="store_true",
  122. help="Start the serving application to handle requests.",
  123. )
  124. serving_group.add_argument(
  125. "--host",
  126. type=str,
  127. default="0.0.0.0",
  128. help="Host address to serve on (default: 0.0.0.0).",
  129. )
  130. serving_group.add_argument(
  131. "--port",
  132. type=int,
  133. default=8080,
  134. help="Port number to serve on (default: 8080).",
  135. )
  136. ################# paddle2onnx #################
  137. paddle2onnx_group.add_argument(
  138. "--paddle2onnx", action="store_true", help="Convert Paddle model to ONNX format"
  139. )
  140. paddle2onnx_group.add_argument(
  141. "--paddle_model_dir", type=str, help="Directory containing the Paddle model"
  142. )
  143. paddle2onnx_group.add_argument(
  144. "--onnx_model_dir",
  145. type=str,
  146. default="onnx",
  147. help="Output directory for the ONNX model",
  148. )
  149. paddle2onnx_group.add_argument(
  150. "--opset_version", type=int, help="Version of the ONNX opset to use"
  151. )
  152. # Parse known arguments to get the pipeline name
  153. args, remaining_args = parser.parse_known_args()
  154. pipeline_name = args.pipeline
  155. pipeline_args = []
  156. if (
  157. not (args.install or args.serve or args.paddle2onnx)
  158. and pipeline_name is not None
  159. ):
  160. if pipeline_name not in PIPELINE_ARGUMENTS:
  161. support_pipelines = ", ".join(PIPELINE_ARGUMENTS.keys())
  162. logging.error(
  163. f"Unsupported pipeline: {pipeline_name}, CLI predict only supports these pipelines: {support_pipelines}\n"
  164. )
  165. sys.exit(1)
  166. pipeline_args = PIPELINE_ARGUMENTS[pipeline_name]
  167. if pipeline_args is None:
  168. pipeline_args = []
  169. pipeline_specific_group = parser.add_argument_group(
  170. f"{pipeline_name.capitalize()} Pipeline Options"
  171. )
  172. for arg in pipeline_args:
  173. pipeline_specific_group.add_argument(
  174. arg["name"],
  175. type=parse_str if arg["type"] is bool else arg["type"],
  176. help=arg.get("help", f"Argument for {pipeline_name} pipeline."),
  177. )
  178. return parser, pipeline_args
  179. def install(args):
  180. """install paddlex"""
  181. def _install_serving_deps():
  182. with as_file(files("paddlex").joinpath("serving_requirements.txt")) as req_file:
  183. return subprocess.check_call(
  184. [sys.executable, "-m", "pip", "install", "-r", str(req_file)]
  185. )
  186. def _install_paddle2onnx_deps():
  187. with as_file(
  188. files("paddlex").joinpath("paddle2onnx_requirements.txt")
  189. ) as req_file:
  190. return subprocess.check_call(
  191. [sys.executable, "-m", "pip", "install", "-r", str(req_file)]
  192. )
  193. def _install_hpi_deps(device_type):
  194. support_device_type = ["cpu", "gpu"]
  195. if device_type not in support_device_type:
  196. logging.error(
  197. "HPI installation failed!\n"
  198. "Supported device_type: %s. Your input device_type: %s.\n"
  199. "Please ensure the device_type is correct.",
  200. support_device_type,
  201. device_type,
  202. )
  203. sys.exit(2)
  204. if device_type == "cpu":
  205. packages = ["ultra_infer_python", "paddlex_hpi"]
  206. elif device_type == "gpu":
  207. packages = ["ultra_infer_gpu_python", "paddlex_hpi"]
  208. return subprocess.check_call(
  209. [sys.executable, "-m", "pip", "install"]
  210. + packages
  211. + [
  212. "--find-links",
  213. "https://github.com/PaddlePaddle/PaddleX/blob/develop/docs/pipeline_deploy/high_performance_inference.md",
  214. ]
  215. )
  216. # Enable debug info
  217. os.environ["PADDLE_PDX_DEBUG"] = "True"
  218. # Disable eager initialization
  219. os.environ["PADDLE_PDX_EAGER_INIT"] = "False"
  220. plugins = args.plugins[:]
  221. if "serving" in plugins:
  222. plugins.remove("serving")
  223. if plugins:
  224. logging.error("`serving` cannot be used together with other plugins.")
  225. sys.exit(2)
  226. _install_serving_deps()
  227. return
  228. if "paddle2onnx" in plugins:
  229. plugins.remove("paddle2onnx")
  230. if plugins:
  231. logging.error("`paddle2onnx` cannot be used together with other plugins.")
  232. sys.exit(2)
  233. _install_paddle2onnx_deps()
  234. return
  235. hpi_plugins = list(filter(lambda name: name.startswith("hpi-"), plugins))
  236. if hpi_plugins:
  237. for i in hpi_plugins:
  238. plugins.remove(i)
  239. if plugins:
  240. logging.error("`hpi` cannot be used together with other plugins.")
  241. sys.exit(2)
  242. if len(hpi_plugins) > 1 or len(hpi_plugins[0].split("-")) != 2:
  243. logging.error(
  244. "Invalid HPI plugin installation format detected.\n"
  245. "Correct format: paddlex --install hpi-<device_type>\n"
  246. "Example: paddlex --install hpi-gpu"
  247. )
  248. sys.exit(2)
  249. device_type = hpi_plugins[0].split("-")[1]
  250. _install_hpi_deps(device_type=device_type)
  251. return
  252. if plugins:
  253. repo_names = plugins
  254. elif len(plugins) == 0:
  255. repo_names = get_all_supported_repo_names()
  256. setup(
  257. repo_names=repo_names,
  258. no_deps=args.no_deps,
  259. platform=args.platform,
  260. update_repos=args.update_repos,
  261. use_local_repos=args.use_local_repos,
  262. )
  263. return
  264. def pipeline_predict(
  265. pipeline,
  266. input,
  267. device,
  268. save_path,
  269. use_hpip,
  270. **pipeline_args,
  271. ):
  272. """pipeline predict"""
  273. pipeline = create_pipeline(pipeline, device=device, use_hpip=use_hpip)
  274. result = pipeline.predict(input, **pipeline_args)
  275. for res in result:
  276. res.print()
  277. if save_path:
  278. res.save_all(save_path=save_path)
  279. def serve(pipeline, *, device, use_hpip, host, port):
  280. from .inference.serving.basic_serving import create_pipeline_app, run_server
  281. pipeline_config = load_pipeline_config(pipeline)
  282. pipeline = create_pipeline(config=pipeline_config, device=device, use_hpip=use_hpip)
  283. app = create_pipeline_app(pipeline, pipeline_config)
  284. run_server(app, host=host, port=port)
  285. # TODO: Move to another module
  286. def paddle_to_onnx(paddle_model_dir, onnx_model_dir, *, opset_version):
  287. PD_MODEL_FILE_PREFIX = "inference"
  288. PD_PARAMS_FILENAME = "inference.pdiparams"
  289. ONNX_MODEL_FILENAME = "inference.onnx"
  290. CONFIG_FILENAME = "inference.yml"
  291. ADDITIONAL_FILENAMES = ["scaler.pkl"]
  292. def _check_input_dir(input_dir, pd_model_file_ext):
  293. if input_dir is None:
  294. sys.exit("Input directory must be specified")
  295. if not input_dir.exists():
  296. sys.exit(f"{input_dir} does not exist")
  297. if not input_dir.is_dir():
  298. sys.exit(f"{input_dir} is not a directory")
  299. model_path = (input_dir / PD_MODEL_FILE_PREFIX).with_suffix(pd_model_file_ext)
  300. if not model_path.exists():
  301. sys.exit(f"{model_path} does not exist")
  302. params_path = input_dir / PD_PARAMS_FILENAME
  303. if not params_path.exists():
  304. sys.exit(f"{params_path} does not exist")
  305. config_path = input_dir / CONFIG_FILENAME
  306. if not config_path.exists():
  307. sys.exit(f"{config_path} does not exist")
  308. def _check_paddle2onnx():
  309. if shutil.which("paddle2onnx") is None:
  310. sys.exit("Paddle2ONNX is not available. Please install the plugin first.")
  311. def _run_paddle2onnx(input_dir, pd_model_file_ext, output_dir, opset_version):
  312. logging.info("Paddle2ONNX conversion starting...")
  313. # XXX: To circumvent Paddle2ONNX's bug
  314. if opset_version is None:
  315. if pd_model_file_ext == ".json":
  316. opset_version = 19
  317. else:
  318. opset_version = 7
  319. logging.info("Using default ONNX opset version: %d", opset_version)
  320. cmd = [
  321. "paddle2onnx",
  322. "--model_dir",
  323. str(input_dir),
  324. "--model_filename",
  325. str(Path(PD_MODEL_FILE_PREFIX).with_suffix(pd_model_file_ext)),
  326. "--params_filename",
  327. PD_PARAMS_FILENAME,
  328. "--save_file",
  329. str(output_dir / ONNX_MODEL_FILENAME),
  330. "--opset_version",
  331. str(opset_version),
  332. ]
  333. try:
  334. subprocess.check_call(cmd)
  335. except subprocess.CalledProcessError as e:
  336. sys.exit(f"Paddle2ONNX conversion failed with exit code {e.returncode}")
  337. logging.info("Paddle2ONNX conversion succeeded")
  338. def _copy_config_file(input_dir, output_dir):
  339. src_path = input_dir / CONFIG_FILENAME
  340. dst_path = output_dir / CONFIG_FILENAME
  341. shutil.copy(src_path, dst_path)
  342. logging.info(f"Copied {src_path} to {dst_path}")
  343. def _copy_additional_files(input_dir, output_dir):
  344. for filename in ADDITIONAL_FILENAMES:
  345. src_path = input_dir / filename
  346. if not src_path.exists():
  347. continue
  348. dst_path = output_dir / filename
  349. shutil.copy(src_path, dst_path)
  350. logging.info(f"Copied {src_path} to {dst_path}")
  351. paddle_model_dir = Path(paddle_model_dir)
  352. onnx_model_dir = Path(onnx_model_dir)
  353. logging.info(f"Input dir: {paddle_model_dir}")
  354. logging.info(f"Output dir: {onnx_model_dir}")
  355. pd_model_file_ext = ".json"
  356. if not FLAGS_json_format_model:
  357. if not (paddle_model_dir / f"{PD_MODEL_FILE_PREFIX}.json").exists():
  358. pd_model_file_ext = ".pdmodel"
  359. _check_input_dir(paddle_model_dir, pd_model_file_ext)
  360. _check_paddle2onnx()
  361. _run_paddle2onnx(paddle_model_dir, pd_model_file_ext, onnx_model_dir, opset_version)
  362. if not (onnx_model_dir.exists() and onnx_model_dir.samefile(paddle_model_dir)):
  363. _copy_config_file(paddle_model_dir, onnx_model_dir)
  364. _copy_additional_files(paddle_model_dir, onnx_model_dir)
  365. logging.info("Done")
  366. # for CLI
  367. def main():
  368. """API for commad line"""
  369. parser, pipeline_args = args_cfg()
  370. args = parser.parse_args()
  371. if len(sys.argv) == 1:
  372. logging.warning("No arguments provided. Displaying help information:")
  373. parser.print_help()
  374. sys.exit(2)
  375. if args.install:
  376. install(args)
  377. elif args.serve:
  378. serve(
  379. args.pipeline,
  380. device=args.device,
  381. use_hpip=args.use_hpip,
  382. host=args.host,
  383. port=args.port,
  384. )
  385. elif args.paddle2onnx:
  386. paddle_to_onnx(
  387. args.paddle_model_dir,
  388. args.onnx_model_dir,
  389. opset_version=args.opset_version,
  390. )
  391. else:
  392. if args.get_pipeline_config is not None:
  393. interactive_get_pipeline(args.get_pipeline_config, args.save_path)
  394. else:
  395. pipeline_args_dict = {}
  396. for arg in pipeline_args:
  397. arg_name = arg["name"].lstrip("-")
  398. if hasattr(args, arg_name):
  399. pipeline_args_dict[arg_name] = getattr(args, arg_name)
  400. else:
  401. logging.warning(f"Argument {arg_name} is missing in args")
  402. return pipeline_predict(
  403. args.pipeline,
  404. args.input,
  405. args.device,
  406. args.save_path,
  407. use_hpip=args.use_hpip,
  408. **pipeline_args_dict,
  409. )