# File: optimum-nvidia-main/src/optimum/commands/env.py import platform import subprocess import huggingface_hub from tensorrt import __version__ as trt_version from tensorrt_llm import __version__ as trtllm_version from transformers import __version__ as transformers_version from transformers.utils import is_torch_available from optimum.commands import BaseOptimumCLICommand, CommandInfo from optimum.version import __version__ as optimum_version class EnvironmentCommand(BaseOptimumCLICommand): COMMAND = CommandInfo(name='env', help='Get information about the environment used.') @staticmethod def print_apt_pkgs(): apt = subprocess.Popen(['apt', 'list', '--installed'], stdout=subprocess.PIPE) grep = subprocess.Popen(['grep', 'cuda'], stdin=apt.stdout, stdout=subprocess.PIPE) pkgs_list = list(grep.stdout) for pkg in pkgs_list: print(pkg.decode('utf-8').split('\n')[0]) def run(self): pt_version = 'not installed' if is_torch_available(): import torch pt_version = torch.__version__ platform_info = {'Platform': platform.platform(), 'Python version': platform.python_version()} info = {'`tensorrt` version': trt_version, '`tensorrt-llm` version': trtllm_version, '`optimum` version': optimum_version, '`transformers` version': transformers_version, '`huggingface_hub` version': huggingface_hub.__version__, '`torch` version': f'{pt_version}'} print('\nCopy-and-paste the text below in your GitHub issue:\n') print('\nPlatform:\n') print(self.format_dict(platform_info)) print('\nPython packages:\n') print(self.format_dict(info)) print('\nCUDA system packages:\n') self.print_apt_pkgs() # File: optimum-nvidia-main/src/optimum/nvidia/compression/modelopt.py from abc import ABC, abstractmethod from typing import TYPE_CHECKING, Iterable, Optional, Protocol, Union, runtime_checkable import modelopt.torch.quantization as mtq import modelopt.torch.sparsity as mts import torch from modelopt.torch.export import export_tensorrt_llm_checkpoint from transformers.quantizers import HfQuantizer from transformers.utils.quantization_config import QuantizationConfigMixin from optimum.nvidia.compression import CompressionRecipe if TYPE_CHECKING: from modelopt.torch.quantization import QuantizeConfig from transformers import PreTrainedModel as TransformersPreTrainedModel from optimum.nvidia.export import Workspace @runtime_checkable class IntoModelOptQuantizeConfig(Protocol): def into_modelopt_qconfig(self) -> 'QuantizeConfig': ... class ModelOptConfig(QuantizationConfigMixin): def __init__(self, qconfig: Union['QuantizeConfig', 'IntoModelOptQuantizeConfig'], sparsity: Optional[Union[mts.mode.SparseGPTConfig, mts.mode.SparseMagnitudeConfig]]=None): self._qconfig = qconfig.into_modelopt_qconfig() if isinstance(qconfig, IntoModelOptQuantizeConfig) else qconfig self._sparsity = sparsity @property def quant_method(self): return self._qconfig.algorithm @property def qconfig(self) -> 'QuantizeConfig': return self._qconfig @property def sparsity(self) -> Optional[str]: return self._sparsity class ModelOptRecipe(CompressionRecipe[ModelOptConfig], ABC): @property @abstractmethod def config(self) -> ModelOptConfig: raise NotImplementedError() @property @abstractmethod def dataset(self) -> Iterable: raise NotImplementedError() class ModelOptQuantizer(HfQuantizer): def __init__(self, recipe: ModelOptRecipe): super().__init__(recipe.config) self._recipe = recipe def _looper(self, model: 'TransformersPreTrainedModel'): for sample in self._recipe.dataset: _ = model(**sample) def _process_model_before_weight_loading(self, model, **kwargs): return model def _process_model_after_weight_loading(self, model, **kwargs): if 'workspace' not in kwargs: raise KeyError('workspace not provided but required to generate quantized model representation') workspace: 'Workspace' = kwargs.pop('workspace') with torch.inference_mode(): if (sconfig := self._recipe.config.sparsity): device = model.device model = mts.sparsify(model.cpu(), sconfig, {'data_loader': self._recipe.dataset, 'collect_func': lambda x: x}) model = mts.export(model) model.to(device) qmodel = mtq.quantize(model, vars(self._recipe.config.qconfig), forward_loop=self._looper) export_tensorrt_llm_checkpoint(qmodel, decoder_type=model.config.model_type, dtype=model.dtype, export_dir=workspace.checkpoints_path, inference_tensor_parallel=1, inference_pipeline_parallel=1, use_nfs_workspace=False, naive_fp8_quantization=False) return qmodel @property def is_serializable(self): return True @property def is_trainable(self): return True # File: optimum-nvidia-main/src/optimum/nvidia/errors.py from typing import Optional from optimum.nvidia.utils.nvml import SM_FP8_SUPPORTED class OptimumNvidiaException(Exception): def __init__(self, msg: str, operation: Optional[str]=None): if operation: super().__init__(f'[{operation}] {msg}.') else: super().__init__(f'{msg}') class UnsupportedModelException(OptimumNvidiaException): def __init__(self, model_type: str): super().__init__(f'Model of type {model_type} is not supported. Please open-up an issue at https://github.com/huggingface/optimum-nvidia/issues') class UnsupportedHardwareFeature(OptimumNvidiaException): def __init__(self, msg, feature: str): super(msg) @classmethod def float8(cls) -> 'UnsupportedHardwareFeature': return Float8NotSupported() class Float8NotSupported(UnsupportedHardwareFeature): def __init__(self): super().__init__(f'float8 is not supported on your device. Please use a device with compute capabilities {SM_FP8_SUPPORTED}', 'float8') # File: optimum-nvidia-main/src/optimum/nvidia/export/cli.py from typing import TYPE_CHECKING if TYPE_CHECKING: from argparse import ArgumentParser def common_trtllm_export_args(parser: 'ArgumentParser'): parser.add_argument('model', type=str, help='Model to export.') required_group = parser.add_argument_group('Required arguments') required_group.add_argument('--max-input-length', type=int, default=-1, help='Maximum sequence length, in number of tokens, the prompt can be. The maximum number of potential tokens generated will be - .') required_group.add_argument('--max-output-length', type=int, default=-1, help='Maximum sequence length, in number of tokens, the model supports.') optional_group = parser.add_argument_group('Optional arguments') optional_group.add_argument('-d', '--dtype', type=str, default='auto', help="Computational data type used for the model. Default to 'auto' matching model's data type.") optional_group.add_argument('--max-batch-size', type=int, default=1, help='Maximum number of concurrent requests the model can process. Default to 1.') optional_group.add_argument('--max-beams-width', type=int, default=1, help='Maximum number of sampling paths ("beam") to evaluate when decoding new a token. Default to 1.') optional_group.add_argument('-q', '--quantization', type=str, help='Path to a quantization recipe file.') optional_group.add_argument('--destination', type=str, default=None, help='Folder where the resulting exported engines will be stored. Default to Hugging Face Hub cache.') optional_group.add_argument('--push-to-hub', type=str, help='Repository to push generated engines to.') # File: optimum-nvidia-main/src/optimum/nvidia/export/config.py from dataclasses import dataclass from logging import getLogger from os import PathLike from typing import TYPE_CHECKING, Optional, Union from warnings import warn from tensorrt_llm import BuildConfig from tensorrt_llm import Mapping as ShardingInfo from tensorrt_llm.bindings import QuantMode from tensorrt_llm.plugin import PluginConfig from tensorrt_llm.plugin.plugin import ContextFMHAType from transformers import AutoConfig from optimum.nvidia.lang import DataType from optimum.utils import NormalizedConfig if TYPE_CHECKING: from transformers import PretrainedConfig INFER_NUM_LOCAL_GPUS = -1 LOGGER = getLogger() @dataclass class ExportConfig: dtype: str max_input_len: int max_output_len: int max_batch_size: int max_beam_width: int = 1 max_num_tokens: int = -1 enabled_chunked_context: int = False sharding: Optional[ShardingInfo] = None optimization_level: int = 3 def __post_init__(self): if self.max_batch_size < 1: raise ValueError(f'max_batch_size should >= 1, got {self.max_batch_size}') @staticmethod def from_pretrained(model_id_or_path: Union[str, PathLike], max_batch_size: int=1) -> 'ExportConfig': return ExportConfig.from_config(AutoConfig.from_pretrained(model_id_or_path), max_batch_size) @staticmethod def from_config(config: Union[NormalizedConfig, 'PretrainedConfig'], max_batch_size: int=1) -> 'ExportConfig': if not isinstance(config, NormalizedConfig): config = NormalizedConfig(config) dtype = DataType.from_torch(config.torch_dtype).value max_input_len = config.max_position_embeddings max_output_len = config.max_position_embeddings econfig = ExportConfig(dtype=dtype, max_input_len=max_input_len, max_output_len=max_output_len, max_batch_size=max_batch_size) econfig.with_sharding() econfig.validate() return econfig def validate(self) -> 'ExportConfig': if self.optimization_level < 0: raise ValueError(f'optimization_level should be >= 0, got {self.optimization_level}') if self.max_num_tokens == -1: if self.enabled_chunked_context: self.max_num_tokens = 128 warn(f'max_num_tokens set to {self.max_num_tokens} with chunked context enabled might not be optimal.') else: self.max_num_tokens = 2 * self.max_input_len LOGGER.debug(f'Inferred max_num_tokens={self.max_num_tokens}') return self @property def plugin_config(self) -> 'PluginConfig': config = PluginConfig() config.gemm_plugin = 'auto' config.gpt_attention_plugin = 'auto' config.set_context_fmha(ContextFMHAType.enabled) if self.sharding.world_size > 1: config.lookup_plugin = 'auto' config.set_nccl_plugin() if DataType(self.dtype) == DataType.FLOAT8: config.gemm_swiglu_plugin = True return config def to_builder_config(self, qmode: Optional['QuantMode']=None, plugin_config: Optional[PluginConfig]=None) -> 'BuildConfig': self.validate() plugin_config = plugin_config or self.plugin_config if qmode: plugin_config.use_fp8_context_fmha = qmode.has_fp8_qdq() or qmode.has_fp8_kv_cache() if qmode.is_weight_only(): plugin_config.weight_only_groupwise_quant_matmul_plugin = 'auto' weight_sparsity = False else: weight_sparsity = False return BuildConfig(max_input_len=self.max_input_len, max_seq_len=self.max_output_len, max_batch_size=self.max_batch_size, max_beam_width=self.max_beam_width, max_num_tokens=self.max_num_tokens, builder_opt=self.optimization_level, plugin_config=plugin_config, use_fused_mlp=True, weight_sparsity=weight_sparsity) def with_sharding(self, tp: int=1, pp: int=1, gpus_per_node: int=8, sharding: Optional[ShardingInfo]=None) -> 'ExportConfig': self.sharding = sharding or ShardingInfo(tp_size=tp, pp_size=pp, world_size=tp * pp, gpus_per_node=gpus_per_node) return self def auto_parallel(config: 'ExportConfig', world_size: int=INFER_NUM_LOCAL_GPUS) -> 'ExportConfig': if world_size < 1: from optimum.nvidia.utils.nvml import get_device_count world_size = get_device_count() LOGGER.info(f'Found {world_size} GPUs on the system') if world_size == 0: raise ValueError('No GPU found') elif world_size == 1: return config.with_sharding(tp=1, pp=1, gpus_per_node=world_size) else: LOGGER.info(f'Creating auto-parallelization strategy on {world_size}-GPUs') LOGGER.warning('Auto-parallelization strategy is currently in beta and might not be optimal') if world_size == 2: return config.with_sharding(tp=2, pp=1, gpus_per_node=world_size) elif world_size == 4: return config.with_sharding(tp=2, pp=2, gpus_per_node=world_size) elif world_size == 8: return config.with_sharding(tp=4, pp=2, gpus_per_node=world_size) else: raise ValueError(f'Unsupported number of GPUs: {world_size}. Please open-up and issue on the optimum-nvidia repository: https://github.com/huggingface/optimum-nvidia') def sharded(config: 'ExportConfig', tp: int=1, pp: int=1) -> 'ExportConfig': if tp < 1: raise ValueError(f'Tensor Parallelism (tp) should be >= 1 (got: tp={tp})') if pp < 1: raise ValueError(f'Pipeline Parallelism (pp) should be >= 1 (got: pp={pp})') return config.with_sharding(sharding=ShardingInfo(tp_size=tp, pp_size=pp, world_size=tp * pp)) # File: optimum-nvidia-main/src/optimum/nvidia/export/converter.py import shutil from abc import ABC from enum import Enum from logging import getLogger from os import PathLike from pathlib import Path from typing import TYPE_CHECKING, Optional, Sequence, Type, Union from tensorrt_llm.builder import build from optimum.nvidia.compression.modelopt import ModelOptQuantizer from optimum.nvidia.export import Workspace from optimum.nvidia.utils.nvml import get_device_name, is_post_ampere if TYPE_CHECKING: from tensorrt_llm import BuildConfig, Mapping from tensorrt_llm.models import PretrainedModel from transformers import PreTrainedModel as TransformersPreTrainedModel from optimum.nvidia.compression.modelopt import ModelOptRecipe LOGGER = getLogger() def infer_plugin_from_build_config(config: 'BuildConfig') -> 'BuildConfig': if is_post_ampere(): LOGGER.debug('Enabling Paged Context FMHA plugin') config.plugin_config.update_from_dict({'use_paged_context_fmha': True}) config.plugin_config.update_from_dict({'enable_xqa': False}) return config class TensorRTArtifactKind(Enum): CHECKPOINTS = 'checkpoints' ENGINES = 'engines' class TensorRTArtifact: @staticmethod def checkpoints(root: Union[str, PathLike]) -> 'TensorRTArtifact': return TensorRTArtifact(TensorRTArtifactKind.CHECKPOINTS, root) @staticmethod def engines(root: Union[str, PathLike]) -> 'TensorRTArtifact': return TensorRTArtifact(TensorRTArtifactKind.ENGINES, root) def __init__(self, kind: TensorRTArtifactKind, root: Union[str, PathLike]): self._kind = kind self._root = root @property def kind(self) -> TensorRTArtifactKind: return self._kind @property def root(self) -> Path: return Path(self._root) def push_to_hub(self): raise NotImplementedError() class TensorRTModelConverter(ABC): CONFIG_CLASS: Type MODEL_CLASS: Type def __init__(self, model_id: str, subpart: str='', workspace: Optional[Union['Workspace', str, bytes, Path]]=None, license_path: Optional[Union[str, bytes, Path]]=None): LOGGER.info(f'Creating a model converter for {subpart}') if not workspace: target_device = get_device_name(0)[-1] workspace = Workspace.from_hub_cache(model_id, target_device, subpart=subpart) if isinstance(workspace, (str, bytes, Path)): workspace = Workspace(Path(workspace)) LOGGER.debug(f'Initializing model converter workspace at {workspace.root}') self._workspace = workspace self._license_path = license_path @property def workspace(self) -> Workspace: return self._workspace def save_license(self, licence_filename: str='LICENSE'): if not (dst_licence_file_path := (self.workspace.root / licence_filename)).exists() and self._license_path: shutil.copyfile(self._license_path, dst_licence_file_path) def quantize(self, model: 'TransformersPreTrainedModel', qconfig: 'ModelOptRecipe') -> TensorRTArtifact: quantizer = ModelOptQuantizer(qconfig) quantizer.preprocess_model(model, workspace=self.workspace) quantizer.postprocess_model(model, workspace=self.workspace) self.save_license() return TensorRTArtifact.checkpoints(self._workspace.checkpoints_path) def convert(self, models: Union['PretrainedModel', Sequence['PretrainedModel']], mapping: Optional['Mapping']=None) -> TensorRTArtifact: if isinstance(models, PretrainedModel): models = [models] for (rank, model) in enumerate(models): LOGGER.info(f'Converting {models[0].config.architecture} model for rank {rank} to TRTLLM') model.save_checkpoint(str(self._workspace.checkpoints_path)) self.save_license() return TensorRTArtifact.checkpoints(str(self._workspace.checkpoints_path)) def build(self, models: Union['PretrainedModel', Sequence['PretrainedModel']], config: 'BuildConfig') -> TensorRTArtifact: if not isinstance(models, Sequence): models = [models] config = infer_plugin_from_build_config(config) for model in models: LOGGER.info(f'Building TRTLLM engine for rank {model.config.mapping.rank} ->> {config.to_dict()}') engine = build(model, config) engine.save(str(self._workspace.engines_path)) self.save_license() return TensorRTArtifact.engines(str(self._workspace.engines_path)) # File: optimum-nvidia-main/src/optimum/nvidia/export/workspace.py from dataclasses import dataclass from pathlib import Path from typing import Iterable, Optional from huggingface_hub import cached_assets_path from tensorrt_llm import __version__ as TRTLLM_VERSION from optimum.nvidia import LIBRARY_NAME from optimum.nvidia.export import PATH_FILE_CHECKPOINTS, PATH_FILE_ENGINES, PATH_FOLDER_CHECKPOINTS, PATH_FOLDER_ENGINES @dataclass class Workspace: root: Path @staticmethod def from_hub_cache(model_id: str, device: str, namespace: str=LIBRARY_NAME, version: str=TRTLLM_VERSION, subpart: Optional[str]=None) -> 'Workspace': assets_path = cached_assets_path(namespace, namespace=version, subfolder=model_id) assets_path = assets_path.joinpath(device) if subpart: assets_path = assets_path.joinpath(subpart) assets_path.mkdir(exist_ok=True, parents=True) return Workspace(assets_path) def __post_init__(self): if not self.checkpoints_path.exists(): self.checkpoints_path.mkdir(parents=True) if not self.engines_path.exists(): self.engines_path.mkdir(parents=True) @property def checkpoints_path(self) -> Path: return self.root / PATH_FOLDER_CHECKPOINTS @property def engines_path(self) -> Path: return self.root / PATH_FOLDER_ENGINES @property def checkpoints(self) -> Iterable[Path]: return self.checkpoints_path.glob(PATH_FILE_CHECKPOINTS) def engines(self) -> Iterable[Path]: return self.engines_path.glob(PATH_FILE_ENGINES) # File: optimum-nvidia-main/src/optimum/nvidia/generation/logits_process.py import torch from transformers import ForceTokensLogitsProcessor, SuppressTokensAtBeginLogitsProcessor, SuppressTokensLogitsProcessor from transformers.generation.logits_process import WhisperNoSpeechDetection class TrtSuppressTokensLogitsProcessor(SuppressTokensLogitsProcessor): def __call__(self, step: int, input_ids: torch.Tensor, scores: torch.Tensor): scores = super().__call__(input_ids, scores) return scores class TrtSuppressTokensAtBeginLogitsProcessor(SuppressTokensAtBeginLogitsProcessor): def __call__(self, step: int, input_ids: torch.Tensor, scores: torch.Tensor): scores = super().__call__(input_ids, scores) return scores class TrtForceTokensLogitsProcessor(ForceTokensLogitsProcessor): def __call__(self, step: int, input_ids: torch.Tensor, scores: torch.Tensor): scores = super().__call__(input_ids, scores) return scores class TrtWhisperNoSpeechDetection(WhisperNoSpeechDetection): def __call__(self, step: int, input_ids: torch.Tensor, scores: torch.Tensor): scores = super().__call__(input_ids, scores) return scores LOGITS_PROCESSOR_MAP = {SuppressTokensLogitsProcessor: TrtSuppressTokensLogitsProcessor, SuppressTokensAtBeginLogitsProcessor: TrtSuppressTokensAtBeginLogitsProcessor, ForceTokensLogitsProcessor: TrtForceTokensLogitsProcessor, WhisperNoSpeechDetection: TrtWhisperNoSpeechDetection} # File: optimum-nvidia-main/src/optimum/nvidia/hub.py import re from abc import ABCMeta, abstractmethod from logging import getLogger from os import PathLike, scandir, symlink from pathlib import Path from shutil import copyfile, copytree from typing import Dict, Generator, Iterable, List, Mapping, Optional, Type, Union import torch.cuda from huggingface_hub import ModelHubMixin, snapshot_download from huggingface_hub.hub_mixin import T from tensorrt_llm import __version__ as trtllm_version from tensorrt_llm.models import PretrainedConfig from tensorrt_llm.models import PretrainedModel as TrtLlmPreTrainedModel from transformers import AutoConfig, GenerationConfig from transformers import PretrainedConfig as TransformersPretraineConfig from transformers.utils import CONFIG_NAME, GENERATION_CONFIG_NAME, SAFE_WEIGHTS_INDEX_NAME from optimum.nvidia import LIBRARY_NAME from optimum.nvidia.compression.modelopt import ModelOptRecipe from optimum.nvidia.export import PATH_FOLDER_ENGINES, ExportConfig, TensorRTModelConverter, Workspace, auto_parallel from optimum.nvidia.lang import DataType from optimum.nvidia.models import SupportsFromHuggingFace, SupportsTransformersConversion from optimum.nvidia.models.base import SupportFromTrtLlmCheckpoint from optimum.nvidia.utils import get_user_agent from optimum.nvidia.utils.nvml import get_device_count, get_device_name from optimum.utils import NormalizedConfig ATTR_TRTLLM_ENGINE_FOLDER = '__trtllm_engine_folder__' FILE_TRTLLM_ENGINE_PATTERN = 'rank[0-9]*.engine' FILE_TRTLLM_CHECKPOINT_PATTERN = 'rank[0-9]*.engine' FILE_LICENSE_NAME = 'LICENSE' HUB_SNAPSHOT_ALLOW_PATTERNS = [CONFIG_NAME, GENERATION_CONFIG_NAME, SAFE_WEIGHTS_INDEX_NAME, '*.safetensors', FILE_LICENSE_NAME] LOGGER = getLogger() def folder_list_engines(folder: Path) -> Iterable[Path]: if folder.exists(): return list(folder.glob('*.engine')) return [] def folder_list_checkpoints(folder: Path) -> Iterable[Path]: checkpoint_candidates = [] if folder.exists(): re_checkpoint_filename = re.compile('rank[0-9]+\\.safetensors') checkpoint_candidates = list(map(Path, filter(lambda item: re_checkpoint_filename.match(item.name), scandir(folder)))) return checkpoint_candidates def get_rank_from_filename(filename: str) -> int: name = filename.split('.')[0] if name.startswith('rank'): return int(name[3:]) else: raise ValueError(f'Unknown filename format {filename} to extract rank from') def get_trtllm_artifact(model_id: str, patterns: List[str], add_default_allow_patterns: bool=True) -> Path: if (local_path := Path(model_id)).exists(): return local_path return Path(snapshot_download(repo_id=model_id, repo_type='model', library_name=LIBRARY_NAME, library_version=trtllm_version, user_agent=get_user_agent(), allow_patterns=patterns + HUB_SNAPSHOT_ALLOW_PATTERNS if add_default_allow_patterns else patterns)) def get_trtllm_checkpoints(model_id: str, device: str, dtype: str): if (workspace := Workspace.from_hub_cache(model_id, device)).checkpoints_path.exists(): return workspace.checkpoints_path return get_trtllm_artifact(model_id, [f'{device}/{dtype}/**/*.safetensors']) def get_trtllm_engines(model_id: str, device: str, dtype: str): if (workspace := Workspace.from_hub_cache(model_id, device)).engines_path.exists(): return workspace.engines_path return get_trtllm_artifact(model_id, [f'{device}/{dtype}/**/{PATH_FOLDER_ENGINES}/*.engine']) def from_ranked_checkpoints(checkpoints_folder: Path, target_class: Type[SupportFromTrtLlmCheckpoint]) -> Generator['TrtLlmPreTrainedModel', None, None]: root = str(checkpoints_folder) trtllm_config = PretrainedConfig.from_checkpoint(root) for rank in range(trtllm_config.mapping.world_size): yield target_class.from_checkpoint(root, rank, trtllm_config) def from_ranked_hf_model(local_hf_model_path: Path, config: 'TransformersPretraineConfig', target_class: Type['TrtLlmPreTrainedModel'], export_config: 'ExportConfig'): root = str(local_hf_model_path) for rank in range(export_config.sharding.world_size): export_config.sharding.rank = rank ranked_model = target_class.from_hugging_face(root, dtype=DataType.from_torch(config.torch_dtype).value, mapping=export_config.sharding, load_by_shard=True, use_parallel_embedding=export_config.sharding.world_size > 1, share_embedding_table=config.tie_word_embeddings) ranked_model.config.mapping.rank = rank yield ranked_model class HuggingFaceHubModel(ModelHubMixin, library_name=LIBRARY_NAME, languages=['python', 'c++'], tags=['optimum-nvidia', 'trtllm'], repo_url='https://github.com/huggingface/optimum-nvidia', docs_url='https://huggingface.co/docs/optimum/nvidia_overview', metaclass=ABCMeta): def __init__(self, engines_path: Union[str, PathLike, Path]): self._engines_path = Path(engines_path) @classmethod def _from_pretrained(cls: Type[T], *, model_id: str, config: Dict, revision: Optional[str], cache_dir: Optional[Union[str, Path]], force_download: bool, proxies: Optional[Dict], resume_download: bool, local_files_only: bool, token: Optional[Union[str, bool]], use_cuda_graph: bool=False, device_map: Optional[str]=None, export_config: Optional[ExportConfig]=None, quantization_config: Optional[ModelOptRecipe]=None, force_export: bool=False, export_only: bool=False, save_intermediate_checkpoints: bool=False) -> T: if get_device_count() < 1: raise ValueError('No GPU detected on this platform') device_name = get_device_name(0)[-1] if 'torch_dtype' in config: dtype = config['torch_dtype'] elif 'pretrained_config' in config and 'dtype' in config['pretrained_config']: dtype = config['pretrained_config']['dtype'] else: raise RuntimeError("Failed to detect model's dtype") local_model_id = Path(model_id) engines_folder = checkpoints_folder = None engine_files = checkpoint_files = [] if local_model_id.exists() and local_model_id.is_dir(): if any((engine_files := list(folder_list_engines(local_model_id)))): engines_folder = engine_files[0].parent checkpoints_folder = None else: checkpoint_files = list(folder_list_checkpoints(local_model_id)) if checkpoint_files: checkpoints_folder = checkpoint_files[0].parent else: if not force_export: LOGGER.debug(f'Retrieving prebuild engine(s) for device {device_name}') engines_folder = get_trtllm_engines(model_id, device_name, dtype) engine_files = folder_list_engines(engines_folder) if not engine_files: LOGGER.debug(f'Retrieving checkpoint(s) for {device_name}') checkpoints_folder = get_trtllm_checkpoints(model_id, device_name, dtype) checkpoint_files = folder_list_checkpoints(checkpoints_folder) if not engine_files: LOGGER.info(f'No prebuild engines nor checkpoint were found for {model_id}') if local_model_id.is_dir(): LOGGER.debug(f'Retrieving model from local folder: {local_model_id}') original_checkpoints_path_for_conversion = local_model_id workspace = Workspace(local_model_id) else: LOGGER.debug(f'Retrieving model from snapshot {model_id} on the Hugging Face Hub') original_checkpoints_path_for_conversion = snapshot_download(model_id, repo_type='model', revision=revision, cache_dir=cache_dir, force_download=force_download, proxies=proxies, resume_download=resume_download, local_files_only=local_files_only, token=token, allow_patterns=HUB_SNAPSHOT_ALLOW_PATTERNS) workspace = None config = NormalizedConfig(AutoConfig.for_model(**config)) generation_config = GenerationConfig.from_pretrained(original_checkpoints_path_for_conversion) if FILE_LICENSE_NAME in original_checkpoints_path_for_conversion: licence_path = original_checkpoints_path_for_conversion.joinpath(FILE_LICENSE_NAME) else: licence_path = None export_config = export_config or ExportConfig.from_config(config) if device_map and device_map == 'auto': LOGGER.info('Auto-parallel we will be used') export_config = auto_parallel(export_config) if isinstance(cls, SupportsTransformersConversion): targets = cls.TRT_LLM_TARGET_MODEL_CLASSES if not isinstance(targets, Mapping): targets = {'': targets} for (idx, (subpart, clazz)) in enumerate(targets.items()): LOGGER.info(f'Building {model_id} {subpart} ({idx + 1} / {len(targets)})') converter = TensorRTModelConverter(model_id, subpart, workspace, licence_path) if quantization_config: hf_model = cls.HF_LIBRARY_TARGET_MODEL_CLASS.from_pretrained(original_checkpoints_path_for_conversion, torch_dtype='auto', device_map='auto') checkpoints_folder = converter.quantize(hf_model, quantization_config) checkpoints_folder = checkpoints_folder.root checkpoint_files = folder_list_checkpoints(checkpoints_folder) del hf_model torch.cuda.empty_cache() if force_export or not len(list(converter.workspace.engines_path.glob('*.engine'))): if checkpoint_files and isinstance(clazz, SupportFromTrtLlmCheckpoint): ranked_models = from_ranked_checkpoints(checkpoints_folder, clazz) elif isinstance(clazz, SupportsFromHuggingFace): ranked_models = from_ranked_hf_model(original_checkpoints_path_for_conversion, config, clazz, export_config) else: raise TypeError(f"{clazz} can't convert from HF checkpoint") generation_config = GenerationConfig.from_pretrained(original_checkpoints_path_for_conversion) for ranked_model in ranked_models: if save_intermediate_checkpoints: _ = converter.convert(ranked_model) LOGGER.info(f'Saved intermediate checkpoints at {converter.workspace.checkpoints_path}') build_config = export_config.to_builder_config(ranked_model.config.quantization.quant_mode) _ = converter.build(ranked_model, build_config) engines_folder = converter.workspace.engines_path generation_config.save_pretrained(engines_folder) LOGGER.info(f'Saved TensorRT-LLM engines at {converter.workspace.engines_path}') else: LOGGER.info(f'Found existing engines at {converter.workspace.engines_path}') else: raise ValueError("Model doesn't support Hugging Face transformers conversion, aborting.") else: generation_config = GenerationConfig.from_pretrained(engines_folder) return cls(engines_path=engines_folder, generation_config=generation_config, load_engines=not export_only) @abstractmethod def _save_additional_parcels(self, save_directory: Path): raise NotImplementedError() def _save_pretrained(self, save_directory: Path) -> None: device_name = get_device_name(0)[-1] save_directory = save_directory.joinpath(device_name) save_directory.mkdir(parents=True, exist_ok=True) src_license_file_path = self._engines_path.parent / FILE_LICENSE_NAME dst_files = [src_license_file_path] if src_license_file_path.exists() else [] dst_files += list(self._engines_path.glob('*')) for file in dst_files: try: symlink(file, save_directory.joinpath(file.relative_to(self._engines_path))) except OSError as ose: LOGGER.error(f'Failed to create symlink from current engine folder {self._engines_path.parent} to {save_directory}. Will default to copy based _save_pretrained', exc_info=ose) dst = save_directory.joinpath(file.relative_to(self._engines_path)) if file.is_dir(): copytree(file, dst, symlinks=True) elif file: copyfile(file, dst) self._save_additional_parcels(save_directory) # File: optimum-nvidia-main/src/optimum/nvidia/lang/__init__.py from enum import Enum from typing import List import torch class DataType(str, Enum): FLOAT32 = 'float32' FLOAT16 = 'float16' BFLOAT16 = 'bfloat16' FLOAT8 = 'float8' INT64 = 'int64' INT32 = 'int32' INT8 = 'int8' UINT8 = 'uint8' BOOL = 'bool' @staticmethod def from_torch(dtype: torch.dtype) -> 'DataType': if dtype == torch.float32: return DataType.FLOAT32 elif dtype == torch.float16: return DataType.FLOAT16 elif dtype == torch.bfloat16: return DataType.BFLOAT16 elif dtype == torch.float8_e4m3fn: return DataType.FLOAT8 elif dtype == torch.int64: return DataType.INT64 elif dtype == torch.int32: return DataType.INT32 elif dtype == torch.int8: return DataType.INT8 elif dtype == torch.uint8: return DataType.UINT8 elif dtype == torch.bool: return DataType.BOOL else: raise ValueError(f'Unknown torch.dtype {dtype}') def to_trt(self) -> 'DataType': import tensorrt as trt if self == DataType.FLOAT32: return trt.DataType.FLOAT elif self == DataType.FLOAT16: return trt.DataType.HALF elif self == DataType.BFLOAT16: return trt.DataType.BF16 elif self == DataType.FLOAT8: return trt.DataType.FP8 elif self == DataType.INT8: return trt.DataType.INT8 elif self == DataType.UINT8: return trt.DataType.UINT8 elif self == DataType.INT32: return trt.DataType.INT32 elif self == DataType.INT64: return trt.DataType.INT64 elif self == DataType.BOOL: return trt.DataType.BOOL else: raise ValueError(f'Unknown value {self}') def to_torch(self): import torch if self == DataType.FLOAT32: return torch.float32 elif self == DataType.FLOAT16: return torch.float16 elif self == DataType.BFLOAT16: return torch.bfloat16 elif self == DataType.FLOAT8: return torch.float8_e4m3fn elif self == DataType.INT8: return torch.int8 elif self == DataType.UINT8: return torch.uint8 elif self == DataType.INT32: return torch.int32 elif self == DataType.INT64: return torch.int64 elif self == DataType.BOOL: return torch.bool else: raise ValueError(f'Unknown value {self}') @staticmethod def values() -> List[str]: return [item.value for item in DataType] # File: optimum-nvidia-main/src/optimum/nvidia/models/auto.py from pathlib import Path from typing import TYPE_CHECKING, Any, Dict, Optional, Type, Union from huggingface_hub import ModelHubMixin from optimum.nvidia.errors import UnsupportedModelException from optimum.nvidia.models.gemma import GemmaForCausalLM from optimum.nvidia.models.llama import LlamaForCausalLM from optimum.nvidia.utils import model_type_from_known_config if TYPE_CHECKING: from optimum.nvidia.export import ExportConfig from optimum.nvidia.runtime import CausalLM class AutoModelForCausalLM(ModelHubMixin): """""" _SUPPORTED_MODEL_CLASS = {'llama': LlamaForCausalLM, 'mistral': LlamaForCausalLM, 'mixtral': LlamaForCausalLM, 'gemma': GemmaForCausalLM} def __init__(self): super().__init__() @classmethod def _from_pretrained(cls: Type, *, model_id: str, revision: Optional[str], cache_dir: Optional[Union[str, Path]], force_download: bool, proxies: Optional[Dict], resume_download: bool, local_files_only: bool, token: Optional[Union[str, bool]], config: Optional[Dict[str, Any]]=None, export_config: Optional['ExportConfig']=None, force_export: bool=False, use_cuda_graph: bool=False, **model_kwargs) -> 'CausalLM': if config is None: raise ValueError('Unable to determine the model type with config = None') model_type = model_type_from_known_config(config) if not model_type or model_type not in AutoModelForCausalLM._SUPPORTED_MODEL_CLASS: raise UnsupportedModelException(model_type) model_clazz = AutoModelForCausalLM._SUPPORTED_MODEL_CLASS[model_type] model = model_clazz.from_pretrained(pretrained_model_name_or_path=model_id, config=config, revision=revision, cache_dir=cache_dir, force_download=force_download, proxies=proxies, resume_download=resume_download, local_files_only=local_files_only, token=token, export_config=export_config, force_export=force_export, use_cuda_graph=use_cuda_graph, **model_kwargs) return model # File: optimum-nvidia-main/src/optimum/nvidia/models/base.py from os import PathLike from typing import TYPE_CHECKING, Mapping, Optional, Protocol, Type, Union, runtime_checkable if TYPE_CHECKING: from tensorrt_llm.models import PretrainedConfig from tensorrt_llm.top_model_mixin import TopModelMixin from transformers import PreTrainedModel as TransformersPreTrainedModel @runtime_checkable class SupportsFromHuggingFace(Protocol): @classmethod def from_hugging_face(cls, hf_model_dir: Union[str, bytes, PathLike], dtype: str='float16', mapping: Optional[Mapping]=None, **kwargs): ... @runtime_checkable class SupportFromTrtLlmCheckpoint(Protocol): @classmethod def from_checkpoint(cls, ckpt_dir: str, rank: Optional[int]=None, config: Optional['PretrainedConfig']=None): ... @runtime_checkable class SupportsTransformersConversion(Protocol): HF_LIBRARY_TARGET_MODEL_CLASS: Type['TransformersPreTrainedModel'] TRT_LLM_TARGET_MODEL_CLASSES: Union[Type['TopModelMixin'], Mapping[str, Type['TopModelMixin']]] # File: optimum-nvidia-main/src/optimum/nvidia/models/gemma.py from logging import getLogger from tensorrt_llm.models.gemma.model import GemmaForCausalLM as TrtGemmaForCausalLM from transformers import GemmaForCausalLM as TransformersGemmaForCausalLM from optimum.nvidia.hub import HuggingFaceHubModel from optimum.nvidia.models import SupportsTransformersConversion from optimum.nvidia.runtime import CausalLM LOGGER = getLogger(__name__) class GemmaForCausalLM(CausalLM, HuggingFaceHubModel, SupportsTransformersConversion): HF_LIBRARY_TARGET_MODEL_CLASS = TransformersGemmaForCausalLM TRT_LLM_TARGET_MODEL_CLASSES = TrtGemmaForCausalLM TRT_LLM_MANDATORY_CONVERSION_PARAMS = {'share_embedding_table': True} # File: optimum-nvidia-main/src/optimum/nvidia/models/mistral.py from logging import getLogger from tensorrt_llm.models.llama.model import LLaMAForCausalLM from transformers import MistralForCausalLM as TransformersMistralForCausalLM from optimum.nvidia.hub import HuggingFaceHubModel from optimum.nvidia.models import SupportsTransformersConversion from optimum.nvidia.runtime import CausalLM LOGGER = getLogger(__name__) class MistralForCausalLM(CausalLM, HuggingFaceHubModel, SupportsTransformersConversion): HF_LIBRARY_TARGET_MODEL_CLASS = TransformersMistralForCausalLM TRT_LLM_TARGET_MODEL_CLASSES = LLaMAForCausalLM # File: optimum-nvidia-main/src/optimum/nvidia/models/mixtral.py from logging import getLogger from tensorrt_llm.models.llama.model import LLaMAForCausalLM from transformers import MixtralForCausalLM as TransformersMixtralForCausalLM from optimum.nvidia.hub import HuggingFaceHubModel from optimum.nvidia.models import SupportsTransformersConversion from optimum.nvidia.runtime import CausalLM LOGGER = getLogger(__name__) class MixtralForCausalLM(CausalLM, HuggingFaceHubModel, SupportsTransformersConversion): HF_LIBRARY_TARGET_MODEL_CLASS = TransformersMixtralForCausalLM TRT_LLM_TARGET_MODEL_CLASSES = LLaMAForCausalLM # File: optimum-nvidia-main/src/optimum/nvidia/models/whisper.py from logging import getLogger from typing import TYPE_CHECKING from tensorrt_llm.models import DecoderModel as TrtDecoderModel from tensorrt_llm.models import WhisperEncoder as TrtWhisperEncoder from transformers.models.whisper.modeling_whisper import WhisperForConditionalGeneration as TransformersWhisperForConditionalGeneration from optimum.nvidia.models import SupportsTransformersConversion if TYPE_CHECKING: pass LOGGER = getLogger(__name__) class WhisperForConditionalGeneration(SupportsTransformersConversion): HF_LIBRARY_TARGET_MODEL_CLASS = TransformersWhisperForConditionalGeneration TRT_LLM_TARGET_MODEL_CLASSES = {'encoder': TrtWhisperEncoder, 'decoder': TrtDecoderModel} # File: optimum-nvidia-main/src/optimum/nvidia/pipelines/__init__.py from os import PathLike from typing import Dict, Optional, Tuple, Type, Union from huggingface_hub import model_info from tensorrt_llm import Module from transformers import AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast from optimum.nvidia import AutoModelForCausalLM from optimum.nvidia.pipelines.text_generation import TextGenerationPipeline from .base import Pipeline SUPPORTED_MODEL_WITH_TASKS: Dict[str, Dict[str, Tuple[Type[Pipeline], Type]]] = {'gemma': {'text-generation': (TextGenerationPipeline, AutoModelForCausalLM)}, 'llama': {'text-generation': (TextGenerationPipeline, AutoModelForCausalLM)}, 'mistral': {'text-generation': (TextGenerationPipeline, AutoModelForCausalLM)}, 'mixtral': {'text-generation': (TextGenerationPipeline, AutoModelForCausalLM)}} def get_target_class_for_model_and_task(task: str, architecture: str) -> Optional[Type]: task_ = SUPPORTED_MODEL_WITH_TASKS.get(task, None) if not task: raise NotImplementedError(f'Task {task} is not supported yet.') target = task_.get(architecture, None) if not target: raise NotImplementedError(f'Architecture {architecture} is not supported for task {task}. Only the following architectures are: {list(task_.keys())}') return target def pipeline(task: str=None, model: Union[str, PathLike, Module]=None, tokenizer: Optional[Union[str, PreTrainedTokenizer, PreTrainedTokenizerFast]]=None, **kwargs): try: info = model_info(model) except Exception as e: raise RuntimeError(f'Failed to instantiate the pipeline inferring the task for model {model}: {e}') model_type = info.config.get('model_type', None) if not model_type: raise RuntimeError(f'Failed to infer model type for model {model}') elif model_type not in SUPPORTED_MODEL_WITH_TASKS: raise NotImplementedError(f'Model type {model_type} is not currently supported') if not task and getattr(info, 'library_name', 'transformers') == 'transformers': if not info.pipeline_tag: raise RuntimeError(f'Failed to infer the task for model {model}, please use `task` parameter') task = info.pipeline_tag if task not in SUPPORTED_MODEL_WITH_TASKS[model_type]: raise NotImplementedError(f'Task {task} is not supported yet for {model_type}.') if tokenizer is None: tokenizer = AutoTokenizer.from_pretrained(model, use_fast=True) (pipeline_factory, model_factory) = SUPPORTED_MODEL_WITH_TASKS[model_type][task] model = model_factory.from_pretrained(model, **kwargs) return pipeline_factory(model, tokenizer) # File: optimum-nvidia-main/src/optimum/nvidia/pipelines/text_generation.py import warnings from enum import Enum from typing import Dict, List, Union import torch from transformers import PreTrainedTokenizer, TensorType from optimum.nvidia import AutoModelForCausalLM from optimum.nvidia.runtime import CausalLM from .base import Pipeline class ReturnType(Enum): TENSORS = 0 NEW_TEXT = 1 FULL_TEXT = 2 class TextGenerationPipeline(Pipeline): TARGET_FACTORY = AutoModelForCausalLM __slots__ = ('tokenizer', '_runtime') def __init__(self, model: CausalLM, tokenizer: PreTrainedTokenizer): super().__init__() if tokenizer.eos_token and (not tokenizer.pad_token): tokenizer.pad_token = tokenizer.eos_token self.tokenizer = tokenizer self._runtime = model def __call__(self, inputs: Union[str, List[str]], add_special_tokens: bool=True, **kwargs): (preprocess_params, forward_params, postprocess_params) = self._sanitize_parameters(add_special_tokens=add_special_tokens, **kwargs) model_inputs = self.preprocess(inputs, **preprocess_params) model_outputs = self._forward(model_inputs, **forward_params) outputs = self.postprocess(model_outputs, **postprocess_params) return outputs def _sanitize_parameters(self, return_full_text=None, return_tensors=None, return_text=None, return_type=None, clean_up_tokenization_spaces=None, prefix=None, handle_long_generation=None, stop_sequence=None, add_special_tokens=False, **generate_kwargs): preprocess_params = {'add_special_tokens': add_special_tokens} if prefix is not None: preprocess_params['prefix'] = prefix if prefix: prefix_inputs = self.tokenizer(prefix, padding=False, add_special_tokens=add_special_tokens, return_tensors=TensorType.PYTORCH) generate_kwargs['prefix_length'] = prefix_inputs['input_ids'].shape[-1] if handle_long_generation is not None: if handle_long_generation not in {'hole'}: raise ValueError(f"{handle_long_generation} is not a valid value for `handle_long_generation` parameter expected [None, 'hole']") preprocess_params['handle_long_generation'] = handle_long_generation preprocess_params.update(generate_kwargs) forward_params = generate_kwargs postprocess_params = {} if return_full_text is not None and return_type is None: if return_text is not None: raise ValueError('`return_text` is mutually exclusive with `return_full_text`') if return_tensors is not None: raise ValueError('`return_full_text` is mutually exclusive with `return_tensors`') return_type = ReturnType.FULL_TEXT if return_full_text else ReturnType.NEW_TEXT if return_tensors is not None and return_type is None: if return_text is not None: raise ValueError('`return_text` is mutually exclusive with `return_tensors`') return_type = ReturnType.TENSORS if return_type is not None: postprocess_params['return_type'] = return_type if clean_up_tokenization_spaces is not None: postprocess_params['clean_up_tokenization_spaces'] = clean_up_tokenization_spaces if stop_sequence is not None: stop_sequence_ids = self.tokenizer.encode(stop_sequence, add_special_tokens=False) if len(stop_sequence_ids) > 1: warnings.warn('Stopping on a multiple token sequence is not yet supported on transformers. The first token of the stop sequence will be used as the stop sequence string in the interim.') generate_kwargs['eos_token_id'] = stop_sequence_ids[0] return (preprocess_params, forward_params, postprocess_params) def _forward(self, model_inputs, **generate_kwargs): input_ids = model_inputs['input_ids'] prompt_text = model_inputs.pop('prompt_text') attention_mask = model_inputs.get('attention_mask', None) max_new_tokens = generate_kwargs.pop('max_new_tokens', None) min_length = generate_kwargs.pop('min_length', -1) num_beams = generate_kwargs.pop('num_beams', 1) temperature = generate_kwargs.pop('temperature', 1.0) top_k = generate_kwargs.pop('top_k', 50) top_p = generate_kwargs.pop('top_p', 1.0) repetition_penalty = generate_kwargs.pop('repetition_penalty', 1.0) length_penalty = generate_kwargs.pop('length_penalty', 1.0) seed = generate_kwargs.pop('seed', 2017) (generated_sequence, lengths) = self._runtime.generate(input_ids=input_ids, attention_mask=attention_mask, max_new_tokens=max_new_tokens, min_length=min_length, num_beams=num_beams, temperature=temperature, top_k=top_k, top_p=top_p, repetition_penalty=repetition_penalty, length_penalty=length_penalty, seed=seed) return {'generated_sequence': generated_sequence, 'lengths': lengths, 'input_ids': input_ids, 'prompt_text': prompt_text} def preprocess(self, prompt_text, prefix='', handle_long_generation=None, add_special_tokens=False, **generate_kwargs) -> Dict[str, torch.Tensor]: if isinstance(prompt_text, List): text = [prefix + prompt for prompt in prompt_text] else: text = prefix + prompt_text inputs = self.tokenizer(text, padding=False, add_special_tokens=add_special_tokens, return_tensors=TensorType.PYTORCH) inputs['prompt_text'] = prompt_text return inputs def postprocess(self, model_outputs, return_type=ReturnType.FULL_TEXT, clean_up_tokenization_spaces=True): generated_sequence = model_outputs['generated_sequence'] generated_sequence = generated_sequence.cpu().numpy().tolist() records = [] if return_type == ReturnType.TENSORS: return [{'generated_token_ids': generated for generated in generated_sequence}] for sequence in generated_sequence: text = self.tokenizer.decode(sequence, skip_special_tokens=True, clean_up_tokenization_spaces=clean_up_tokenization_spaces) record = {'generated_text': text} records.append(record) return records # File: optimum-nvidia-main/src/optimum/nvidia/runtime.py import asyncio import json import math from logging import getLogger from os import PathLike from pathlib import Path from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union import torch from tensorrt_llm.bindings.executor import ExecutorConfig, KvCacheConfig from tensorrt_llm.executor import GenerationExecutor, GenerationRequest, GenerationResult from tensorrt_llm.hlapi import SamplingParams from optimum.nvidia.hub import HuggingFaceHubModel from optimum.nvidia.utils.nvml import is_post_ampere if TYPE_CHECKING: from transformers import GenerationConfig LOGGER = getLogger(__name__) def read_engine_config_file(path: Path) -> Dict[str, Any]: with open(path / 'config.json', 'r', encoding='utf-8') as config_f: return json.load(config_f) def convert_generation_config(config: 'GenerationConfig') -> 'SamplingParams': return SamplingParams(end_id=config.eos_token_id, pad_id=config.pad_token_id, top_k=config.top_k if config.do_sample else 1, top_p=config.top_p, temperature=config.temperature, beam_width=config.num_beams if config.do_sample else 1, bad_token_ids=config.bad_words_ids, length_penalty=config.length_penalty, repetition_penalty=config.repetition_penalty, no_repeat_ngram_size=config.no_repeat_ngram_size if config.no_repeat_ngram_size > 0 else 1, min_length=config.min_length if config.min_length > 0 else 1, max_new_tokens=config.max_new_tokens, return_generation_logits=config.output_logits, return_log_probs=not config.renormalize_logits) def default_executor_config(config: Dict[str, Any]) -> 'ExecutorConfig': build_config = config['build_config'] plugin_config = config['build_config']['plugin_config'] max_blocks_per_sequence = math.floor(build_config['max_seq_len'] / plugin_config['tokens_per_block']) return ExecutorConfig(enable_chunked_context=is_post_ampere(), kv_cache_config=KvCacheConfig(enable_block_reuse=True, max_tokens=build_config['max_beam_width'] * plugin_config['tokens_per_block'] * max_blocks_per_sequence)) class InferenceRuntimeBase: __slots__ = ('_config', '_executor', '_generation_config', '_sampling_config') def __init__(self, engines_path: Union[str, PathLike], generation_config: 'GenerationConfig', executor_config: Optional['ExecutorConfig']=None, load_engines: bool=True): engines_path = Path(engines_path) if not engines_path.exists(): raise OSError(f"engine folder {engines_path} doesn't exist") self._config = read_engine_config_file(engines_path) self._generation_config = generation_config self._sampling_config = convert_generation_config(generation_config) if load_engines: self._executor = GenerationExecutor.create(engine=engines_path, executor_config=executor_config or default_executor_config(self._config)) def generate(self, inputs: Union[List[int], 'torch.IntTensor'], generation_config: Optional['GenerationConfig']=None): sampling = convert_generation_config(generation_config) if generation_config else self._sampling_config if isinstance(inputs, torch.Tensor): inputs = inputs.tolist() result = self._executor.generate(inputs, sampling_params=sampling) return result[0].outputs[0].token_ids async def agenerate(self, inputs: Union[List[int], 'torch.IntTensor'], generation_config: Optional['GenerationConfig']=None) -> List[int]: sampling = convert_generation_config(generation_config) if generation_config else self._sampling_config if isinstance(inputs, torch.Tensor): inputs = inputs.tolist() futures = self._executor.generate_async(inputs, streaming=False, sampling_params=sampling) if isinstance(futures, GenerationRequest): results = await futures.aresult() return results.token_ids else: results = await asyncio.gather(*[f.aresult() for f in futures]) return [r.token_ids for r in results] class CausalLMOutput: __slots__ = ('_results',) def __init__(self, results: Union['GenerationResult', Sequence['GenerationResult']]): self._results = results @property def logits(self): return self._results.token_ids @property def loss(self) -> None: return None class CausalLM(HuggingFaceHubModel, InferenceRuntimeBase): def __init__(self, engines_path: Union[str, PathLike, Path], generation_config: 'GenerationConfig', executor_config: Optional['ExecutorConfig']=None, load_engines: bool=True): InferenceRuntimeBase.__init__(self, engines_path, generation_config, executor_config, load_engines) HuggingFaceHubModel.__init__(self, engines_path) def _save_additional_parcels(self, save_directory: Path): self._generation_config.save_pretrained(save_directory, 'generation_config.json') # File: optimum-nvidia-main/src/optimum/nvidia/subpackage/commands/export.py import sys from typing import TYPE_CHECKING, Optional, Union from transformers import AutoConfig, AutoTokenizer from optimum.commands import optimum_cli_subcommand from optimum.commands.base import BaseOptimumCLICommand, CommandInfo from optimum.commands.export.base import ExportCommand from optimum.nvidia import AutoModelForCausalLM, ExportConfig from optimum.nvidia.export.cli import common_trtllm_export_args if TYPE_CHECKING: from argparse import ArgumentParser, Namespace, _SubParsersAction from pathlib import Path OPTIMUM_NVIDIA_CLI_QUANTIZATION_TARGET_REF = 'TARGET_QUANTIZATION_RECIPE' def import_source_file(fname: Union[str, 'Path'], modname: str): import importlib.util spec = importlib.util.spec_from_file_location(modname, fname) module = importlib.util.module_from_spec(spec) sys.modules[modname] = module spec.loader.exec_module(module) @optimum_cli_subcommand(ExportCommand) class TrtLlmExportCommand(BaseOptimumCLICommand): COMMAND = CommandInfo(name='trtllm', help='Export PyTorch models to TensorRT-LLM compiled engines') def __init__(self, subparsers: '_SubParsersAction', args: Optional['Namespace']=None, command: Optional['CommandInfo']=None, from_defaults_factory: bool=False, parser: Optional['ArgumentParser']=None): super().__init__(subparsers, args=args, command=command, from_defaults_factory=from_defaults_factory, parser=parser) self.args_string = ' '.join(sys.argv[3:]) @staticmethod def parse_args(parser: 'ArgumentParser'): return common_trtllm_export_args(parser) def run(self): args = self.args if args.quantization: tokenizer = AutoTokenizer.from_pretrained(args.model) import_source_file(args.quantization, 'recipe') try: from recipe import TARGET_QUANTIZATION_RECIPE qconfig = TARGET_QUANTIZATION_RECIPE(tokenizer) except ImportError: raise ModuleNotFoundError(f"Global variable 'TARGET_QUANTIZATION_RECIPE' was not found in {args.quantization}. This is required to automatically detect and allocate the right recipe for quantization.") else: qconfig = None config = AutoConfig.from_pretrained(args.model) export = ExportConfig.from_config(config, args.max_batch_size) model = AutoModelForCausalLM.from_pretrained(args.model, export_config=export, quantization_config=qconfig, export_only=True, force_export=True) if args.destination: model.save_pretrained(args.destination) if args.push_to_hub: print(f'Exporting model to the Hugging Face Hub: {args.push_to_hub}') model.push_to_hub(args.push_to_hub, commit_message=f'Optimum-CLI TensorRT-LLM {args.model} export') # File: optimum-nvidia-main/templates/inference-endpoints/postprocessing/1/model.py import json import numpy as np import triton_python_backend_utils as pb_utils from transformers import AutoTokenizer, LlamaTokenizer, T5Tokenizer class TritonPythonModel: __slots__ = ('tokenizer', 'output_dtype') def initialize(self, args): model_config = json.loads(args['model_config']) tokenizer_dir = model_config['parameters']['tokenizer_dir']['string_value'] self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir, padding_side='left') self.tokenizer.pad_token = self.tokenizer.eos_token output_config = pb_utils.get_output_config_by_name(model_config, 'OUTPUT') self.output_dtype = pb_utils.triton_string_to_numpy(output_config['data_type']) def execute(self, requests): responses = [] for (idx, request) in enumerate(requests): tokens_batch = pb_utils.get_input_tensor_by_name(request, 'TOKENS_BATCH').as_numpy() outputs = self._postprocessing(tokens_batch) output_tensor = pb_utils.Tensor('OUTPUT', np.array(outputs).astype(self.output_dtype)) inference_response = pb_utils.InferenceResponse(output_tensors=[output_tensor]) responses.append(inference_response) return responses def finalize(self): print('Cleaning up...') def _postprocessing(self, tokens_batch): outputs = [] for beam_tokens in tokens_batch: for tokens in beam_tokens: output = self.tokenizer.decode(tokens) outputs.append(output.encode('utf8')) return outputs # File: optimum-nvidia-main/templates/inference-endpoints/preprocessing/1/model.py import csv import json from pathlib import Path from typing import List, Sequence import numpy as np import triton_python_backend_utils as pb_utils from tokenizers import Tokenizer INPUT_NAMES = {'INPUT_ID', 'REQUEST_INPUT_LEN', 'BAD_WORDS_IDS', 'STOP_WORDS_IDS'} class TritonPythonModel: __slots__ = ('tokenizer', 'pad_token', 'pad_token_id', 'input_id_dtype', 'request_input_len_dtype', 'bad_words_ids_dtype', 'stop_words_ids_dtype') def initialize(self, args): model_config = json.loads(args['model_config']) tokenizer_dir = Path(model_config['parameters']['tokenizer_dir']['string_value']) tokenizer_path = tokenizer_dir.joinpath('tokenizer.json') pad_to_multiple_of = int(model_config['parameters']['pad_to_multiple_of']['string_value']) special_tokens_map_path = tokenizer_dir.joinpath('special_tokens_map.json') with open(special_tokens_map_path, 'r', encoding='utf-8') as special_tokens_f: special_tokens_map = json.load(special_tokens_f) self.tokenizer = Tokenizer.from_file(str(tokenizer_path)) if 'eos_token' in special_tokens_map: eos_token = special_tokens_map['eos_token']['content'] eos_token_id = self.tokenizer.encode(eos_token, add_special_tokens=False).ids[0] self.pad_token = eos_token self.pad_token_id = eos_token_id for name in INPUT_NAMES: dtype = pb_utils.triton_string_to_numpy(pb_utils.get_output_config_by_name(model_config, name)['data_type']) setattr(self, name.lower() + '_dtype', dtype) def execute(self, requests: Sequence): responses = [] for request in requests: response = self.handle_request(request) responses.append(response) return responses def finalize(self): print('Cleaning up...') def handle_request(self, request: Sequence): query = pb_utils.get_input_tensor_by_name(request, 'QUERY').as_numpy().item().decode('utf-8') request_output_len = pb_utils.get_input_tensor_by_name(request, 'REQUEST_OUTPUT_LEN') encoding = self.tokenizer.encode(query) bad_words_ids = pb_utils.Tensor('BAD_WORDS_IDS', np.array([[], []], dtype=self.bad_words_ids_dtype)) stop_words_ids = pb_utils.Tensor('STOP_WORDS_IDS', np.array([[], []], dtype=self.stop_words_ids_dtype)) input_ids = pb_utils.Tensor('INPUT_ID', np.array([encoding.ids], dtype=self.input_id_dtype)) request_input_len = pb_utils.Tensor('REQUEST_INPUT_LEN', np.array([[len(encoding.ids)]], dtype=self.request_input_len_dtype)) return pb_utils.InferenceResponse(output_tensors=[input_ids, bad_words_ids, stop_words_ids, request_input_len, request_output_len]) def _to_word_list_format(self, word_dict: List[List[str]]): assert self.tokenizer != None, 'need to set tokenizer' flat_ids = [] offsets = [] for word_dict_item in word_dict: item_flat_ids = [] item_offsets = [] if isinstance(word_dict_item[0], bytes): word_dict_item = [word_dict_item[0].decode()] words = list(csv.reader(word_dict_item))[0] for word in words: ids = self.tokenizer.encode(word) if len(ids) == 0: continue item_flat_ids += ids item_offsets.append(len(ids)) flat_ids.append(np.array(item_flat_ids)) offsets.append(np.cumsum(np.array(item_offsets))) pad_to = max(1, max((len(ids) for ids in flat_ids))) for (i, (ids, offs)) in enumerate(zip(flat_ids, offsets)): flat_ids[i] = np.pad(ids, (0, pad_to - len(ids)), constant_values=0) offsets[i] = np.pad(offs, (0, pad_to - len(offs)), constant_values=-1) return np.array([flat_ids, offsets], dtype='int32').transpose((1, 0, 2))