# 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()