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