class_docstr: Arguments for vLLM engine.
class_docstr_tok: ["Arguments","for","vLLM","engine","."]
docstr: Shared CLI arguments for vLLM engine.
docstr_tok: ["Shared","CLI","arguments","for","vLLM","engine","."]
code: def add_cli_args(
      parser: argparse.ArgumentParser,
  ) -> argparse.ArgumentParser:
      """Shared CLI arguments for vLLM engine."""
      # Model arguments
      parser.add_argument(
          "--model",
          type=str,
          default="facebook/opt-125m",
          help="name or path of the huggingface model to use",
      )
      parser.add_argument(
          "--tokenizer",
          type=str,
          default=EngineArgs.tokenizer,
          help="name or path of the huggingface tokenizer to use",
      )
      parser.add_argument(
          "--revision",
          type=str,
          default=None,
          help="the specific model version to use. It can be a branch "
          "name, a tag name, or a commit id. If unspecified, will use "
          "the default version.",
      )
      parser.add_argument(
          "--tokenizer-revision",
          type=str,
          default=None,
          help="the specific tokenizer version to use. It can be a branch "
          "name, a tag name, or a commit id. If unspecified, will use "
          "the default version.",
      )
      parser.add_argument(
          "--tokenizer-mode",
          type=str,
          default=EngineArgs.tokenizer_mode,
          choices=["auto", "slow"],
          help='tokenizer mode. "auto" will use the fast '
          'tokenizer if available, and "slow" will '
          "always use the slow tokenizer.",
      )
      parser.add_argument(
          "--trust-remote-code",
          action="store_true",
          help="trust remote code from huggingface",
      )
      parser.add_argument(
          "--download-dir",
          type=str,
          default=EngineArgs.download_dir,
          help="directory to download and load the weights, "
          "default to the default cache dir of "
          "huggingface",
      )
      parser.add_argument(
          "--load-format",
          type=str,
          default=EngineArgs.load_format,
          choices=["auto", "pt", "safetensors", "npcache", "dummy"],
          help="The format of the model weights to load. "
          '"auto" will try to load the weights in the safetensors format '
          "and fall back to the pytorch bin format if safetensors format "
          "is not available. "
          '"pt" will load the weights in the pytorch bin format. '
          '"safetensors" will load the weights in the safetensors format. '
          '"npcache" will load the weights in pytorch format and store '
          "a numpy cache to speed up the loading. "
          '"dummy" will initialize the weights with random values, '
          "which is mainly for profiling.",
      )
      parser.add_argument(
          "--dtype",
          type=str,
          default=EngineArgs.dtype,
          choices=[
              "auto",
              "half",
              "float16",
              "bfloat16",
              "float",
              "float32",
          ],
          help="data type for model weights and activations. "
          'The "auto" option will use FP16 precision '
          "for FP32 and FP16 models, and BF16 precision "
          "for BF16 models.",
      )
      parser.add_argument(
          "--max-model-len",
          type=int,
          default=None,
          help="model context length. If unspecified, "
          "will be automatically derived from the model.",
      )
      # disable Parallel arguments
      # parser.add_argument('--worker-use-ray',
      #                     action='store_true',
      #                     help='use Ray for distributed serving, will be '
      #                     'automatically set when using more than 1 GPU')
      # parser.add_argument('--pipeline-parallel-size',
      #                     '-pp',
      #                     type=int,
      #                     default=EngineArgs.pipeline_parallel_size,
      #                     help='number of pipeline stages')
      # parser.add_argument('--tensor-parallel-size',
      #                     '-tp',
      #                     type=int,
      #                     default=EngineArgs.tensor_parallel_size,
      #                     help='number of tensor parallel replicas')
      # KV cache arguments
      parser.add_argument(
          "--block-size",
          type=int,
          default=EngineArgs.block_size,
          choices=[8, 16, 32],
          help="token block size",
      )
      # TODO(woosuk): Support fine-grained seeds (e.g., seed per request).
      parser.add_argument(
          "--seed",
          type=int,
          default=EngineArgs.seed,
          help="random seed",
      )
      parser.add_argument(
          "--swap-space",
          type=int,
          default=EngineArgs.swap_space,
          help="CPU swap space size (GiB) per GPU",
      )
      parser.add_argument(
          "--gpu-memory-utilization",
          type=float,
          default=EngineArgs.gpu_memory_utilization,
          help="the percentage of GPU memory to be used for"
          "the model executor",
      )
      parser.add_argument(
          "--max-num-batched-tokens",
          type=int,
          default=EngineArgs.max_num_batched_tokens,
          help="maximum number of batched tokens per " "iteration",
      )
      parser.add_argument(
          "--max-num-seqs",
          type=int,
          default=EngineArgs.max_num_seqs,
          help="maximum number of sequences per iteration",
      )
      parser.add_argument(
          "--disable-log-stats",
          action="store_true",
          help="disable logging statistics",
      )
      # Quantization settings.
      parser.add_argument(
          "--quantization",
          "-q",
          type=str,
          choices=["awq", None],
          default=None,
          help="Method used to quantize the weights",
      )
      parser.add_argument(
          "--device",
          type=str,
          choices=["gpu", "cpu", "xpu", None],
          default=None,
          help="Device to execute LLM model",
      )
  
      return parser
  
file_path: BigDL/python/llm/src/bigdl/llm/vllm/engine/arg_utils.py
imports: import argparse
  import dataclasses
  from dataclasses import dataclass
  from typing import Optional, Tuple
  from bigdl.llm.vllm.config import ModelConfig, SchedulerConfig
label_desc: Use image node_id 2 for calling the EngineArgs obj's underlying member method code with example usage: obj.add_cli_args(parser) and returns: parser