Delete server.py

server.py

@@ -1,226 +0,0 @@
-import os
-import sys
-import time
-import struct
-import random
-from uuid import uuid4
-from typing import List, Optional
-
-import torch
-import torchaudio
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException
-from fastapi.responses import FileResponse, JSONResponse
-import uvicorn
-
-# append model paths
-sys.path.append("S2A/bigvgan_v2_24khz_100band_256x")
-sys.path.append("S2A/")
-sys.path.append("T2S/")
-sys.path.append("hifi-gan/")
-
-# from S2A.inference import *
-# from T2S.autoregressive import TS_model
-# from T2S.mel_spec import get_mel_spectrogram
-# from Text import labels, text_labels, code_labels
-from config import config
-from torch.cuda.amp import autocast
-from inference import *
-# directories for saving uploads and generated audio
-UPLOAD_DIR = "uploads"
-OUTPUT_DIR = "generated_samples"
-os.makedirs(UPLOAD_DIR, exist_ok=True)
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-# text/code encoders
-text_enc = {j: i for i, j in enumerate(text_labels)}
-code_enc = {j: i for i, j in enumerate(code_labels)}
-
-# inference globals
-FM = None
-vocoder = None
-m2 = None
-mu = None
-std = None
-m1 = None
-DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-# load models on startup
-def load_models(
-    m1_ckpt: str,
-    m2_ckpt: str,
-    vocoder_ckpt: Optional[str]
-):
-    global FM, vocoder, m2, mu, std, m1
-    FM,vocoder,m2,mu,std = load_cfm(m2_ckpt,vocoder_ckpt,DEVICE)
-    m1 = load_t2s_model(m1_ckpt,DEVICE)
-
-# utility: WAV header
-def create_wav_header(sample_rate=24000, bits_per_sample=16, channels=1):
-    chunk_id = b'RIFF'
-    chunk_size = 0xFFFFFFFF
-    format_tag = b'WAVE'
-    subchunk1_id = b'fmt '
-    subchunk1_size = 16
-    audio_format = 1
-    num_channels = channels
-    byte_rate = sample_rate * num_channels * bits_per_sample // 8
-    block_align = num_channels * bits_per_sample // 8
-    subchunk2_id = b'data'
-    subchunk2_size = 0xFFFFFFFF
-    header = struct.pack(
-        '<4sI4s4sIHHIIHH4sI',
-        chunk_id,
-        chunk_size,
-        format_tag,
-        subchunk1_id,
-        subchunk1_size,
-        audio_format,
-        num_channels,
-        sample_rate,
-        byte_rate,
-        block_align,
-        bits_per_sample,
-        subchunk2_id,
-        subchunk2_size,
-    )
-    return header
-
-# # prepare mels
-# def get_processed_clips(ref_clips: List[str]):
-#     frame_rate = 24000
-#     new_clips = []
-#     from pydub import AudioSegment
-
-#     for path in ref_clips:
-#         if path.endswith('_proc.wav'):
-#             new_clips.append(path)
-#             continue
-#         audio = AudioSegment.from_file(path)
-#         audio = audio.set_channels(1).set_frame_rate(frame_rate).set_sample_width(2)
-#         out = path.rstrip('.') + '_proc.wav'
-#         audio.export(out, format='wav')
-#         new_clips.append(out)
-#     return new_clips
-
-# def get_ref_mels(ref_clips: List[str]):
-#     ref_mels = []
-#     for p in ref_clips:
-#         audio_norm, sr = torchaudio.load(p)
-#         ref_mels.append(get_mel_spectrogram(audio_norm, sr).squeeze(0)[:, :1024])
-#     # pad to (len,100,500)
-#     padded = torch.randn((len(ref_mels), 100, 1024)) * 1e-9
-#     for i, mel in enumerate(ref_mels):
-#         padded[i, :, : mel.size(1)] = mel
-#     return padded.unsqueeze(0)
-
-app = FastAPI(title="T2S+CFM Inference API")
-
-@app.on_event("startup")
-def on_startup():
-    # configure these paths as needed
-    m1_checkpoint = []
-
-    m1_checkpoint = os.getenv('M1_CKPT', "/delta/MahaTTS/models/m1_gemma_benchmark_1_latest_weights.pt")
-    # m1_checkpoint.append((os.getenv('M1_CKPT', "/delta/horizon/133939_7_latest.pt"),"pt-1"))
-    # m1_checkpoint.append((os.getenv('M1_CKPT', "/delta/horizon/137877_8_latest.pt"),"pt-2"))
-
-    m2_checkpoint = os.getenv('M2_CKPT', '/delta/model_gemma/_latest_700000.pt')
-    vocoder_checkpoint = os.getenv('VOCODER_CKPT', '/delta/model_gemma/700_580k_multilingual_infer_ready/')
-    load_models(m1_checkpoint, m2_checkpoint, vocoder_checkpoint)
-
-@app.post("/infer")
-async def infer_endpoint(
-    text: str = Form(..., description="Input text to synthesize"),
-    language: str = Form(..., description="Language code, e.g. 'hindi' or 'english'"),
-    seed: int = Form(0),
-    temperature: float = Form(0.8),
-    length_penalty: Optional[float] = Form(None),
-    repetition_penalty: Optional[float] = Form(None),
-    top_k: int = Form(50),
-    top_p: float = Form(0.8),
-    do_sample: bool = Form(True),
-    num_beams: int = Form(1),
-    n_timesteps: int = Form(20),
-    no_repeat_ngram_size: int = Form(None),
-    ref_clips_m1: List[UploadFile] = File(..., description="Reference audio files for m1"),
-    ref_clips_m2: List[UploadFile] = File(..., description="Reference audio files for m2"),
-    model_name: str = Form("pt-2"),
-):
-
-    print(text)
-    # save uploaded reference clips
-    def save_files(files):
-        paths = []
-        for f in files:
-            fname = f"{uuid4().hex}_{f.filename}"
-            fpath = os.path.join(UPLOAD_DIR, fname)
-            with open(fpath, "wb") as out:
-                out.write(f.file.read())
-            paths.append(fpath)
-        return paths
-
-    # try:
-    m1_paths = save_files(ref_clips_m1)
-    m2_paths = save_files(ref_clips_m2)
-
-    # prepare inputs
-    text_ids, code_ids, lang_tensor, ref_mels1, ref_mels2 = prepare_inputs(
-        text.lower().strip(), m1_paths, m2_paths, language, device=str(DEVICE)
-    )
-
-    # set RNG seeds
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)
-    random.seed(seed)
-    if repetition_penalty == 0:
-        repetition_penalty=None
-    print("repetition_penalty",repetition_penalty)
-    print("no_repeat_ngram_size",no_repeat_ngram_size)
-    # generate code embedding
-    seed_value = 42
-    with torch.no_grad(),autocast(dtype=torch.bfloat16):
-        torch.manual_seed(seed_value)
-        torch.cuda.manual_seed_all(seed_value)
-        np.random.seed(seed_value)
-        random.seed(seed_value)
-        cond_latents = m1.get_speaker_latent(ref_mels1.to(DEVICE))
-        code_emb = m1.generate(
-            lang_tensor.to(DEVICE), cond_latents.to(DEVICE), text_ids.to(DEVICE), code_ids, 
-            temperature=temperature,
-            length_penalty=length_penalty,
-            repetition_penalty=repetition_penalty,
-            top_k=top_k,
-            top_p=top_p,
-            do_sample=do_sample,
-            num_beams=num_beams,
-            no_repeat_ngram_size=no_repeat_ngram_size,
-            max_new_tokens = 1500,
-            renormalize_logits = True,
-            penalty_alpha=0
-        )[:, :-1]
-        print(code_emb.shape[-1],code_emb)
-        torch.save(code_emb,"file.txt")
-        mel = FM(m2, code_emb+1, (1, 100, int(1+93*(code_emb.shape[-1]+1)/50)), ref_mels2.to(DEVICE), n_timesteps=20, temperature=1.0)
-        mel = denormalize_tacotron_mel(mel,mu,std)
-        audio = vocoder(mel)
-        audio = audio.squeeze(0).detach().cpu()
-        audio = audio * 32767.0
-        audio_int16 = (
-            audio.to(torch.float32).numpy().reshape(-1).astype(np.int16)
-        )
-    # save output wav
-    out_name = f"{uuid4().hex}.wav"
-    out_path = os.path.join(OUTPUT_DIR, out_name)
-    with open(out_path, "wb") as wf:
-        wf.write(create_wav_header())
-        wf.write(audio_int16.tobytes())
-
-    return FileResponse(out_path, media_type="audio/wav", filename=out_name)
-
-    # except Exception as e:
-    #     print(e)
-    #     raise HTTPException(status_code=500, detail=str(e))
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=6000)
-    # use ngrok