Spaces:
Sleeping
Sleeping
| import re | |
| import gradio as gr | |
| import torch | |
| import unicodedata | |
| import commons | |
| import utils | |
| import pathlib | |
| from models import SynthesizerTrn | |
| from text import text_to_sequence | |
| import time | |
| import os | |
| import io | |
| from scipy.io.wavfile import write | |
| from flask import Flask, request | |
| from threading import Thread | |
| import openai | |
| import requests | |
| import json | |
| import soundfile as sf | |
| from scipy import signal | |
| class VitsGradio: | |
| def __init__(self): | |
| self.lan = ["中文","日文","自动"] | |
| self.chatapi = ["gpt-3.5-turbo","gpt3"] | |
| self.modelPaths = [] | |
| for root,dirs,files in os.walk("checkpoints"): | |
| for dir in dirs: | |
| self.modelPaths.append(dir) | |
| with gr.Blocks() as self.Vits: | |
| with gr.Tab("调试用"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| with gr.Column(): | |
| self.text = gr.TextArea(label="Text", value="你好") | |
| with gr.Accordion(label="测试api", open=False): | |
| self.local_chat1 = gr.Checkbox(value=False, label="使用网址+文本进行模拟") | |
| self.url_input = gr.TextArea(label="键入测试", value="http://127.0.0.1:8080/chat?Text=") | |
| butto = gr.Button("模拟前端抓取语音文件") | |
| btnVC = gr.Button("测试tts+对话程序") | |
| with gr.Column(): | |
| output2 = gr.TextArea(label="回复") | |
| output1 = gr.Audio(label="采样率22050") | |
| output3 = gr.outputs.File(label="44100hz: output.wav") | |
| butto.click(self.Simul, inputs=[self.text, self.url_input], outputs=[output2,output3]) | |
| btnVC.click(self.tts_fn, inputs=[self.text], outputs=[output1,output2]) | |
| with gr.Tab("控制面板"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| with gr.Column(): | |
| self.api_input1 = gr.TextArea(label="输入gpt/茉莉云的api-key或本地存储说话模型的路径.如果要用茉莉云则用'|'隔开key和密码", value="49eig5nu3rllvg6e|itcn9760") | |
| with gr.Accordion(label="chatbot选择(默认gpt3.5)", open=False): | |
| self.api_input2 = gr.Checkbox(value=False, label="茉莉云") | |
| self.local_chat1 = gr.Checkbox(value=False, label="启动本地chatbot") | |
| self.local_chat2 = gr.Checkbox(value=False, label="是否量化") | |
| res = gr.TextArea() | |
| Botselection = gr.Button("完成chatbot设定") | |
| Botselection.click(self.check_bot, inputs=[self.api_input1,self.api_input2,self.local_chat1,self.local_chat2], outputs = [res]) | |
| self.input1 = gr.Dropdown(label = "模型", choices = self.modelPaths, value = self.modelPaths[0], type = "value") | |
| self.input2 = gr.Dropdown(label="Language", choices=self.lan, value="自动", interactive=True) | |
| with gr.Column(): | |
| btnVC = gr.Button("完成vits TTS端设定") | |
| self.input3 = gr.Dropdown(label="Speaker", choices=list(range(1001)), value=0, interactive=True) | |
| self.input4 = gr.Slider(minimum=0, maximum=1.0, label="更改噪声比例(noise scale)，以控制情感", value=0.6) | |
| self.input5 = gr.Slider(minimum=0, maximum=1.0, label="更改噪声偏差(noise scale w)，以控制音素长短", value=0.667) | |
| self.input6 = gr.Slider(minimum=0.1, maximum=10, label="duration", value=1) | |
| statusa = gr.TextArea() | |
| btnVC.click(self.create_tts_fn, inputs=[self.input1, self.input2, self.input3, self.input4, self.input5, self.input6], outputs = [statusa]) | |
| def Simul(self,text,url_input): | |
| web = url_input + text | |
| res = requests.get(web) | |
| music = res.content | |
| with open('output.wav', 'wb') as code: | |
| code.write(music) | |
| file_path = "output.wav" | |
| return web,file_path | |
| def mori(self,text): | |
| import http.client | |
| conn = http.client.HTTPSConnection("api.mlyai.com") | |
| payload = json.dumps({ | |
| "content": text, | |
| "type": 1, | |
| "from": "123456", | |
| "fromName": "侑" | |
| }) | |
| headers = { | |
| 'Api-Key': self.api_key, | |
| 'Api-Secret': self.api_secret, | |
| 'Content-Type': 'application/json' | |
| } | |
| conn.request("POST", "/reply", payload, headers) | |
| res = conn.getresponse() | |
| data = res.read() | |
| decoded_data = json.loads(data.decode("utf-8")) | |
| if decoded_data["code"] == "00000": | |
| answer = decoded_data["data"][0]["content"] | |
| if text == 'exit': | |
| conn.close() | |
| return answer | |
| else: | |
| conn.close() | |
| return '对不起，做不到' | |
| def chatgpt(self,text): | |
| self.messages.append({"role": "user", "content": text},) | |
| chat = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages= self.messages) | |
| reply = chat.choices[0].message.content | |
| return reply | |
| def ChATGLM(self,text): | |
| if text == 'clear': | |
| self.history = [] | |
| response, new_history = self.model.chat(self.tokenizer, text, self.history) | |
| response = response.replace(" ",'').replace("\n",'.') | |
| self.history = new_history | |
| return response | |
| def gpt3_chat(self,text): | |
| call_name = "Waifu" | |
| openai.api_key = args.key | |
| identity = "" | |
| start_sequence = '\n'+str(call_name)+':' | |
| restart_sequence = "\nYou: " | |
| if 1 == 1: | |
| prompt0 = text #当期prompt | |
| if text == 'quit': | |
| return prompt0 | |
| prompt = identity + prompt0 + start_sequence | |
| response = openai.Completion.create( | |
| model="text-davinci-003", | |
| prompt=prompt, | |
| temperature=0.5, | |
| max_tokens=1000, | |
| top_p=1.0, | |
| frequency_penalty=0.5, | |
| presence_penalty=0.0, | |
| stop=["\nYou:"] | |
| ) | |
| return response['choices'][0]['text'].strip() | |
| def check_bot(self,api_input1,api_input2,local_chat1,local_chat2): | |
| try: | |
| self.api_key, self.api_secret = api_input1.split("|") | |
| except: | |
| pass | |
| if local_chat1: | |
| from transformers import AutoTokenizer, AutoModel | |
| self.tokenizer = AutoTokenizer.from_pretrained(api_input1, trust_remote_code=True) | |
| if local_chat2: | |
| self.model = AutoModel.from_pretrained(api_input1, trust_remote_code=True).half().quantize(4).cuda() | |
| else: | |
| self.model = AutoModel.from_pretrained(api_input1, trust_remote_code=True) | |
| self.history = [] | |
| else: | |
| try: | |
| self.messages = [] | |
| openai.api_key = api_input1 | |
| except: | |
| pass | |
| return "Finished" | |
| def is_japanese(self,string): | |
| for ch in string: | |
| if ord(ch) > 0x3040 and ord(ch) < 0x30FF: | |
| return True | |
| return False | |
| def is_english(self,string): | |
| import re | |
| pattern = re.compile('^[A-Za-z0-9.,:;!?()_*"\' ]+$') | |
| if pattern.fullmatch(string): | |
| return True | |
| else: | |
| return False | |
| def get_text(self,text, hps, cleaned=False): | |
| if cleaned: | |
| text_norm = text_to_sequence(text, self.hps_ms.symbols, []) | |
| else: | |
| text_norm = text_to_sequence(text, self.hps_ms.symbols, self.hps_ms.data.text_cleaners) | |
| if self.hps_ms.data.add_blank: | |
| text_norm = commons.intersperse(text_norm, 0) | |
| text_norm = torch.LongTensor(text_norm) | |
| return text_norm | |
| def get_label(self,text, label): | |
| if f'[{label}]' in text: | |
| return True, text.replace(f'[{label}]', '') | |
| else: | |
| return False, text | |
| def sle(self,language,text): | |
| text = text.replace('\n','。').replace(' ',',') | |
| if language == "中文": | |
| tts_input1 = "[ZH]" + text + "[ZH]" | |
| return tts_input1 | |
| elif language == "自动": | |
| tts_input1 = f"[JA]{text}[JA]" if self.is_japanese(text) else f"[ZH]{text}[ZH]" | |
| return tts_input1 | |
| elif language == "日文": | |
| tts_input1 = "[JA]" + text + "[JA]" | |
| return tts_input1 | |
| def create_tts_fn(self,path, input2, input3, n_scale= 0.667,n_scale_w = 0.8, l_scale = 1 ): | |
| self.language = input2 | |
| self.speaker_id = int(input3) | |
| self.n_scale = n_scale | |
| self.n_scale_w = n_scale_w | |
| self.l_scale = l_scale | |
| self.dev = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") | |
| self.hps_ms = utils.get_hparams_from_file(f"checkpoints/{path}/config.json") | |
| self.n_speakers = self.hps_ms.data.n_speakers if 'n_speakers' in self.hps_ms.data.keys() else 0 | |
| self.n_symbols = len(self.hps_ms.symbols) if 'symbols' in self.hps_ms.keys() else 0 | |
| self.net_g_ms = SynthesizerTrn( | |
| self.n_symbols, | |
| self.hps_ms.data.filter_length // 2 + 1, | |
| self.hps_ms.train.segment_size // self.hps_ms.data.hop_length, | |
| n_speakers=self.n_speakers, | |
| **self.hps_ms.model).to(self.dev) | |
| _ = self.net_g_ms.eval() | |
| _ = utils.load_checkpoint(f"checkpoints/{path}/model.pth", self.net_g_ms) | |
| return 'success' | |
| def tts_fn(self,text): | |
| if self.local_chat1: | |
| text = self.mori(text) | |
| elif self.api_input2: | |
| text = self.ChATGLM(text) | |
| else: | |
| text = text = self.chatgpt(text) | |
| print(text) | |
| text =self.sle(self.language,text) | |
| with torch.no_grad(): | |
| stn_tst = self.get_text(text, self.hps_ms, cleaned=False) | |
| x_tst = stn_tst.unsqueeze(0).to(self.dev) | |
| x_tst_lengths = torch.LongTensor([stn_tst.size(0)]).to(self.dev) | |
| sid = torch.LongTensor([self.speaker_id]).to(self.dev) | |
| audio = self.net_g_ms.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=self.n_scale, noise_scale_w=self.n_scale_w, length_scale=self.l_scale)[0][ | |
| 0, 0].data.cpu().float().numpy() | |
| resampled_audio_data = signal.resample(audio, len(audio) * 2) | |
| sf.write('temp.wav', resampled_audio_data, 44100, 'PCM_24') | |
| return (self.hps_ms.data.sampling_rate, audio),text.replace('[JA]','').replace('[ZH]','') | |
| app = Flask(__name__) | |
| print("开始部署") | |
| grVits = VitsGradio() | |
| if __name__ == '__main__': | |
| grVits.Vits.launch() |