Ported the space to use API and local version still exists but in different branch

app.py

@@ -1,150 +1,30 @@
 import gradio as gr
-import spaces
-import os, torch, io
-import json
-import re
-os.system("python -m unidic download")
-import httpx
-# print("Make sure you've downloaded unidic (python -m unidic download) for this WebUI to work.")
-from melo.api import TTS
-import tempfile
-import wave
-from pydub import AudioSegment
-from transformers import (
-    AutoModelForCausalLM,
-    AutoTokenizer,
-    TextIteratorStreamer,
-    BitsAndBytesConfig,
-)
-from threading import Thread
+import os
+import asyncio
+from conver import ConversationConfig, URLToAudioConverter
+from dotenv import load_dotenv
 
-from gradio_client import Client
+load_dotenv()
+def synthesize_sync(article_url):
+    return asyncio.run(synthesize(article_url))
 
-# client = Client("eswardivi/AIO_Chat")
-quantization_config = BitsAndBytesConfig(
-    load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16
-)
+async def synthesize(article_url):
+    if not article_url:
+        return "Please provide a valid URL.", None
 
-model = AutoModelForCausalLM.from_pretrained(
-    "NousResearch/Hermes-2-Pro-Llama-3-8B", quantization_config=quantization_config
-)
-tok = AutoTokenizer.from_pretrained("NousResearch/Hermes-2-Pro-Llama-3-8B",revision='8ab73a6800796d84448bc936db9bac5ad9f984ae')
-terminators = [
-    tok.eos_token_id,
-    tok.convert_tokens_to_ids("<|eot_id|>")
-]
-def validate_url(url):
     try:
-        response = httpx.get(url, timeout=60.0)
-        response.raise_for_status()
-        return response.text
-    except httpx.RequestError as e:
-        return f"An error occurred while requesting {url}: {str(e)}"
-    except httpx.HTTPStatusError as e:
-        return f"Error response {e.response.status_code} while requesting {url}"
+        config = ConversationConfig()
+        converter = URLToAudioConverter(config, llm_api_key=os.environ.get("TOGETHER_API_KEY"))
+        
+        output_file, conversation = await converter.url_to_audio(
+            article_url, 
+            "en-US-AvaMultilingualNeural", 
+            "en-US-AndrewMultilingualNeural"
+        )
+        
+        return conversation, output_file
     except Exception as e:
-        return f"An unexpected error occurred: {str(e)}"
-
-def fetch_text(url):
-    print("Entered Webpage Extraction")
-    prefix_url = "https://r.jina.ai/"
-    full_url = prefix_url + url
-    print(full_url)
-    print("Exited Webpage Extraction")
-    return validate_url(full_url)
-    
-@spaces.GPU(duration=100)
-def synthesize(article_url,progress_audio=gr.Progress()):
-    if not article_url.startswith("http://") and not article_url.startswith("https://"):
-        return "URL must start with 'http://' or 'https://'",None
-
-    text = fetch_text(article_url)
-    if "Error" in text:
-        return text, None
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    template = """
-        {
-            "conversation": [
-                {"speaker": "", "text": ""},
-                {"speaker": "", "text": ""}
-            ]
-        }
-        """
-    chat = []
-    chat.append(
-        {
-            "role": "user",
-            "content": text + """\n Convert the provided text into a short, informative podcast conversation between two experts. The tone should be professional and engaging. Please adhere to the following format and return only JSON:
-    {
-        "conversation": [
-            {"speaker": "", "text": ""},
-            {"speaker": "", "text": ""}
-        ]
-    }
-    """,
-        }
-    )
-
-
-    messages = tok.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
-    model_inputs = tok([messages], return_tensors="pt").to(device)
-    streamer = TextIteratorStreamer(
-        tok, timeout=10.0, skip_prompt=True, skip_special_tokens=True
-    )
-    generate_kwargs = dict(
-        model_inputs,
-        streamer=streamer,
-        max_new_tokens=1024,
-        do_sample=True,
-        temperature=0.9,
-        eos_token_id=terminators,
-    )
-    print("Entered Generation")
-    t = Thread(target=model.generate, kwargs=generate_kwargs)
-    t.start()
-
-    partial_text = ""
-    for new_text in streamer:
-        partial_text += new_text
-
-    # print("Calling API")
-    # result = client.predict(
-	# 	f"{text} \n Convert the text as Elaborate Conversation between two people as Podcast.\nfollowing this template and return only JSON \n {template}",
-	# 	0.9,	
-	# 	True,	
-	# 	1024,
-	# 	api_name="/chat"
-    # )
-    # print("API Call Completed")
-    pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
-    json_match = re.search(pattern, partial_text)
-    print("Exited Generation")
-    if json_match:
-        conversation=json_match.group()
-    else:
-        conversation = template
-    print(partial_text)
-    print(conversation)
-    speed = 1.0
-    models = {"EN": TTS(language="EN", device=device)}
-    speakers = ["EN-Default", "EN-US"]
-    combined_audio = AudioSegment.empty()
-
-    conversation_dict = json.loads(conversation)
-    for i, turn in enumerate(conversation_dict["conversation"]):
-        bio = io.BytesIO()
-        text = turn["text"]
-        speaker = speakers[i % 2]
-        speaker_id = models["EN"].hps.data.spk2id[speaker]
-        models["EN"].tts_to_file(text, speaker_id, bio, speed=1.0, pbar=progress_audio.tqdm, format="wav")
-        bio.seek(0)
-        audio_segment = AudioSegment.from_file(bio, format="wav")
-        combined_audio += audio_segment
-    final_audio_path = "final.mp3"
-    combined_audio.export(final_audio_path, format="mp3")
-    return conversation, final_audio_path
-
+        return f"Error: {str(e)}", None
 
 with gr.Blocks(theme='gstaff/sketch') as demo:
     gr.Markdown("# Turn Any Article into a Podcast")
@@ -158,19 +38,29 @@ with gr.Blocks(theme='gstaff/sketch') as demo:
     gr.Markdown("""
     - View the code at [GitHub - NarrateIt](https://github.com/EswarDivi/NarrateIt).
     """)
+
     with gr.Group():
-        text = gr.Textbox(label="Article Link")
+        text = gr.Textbox(label="Article Link", placeholder="Enter the article URL here...")
         btn = gr.Button("Podcastify", variant="primary")
+        
     with gr.Row():
-        conv_display = gr.Textbox(label="Conversation", interactive=False)
-        aud = gr.Audio(interactive=False)
-    btn.click(synthesize, inputs=[text], outputs=[conv_display, aud])
+        conv_display = gr.Textbox(label="Conversation", interactive=False, lines=10)
+        aud = gr.Audio(label="Generated Podcast", interactive=False)
+    
+    gr.Examples(
+        examples=["https://huggingface.co/blog/gradio-mcp"],
+        inputs=text,  
+        fn=synthesize_sync,
+        outputs=[conv_display, aud] 
+    )
+    
+    btn.click(synthesize_sync, inputs=[text], outputs=[conv_display, aud])
+
     gr.Markdown("""
     Special thanks to:
 
     - [gstaff/sketch](https://huggingface.co/spaces/gstaff/sketch) for the Sketch Theme.
-    - [mrfakename/MeloTTS](https://huggingface.co/spaces/mrfakename/MeloTTS) and [GitHub](https://github.com/myshell-ai/MeloTTS) for MeloTTS.
-    - [Hermes-2-Pro-Llama-3-8B](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B) for Function Calling Support.
     - [Jina AI](https://jina.ai/reader/) for the web page parsing.
     """)
-demo.queue(api_open=True, default_concurrency_limit=10).launch(show_api=True,share=True)
+
+demo.queue(api_open=True, default_concurrency_limit=15).launch(show_api=True)

bckp.py

@@ -0,0 +1,176 @@
+import gradio as gr
+import spaces
+import os, torch, io
+import json
+import re
+os.system("python -m unidic download")
+import httpx
+# print("Make sure you've downloaded unidic (python -m unidic download) for this WebUI to work.")
+from melo.api import TTS
+import tempfile
+import wave
+from pydub import AudioSegment
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TextIteratorStreamer,
+    BitsAndBytesConfig,
+)
+from threading import Thread
+
+from gradio_client import Client
+
+# client = Client("eswardivi/AIO_Chat")
+quantization_config = BitsAndBytesConfig(
+    load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16
+)
+
+model = AutoModelForCausalLM.from_pretrained(
+    "NousResearch/Hermes-2-Pro-Llama-3-8B", quantization_config=quantization_config
+)
+tok = AutoTokenizer.from_pretrained("NousResearch/Hermes-2-Pro-Llama-3-8B",revision='8ab73a6800796d84448bc936db9bac5ad9f984ae')
+terminators = [
+    tok.eos_token_id,
+    tok.convert_tokens_to_ids("<|eot_id|>")
+]
+def validate_url(url):
+    try:
+        response = httpx.get(url, timeout=60.0)
+        response.raise_for_status()
+        return response.text
+    except httpx.RequestError as e:
+        return f"An error occurred while requesting {url}: {str(e)}"
+    except httpx.HTTPStatusError as e:
+        return f"Error response {e.response.status_code} while requesting {url}"
+    except Exception as e:
+        return f"An unexpected error occurred: {str(e)}"
+
+def fetch_text(url):
+    print("Entered Webpage Extraction")
+    prefix_url = "https://r.jina.ai/"
+    full_url = prefix_url + url
+    print(full_url)
+    print("Exited Webpage Extraction")
+    return validate_url(full_url)
+    
+@spaces.GPU(duration=100)
+def synthesize(article_url,progress_audio=gr.Progress()):
+    if not article_url.startswith("http://") and not article_url.startswith("https://"):
+        return "URL must start with 'http://' or 'https://'",None
+
+    text = fetch_text(article_url)
+    if "Error" in text:
+        return text, None
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    template = """
+        {
+            "conversation": [
+                {"speaker": "", "text": ""},
+                {"speaker": "", "text": ""}
+            ]
+        }
+        """
+    chat = []
+    chat.append(
+        {
+            "role": "user",
+            "content": text + """\n Convert the provided text into a short, informative podcast conversation between two experts. The tone should be professional and engaging. Please adhere to the following format and return only JSON:
+    {
+        "conversation": [
+            {"speaker": "", "text": ""},
+            {"speaker": "", "text": ""}
+        ]
+    }
+    """,
+        }
+    )
+
+
+    messages = tok.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
+    model_inputs = tok([messages], return_tensors="pt").to(device)
+    streamer = TextIteratorStreamer(
+        tok, timeout=10.0, skip_prompt=True, skip_special_tokens=True
+    )
+    generate_kwargs = dict(
+        model_inputs,
+        streamer=streamer,
+        max_new_tokens=1024,
+        do_sample=True,
+        temperature=0.9,
+        eos_token_id=terminators,
+    )
+    print("Entered Generation")
+    t = Thread(target=model.generate, kwargs=generate_kwargs)
+    t.start()
+
+    partial_text = ""
+    for new_text in streamer:
+        partial_text += new_text
+
+    # print("Calling API")
+    # result = client.predict(
+	# 	f"{text} \n Convert the text as Elaborate Conversation between two people as Podcast.\nfollowing this template and return only JSON \n {template}",
+	# 	0.9,	
+	# 	True,	
+	# 	1024,
+	# 	api_name="/chat"
+    # )
+    # print("API Call Completed")
+    pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
+    json_match = re.search(pattern, partial_text)
+    print("Exited Generation")
+    if json_match:
+        conversation=json_match.group()
+    else:
+        conversation = template
+    print(partial_text)
+    print(conversation)
+    speed = 1.0
+    models = {"EN": TTS(language="EN", device=device)}
+    speakers = ["EN-Default", "EN-US"]
+    combined_audio = AudioSegment.empty()
+
+    conversation_dict = json.loads(conversation)
+    for i, turn in enumerate(conversation_dict["conversation"]):
+        bio = io.BytesIO()
+        text = turn["text"]
+        speaker = speakers[i % 2]
+        speaker_id = models["EN"].hps.data.spk2id[speaker]
+        models["EN"].tts_to_file(text, speaker_id, bio, speed=1.0, pbar=progress_audio.tqdm, format="wav")
+        bio.seek(0)
+        audio_segment = AudioSegment.from_file(bio, format="wav")
+        combined_audio += audio_segment
+    final_audio_path = "final.mp3"
+    combined_audio.export(final_audio_path, format="mp3")
+    return conversation, final_audio_path
+
+
+with gr.Blocks(theme='gstaff/sketch') as demo:
+    gr.Markdown("# Turn Any Article into a Podcast")
+    gr.Markdown("## Easily convert articles from URLs into listenable audio podcasts.")
+    gr.Markdown("### Instructions")
+    gr.Markdown("""
+    - **Step 1:** Paste the URL of the article you want to convert into the textbox.
+    - **Step 2:** Click on "Podcastify" to generate the podcast.
+    - **Step 3:** Listen to the podcast or view the conversation.
+    """)
+    gr.Markdown("""
+    - View the code at [GitHub - NarrateIt](https://github.com/EswarDivi/NarrateIt).
+    """)
+    with gr.Group():
+        text = gr.Textbox(label="Article Link")
+        btn = gr.Button("Podcastify", variant="primary")
+    with gr.Row():
+        conv_display = gr.Textbox(label="Conversation", interactive=False)
+        aud = gr.Audio(interactive=False)
+    btn.click(synthesize, inputs=[text], outputs=[conv_display, aud])
+    gr.Markdown("""
+    Special thanks to:
+
+    - [gstaff/sketch](https://huggingface.co/spaces/gstaff/sketch) for the Sketch Theme.
+    - [mrfakename/MeloTTS](https://huggingface.co/spaces/mrfakename/MeloTTS) and [GitHub](https://github.com/myshell-ai/MeloTTS) for MeloTTS.
+    - [Hermes-2-Pro-Llama-3-8B](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B) for Function Calling Support.
+    - [Jina AI](https://jina.ai/reader/) for the web page parsing.
+    """)
+demo.queue(api_open=True, default_concurrency_limit=10).launch(show_api=True,share=True)

conver.py

@@ -0,0 +1,156 @@
+from dataclasses import dataclass
+from typing import List, Tuple, Dict
+import os
+import re
+import httpx
+import json
+from openai import OpenAI
+import edge_tts
+import tempfile
+import wave
+from pydub import AudioSegment
+import base64
+from pathlib import Path
+
+
+@dataclass
+class ConversationConfig:
+    max_words: int = 3000
+    prefix_url: str = "https://r.jina.ai/"
+    model_name: str = "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"
+
+
+class URLToAudioConverter:
+    def __init__(self, config: ConversationConfig, llm_api_key: str):
+        self.config = config
+        self.llm_client = OpenAI(api_key=llm_api_key, base_url="https://api.together.xyz/v1")
+        self.llm_out = None
+
+    def fetch_text(self, url: str) -> str:
+        if not url:
+            raise ValueError("URL cannot be empty")
+
+        full_url = f"{self.config.prefix_url}{url}"
+        try:
+            response = httpx.get(full_url, timeout=60.0)
+            response.raise_for_status()
+            return response.text
+        except httpx.HTTPError as e:
+            raise RuntimeError(f"Failed to fetch URL: {e}")
+
+    def extract_conversation(self, text: str) -> Dict:
+        if not text:
+            raise ValueError("Input text cannot be empty")
+
+        try:
+            chat_completion = self.llm_client.chat.completions.create(
+                messages=[{"role": "user", "content": self._build_prompt(text)}],
+                model=self.config.model_name,
+            )
+
+            pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
+            json_match = re.search(pattern, chat_completion.choices[0].message.content)
+
+            if not json_match:
+                raise ValueError("No valid JSON found in response")
+
+            return json.loads(json_match.group())
+        except Exception as e:
+            raise RuntimeError(f"Failed to extract conversation: {e}")
+
+    def _build_prompt(self, text: str) -> str:
+        template = """
+        {
+            "conversation": [
+                {"speaker": "", "text": ""},
+                {"speaker": "", "text": ""}
+            ]
+        }
+        """
+        return (
+            f"{text}\nConvert the provided text into a short informative and crisp "
+            f"podcast conversation between two experts. The tone should be "
+            f"professional and engaging. Please adhere to the following "
+            f"format and return the conversation in JSON:\n{template}"
+        )
+
+    async def text_to_speech(self, conversation_json: Dict, voice_1: str, voice_2: str) -> Tuple[List[str], str]:
+        output_dir = Path(self._create_output_directory())
+        filenames = []
+
+        try:
+            for i, turn in enumerate(conversation_json["conversation"]):
+                filename = output_dir / f"output_{i}.wav"
+                voice = voice_1 if i % 2 == 0 else voice_2
+
+                tmp_path, error = await self._generate_audio(turn["text"], voice)
+                if error:
+                    raise RuntimeError(f"Text-to-speech failed: {error}")
+
+                os.rename(tmp_path, filename)
+                filenames.append(str(filename))
+
+            return filenames, str(output_dir)
+        except Exception as e:
+            raise RuntimeError(f"Failed to convert text to speech: {e}")
+
+    async def _generate_audio(self, text: str, voice: str, rate: int = 0, pitch: int = 0) -> Tuple[str, str]:
+        if not text.strip():
+            return None, "Text cannot be empty"
+        if not voice:
+            return None, "Voice cannot be empty"
+
+        voice_short_name = voice.split(" - ")[0]
+        rate_str = f"{rate:+d}%"
+        pitch_str = f"{pitch:+d}Hz"
+        communicate = edge_tts.Communicate(text, voice_short_name, rate=rate_str, pitch=pitch_str)
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+            tmp_path = tmp_file.name
+            await communicate.save(tmp_path)
+
+        return tmp_path, None
+
+    def _create_output_directory(self) -> str:
+        random_bytes = os.urandom(8)
+        folder_name = base64.urlsafe_b64encode(random_bytes).decode("utf-8")
+        os.makedirs(folder_name, exist_ok=True)
+        return folder_name
+
+    def combine_audio_files(self, filenames: List[str], output_file: str) -> None:
+        if not filenames:
+            raise ValueError("No input files provided")
+
+        try:
+            audio_segments = []
+
+            for filename in filenames:
+                audio_segment = AudioSegment.from_mp3(filename)
+                audio_segments.append(audio_segment)
+
+            combined = sum(audio_segments)
+
+            combined.export(output_file, format="wav")
+
+            for filename in filenames:
+                os.remove(filename)
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to combine audio files: {e}")
+
+    async def url_to_audio(self, url: str, voice_1: str, voice_2: str) -> str:
+        text = self.fetch_text(url)
+
+        words = text.split()
+        if len(words) > self.config.max_words:
+            text = " ".join(words[: self.config.max_words])
+
+        conversation_json = self.extract_conversation(text)
+        self.llm_out = conversation_json
+        audio_files, folder_name = await self.text_to_speech(
+            conversation_json, voice_1, voice_2
+        )
+
+        final_output = os.path.join(folder_name, "combined_output.wav")
+        self.combine_audio_files(audio_files, final_output)
+        return final_output

melo/api.py

@@ -1,121 +0,0 @@
-import os
-import re
-import json
-import torch
-import librosa
-import soundfile
-import torchaudio
-import numpy as np
-import torch.nn as nn
-from tqdm import tqdm
-from . import utils
-from . import commons
-from .models import SynthesizerTrn
-from .split_utils import split_sentence
-from .mel_processing import spectrogram_torch, spectrogram_torch_conv
-from .download_utils import load_or_download_config, load_or_download_model
-
-class TTS(nn.Module):
-    def __init__(self, 
-                language,
-                device='cuda:0'):
-        super().__init__()
-        if 'cuda' in device:
-            assert torch.cuda.is_available()
-
-        # config_path = 
-        hps = load_or_download_config(language)
-
-        num_languages = hps.num_languages
-        num_tones = hps.num_tones
-        symbols = hps.symbols
-
-        model = SynthesizerTrn(
-            len(symbols),
-            hps.data.filter_length // 2 + 1,
-            hps.train.segment_size // hps.data.hop_length,
-            n_speakers=hps.data.n_speakers,
-            num_tones=num_tones,
-            num_languages=num_languages,
-            **hps.model,
-        ).to(device)
-
-        model.eval()
-        self.model = model
-        self.symbol_to_id = {s: i for i, s in enumerate(symbols)}
-        self.hps = hps
-        self.device = device
-    
-        # load state_dict
-        checkpoint_dict = load_or_download_model(language, device)
-        self.model.load_state_dict(checkpoint_dict['model'], strict=True)
-        
-        language = language.split('_')[0]
-        self.language = 'ZH_MIX_EN' if language == 'ZH' else language # we support a ZH_MIX_EN model
-
-    @staticmethod
-    def audio_numpy_concat(segment_data_list, sr, speed=1.):
-        audio_segments = []
-        for segment_data in segment_data_list:
-            audio_segments += segment_data.reshape(-1).tolist()
-            audio_segments += [0] * int((sr * 0.05) / speed)
-        audio_segments = np.array(audio_segments).astype(np.float32)
-        return audio_segments
-
-    @staticmethod
-    def split_sentences_into_pieces(text, language):
-        texts = split_sentence(text, language_str=language)
-        # print(" > Text splitted to sentences.")
-        # print('\n'.join(texts))
-        # print(" > ===========================")
-        return texts
-
-    def tts_to_file(self, text, speaker_id, output_path=None, sdp_ratio=0.2, noise_scale=0.6, noise_scale_w=0.8, speed=1.0, pbar=None, format=None, position=None):
-        language = self.language
-        texts = self.split_sentences_into_pieces(text, language)
-        audio_list = []
-        tx = texts
-        if pbar:
-            tx = pbar(texts)
-        else:
-            if position:
-                tx = tqdm(texts, position=position)
-            else:
-                tx = tqdm(texts)
-        for t in tx:
-            if language in ['EN', 'ZH_MIX_EN']:
-                t = re.sub(r'([a-z])([A-Z])', r'\1 \2', t)
-            device = self.device
-            bert, ja_bert, phones, tones, lang_ids = utils.get_text_for_tts_infer(t, language, self.hps, device, self.symbol_to_id)
-            with torch.no_grad():
-                x_tst = phones.to(device).unsqueeze(0)
-                tones = tones.to(device).unsqueeze(0)
-                lang_ids = lang_ids.to(device).unsqueeze(0)
-                bert = bert.to(device).unsqueeze(0)
-                ja_bert = ja_bert.to(device).unsqueeze(0)
-                x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
-                del phones
-                speakers = torch.LongTensor([speaker_id]).to(device)
-                audio = self.model.infer(
-                        x_tst,
-                        x_tst_lengths,
-                        speakers,
-                        tones,
-                        lang_ids,
-                        bert,
-                        ja_bert,
-                        sdp_ratio=sdp_ratio,
-                        noise_scale=noise_scale,
-                        noise_scale_w=noise_scale_w,
-                        length_scale=1. / speed,
-                    )[0][0, 0].data.cpu().float().numpy()
-                del x_tst, tones, lang_ids, bert, ja_bert, x_tst_lengths, speakers
-                # 
-            audio_list.append(audio)
-        torch.cuda.empty_cache()
-        audio = self.audio_numpy_concat(audio_list, sr=self.hps.data.sampling_rate, speed=speed)
-
-        if output_path is None:
-            return audio
-        else:
-            soundfile.write(output_path, audio, self.hps.data.sampling_rate, format=format)

melo/attentions.py

@@ -1,459 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from . import commons
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class LayerNorm(nn.Module):
-    def __init__(self, channels, eps=1e-5):
-        super().__init__()
-        self.channels = channels
-        self.eps = eps
-
-        self.gamma = nn.Parameter(torch.ones(channels))
-        self.beta = nn.Parameter(torch.zeros(channels))
-
-    def forward(self, x):
-        x = x.transpose(1, -1)
-        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-        return x.transpose(1, -1)
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-class Encoder(nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size=1,
-        p_dropout=0.0,
-        window_size=4,
-        isflow=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.window_size = window_size
-
-        self.cond_layer_idx = self.n_layers
-        if "gin_channels" in kwargs:
-            self.gin_channels = kwargs["gin_channels"]
-            if self.gin_channels != 0:
-                self.spk_emb_linear = nn.Linear(self.gin_channels, self.hidden_channels)
-                self.cond_layer_idx = (
-                    kwargs["cond_layer_idx"] if "cond_layer_idx" in kwargs else 2
-                )
-                assert (
-                    self.cond_layer_idx < self.n_layers
-                ), "cond_layer_idx should be less than n_layers"
-        self.drop = nn.Dropout(p_dropout)
-        self.attn_layers = nn.ModuleList()
-        self.norm_layers_1 = nn.ModuleList()
-        self.ffn_layers = nn.ModuleList()
-        self.norm_layers_2 = nn.ModuleList()
-
-        for i in range(self.n_layers):
-            self.attn_layers.append(
-                MultiHeadAttention(
-                    hidden_channels,
-                    hidden_channels,
-                    n_heads,
-                    p_dropout=p_dropout,
-                    window_size=window_size,
-                )
-            )
-            self.norm_layers_1.append(LayerNorm(hidden_channels))
-            self.ffn_layers.append(
-                FFN(
-                    hidden_channels,
-                    hidden_channels,
-                    filter_channels,
-                    kernel_size,
-                    p_dropout=p_dropout,
-                )
-            )
-            self.norm_layers_2.append(LayerNorm(hidden_channels))
-
-    def forward(self, x, x_mask, g=None):
-        attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-        x = x * x_mask
-        for i in range(self.n_layers):
-            if i == self.cond_layer_idx and g is not None:
-                g = self.spk_emb_linear(g.transpose(1, 2))
-                g = g.transpose(1, 2)
-                x = x + g
-                x = x * x_mask
-            y = self.attn_layers[i](x, x, attn_mask)
-            y = self.drop(y)
-            x = self.norm_layers_1[i](x + y)
-
-            y = self.ffn_layers[i](x, x_mask)
-            y = self.drop(y)
-            x = self.norm_layers_2[i](x + y)
-        x = x * x_mask
-        return x
-
-
-class Decoder(nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size=1,
-        p_dropout=0.0,
-        proximal_bias=False,
-        proximal_init=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.proximal_bias = proximal_bias
-        self.proximal_init = proximal_init
-
-        self.drop = nn.Dropout(p_dropout)
-        self.self_attn_layers = nn.ModuleList()
-        self.norm_layers_0 = nn.ModuleList()
-        self.encdec_attn_layers = nn.ModuleList()
-        self.norm_layers_1 = nn.ModuleList()
-        self.ffn_layers = nn.ModuleList()
-        self.norm_layers_2 = nn.ModuleList()
-        for i in range(self.n_layers):
-            self.self_attn_layers.append(
-                MultiHeadAttention(
-                    hidden_channels,
-                    hidden_channels,
-                    n_heads,
-                    p_dropout=p_dropout,
-                    proximal_bias=proximal_bias,
-                    proximal_init=proximal_init,
-                )
-            )
-            self.norm_layers_0.append(LayerNorm(hidden_channels))
-            self.encdec_attn_layers.append(
-                MultiHeadAttention(
-                    hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout
-                )
-            )
-            self.norm_layers_1.append(LayerNorm(hidden_channels))
-            self.ffn_layers.append(
-                FFN(
-                    hidden_channels,
-                    hidden_channels,
-                    filter_channels,
-                    kernel_size,
-                    p_dropout=p_dropout,
-                    causal=True,
-                )
-            )
-            self.norm_layers_2.append(LayerNorm(hidden_channels))
-
-    def forward(self, x, x_mask, h, h_mask):
-        """
-        x: decoder input
-        h: encoder output
-        """
-        self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(
-            device=x.device, dtype=x.dtype
-        )
-        encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-        x = x * x_mask
-        for i in range(self.n_layers):
-            y = self.self_attn_layers[i](x, x, self_attn_mask)
-            y = self.drop(y)
-            x = self.norm_layers_0[i](x + y)
-
-            y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
-            y = self.drop(y)
-            x = self.norm_layers_1[i](x + y)
-
-            y = self.ffn_layers[i](x, x_mask)
-            y = self.drop(y)
-            x = self.norm_layers_2[i](x + y)
-        x = x * x_mask
-        return x
-
-
-class MultiHeadAttention(nn.Module):
-    def __init__(
-        self,
-        channels,
-        out_channels,
-        n_heads,
-        p_dropout=0.0,
-        window_size=None,
-        heads_share=True,
-        block_length=None,
-        proximal_bias=False,
-        proximal_init=False,
-    ):
-        super().__init__()
-        assert channels % n_heads == 0
-
-        self.channels = channels
-        self.out_channels = out_channels
-        self.n_heads = n_heads
-        self.p_dropout = p_dropout
-        self.window_size = window_size
-        self.heads_share = heads_share
-        self.block_length = block_length
-        self.proximal_bias = proximal_bias
-        self.proximal_init = proximal_init
-        self.attn = None
-
-        self.k_channels = channels // n_heads
-        self.conv_q = nn.Conv1d(channels, channels, 1)
-        self.conv_k = nn.Conv1d(channels, channels, 1)
-        self.conv_v = nn.Conv1d(channels, channels, 1)
-        self.conv_o = nn.Conv1d(channels, out_channels, 1)
-        self.drop = nn.Dropout(p_dropout)
-
-        if window_size is not None:
-            n_heads_rel = 1 if heads_share else n_heads
-            rel_stddev = self.k_channels**-0.5
-            self.emb_rel_k = nn.Parameter(
-                torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
-                * rel_stddev
-            )
-            self.emb_rel_v = nn.Parameter(
-                torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
-                * rel_stddev
-            )
-
-        nn.init.xavier_uniform_(self.conv_q.weight)
-        nn.init.xavier_uniform_(self.conv_k.weight)
-        nn.init.xavier_uniform_(self.conv_v.weight)
-        if proximal_init:
-            with torch.no_grad():
-                self.conv_k.weight.copy_(self.conv_q.weight)
-                self.conv_k.bias.copy_(self.conv_q.bias)
-
-    def forward(self, x, c, attn_mask=None):
-        q = self.conv_q(x)
-        k = self.conv_k(c)
-        v = self.conv_v(c)
-
-        x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
-        x = self.conv_o(x)
-        return x
-
-    def attention(self, query, key, value, mask=None):
-        # reshape [b, d, t] -> [b, n_h, t, d_k]
-        b, d, t_s, t_t = (*key.size(), query.size(2))
-        query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
-        key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-        value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
-        scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
-        if self.window_size is not None:
-            assert (
-                t_s == t_t
-            ), "Relative attention is only available for self-attention."
-            key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
-            rel_logits = self._matmul_with_relative_keys(
-                query / math.sqrt(self.k_channels), key_relative_embeddings
-            )
-            scores_local = self._relative_position_to_absolute_position(rel_logits)
-            scores = scores + scores_local
-        if self.proximal_bias:
-            assert t_s == t_t, "Proximal bias is only available for self-attention."
-            scores = scores + self._attention_bias_proximal(t_s).to(
-                device=scores.device, dtype=scores.dtype
-            )
-        if mask is not None:
-            scores = scores.masked_fill(mask == 0, -1e4)
-            if self.block_length is not None:
-                assert (
-                    t_s == t_t
-                ), "Local attention is only available for self-attention."
-                block_mask = (
-                    torch.ones_like(scores)
-                    .triu(-self.block_length)
-                    .tril(self.block_length)
-                )
-                scores = scores.masked_fill(block_mask == 0, -1e4)
-        p_attn = F.softmax(scores, dim=-1)  # [b, n_h, t_t, t_s]
-        p_attn = self.drop(p_attn)
-        output = torch.matmul(p_attn, value)
-        if self.window_size is not None:
-            relative_weights = self._absolute_position_to_relative_position(p_attn)
-            value_relative_embeddings = self._get_relative_embeddings(
-                self.emb_rel_v, t_s
-            )
-            output = output + self._matmul_with_relative_values(
-                relative_weights, value_relative_embeddings
-            )
-        output = (
-            output.transpose(2, 3).contiguous().view(b, d, t_t)
-        )  # [b, n_h, t_t, d_k] -> [b, d, t_t]
-        return output, p_attn
-
-    def _matmul_with_relative_values(self, x, y):
-        """
-        x: [b, h, l, m]
-        y: [h or 1, m, d]
-        ret: [b, h, l, d]
-        """
-        ret = torch.matmul(x, y.unsqueeze(0))
-        return ret
-
-    def _matmul_with_relative_keys(self, x, y):
-        """
-        x: [b, h, l, d]
-        y: [h or 1, m, d]
-        ret: [b, h, l, m]
-        """
-        ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
-        return ret
-
-    def _get_relative_embeddings(self, relative_embeddings, length):
-        2 * self.window_size + 1
-        # Pad first before slice to avoid using cond ops.
-        pad_length = max(length - (self.window_size + 1), 0)
-        slice_start_position = max((self.window_size + 1) - length, 0)
-        slice_end_position = slice_start_position + 2 * length - 1
-        if pad_length > 0:
-            padded_relative_embeddings = F.pad(
-                relative_embeddings,
-                commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]),
-            )
-        else:
-            padded_relative_embeddings = relative_embeddings
-        used_relative_embeddings = padded_relative_embeddings[
-            :, slice_start_position:slice_end_position
-        ]
-        return used_relative_embeddings
-
-    def _relative_position_to_absolute_position(self, x):
-        """
-        x: [b, h, l, 2*l-1]
-        ret: [b, h, l, l]
-        """
-        batch, heads, length, _ = x.size()
-        # Concat columns of pad to shift from relative to absolute indexing.
-        x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]]))
-
-        # Concat extra elements so to add up to shape (len+1, 2*len-1).
-        x_flat = x.view([batch, heads, length * 2 * length])
-        x_flat = F.pad(
-            x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [0, length - 1]])
-        )
-
-        # Reshape and slice out the padded elements.
-        x_final = x_flat.view([batch, heads, length + 1, 2 * length - 1])[
-            :, :, :length, length - 1 :
-        ]
-        return x_final
-
-    def _absolute_position_to_relative_position(self, x):
-        """
-        x: [b, h, l, l]
-        ret: [b, h, l, 2*l-1]
-        """
-        batch, heads, length, _ = x.size()
-        # pad along column
-        x = F.pad(
-            x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length - 1]])
-        )
-        x_flat = x.view([batch, heads, length**2 + length * (length - 1)])
-        # add 0's in the beginning that will skew the elements after reshape
-        x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
-        x_final = x_flat.view([batch, heads, length, 2 * length])[:, :, :, 1:]
-        return x_final
-
-    def _attention_bias_proximal(self, length):
-        """Bias for self-attention to encourage attention to close positions.
-        Args:
-          length: an integer scalar.
-        Returns:
-          a Tensor with shape [1, 1, length, length]
-        """
-        r = torch.arange(length, dtype=torch.float32)
-        diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
-        return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        filter_channels,
-        kernel_size,
-        p_dropout=0.0,
-        activation=None,
-        causal=False,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.activation = activation
-        self.causal = causal
-
-        if causal:
-            self.padding = self._causal_padding
-        else:
-            self.padding = self._same_padding
-
-        self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
-        self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
-        self.drop = nn.Dropout(p_dropout)
-
-    def forward(self, x, x_mask):
-        x = self.conv_1(self.padding(x * x_mask))
-        if self.activation == "gelu":
-            x = x * torch.sigmoid(1.702 * x)
-        else:
-            x = torch.relu(x)
-        x = self.drop(x)
-        x = self.conv_2(self.padding(x * x_mask))
-        return x * x_mask
-
-    def _causal_padding(self, x):
-        if self.kernel_size == 1:
-            return x
-        pad_l = self.kernel_size - 1
-        pad_r = 0
-        padding = [[0, 0], [0, 0], [pad_l, pad_r]]
-        x = F.pad(x, commons.convert_pad_shape(padding))
-        return x
-
-    def _same_padding(self, x):
-        if self.kernel_size == 1:
-            return x
-        pad_l = (self.kernel_size - 1) // 2
-        pad_r = self.kernel_size // 2
-        padding = [[0, 0], [0, 0], [pad_l, pad_r]]
-        x = F.pad(x, commons.convert_pad_shape(padding))
-        return x

melo/commons.py

@@ -1,160 +0,0 @@
-import math
-import torch
-from torch.nn import functional as F
-
-
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-    return int((kernel_size * dilation - dilation) / 2)
-
-
-def convert_pad_shape(pad_shape):
-    layer = pad_shape[::-1]
-    pad_shape = [item for sublist in layer for item in sublist]
-    return pad_shape
-
-
-def intersperse(lst, item):
-    result = [item] * (len(lst) * 2 + 1)
-    result[1::2] = lst
-    return result
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-    """KL(P||Q)"""
-    kl = (logs_q - logs_p) - 0.5
-    kl += (
-        0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
-    )
-    return kl
-
-
-def rand_gumbel(shape):
-    """Sample from the Gumbel distribution, protect from overflows."""
-    uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-    return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
-    g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-    return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:, :, :segment_size])
-    for i in range(x.size(0)):
-        idx_str = ids_str[i]
-        idx_end = idx_str + segment_size
-        ret[i] = x[i, :, idx_str:idx_end]
-    return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-    b, d, t = x.size()
-    if x_lengths is None:
-        x_lengths = t
-    ids_str_max = x_lengths - segment_size + 1
-    ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-    ret = slice_segments(x, ids_str, segment_size)
-    return ret, ids_str
-
-
-def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
-    position = torch.arange(length, dtype=torch.float)
-    num_timescales = channels // 2
-    log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
-        num_timescales - 1
-    )
-    inv_timescales = min_timescale * torch.exp(
-        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
-    )
-    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-    signal = F.pad(signal, [0, 0, 0, channels % 2])
-    signal = signal.view(1, channels, length)
-    return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
-    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-    return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-def convert_pad_shape(pad_shape):
-    layer = pad_shape[::-1]
-    pad_shape = [item for sublist in layer for item in sublist]
-    return pad_shape
-
-
-def shift_1d(x):
-    x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-    return x
-
-
-def sequence_mask(length, max_length=None):
-    if max_length is None:
-        max_length = length.max()
-    x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-    return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
-    """
-    duration: [b, 1, t_x]
-    mask: [b, 1, t_y, t_x]
-    """
-
-    b, _, t_y, t_x = mask.shape
-    cum_duration = torch.cumsum(duration, -1)
-
-    cum_duration_flat = cum_duration.view(b * t_x)
-    path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-    path = path.view(b, t_x, t_y)
-    path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-    path = path.unsqueeze(1).transpose(2, 3) * mask
-    return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-    if isinstance(parameters, torch.Tensor):
-        parameters = [parameters]
-    parameters = list(filter(lambda p: p.grad is not None, parameters))
-    norm_type = float(norm_type)
-    if clip_value is not None:
-        clip_value = float(clip_value)
-
-    total_norm = 0
-    for p in parameters:
-        param_norm = p.grad.data.norm(norm_type)
-        total_norm += param_norm.item() ** norm_type
-        if clip_value is not None:
-            p.grad.data.clamp_(min=-clip_value, max=clip_value)
-    total_norm = total_norm ** (1.0 / norm_type)
-    return total_norm

melo/download_utils.py

@@ -1,47 +0,0 @@
-import torch
-import os
-from . import utils
-
-DOWNLOAD_CKPT_URLS = {
-    'EN': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/EN/checkpoint.pth',
-    'EN_V2': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/EN_V2/checkpoint.pth',
-    'FR': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/FR/checkpoint.pth',
-    'JP': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/JP/checkpoint.pth',
-    'ES': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/ES/checkpoint.pth',
-    'ZH': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/ZH/checkpoint.pth',
-    'KR': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/KR/checkpoint.pth',
-}
-
-DOWNLOAD_CONFIG_URLS = {
-    'EN': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/EN/config.json',
-    'EN_V2': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/EN_V2/config.json',
-    'FR': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/FR/config.json',
-    'JP': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/JP/config.json',
-    'ES': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/ES/config.json',
-    'ZH': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/ZH/config.json',
-    'KR': 'https://myshell-public-repo-host.s3.amazonaws.com/openvoice/basespeakers/KR/config.json',
-}
-
-def load_or_download_config(locale):
-    language = locale.split('-')[0].upper()
-    assert language in DOWNLOAD_CONFIG_URLS
-    config_path = os.path.expanduser(f'~/.local/share/openvoice/basespeakers/{language}/config.json')
-    try:
-        return utils.get_hparams_from_file(config_path)
-    except:
-        # download
-        os.makedirs(os.path.dirname(config_path), exist_ok=True)
-        os.system(f'wget {DOWNLOAD_CONFIG_URLS[language]} -O {config_path}')
-    return utils.get_hparams_from_file(config_path)
-
-def load_or_download_model(locale, device):
-    language = locale.split('-')[0].upper()
-    assert language in DOWNLOAD_CKPT_URLS
-    ckpt_path = os.path.expanduser(f'~/.local/share/openvoice/basespeakers/{language}/checkpoint.pth')
-    try:
-        return torch.load(ckpt_path, map_location=device)
-    except:
-        # download
-        os.makedirs(os.path.dirname(ckpt_path), exist_ok=True)
-        os.system(f'wget {DOWNLOAD_CKPT_URLS[language]} -O {ckpt_path}')
-    return torch.load(ckpt_path, map_location=device)

melo/mel_processing.py

@@ -1,174 +0,0 @@
-import torch
-import torch.utils.data
-import librosa
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
-
-
-def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    if torch.min(y) < -1.1:
-        print("min value is ", torch.min(y))
-    if torch.max(y) > 1.1:
-        print("max value is ", torch.max(y))
-
-    global hann_window
-    dtype_device = str(y.dtype) + "_" + str(y.device)
-    wnsize_dtype_device = str(win_size) + "_" + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(
-            dtype=y.dtype, device=y.device
-        )
-
-    y = torch.nn.functional.pad(
-        y.unsqueeze(1),
-        (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)),
-        mode="reflect",
-    )
-    y = y.squeeze(1)
-
-    spec = torch.stft(
-        y,
-        n_fft,
-        hop_length=hop_size,
-        win_length=win_size,
-        window=hann_window[wnsize_dtype_device],
-        center=center,
-        pad_mode="reflect",
-        normalized=False,
-        onesided=True,
-        return_complex=False,
-    )
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spectrogram_torch_conv(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    global hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    
-    # ******************** original ************************#
-    # y = y.squeeze(1)
-    # spec1 = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-    #                   center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
-    # ******************** ConvSTFT ************************#
-    freq_cutoff = n_fft // 2 + 1
-    fourier_basis = torch.view_as_real(torch.fft.fft(torch.eye(n_fft)))
-    forward_basis = fourier_basis[:freq_cutoff].permute(2, 0, 1).reshape(-1, 1, fourier_basis.shape[1])
-    forward_basis = forward_basis * torch.as_tensor(librosa.util.pad_center(torch.hann_window(win_size), size=n_fft)).float()
-
-    import torch.nn.functional as F
-
-    # if center:
-    #     signal = F.pad(y[:, None, None, :], (n_fft // 2, n_fft // 2, 0, 0), mode = 'reflect').squeeze(1)
-    assert center is False
-
-    forward_transform_squared = F.conv1d(y, forward_basis.to(y.device), stride = hop_size)
-    spec2 = torch.stack([forward_transform_squared[:, :freq_cutoff, :], forward_transform_squared[:, freq_cutoff:, :]], dim = -1)
-
-
-    # ******************** Verification ************************#
-    spec1 = torch.stft(y.squeeze(1), n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-    assert torch.allclose(spec1, spec2, atol=1e-4)
-
-    spec = torch.sqrt(spec2.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
-    global mel_basis
-    dtype_device = str(spec.dtype) + "_" + str(spec.device)
-    fmax_dtype_device = str(fmax) + "_" + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(
-            dtype=spec.dtype, device=spec.device
-        )
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
-
-
-def mel_spectrogram_torch(
-    y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False
-):
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + "_" + str(y.device)
-    fmax_dtype_device = str(fmax) + "_" + dtype_device
-    wnsize_dtype_device = str(win_size) + "_" + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(
-            dtype=y.dtype, device=y.device
-        )
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(
-            dtype=y.dtype, device=y.device
-        )
-
-    y = torch.nn.functional.pad(
-        y.unsqueeze(1),
-        (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)),
-        mode="reflect",
-    )
-    y = y.squeeze(1)
-
-    spec = torch.stft(
-        y,
-        n_fft,
-        hop_length=hop_size,
-        win_length=win_size,
-        window=hann_window[wnsize_dtype_device],
-        center=center,
-        pad_mode="reflect",
-        normalized=False,
-        onesided=True,
-        return_complex=False,
-    )
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec

melo/models.py

@@ -1,1038 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from . import commons
-from . import modules
-from . import attentions
-
-from torch.nn import Conv1d, ConvTranspose1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-
-from .commons import init_weights, get_padding
-
-
-class DurationDiscriminator(nn.Module):  # vits2
-    def __init__(
-        self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = gin_channels
-
-        self.drop = nn.Dropout(p_dropout)
-        self.conv_1 = nn.Conv1d(
-            in_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_1 = modules.LayerNorm(filter_channels)
-        self.conv_2 = nn.Conv1d(
-            filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_2 = modules.LayerNorm(filter_channels)
-        self.dur_proj = nn.Conv1d(1, filter_channels, 1)
-
-        self.pre_out_conv_1 = nn.Conv1d(
-            2 * filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.pre_out_norm_1 = modules.LayerNorm(filter_channels)
-        self.pre_out_conv_2 = nn.Conv1d(
-            filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.pre_out_norm_2 = modules.LayerNorm(filter_channels)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
-        self.output_layer = nn.Sequential(nn.Linear(filter_channels, 1), nn.Sigmoid())
-
-    def forward_probability(self, x, x_mask, dur, g=None):
-        dur = self.dur_proj(dur)
-        x = torch.cat([x, dur], dim=1)
-        x = self.pre_out_conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.pre_out_norm_1(x)
-        x = self.drop(x)
-        x = self.pre_out_conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.pre_out_norm_2(x)
-        x = self.drop(x)
-        x = x * x_mask
-        x = x.transpose(1, 2)
-        output_prob = self.output_layer(x)
-        return output_prob
-
-    def forward(self, x, x_mask, dur_r, dur_hat, g=None):
-        x = torch.detach(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_1(x)
-        x = self.drop(x)
-        x = self.conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_2(x)
-        x = self.drop(x)
-
-        output_probs = []
-        for dur in [dur_r, dur_hat]:
-            output_prob = self.forward_probability(x, x_mask, dur, g)
-            output_probs.append(output_prob)
-
-        return output_probs
-
-
-class TransformerCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        n_flows=4,
-        gin_channels=0,
-        share_parameter=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-
-        self.wn = (
-            attentions.FFT(
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-                isflow=True,
-                gin_channels=self.gin_channels,
-            )
-            if share_parameter
-            else None
-        )
-
-        for i in range(n_flows):
-            self.flows.append(
-                modules.TransformerCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    n_layers,
-                    n_heads,
-                    p_dropout,
-                    filter_channels,
-                    mean_only=True,
-                    wn_sharing_parameter=self.wn,
-                    gin_channels=self.gin_channels,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-
-class StochasticDurationPredictor(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        filter_channels,
-        kernel_size,
-        p_dropout,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        filter_channels = in_channels  # it needs to be removed from future version.
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.log_flow = modules.Log()
-        self.flows = nn.ModuleList()
-        self.flows.append(modules.ElementwiseAffine(2))
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3)
-            )
-            self.flows.append(modules.Flip())
-
-        self.post_pre = nn.Conv1d(1, filter_channels, 1)
-        self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
-        self.post_convs = modules.DDSConv(
-            filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout
-        )
-        self.post_flows = nn.ModuleList()
-        self.post_flows.append(modules.ElementwiseAffine(2))
-        for i in range(4):
-            self.post_flows.append(
-                modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3)
-            )
-            self.post_flows.append(modules.Flip())
-
-        self.pre = nn.Conv1d(in_channels, filter_channels, 1)
-        self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
-        self.convs = modules.DDSConv(
-            filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout
-        )
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
-    def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
-        x = torch.detach(x)
-        x = self.pre(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.convs(x, x_mask)
-        x = self.proj(x) * x_mask
-
-        if not reverse:
-            flows = self.flows
-            assert w is not None
-
-            logdet_tot_q = 0
-            h_w = self.post_pre(w)
-            h_w = self.post_convs(h_w, x_mask)
-            h_w = self.post_proj(h_w) * x_mask
-            e_q = (
-                torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype)
-                * x_mask
-            )
-            z_q = e_q
-            for flow in self.post_flows:
-                z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
-                logdet_tot_q += logdet_q
-            z_u, z1 = torch.split(z_q, [1, 1], 1)
-            u = torch.sigmoid(z_u) * x_mask
-            z0 = (w - u) * x_mask
-            logdet_tot_q += torch.sum(
-                (F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1, 2]
-            )
-            logq = (
-                torch.sum(-0.5 * (math.log(2 * math.pi) + (e_q**2)) * x_mask, [1, 2])
-                - logdet_tot_q
-            )
-
-            logdet_tot = 0
-            z0, logdet = self.log_flow(z0, x_mask)
-            logdet_tot += logdet
-            z = torch.cat([z0, z1], 1)
-            for flow in flows:
-                z, logdet = flow(z, x_mask, g=x, reverse=reverse)
-                logdet_tot = logdet_tot + logdet
-            nll = (
-                torch.sum(0.5 * (math.log(2 * math.pi) + (z**2)) * x_mask, [1, 2])
-                - logdet_tot
-            )
-            return nll + logq  # [b]
-        else:
-            flows = list(reversed(self.flows))
-            flows = flows[:-2] + [flows[-1]]  # remove a useless vflow
-            z = (
-                torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype)
-                * noise_scale
-            )
-            for flow in flows:
-                z = flow(z, x_mask, g=x, reverse=reverse)
-            z0, z1 = torch.split(z, [1, 1], 1)
-            logw = z0
-            return logw
-
-
-class DurationPredictor(nn.Module):
-    def __init__(
-        self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0
-    ):
-        super().__init__()
-
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = gin_channels
-
-        self.drop = nn.Dropout(p_dropout)
-        self.conv_1 = nn.Conv1d(
-            in_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_1 = modules.LayerNorm(filter_channels)
-        self.conv_2 = nn.Conv1d(
-            filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_2 = modules.LayerNorm(filter_channels)
-        self.proj = nn.Conv1d(filter_channels, 1, 1)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
-    def forward(self, x, x_mask, g=None):
-        x = torch.detach(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_1(x)
-        x = self.drop(x)
-        x = self.conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_2(x)
-        x = self.drop(x)
-        x = self.proj(x * x_mask)
-        return x * x_mask
-
-
-class TextEncoder(nn.Module):
-    def __init__(
-        self,
-        n_vocab,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        gin_channels=0,
-        num_languages=None,
-        num_tones=None,
-    ):
-        super().__init__()
-        if num_languages is None:
-            from text import num_languages
-        if num_tones is None:
-            from text import num_tones
-        self.n_vocab = n_vocab
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = gin_channels
-        self.emb = nn.Embedding(n_vocab, hidden_channels)
-        nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-        self.tone_emb = nn.Embedding(num_tones, hidden_channels)
-        nn.init.normal_(self.tone_emb.weight, 0.0, hidden_channels**-0.5)
-        self.language_emb = nn.Embedding(num_languages, hidden_channels)
-        nn.init.normal_(self.language_emb.weight, 0.0, hidden_channels**-0.5)
-        self.bert_proj = nn.Conv1d(1024, hidden_channels, 1)
-        self.ja_bert_proj = nn.Conv1d(768, hidden_channels, 1)
-
-        self.encoder = attentions.Encoder(
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            gin_channels=self.gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, tone, language, bert, ja_bert, g=None):
-        bert_emb = self.bert_proj(bert).transpose(1, 2)
-        ja_bert_emb = self.ja_bert_proj(ja_bert).transpose(1, 2)
-        x = (
-            self.emb(x)
-            + self.tone_emb(tone)
-            + self.language_emb(language)
-            + bert_emb
-            + ja_bert_emb
-        ) * math.sqrt(
-            self.hidden_channels
-        )  # [b, t, h]
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-
-        x = self.encoder(x * x_mask, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None, tau=1.0):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * tau * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        print("Removing weight norm...")
-        for layer in self.ups:
-            remove_weight_norm(layer)
-        for layer in self.resblocks:
-            layer.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm is False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for layer in self.convs:
-            x = layer(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm is False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for layer in self.convs:
-            x = layer(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class ReferenceEncoder(nn.Module):
-    """
-    inputs --- [N, Ty/r, n_mels*r]  mels
-    outputs --- [N, ref_enc_gru_size]
-    """
-
-    def __init__(self, spec_channels, gin_channels=0, layernorm=False):
-        super().__init__()
-        self.spec_channels = spec_channels
-        ref_enc_filters = [32, 32, 64, 64, 128, 128]
-        K = len(ref_enc_filters)
-        filters = [1] + ref_enc_filters
-        convs = [
-            weight_norm(
-                nn.Conv2d(
-                    in_channels=filters[i],
-                    out_channels=filters[i + 1],
-                    kernel_size=(3, 3),
-                    stride=(2, 2),
-                    padding=(1, 1),
-                )
-            )
-            for i in range(K)
-        ]
-        self.convs = nn.ModuleList(convs)
-        # self.wns = nn.ModuleList([weight_norm(num_features=ref_enc_filters[i]) for i in range(K)]) # noqa: E501
-
-        out_channels = self.calculate_channels(spec_channels, 3, 2, 1, K)
-        self.gru = nn.GRU(
-            input_size=ref_enc_filters[-1] * out_channels,
-            hidden_size=256 // 2,
-            batch_first=True,
-        )
-        self.proj = nn.Linear(128, gin_channels)
-        if layernorm:
-            self.layernorm = nn.LayerNorm(self.spec_channels)
-            print('[Ref Enc]: using layer norm')
-        else:
-            self.layernorm = None
-
-    def forward(self, inputs, mask=None):
-        N = inputs.size(0)
-
-        out = inputs.view(N, 1, -1, self.spec_channels)  # [N, 1, Ty, n_freqs]
-        if self.layernorm is not None:
-            out = self.layernorm(out)
-
-        for conv in self.convs:
-            out = conv(out)
-            # out = wn(out)
-            out = F.relu(out)  # [N, 128, Ty//2^K, n_mels//2^K]
-
-        out = out.transpose(1, 2)  # [N, Ty//2^K, 128, n_mels//2^K]
-        T = out.size(1)
-        N = out.size(0)
-        out = out.contiguous().view(N, T, -1)  # [N, Ty//2^K, 128*n_mels//2^K]
-
-        self.gru.flatten_parameters()
-        memory, out = self.gru(out)  # out --- [1, N, 128]
-
-        return self.proj(out.squeeze(0))
-
-    def calculate_channels(self, L, kernel_size, stride, pad, n_convs):
-        for i in range(n_convs):
-            L = (L - kernel_size + 2 * pad) // stride + 1
-        return L
-
-
-class SynthesizerTrn(nn.Module):
-    """
-    Synthesizer for Training
-    """
-
-    def __init__(
-        self,
-        n_vocab,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        n_speakers=256,
-        gin_channels=256,
-        use_sdp=True,
-        n_flow_layer=4,
-        n_layers_trans_flow=6,
-        flow_share_parameter=False,
-        use_transformer_flow=True,
-        use_vc=False,
-        num_languages=None,
-        num_tones=None,
-        norm_refenc=False,
-        use_se=False,
-        **kwargs
-    ):
-        super().__init__()
-        self.n_vocab = n_vocab
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.n_speakers = n_speakers
-        self.gin_channels = gin_channels
-        self.n_layers_trans_flow = n_layers_trans_flow
-        self.use_spk_conditioned_encoder = kwargs.get(
-            "use_spk_conditioned_encoder", True
-        )
-        self.use_sdp = use_sdp
-        self.use_noise_scaled_mas = kwargs.get("use_noise_scaled_mas", False)
-        self.mas_noise_scale_initial = kwargs.get("mas_noise_scale_initial", 0.01)
-        self.noise_scale_delta = kwargs.get("noise_scale_delta", 2e-6)
-        self.current_mas_noise_scale = self.mas_noise_scale_initial
-        if self.use_spk_conditioned_encoder and gin_channels > 0:
-            self.enc_gin_channels = gin_channels
-        else:
-            self.enc_gin_channels = 0
-        self.enc_p = TextEncoder(
-            n_vocab,
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            gin_channels=self.enc_gin_channels,
-            num_languages=num_languages,
-            num_tones=num_tones,
-        )
-        self.dec = Generator(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        if use_transformer_flow:
-            self.flow = TransformerCouplingBlock(
-                inter_channels,
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers_trans_flow,
-                5,
-                p_dropout,
-                n_flow_layer,
-                gin_channels=gin_channels,
-                share_parameter=flow_share_parameter,
-            )
-        else:
-            self.flow = ResidualCouplingBlock(
-                inter_channels,
-                hidden_channels,
-                5,
-                1,
-                n_flow_layer,
-                gin_channels=gin_channels,
-            )
-        self.sdp = StochasticDurationPredictor(
-            hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels
-        )
-        self.dp = DurationPredictor(
-            hidden_channels, 256, 3, 0.5, gin_channels=gin_channels
-        )
-
-        if n_speakers > 1:
-            if use_se:
-                emb_dim = 512
-                self.emb_g = nn.Linear(emb_dim, gin_channels)
-            else:
-                self.emb_g = nn.Embedding(n_speakers, gin_channels)
-        else:
-            self.ref_enc = ReferenceEncoder(spec_channels, gin_channels, layernorm=norm_refenc)
-        self.use_vc = use_vc
-        self.use_se = use_se
-
-    def forward(self, x, x_lengths, y, y_lengths, sid, tone, language, bert, ja_bert):
-        if self.n_speakers > 0:
-            g = self.emb_g(sid).unsqueeze(-1)  # [b, h, 1]
-        else:
-            g = self.ref_enc(y.transpose(1, 2)).unsqueeze(-1)
-        if self.use_vc:
-            g_p = None
-        else:
-            g_p = g
-        x, m_p, logs_p, x_mask = self.enc_p(
-            x, x_lengths, tone, language, bert, ja_bert, g=g_p
-        )
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-
-        with torch.no_grad():
-            # negative cross-entropy
-            s_p_sq_r = torch.exp(-2 * logs_p)  # [b, d, t]
-            neg_cent1 = torch.sum(
-                -0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True
-            )  # [b, 1, t_s]
-            neg_cent2 = torch.matmul(
-                -0.5 * (z_p**2).transpose(1, 2), s_p_sq_r
-            )  # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
-            neg_cent3 = torch.matmul(
-                z_p.transpose(1, 2), (m_p * s_p_sq_r)
-            )  # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
-            neg_cent4 = torch.sum(
-                -0.5 * (m_p**2) * s_p_sq_r, [1], keepdim=True
-            )  # [b, 1, t_s]
-            neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
-            if self.use_noise_scaled_mas:
-                epsilon = (
-                    torch.std(neg_cent)
-                    * torch.randn_like(neg_cent)
-                    * self.current_mas_noise_scale
-                )
-                neg_cent = neg_cent + epsilon
-
-            attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-            attn = (
-                monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1))
-                .unsqueeze(1)
-                .detach()
-            )
-
-        w = attn.sum(2)
-
-        l_length_sdp = self.sdp(x, x_mask, w, g=g)
-        l_length_sdp = l_length_sdp / torch.sum(x_mask)
-
-        logw_ = torch.log(w + 1e-6) * x_mask
-        logw = self.dp(x, x_mask, g=g)
-        l_length_dp = torch.sum((logw - logw_) ** 2, [1, 2]) / torch.sum(
-            x_mask
-        )  # for averaging
-
-        l_length = l_length_dp + l_length_sdp
-
-        # expand prior
-        m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
-        logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        o = self.dec(z_slice, g=g)
-        return (
-            o,
-            l_length,
-            attn,
-            ids_slice,
-            x_mask,
-            y_mask,
-            (z, z_p, m_p, logs_p, m_q, logs_q),
-            (x, logw, logw_),
-        )
-
-    def infer(
-        self,
-        x,
-        x_lengths,
-        sid,
-        tone,
-        language,
-        bert,
-        ja_bert,
-        noise_scale=0.667,
-        length_scale=1,
-        noise_scale_w=0.8,
-        max_len=None,
-        sdp_ratio=0,
-        y=None,
-        g=None,
-    ):
-        # x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert)
-        # g = self.gst(y)
-        if g is None:
-            if self.n_speakers > 0:
-                g = self.emb_g(sid).unsqueeze(-1)  # [b, h, 1]
-            else:
-                g = self.ref_enc(y.transpose(1, 2)).unsqueeze(-1)
-        if self.use_vc:
-            g_p = None
-        else:
-            g_p = g
-        x, m_p, logs_p, x_mask = self.enc_p(
-            x, x_lengths, tone, language, bert, ja_bert, g=g_p
-        )
-        logw = self.sdp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w) * (
-            sdp_ratio
-        ) + self.dp(x, x_mask, g=g) * (1 - sdp_ratio)
-        w = torch.exp(logw) * x_mask * length_scale
-        
-        w_ceil = torch.ceil(w)
-        y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
-        y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(
-            x_mask.dtype
-        )
-        attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-        attn = commons.generate_path(w_ceil, attn_mask)
-
-        m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(
-            1, 2
-        )  # [b, t', t], [b, t, d] -> [b, d, t']
-        logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(
-            1, 2
-        )  # [b, t', t], [b, t, d] -> [b, d, t']
-
-        z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
-        z = self.flow(z_p, y_mask, g=g, reverse=True)
-        o = self.dec((z * y_mask)[:, :, :max_len], g=g)
-        # print('max/min of o:', o.max(), o.min())
-        return o, attn, y_mask, (z, z_p, m_p, logs_p)
-
-    def voice_conversion(self, y, y_lengths, sid_src, sid_tgt, tau=1.0):
-        if self.use_se:
-            sid_src = self.emb_g(sid_src).unsqueeze(-1)
-            sid_tgt = self.emb_g(sid_tgt).unsqueeze(-1)
-        
-        g_src = sid_src
-        g_tgt = sid_tgt
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src, tau=tau)
-        z_p = self.flow(z, y_mask, g=g_src)
-        z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True)
-        o_hat = self.dec(z_hat * y_mask, g=g_tgt)
-        return o_hat, y_mask, (z, z_p, z_hat)

melo/modules.py

@@ -1,598 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-from . import commons
-from .commons import init_weights, get_padding
-from .transforms import piecewise_rational_quadratic_transform
-from .attentions import Encoder
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
-    def __init__(self, channels, eps=1e-5):
-        super().__init__()
-        self.channels = channels
-        self.eps = eps
-
-        self.gamma = nn.Parameter(torch.ones(channels))
-        self.beta = nn.Parameter(torch.zeros(channels))
-
-    def forward(self, x):
-        x = x.transpose(1, -1)
-        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-        return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        hidden_channels,
-        out_channels,
-        kernel_size,
-        n_layers,
-        p_dropout,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.hidden_channels = hidden_channels
-        self.out_channels = out_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-        assert n_layers > 1, "Number of layers should be larger than 0."
-
-        self.conv_layers = nn.ModuleList()
-        self.norm_layers = nn.ModuleList()
-        self.conv_layers.append(
-            nn.Conv1d(
-                in_channels, hidden_channels, kernel_size, padding=kernel_size // 2
-            )
-        )
-        self.norm_layers.append(LayerNorm(hidden_channels))
-        self.relu_drop = nn.Sequential(nn.ReLU(), nn.Dropout(p_dropout))
-        for _ in range(n_layers - 1):
-            self.conv_layers.append(
-                nn.Conv1d(
-                    hidden_channels,
-                    hidden_channels,
-                    kernel_size,
-                    padding=kernel_size // 2,
-                )
-            )
-            self.norm_layers.append(LayerNorm(hidden_channels))
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask):
-        x_org = x
-        for i in range(self.n_layers):
-            x = self.conv_layers[i](x * x_mask)
-            x = self.norm_layers[i](x)
-            x = self.relu_drop(x)
-        x = x_org + self.proj(x)
-        return x * x_mask
-
-
-class DDSConv(nn.Module):
-    """
-    Dialted and Depth-Separable Convolution
-    """
-
-    def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):
-        super().__init__()
-        self.channels = channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-
-        self.drop = nn.Dropout(p_dropout)
-        self.convs_sep = nn.ModuleList()
-        self.convs_1x1 = nn.ModuleList()
-        self.norms_1 = nn.ModuleList()
-        self.norms_2 = nn.ModuleList()
-        for i in range(n_layers):
-            dilation = kernel_size**i
-            padding = (kernel_size * dilation - dilation) // 2
-            self.convs_sep.append(
-                nn.Conv1d(
-                    channels,
-                    channels,
-                    kernel_size,
-                    groups=channels,
-                    dilation=dilation,
-                    padding=padding,
-                )
-            )
-            self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-            self.norms_1.append(LayerNorm(channels))
-            self.norms_2.append(LayerNorm(channels))
-
-    def forward(self, x, x_mask, g=None):
-        if g is not None:
-            x = x + g
-        for i in range(self.n_layers):
-            y = self.convs_sep[i](x * x_mask)
-            y = self.norms_1[i](y)
-            y = F.gelu(y)
-            y = self.convs_1x1[i](y)
-            y = self.norms_2[i](y)
-            y = F.gelu(y)
-            y = self.drop(y)
-            x = x + y
-        return x * x_mask
-
-
-class WN(torch.nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-        p_dropout=0,
-    ):
-        super(WN, self).__init__()
-        assert kernel_size % 2 == 1
-        self.hidden_channels = hidden_channels
-        self.kernel_size = (kernel_size,)
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-        self.p_dropout = p_dropout
-
-        self.in_layers = torch.nn.ModuleList()
-        self.res_skip_layers = torch.nn.ModuleList()
-        self.drop = nn.Dropout(p_dropout)
-
-        if gin_channels != 0:
-            cond_layer = torch.nn.Conv1d(
-                gin_channels, 2 * hidden_channels * n_layers, 1
-            )
-            self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name="weight")
-
-        for i in range(n_layers):
-            dilation = dilation_rate**i
-            padding = int((kernel_size * dilation - dilation) / 2)
-            in_layer = torch.nn.Conv1d(
-                hidden_channels,
-                2 * hidden_channels,
-                kernel_size,
-                dilation=dilation,
-                padding=padding,
-            )
-            in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
-            self.in_layers.append(in_layer)
-
-            # last one is not necessary
-            if i < n_layers - 1:
-                res_skip_channels = 2 * hidden_channels
-            else:
-                res_skip_channels = hidden_channels
-
-            res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-            res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name="weight")
-            self.res_skip_layers.append(res_skip_layer)
-
-    def forward(self, x, x_mask, g=None, **kwargs):
-        output = torch.zeros_like(x)
-        n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-        if g is not None:
-            g = self.cond_layer(g)
-
-        for i in range(self.n_layers):
-            x_in = self.in_layers[i](x)
-            if g is not None:
-                cond_offset = i * 2 * self.hidden_channels
-                g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
-            else:
-                g_l = torch.zeros_like(x_in)
-
-            acts = commons.fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
-            acts = self.drop(acts)
-
-            res_skip_acts = self.res_skip_layers[i](acts)
-            if i < self.n_layers - 1:
-                res_acts = res_skip_acts[:, : self.hidden_channels, :]
-                x = (x + res_acts) * x_mask
-                output = output + res_skip_acts[:, self.hidden_channels :, :]
-            else:
-                output = output + res_skip_acts
-        return output * x_mask
-
-    def remove_weight_norm(self):
-        if self.gin_channels != 0:
-            torch.nn.utils.remove_weight_norm(self.cond_layer)
-        for l in self.in_layers:
-            torch.nn.utils.remove_weight_norm(l)
-        for l in self.res_skip_layers:
-            torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        padding=get_padding(kernel_size, dilation[0]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        padding=get_padding(kernel_size, dilation[1]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[2],
-                        padding=get_padding(kernel_size, dilation[2]),
-                    )
-                ),
-            ]
-        )
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-            ]
-        )
-        self.convs2.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        self.convs = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        padding=get_padding(kernel_size, dilation[0]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        padding=get_padding(kernel_size, dilation[1]),
-                    )
-                ),
-            ]
-        )
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-            logdet = torch.sum(-y, [1, 2])
-            return y, logdet
-        else:
-            x = torch.exp(x) * x_mask
-            return x
-
-
-class Flip(nn.Module):
-    def forward(self, x, *args, reverse=False, **kwargs):
-        x = torch.flip(x, [1])
-        if not reverse:
-            logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-            return x, logdet
-        else:
-            return x
-
-
-class ElementwiseAffine(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.channels = channels
-        self.m = nn.Parameter(torch.zeros(channels, 1))
-        self.logs = nn.Parameter(torch.zeros(channels, 1))
-
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = self.m + torch.exp(self.logs) * x
-            y = y * x_mask
-            logdet = torch.sum(self.logs * x_mask, [1, 2])
-            return y, logdet
-        else:
-            x = (x - self.m) * torch.exp(-self.logs) * x_mask
-            return x
-
-
-class ResidualCouplingLayer(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        p_dropout=0,
-        gin_channels=0,
-        mean_only=False,
-    ):
-        assert channels % 2 == 0, "channels should be divisible by 2"
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.half_channels = channels // 2
-        self.mean_only = mean_only
-
-        self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-        self.enc = WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            p_dropout=p_dropout,
-            gin_channels=gin_channels,
-        )
-        self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-        self.post.weight.data.zero_()
-        self.post.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0) * x_mask
-        h = self.enc(h, x_mask, g=g)
-        stats = self.post(h) * x_mask
-        if not self.mean_only:
-            m, logs = torch.split(stats, [self.half_channels] * 2, 1)
-        else:
-            m = stats
-            logs = torch.zeros_like(m)
-
-        if not reverse:
-            x1 = m + x1 * torch.exp(logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            logdet = torch.sum(logs, [1, 2])
-            return x, logdet
-        else:
-            x1 = (x1 - m) * torch.exp(-logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            return x
-
-
-class ConvFlow(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        filter_channels,
-        kernel_size,
-        n_layers,
-        num_bins=10,
-        tail_bound=5.0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.num_bins = num_bins
-        self.tail_bound = tail_bound
-        self.half_channels = in_channels // 2
-
-        self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
-        self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.0)
-        self.proj = nn.Conv1d(
-            filter_channels, self.half_channels * (num_bins * 3 - 1), 1
-        )
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0)
-        h = self.convs(h, x_mask, g=g)
-        h = self.proj(h) * x_mask
-
-        b, c, t = x0.shape
-        h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2)  # [b, cx?, t] -> [b, c, t, ?]
-
-        unnormalized_widths = h[..., : self.num_bins] / math.sqrt(self.filter_channels)
-        unnormalized_heights = h[..., self.num_bins : 2 * self.num_bins] / math.sqrt(
-            self.filter_channels
-        )
-        unnormalized_derivatives = h[..., 2 * self.num_bins :]
-
-        x1, logabsdet = piecewise_rational_quadratic_transform(
-            x1,
-            unnormalized_widths,
-            unnormalized_heights,
-            unnormalized_derivatives,
-            inverse=reverse,
-            tails="linear",
-            tail_bound=self.tail_bound,
-        )
-
-        x = torch.cat([x0, x1], 1) * x_mask
-        logdet = torch.sum(logabsdet * x_mask, [1, 2])
-        if not reverse:
-            return x, logdet
-        else:
-            return x
-
-
-class TransformerCouplingLayer(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        n_layers,
-        n_heads,
-        p_dropout=0,
-        filter_channels=0,
-        mean_only=False,
-        wn_sharing_parameter=None,
-        gin_channels=0,
-    ):
-        assert n_layers == 3, n_layers
-        assert channels % 2 == 0, "channels should be divisible by 2"
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.half_channels = channels // 2
-        self.mean_only = mean_only
-
-        self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-        self.enc = (
-            Encoder(
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-                isflow=True,
-                gin_channels=gin_channels,
-            )
-            if wn_sharing_parameter is None
-            else wn_sharing_parameter
-        )
-        self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-        self.post.weight.data.zero_()
-        self.post.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0) * x_mask
-        h = self.enc(h, x_mask, g=g)
-        stats = self.post(h) * x_mask
-        if not self.mean_only:
-            m, logs = torch.split(stats, [self.half_channels] * 2, 1)
-        else:
-            m = stats
-            logs = torch.zeros_like(m)
-
-        if not reverse:
-            x1 = m + x1 * torch.exp(logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            logdet = torch.sum(logs, [1, 2])
-            return x, logdet
-        else:
-            x1 = (x1 - m) * torch.exp(-logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            return x
-
-        x1, logabsdet = piecewise_rational_quadratic_transform(
-            x1,
-            unnormalized_widths,
-            unnormalized_heights,
-            unnormalized_derivatives,
-            inverse=reverse,
-            tails="linear",
-            tail_bound=self.tail_bound,
-        )
-
-        x = torch.cat([x0, x1], 1) * x_mask
-        logdet = torch.sum(logabsdet * x_mask, [1, 2])
-        if not reverse:
-            return x, logdet
-        else:
-            return x

melo/split_utils.py

@@ -1,131 +0,0 @@
-import re
-import os
-import glob
-import numpy as np
-import soundfile as sf
-import torchaudio
-from txtsplit import txtsplit
-def split_sentence(text, min_len=10, language_str='EN'):
-    if language_str in ['EN', 'FR', 'ES', 'SP', 'DE', 'RU']:
-        sentences = split_sentences_latin(text, min_len=min_len)
-    else:
-        sentences = split_sentences_zh(text, min_len=min_len)
-    return sentences
-
-def split_sentences_latin(text, min_len=10):
-    text = re.sub('[。！？；]', '.', text)
-    text = re.sub('[，]', ',', text)
-    text = re.sub('[“”]', '"', text)
-    text = re.sub('[‘’]', "'", text)
-    text = re.sub(r"[\<\>\(\)\[\]\"\«\»]+", "", text)
-    return [item.strip() for item in txtsplit(text, 512, 512) if item.strip()]
-    # 将文本中的换行符、空格和制表符替换为空格
-    # text = re.sub('[\n\t ]+', ' ', text)
-    # # 在标点符号后添加一个空格
-    # text = re.sub('([,.!?;])', r'\1 $#!', text)
-    # # 分隔句子并去除前后空格
-    # sentences = [s.strip() for s in text.split('$#!')]
-    # if len(sentences[-1]) == 0: del sentences[-1]
-
-    # new_sentences = []
-    # new_sent = []
-    # count_len = 0
-    # for ind, sent in enumerate(sentences):
-    #     # print(sent)
-    #     new_sent.append(sent)
-    #     count_len += len(sent.split(" "))
-    #     if count_len > min_len or ind == len(sentences) - 1:
-    #         count_len = 0
-    #         new_sentences.append(' '.join(new_sent))
-    #         new_sent = []
-    # return merge_short_sentences_en(new_sentences)
-
-def split_sentences_zh(text, min_len=10):
-    text = re.sub('[。！？；]', '.', text)
-    text = re.sub('[，]', ',', text)
-    # 将文本中的换行符、空格和制表符替换为空格
-    text = re.sub('[\n\t ]+', ' ', text)
-    # 在标点符号后添加一个空格
-    text = re.sub('([,.!?;])', r'\1 $#!', text)
-    # 分隔句子并去除前后空格
-    # sentences = [s.strip() for s in re.split('(。|！|？|；)', text)]
-    sentences = [s.strip() for s in text.split('$#!')]
-    if len(sentences[-1]) == 0: del sentences[-1]
-
-    new_sentences = []
-    new_sent = []
-    count_len = 0
-    for ind, sent in enumerate(sentences):
-        new_sent.append(sent)
-        count_len += len(sent)
-        if count_len > min_len or ind == len(sentences) - 1:
-            count_len = 0
-            new_sentences.append(' '.join(new_sent))
-            new_sent = []
-    return merge_short_sentences_zh(new_sentences)
-
-def merge_short_sentences_en(sens):
-    """Avoid short sentences by merging them with the following sentence.
-
-    Args:
-        List[str]: list of input sentences.
-
-    Returns:
-        List[str]: list of output sentences.
-    """
-    sens_out = []
-    for s in sens:
-        # If the previous sentense is too short, merge them with
-        # the current sentence.
-        if len(sens_out) > 0 and len(sens_out[-1].split(" ")) <= 2:
-            sens_out[-1] = sens_out[-1] + " " + s
-        else:
-            sens_out.append(s)
-    try:
-        if len(sens_out[-1].split(" ")) <= 2:
-            sens_out[-2] = sens_out[-2] + " " + sens_out[-1]
-            sens_out.pop(-1)
-    except:
-        pass
-    return sens_out
-
-def merge_short_sentences_zh(sens):
-    # return sens
-    """Avoid short sentences by merging them with the following sentence.
-
-    Args:
-        List[str]: list of input sentences.
-
-    Returns:
-        List[str]: list of output sentences.
-    """
-    sens_out = []
-    for s in sens:
-        # If the previous sentense is too short, merge them with
-        # the current sentence.
-        if len(sens_out) > 0 and len(sens_out[-1]) <= 2:
-            sens_out[-1] = sens_out[-1] + " " + s
-        else:
-            sens_out.append(s)
-    try:
-        if len(sens_out[-1]) <= 2:
-            sens_out[-2] = sens_out[-2] + " " + sens_out[-1]
-            sens_out.pop(-1)
-    except:
-        pass
-    return sens_out
-
-
-if __name__ == '__main__':
-    zh_text = "好的，我来给你讲一个故事吧。从前有一个小姑娘，她叫做小红。小红非常喜欢在森林里玩耍，她经常会和她的小伙伴们一起去探险。有一天，小红和她的小伙伴们走到了森林深处，突然遇到了一只凶猛的野兽。小红的小伙伴们都吓得不敢动弹，但是小红并没有被吓倒，她勇敢地走向野兽，用她的智慧和勇气成功地制服了野兽，保护了她的小伙伴们。从那以后，小红变得更加勇敢和自信，成为了她小伙伴们心中的英雄。"
-    en_text = "I didn’t know what to do. I said please kill her because it would be better than being kidnapped,” Ben, whose surname CNN is not using for security concerns, said on Wednesday. “It’s a nightmare. I said ‘please kill her, don’t take her there.’"
-    sp_text = "¡Claro! ¿En qué tema te gustaría que te hable en español? Puedo proporcionarte información o conversar contigo sobre una amplia variedad de temas, desde cultura y comida hasta viajes y tecnología. ¿Tienes alguna preferencia en particular?"
-    fr_text = "Bien sûr ! En quelle matière voudriez-vous que je vous parle en français ? Je peux vous fournir des informations ou discuter avec vous sur une grande variété de sujets, que ce soit la culture, la nourriture, les voyages ou la technologie. Avez-vous une préférence particulière ?"
-    de_text = 'Es war das Wichtigste was wir sichern wollten da es keine Möglichkeit gab eine 20 Megatonnen- H- Bombe ab zu werfen von einem 30, C124.'
-    ru_text = 'Но он был во многом, как-бы, всё равно что сын плантатора, так как являлся сыном человека, у которого было в собственности много чего.'
-    print(split_sentence(zh_text, language_str='ZH'))
-    print(split_sentence(en_text, language_str='EN'))
-    print(split_sentence(sp_text, language_str='SP'))
-    print(split_sentence(fr_text, language_str='FR'))
-    print(split_sentence(de_text, language_str='DE'))
-    print(split_sentence(ru_text, language_str='RU'))

melo/text/__init__.py

@@ -1,35 +0,0 @@
-from .symbols import *
-
-
-_symbol_to_id = {s: i for i, s in enumerate(symbols)}
-
-
-def cleaned_text_to_sequence(cleaned_text, tones, language, symbol_to_id=None):
-    """Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
-    Args:
-      text: string to convert to a sequence
-    Returns:
-      List of integers corresponding to the symbols in the text
-    """
-    symbol_to_id_map = symbol_to_id if symbol_to_id else _symbol_to_id
-    phones = [symbol_to_id_map[symbol] for symbol in cleaned_text]
-    tone_start = language_tone_start_map[language]
-    tones = [i + tone_start for i in tones]
-    lang_id = language_id_map[language]
-    lang_ids = [lang_id for i in phones]
-    return phones, tones, lang_ids
-
-
-def get_bert(norm_text, word2ph, language, device):
-    from .chinese_bert import get_bert_feature as zh_bert
-    from .english_bert import get_bert_feature as en_bert
-    from .japanese_bert import get_bert_feature as jp_bert
-    from .chinese_mix import get_bert_feature as zh_mix_en_bert
-    from .spanish_bert import get_bert_feature as sp_bert
-    from .french_bert import get_bert_feature as fr_bert
-    from .korean import get_bert_feature as kr_bert
-
-    lang_bert_func_map = {"ZH": zh_bert, "EN": en_bert, "JP": jp_bert, 'ZH_MIX_EN': zh_mix_en_bert, 
-                          'FR': fr_bert, 'SP': sp_bert, 'ES': sp_bert, "KR": kr_bert}
-    bert = lang_bert_func_map[language](norm_text, word2ph, device)
-    return bert

melo/text/chinese.py

@@ -1,199 +0,0 @@
-import os
-import re
-
-import cn2an
-from pypinyin import lazy_pinyin, Style
-
-from .symbols import punctuation
-from .tone_sandhi import ToneSandhi
-
-current_file_path = os.path.dirname(__file__)
-pinyin_to_symbol_map = {
-    line.split("\t")[0]: line.strip().split("\t")[1]
-    for line in open(os.path.join(current_file_path, "opencpop-strict.txt")).readlines()
-}
-
-import jieba.posseg as psg
-
-
-rep_map = {
-    "：": ",",
-    "；": ",",
-    "，": ",",
-    "。": ".",
-    "！": "!",
-    "？": "?",
-    "\n": ".",
-    "·": ",",
-    "、": ",",
-    "...": "…",
-    "$": ".",
-    "“": "'",
-    "”": "'",
-    "‘": "'",
-    "’": "'",
-    "（": "'",
-    "）": "'",
-    "(": "'",
-    ")": "'",
-    "《": "'",
-    "》": "'",
-    "【": "'",
-    "】": "'",
-    "[": "'",
-    "]": "'",
-    "—": "-",
-    "～": "-",
-    "~": "-",
-    "「": "'",
-    "」": "'",
-}
-
-tone_modifier = ToneSandhi()
-
-
-def replace_punctuation(text):
-    text = text.replace("嗯", "恩").replace("呣", "母")
-    pattern = re.compile("|".join(re.escape(p) for p in rep_map.keys()))
-
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-
-    replaced_text = re.sub(
-        r"[^\u4e00-\u9fa5" + "".join(punctuation) + r"]+", "", replaced_text
-    )
-
-    return replaced_text
-
-
-def g2p(text):
-    pattern = r"(?<=[{0}])\s*".format("".join(punctuation))
-    sentences = [i for i in re.split(pattern, text) if i.strip() != ""]
-    phones, tones, word2ph = _g2p(sentences)
-    assert sum(word2ph) == len(phones)
-    assert len(word2ph) == len(text)  # Sometimes it will crash,you can add a try-catch.
-    phones = ["_"] + phones + ["_"]
-    tones = [0] + tones + [0]
-    word2ph = [1] + word2ph + [1]
-    return phones, tones, word2ph
-
-
-def _get_initials_finals(word):
-    initials = []
-    finals = []
-    orig_initials = lazy_pinyin(word, neutral_tone_with_five=True, style=Style.INITIALS)
-    orig_finals = lazy_pinyin(
-        word, neutral_tone_with_five=True, style=Style.FINALS_TONE3
-    )
-    for c, v in zip(orig_initials, orig_finals):
-        initials.append(c)
-        finals.append(v)
-    return initials, finals
-
-
-def _g2p(segments):
-    phones_list = []
-    tones_list = []
-    word2ph = []
-    for seg in segments:
-        # Replace all English words in the sentence
-        seg = re.sub("[a-zA-Z]+", "", seg)
-        seg_cut = psg.lcut(seg)
-        initials = []
-        finals = []
-        seg_cut = tone_modifier.pre_merge_for_modify(seg_cut)
-        for word, pos in seg_cut:
-            if pos == "eng":
-                import pdb; pdb.set_trace()
-                continue
-            sub_initials, sub_finals = _get_initials_finals(word)
-            sub_finals = tone_modifier.modified_tone(word, pos, sub_finals)
-            initials.append(sub_initials)
-            finals.append(sub_finals)
-
-            # assert len(sub_initials) == len(sub_finals) == len(word)
-        initials = sum(initials, [])
-        finals = sum(finals, [])
-        #
-        for c, v in zip(initials, finals):
-            raw_pinyin = c + v
-            # NOTE: post process for pypinyin outputs
-            # we discriminate i, ii and iii
-            if c == v:
-                assert c in punctuation
-                phone = [c]
-                tone = "0"
-                word2ph.append(1)
-            else:
-                v_without_tone = v[:-1]
-                tone = v[-1]
-
-                pinyin = c + v_without_tone
-                assert tone in "12345"
-
-                if c:
-                    # 多音节
-                    v_rep_map = {
-                        "uei": "ui",
-                        "iou": "iu",
-                        "uen": "un",
-                    }
-                    if v_without_tone in v_rep_map.keys():
-                        pinyin = c + v_rep_map[v_without_tone]
-                else:
-                    # 单音节
-                    pinyin_rep_map = {
-                        "ing": "ying",
-                        "i": "yi",
-                        "in": "yin",
-                        "u": "wu",
-                    }
-                    if pinyin in pinyin_rep_map.keys():
-                        pinyin = pinyin_rep_map[pinyin]
-                    else:
-                        single_rep_map = {
-                            "v": "yu",
-                            "e": "e",
-                            "i": "y",
-                            "u": "w",
-                        }
-                        if pinyin[0] in single_rep_map.keys():
-                            pinyin = single_rep_map[pinyin[0]] + pinyin[1:]
-
-                assert pinyin in pinyin_to_symbol_map.keys(), (pinyin, seg, raw_pinyin)
-                phone = pinyin_to_symbol_map[pinyin].split(" ")
-                word2ph.append(len(phone))
-
-            phones_list += phone
-            tones_list += [int(tone)] * len(phone)
-    return phones_list, tones_list, word2ph
-
-
-def text_normalize(text):
-    numbers = re.findall(r"\d+(?:\.?\d+)?", text)
-    for number in numbers:
-        text = text.replace(number, cn2an.an2cn(number), 1)
-    text = replace_punctuation(text)
-    return text
-
-
-def get_bert_feature(text, word2ph, device=None):
-    from text import chinese_bert
-
-    return chinese_bert.get_bert_feature(text, word2ph, device=device)
-
-
-if __name__ == "__main__":
-    from text.chinese_bert import get_bert_feature
-
-    text = "啊！chemistry 但是《原神》是由,米哈\游自主，  [研发]的一款全.新开放世界.冒险游戏"
-    text = text_normalize(text)
-    print(text)
-    phones, tones, word2ph = g2p(text)
-    bert = get_bert_feature(text, word2ph)
-
-    print(phones, tones, word2ph, bert.shape)
-
-
-# # 示例用法
-# text = "这是一个示例文本：,你好！这是一个测试...."
-# print(g2p_paddle(text))  # 输出: 这是一个示例文本你好这是一个测试

melo/text/chinese_bert.py

@@ -1,107 +0,0 @@
-import torch
-import sys
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-
-
-# model_id = 'hfl/chinese-roberta-wwm-ext-large'
-local_path = "./bert/chinese-roberta-wwm-ext-large"
-
-
-tokenizers = {}
-models = {}
-
-def get_bert_feature(text, word2ph, device=None, model_id='hfl/chinese-roberta-wwm-ext-large'):
-    if model_id not in models:
-        models[model_id] = AutoModelForMaskedLM.from_pretrained(
-            model_id
-        ).to(device)
-        tokenizers[model_id] = AutoTokenizer.from_pretrained(model_id)
-    model = models[model_id]
-    tokenizer = tokenizers[model_id]
-
-    if (
-        sys.platform == "darwin"
-        and torch.backends.mps.is_available()
-        and device == "cpu"
-    ):
-        device = "mps"
-    if not device:
-        device = "cuda"
-
-    with torch.no_grad():
-        inputs = tokenizer(text, return_tensors="pt")
-        for i in inputs:
-            inputs[i] = inputs[i].to(device)
-        res = model(**inputs, output_hidden_states=True)
-        res = torch.cat(res["hidden_states"][-3:-2], -1)[0].cpu()
-    # import pdb; pdb.set_trace()
-    # assert len(word2ph) == len(text) + 2
-    word2phone = word2ph
-    phone_level_feature = []
-    for i in range(len(word2phone)):
-        repeat_feature = res[i].repeat(word2phone[i], 1)
-        phone_level_feature.append(repeat_feature)
-
-    phone_level_feature = torch.cat(phone_level_feature, dim=0)
-    return phone_level_feature.T
-
-
-if __name__ == "__main__":
-    import torch
-
-    word_level_feature = torch.rand(38, 1024)  # 12个词,每个词1024维特征
-    word2phone = [
-        1,
-        2,
-        1,
-        2,
-        2,
-        1,
-        2,
-        2,
-        1,
-        2,
-        2,
-        1,
-        2,
-        2,
-        2,
-        2,
-        2,
-        1,
-        1,
-        2,
-        2,
-        1,
-        2,
-        2,
-        2,
-        2,
-        1,
-        2,
-        2,
-        2,
-        2,
-        2,
-        1,
-        2,
-        2,
-        2,
-        2,
-        1,
-    ]
-
-    # 计算总帧数
-    total_frames = sum(word2phone)
-    print(word_level_feature.shape)
-    print(word2phone)
-    phone_level_feature = []
-    for i in range(len(word2phone)):
-        print(word_level_feature[i].shape)
-
-        # 对每个词重复word2phone[i]次
-        repeat_feature = word_level_feature[i].repeat(word2phone[i], 1)
-        phone_level_feature.append(repeat_feature)
-
-    phone_level_feature = torch.cat(phone_level_feature, dim=0)
-    print(phone_level_feature.shape)  # torch.Size([36, 1024])

melo/text/chinese_mix.py

@@ -1,253 +0,0 @@
-import os
-import re
-
-import cn2an
-from pypinyin import lazy_pinyin, Style
-
-# from text.symbols import punctuation
-from .symbols import language_tone_start_map
-from .tone_sandhi import ToneSandhi
-from .english import g2p as g2p_en
-from transformers import AutoTokenizer
-
-punctuation = ["!", "?", "…", ",", ".", "'", "-"]
-current_file_path = os.path.dirname(__file__)
-pinyin_to_symbol_map = {
-    line.split("\t")[0]: line.strip().split("\t")[1]
-    for line in open(os.path.join(current_file_path, "opencpop-strict.txt")).readlines()
-}
-
-import jieba.posseg as psg
-
-
-rep_map = {
-    "：": ",",
-    "；": ",",
-    "，": ",",
-    "。": ".",
-    "！": "!",
-    "？": "?",
-    "\n": ".",
-    "·": ",",
-    "、": ",",
-    "...": "…",
-    "$": ".",
-    "“": "'",
-    "”": "'",
-    "‘": "'",
-    "’": "'",
-    "（": "'",
-    "）": "'",
-    "(": "'",
-    ")": "'",
-    "《": "'",
-    "》": "'",
-    "【": "'",
-    "】": "'",
-    "[": "'",
-    "]": "'",
-    "—": "-",
-    "～": "-",
-    "~": "-",
-    "「": "'",
-    "」": "'",
-}
-
-tone_modifier = ToneSandhi()
-
-
-def replace_punctuation(text):
-    text = text.replace("嗯", "恩").replace("呣", "母")
-    pattern = re.compile("|".join(re.escape(p) for p in rep_map.keys()))
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-    replaced_text = re.sub(r"[^\u4e00-\u9fa5_a-zA-Z\s" + "".join(punctuation) + r"]+", "", replaced_text)
-    replaced_text = re.sub(r"[\s]+", " ", replaced_text)
-
-    return replaced_text
-
-
-def g2p(text, impl='v2'):
-    pattern = r"(?<=[{0}])\s*".format("".join(punctuation))
-    sentences = [i for i in re.split(pattern, text) if i.strip() != ""]
-    if impl == 'v1':
-        _func = _g2p
-    elif impl == 'v2':
-        _func = _g2p_v2
-    else:
-        raise NotImplementedError()
-    phones, tones, word2ph = _func(sentences)
-    assert sum(word2ph) == len(phones)
-    # assert len(word2ph) == len(text)  # Sometimes it will crash,you can add a try-catch.
-    phones = ["_"] + phones + ["_"]
-    tones = [0] + tones + [0]
-    word2ph = [1] + word2ph + [1]
-    return phones, tones, word2ph
-
-
-def _get_initials_finals(word):
-    initials = []
-    finals = []
-    orig_initials = lazy_pinyin(word, neutral_tone_with_five=True, style=Style.INITIALS)
-    orig_finals = lazy_pinyin(
-        word, neutral_tone_with_five=True, style=Style.FINALS_TONE3
-    )
-    for c, v in zip(orig_initials, orig_finals):
-        initials.append(c)
-        finals.append(v)
-    return initials, finals
-
-model_id = 'bert-base-multilingual-uncased'
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-def _g2p(segments):
-    phones_list = []
-    tones_list = []
-    word2ph = []
-    for seg in segments:
-        # Replace all English words in the sentence
-        # seg = re.sub("[a-zA-Z]+", "", seg)
-        seg_cut = psg.lcut(seg)
-        initials = []
-        finals = []
-        seg_cut = tone_modifier.pre_merge_for_modify(seg_cut)
-        for word, pos in seg_cut:
-            if pos == "eng":
-                initials.append(['EN_WORD'])
-                finals.append([word])
-            else:
-                sub_initials, sub_finals = _get_initials_finals(word)
-                sub_finals = tone_modifier.modified_tone(word, pos, sub_finals)
-                initials.append(sub_initials)
-                finals.append(sub_finals)
-
-            # assert len(sub_initials) == len(sub_finals) == len(word)
-        initials = sum(initials, [])
-        finals = sum(finals, [])
-        #
-        for c, v in zip(initials, finals):
-            if c == 'EN_WORD':
-                tokenized_en = tokenizer.tokenize(v)
-                phones_en, tones_en, word2ph_en = g2p_en(text=None, pad_start_end=False, tokenized=tokenized_en)
-                # apply offset to tones_en
-                tones_en = [t + language_tone_start_map['EN'] for t in tones_en]
-                phones_list += phones_en
-                tones_list += tones_en
-                word2ph += word2ph_en
-            else:
-                raw_pinyin = c + v
-                # NOTE: post process for pypinyin outputs
-                # we discriminate i, ii and iii
-                if c == v:
-                    assert c in punctuation
-                    phone = [c]
-                    tone = "0"
-                    word2ph.append(1)
-                else:
-                    v_without_tone = v[:-1]
-                    tone = v[-1]
-
-                    pinyin = c + v_without_tone
-                    assert tone in "12345"
-
-                    if c:
-                        # 多音节
-                        v_rep_map = {
-                            "uei": "ui",
-                            "iou": "iu",
-                            "uen": "un",
-                        }
-                        if v_without_tone in v_rep_map.keys():
-                            pinyin = c + v_rep_map[v_without_tone]
-                    else:
-                        # 单音节
-                        pinyin_rep_map = {
-                            "ing": "ying",
-                            "i": "yi",
-                            "in": "yin",
-                            "u": "wu",
-                        }
-                        if pinyin in pinyin_rep_map.keys():
-                            pinyin = pinyin_rep_map[pinyin]
-                        else:
-                            single_rep_map = {
-                                "v": "yu",
-                                "e": "e",
-                                "i": "y",
-                                "u": "w",
-                            }
-                            if pinyin[0] in single_rep_map.keys():
-                                pinyin = single_rep_map[pinyin[0]] + pinyin[1:]
-
-                    assert pinyin in pinyin_to_symbol_map.keys(), (pinyin, seg, raw_pinyin)
-                    phone = pinyin_to_symbol_map[pinyin].split(" ")
-                    word2ph.append(len(phone))
-
-                phones_list += phone
-                tones_list += [int(tone)] * len(phone)
-    return phones_list, tones_list, word2ph
-
-
-def text_normalize(text):
-    numbers = re.findall(r"\d+(?:\.?\d+)?", text)
-    for number in numbers:
-        text = text.replace(number, cn2an.an2cn(number), 1)
-    text = replace_punctuation(text)
-    return text
-
-
-def get_bert_feature(text, word2ph, device):
-    from . import chinese_bert
-    return chinese_bert.get_bert_feature(text, word2ph, model_id='bert-base-multilingual-uncased', device=device)
-
-from .chinese import _g2p as _chinese_g2p
-def _g2p_v2(segments):
-    spliter = '#$&^!@'
-
-    phones_list = []
-    tones_list = []
-    word2ph = []
-
-    for text in segments:
-        assert spliter not in text
-        # replace all english words
-        text = re.sub('([a-zA-Z\s]+)', lambda x: f'{spliter}{x.group(1)}{spliter}', text)
-        texts = text.split(spliter)
-        texts = [t for t in texts if len(t) > 0]
-
-        
-        for text in texts:
-            if re.match('[a-zA-Z\s]+', text):
-                # english
-                tokenized_en = tokenizer.tokenize(text)
-                phones_en, tones_en, word2ph_en = g2p_en(text=None, pad_start_end=False, tokenized=tokenized_en)
-                # apply offset to tones_en
-                tones_en = [t + language_tone_start_map['EN'] for t in tones_en]
-                phones_list += phones_en
-                tones_list += tones_en
-                word2ph += word2ph_en
-            else:
-                phones_zh, tones_zh, word2ph_zh = _chinese_g2p([text])
-                phones_list += phones_zh
-                tones_list += tones_zh
-                word2ph += word2ph_zh
-    return phones_list, tones_list, word2ph
-
-    
-
-if __name__ == "__main__":
-    # from text.chinese_bert import get_bert_feature
-
-    text = "NFT啊！chemistry 但是《原神》是由,米哈\游自主，  [研发]的一款全.新开放世界.冒险游戏"
-    text = '我最近在学习machine learning，希望能够在未来的artificial intelligence领域有所建树。'
-    text = '今天下午，我们准备去shopping mall购物，然后晚上去看一场movie。'
-    text = '我们现在 also 能够 help 很多公司 use some machine learning 的 algorithms 啊!'
-    text = text_normalize(text)
-    print(text)
-    phones, tones, word2ph = g2p(text, impl='v2')
-    bert = get_bert_feature(text, word2ph, device='cuda:0')
-    print(phones)
-    import pdb; pdb.set_trace()
-
-
-# # 示例用法
-# text = "这是一个示例文本：,你好！这是一个测试...."
-# print(g2p_paddle(text))  # 输出: 这是一个示例文本你好这是一个测试

melo/text/cleaner.py

@@ -1,36 +0,0 @@
-from . import chinese, japanese, english, chinese_mix, korean, french, spanish
-from . import cleaned_text_to_sequence
-import copy
-
-language_module_map = {"ZH": chinese, "JP": japanese, "EN": english, 'ZH_MIX_EN': chinese_mix, 'KR': korean,
-                    'FR': french, 'SP': spanish, 'ES': spanish}
-
-
-def clean_text(text, language):
-    language_module = language_module_map[language]
-    norm_text = language_module.text_normalize(text)
-    phones, tones, word2ph = language_module.g2p(norm_text)
-    return norm_text, phones, tones, word2ph
-
-
-def clean_text_bert(text, language, device=None):
-    language_module = language_module_map[language]
-    norm_text = language_module.text_normalize(text)
-    phones, tones, word2ph = language_module.g2p(norm_text)
-    
-    word2ph_bak = copy.deepcopy(word2ph)
-    for i in range(len(word2ph)):
-        word2ph[i] = word2ph[i] * 2
-    word2ph[0] += 1
-    bert = language_module.get_bert_feature(norm_text, word2ph, device=device)
-    
-    return norm_text, phones, tones, word2ph_bak, bert
-
-
-def text_to_sequence(text, language):
-    norm_text, phones, tones, word2ph = clean_text(text, language)
-    return cleaned_text_to_sequence(phones, tones, language)
-
-
-if __name__ == "__main__":
-    pass

melo/text/cleaner_multiling.py

@@ -1,110 +0,0 @@
-"""Set of default text cleaners"""
-# TODO: pick the cleaner for languages dynamically
-
-import re
-
-# Regular expression matching whitespace:
-_whitespace_re = re.compile(r"\s+")
-
-rep_map = {
-    "：": ",",
-    "；": ",",
-    "，": ",",
-    "。": ".",
-    "！": "!",
-    "？": "?",
-    "\n": ".",
-    "·": ",",
-    "、": ",",
-    "...": ".",
-    "…": ".",
-    "$": ".",
-    "“": "'",
-    "”": "'",
-    "‘": "'",
-    "’": "'",
-    "（": "'",
-    "）": "'",
-    "(": "'",
-    ")": "'",
-    "《": "'",
-    "》": "'",
-    "【": "'",
-    "】": "'",
-    "[": "'",
-    "]": "'",
-    "—": "",
-    "～": "-",
-    "~": "-",
-    "「": "'",
-    "」": "'",
-}
-
-def replace_punctuation(text):
-    pattern = re.compile("|".join(re.escape(p) for p in rep_map.keys()))
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-    return replaced_text
-
-def lowercase(text):
-    return text.lower()
-
-
-def collapse_whitespace(text):
-    return re.sub(_whitespace_re, " ", text).strip()
-
-def remove_punctuation_at_begin(text):
-    return re.sub(r'^[,.!?]+', '', text)
-
-def remove_aux_symbols(text):
-    text = re.sub(r"[\<\>\(\)\[\]\"\«\»\']+", "", text)
-    return text
-
-
-def replace_symbols(text, lang="en"):
-    """Replace symbols based on the lenguage tag.
-
-    Args:
-      text:
-       Input text.
-      lang:
-        Lenguage identifier. ex: "en", "fr", "pt", "ca".
-
-    Returns:
-      The modified text
-      example:
-        input args:
-            text: "si l'avi cau, diguem-ho"
-            lang: "ca"
-        Output:
-            text: "si lavi cau, diguemho"
-    """
-    text = text.replace(";", ",")
-    text = text.replace("-", " ") if lang != "ca" else text.replace("-", "")
-    text = text.replace(":", ",")
-    if lang == "en":
-        text = text.replace("&", " and ")
-    elif lang == "fr":
-        text = text.replace("&", " et ")
-    elif lang == "pt":
-        text = text.replace("&", " e ")
-    elif lang == "ca":
-        text = text.replace("&", " i ")
-        text = text.replace("'", "")
-    elif lang== "es":
-        text=text.replace("&","y")
-        text = text.replace("'", "")
-    return text
-
-def unicleaners(text, cased=False, lang='en'):
-    """Basic pipeline for Portuguese text. There is no need to expand abbreviation and
-    numbers, phonemizer already does that"""
-    if not cased:
-        text = lowercase(text)
-    text = replace_punctuation(text)
-    text = replace_symbols(text, lang=lang)
-    text = remove_aux_symbols(text)
-    text = remove_punctuation_at_begin(text)
-    text = collapse_whitespace(text)
-    text = re.sub(r'([^\.,!\?\-…])$', r'\1.', text)
-    return text
-

melo/text/cmudict_cache.pickle

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

melo/text/english.py

@@ -1,284 +0,0 @@
-import pickle
-import os
-import re
-from g2p_en import G2p
-
-from . import symbols
-
-from .english_utils.abbreviations import expand_abbreviations
-from .english_utils.time_norm import expand_time_english
-from .english_utils.number_norm import normalize_numbers
-from .japanese import distribute_phone
-
-from transformers import AutoTokenizer
-
-current_file_path = os.path.dirname(__file__)
-CMU_DICT_PATH = os.path.join(current_file_path, "cmudict.rep")
-CACHE_PATH = os.path.join(current_file_path, "cmudict_cache.pickle")
-_g2p = G2p()
-
-arpa = {
-    "AH0",
-    "S",
-    "AH1",
-    "EY2",
-    "AE2",
-    "EH0",
-    "OW2",
-    "UH0",
-    "NG",
-    "B",
-    "G",
-    "AY0",
-    "M",
-    "AA0",
-    "F",
-    "AO0",
-    "ER2",
-    "UH1",
-    "IY1",
-    "AH2",
-    "DH",
-    "IY0",
-    "EY1",
-    "IH0",
-    "K",
-    "N",
-    "W",
-    "IY2",
-    "T",
-    "AA1",
-    "ER1",
-    "EH2",
-    "OY0",
-    "UH2",
-    "UW1",
-    "Z",
-    "AW2",
-    "AW1",
-    "V",
-    "UW2",
-    "AA2",
-    "ER",
-    "AW0",
-    "UW0",
-    "R",
-    "OW1",
-    "EH1",
-    "ZH",
-    "AE0",
-    "IH2",
-    "IH",
-    "Y",
-    "JH",
-    "P",
-    "AY1",
-    "EY0",
-    "OY2",
-    "TH",
-    "HH",
-    "D",
-    "ER0",
-    "CH",
-    "AO1",
-    "AE1",
-    "AO2",
-    "OY1",
-    "AY2",
-    "IH1",
-    "OW0",
-    "L",
-    "SH",
-}
-
-
-def post_replace_ph(ph):
-    rep_map = {
-        "：": ",",
-        "；": ",",
-        "，": ",",
-        "。": ".",
-        "！": "!",
-        "？": "?",
-        "\n": ".",
-        "·": ",",
-        "、": ",",
-        "...": "…",
-        "v": "V",
-    }
-    if ph in rep_map.keys():
-        ph = rep_map[ph]
-    if ph in symbols:
-        return ph
-    if ph not in symbols:
-        ph = "UNK"
-    return ph
-
-
-def read_dict():
-    g2p_dict = {}
-    start_line = 49
-    with open(CMU_DICT_PATH) as f:
-        line = f.readline()
-        line_index = 1
-        while line:
-            if line_index >= start_line:
-                line = line.strip()
-                word_split = line.split("  ")
-                word = word_split[0]
-
-                syllable_split = word_split[1].split(" - ")
-                g2p_dict[word] = []
-                for syllable in syllable_split:
-                    phone_split = syllable.split(" ")
-                    g2p_dict[word].append(phone_split)
-
-            line_index = line_index + 1
-            line = f.readline()
-
-    return g2p_dict
-
-
-def cache_dict(g2p_dict, file_path):
-    with open(file_path, "wb") as pickle_file:
-        pickle.dump(g2p_dict, pickle_file)
-
-
-def get_dict():
-    if os.path.exists(CACHE_PATH):
-        with open(CACHE_PATH, "rb") as pickle_file:
-            g2p_dict = pickle.load(pickle_file)
-    else:
-        g2p_dict = read_dict()
-        cache_dict(g2p_dict, CACHE_PATH)
-
-    return g2p_dict
-
-
-eng_dict = get_dict()
-
-
-def refine_ph(phn):
-    tone = 0
-    if re.search(r"\d$", phn):
-        tone = int(phn[-1]) + 1
-        phn = phn[:-1]
-    return phn.lower(), tone
-
-
-def refine_syllables(syllables):
-    tones = []
-    phonemes = []
-    for phn_list in syllables:
-        for i in range(len(phn_list)):
-            phn = phn_list[i]
-            phn, tone = refine_ph(phn)
-            phonemes.append(phn)
-            tones.append(tone)
-    return phonemes, tones
-
-
-def text_normalize(text):
-    text = text.lower()
-    text = expand_time_english(text)
-    text = normalize_numbers(text)
-    text = expand_abbreviations(text)
-    return text
-
-model_id = 'bert-base-uncased'
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-def g2p_old(text):
-    tokenized = tokenizer.tokenize(text)
-    # import pdb; pdb.set_trace()
-    phones = []
-    tones = []
-    words = re.split(r"([,;.\-\?\!\s+])", text)
-    for w in words:
-        if w.upper() in eng_dict:
-            phns, tns = refine_syllables(eng_dict[w.upper()])
-            phones += phns
-            tones += tns
-        else:
-            phone_list = list(filter(lambda p: p != " ", _g2p(w)))
-            for ph in phone_list:
-                if ph in arpa:
-                    ph, tn = refine_ph(ph)
-                    phones.append(ph)
-                    tones.append(tn)
-                else:
-                    phones.append(ph)
-                    tones.append(0)
-    # todo: implement word2ph
-    word2ph = [1 for i in phones]
-
-    phones = [post_replace_ph(i) for i in phones]
-    return phones, tones, word2ph
-
-def g2p(text, pad_start_end=True, tokenized=None):
-    if tokenized is None:
-        tokenized = tokenizer.tokenize(text)
-    # import pdb; pdb.set_trace()
-    phs = []
-    ph_groups = []
-    for t in tokenized:
-        if not t.startswith("#"):
-            ph_groups.append([t])
-        else:
-            ph_groups[-1].append(t.replace("#", ""))
-    
-    phones = []
-    tones = []
-    word2ph = []
-    for group in ph_groups:
-        w = "".join(group)
-        phone_len = 0
-        word_len = len(group)
-        if w.upper() in eng_dict:
-            phns, tns = refine_syllables(eng_dict[w.upper()])
-            phones += phns
-            tones += tns
-            phone_len += len(phns)
-        else:
-            phone_list = list(filter(lambda p: p != " ", _g2p(w)))
-            for ph in phone_list:
-                if ph in arpa:
-                    ph, tn = refine_ph(ph)
-                    phones.append(ph)
-                    tones.append(tn)
-                else:
-                    phones.append(ph)
-                    tones.append(0)
-                phone_len += 1
-        aaa = distribute_phone(phone_len, word_len)
-        word2ph += aaa
-    phones = [post_replace_ph(i) for i in phones]
-
-    if pad_start_end:
-        phones = ["_"] + phones + ["_"]
-        tones = [0] + tones + [0]
-        word2ph = [1] + word2ph + [1]
-    return phones, tones, word2ph
-
-def get_bert_feature(text, word2ph, device=None):
-    from text import english_bert
-
-    return english_bert.get_bert_feature(text, word2ph, device=device)
-
-if __name__ == "__main__":
-    # print(get_dict())
-    # print(eng_word_to_phoneme("hello"))
-    from text.english_bert import get_bert_feature
-    text = "In this paper, we propose 1 DSPGAN, a N-F-T GAN-based universal vocoder."
-    text = text_normalize(text)
-    phones, tones, word2ph = g2p(text)
-    import pdb; pdb.set_trace()
-    bert = get_bert_feature(text, word2ph)
-    
-    print(phones, tones, word2ph, bert.shape)
-
-    # all_phones = set()
-    # for k, syllables in eng_dict.items():
-    #     for group in syllables:
-    #         for ph in group:
-    #             all_phones.add(ph)
-    # print(all_phones)

melo/text/english_bert.py

@@ -1,39 +0,0 @@
-import torch
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-import sys
-
-model_id = 'bert-base-uncased'
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-model = None
-
-def get_bert_feature(text, word2ph, device=None):
-    global model
-    if (
-        sys.platform == "darwin"
-        and torch.backends.mps.is_available()
-        and device == "cpu"
-    ):
-        device = "mps"
-    if not device:
-        device = "cuda"
-    if model is None:
-        model = AutoModelForMaskedLM.from_pretrained(model_id).to(
-            device
-        )
-    with torch.no_grad():
-        inputs = tokenizer(text, return_tensors="pt")
-        for i in inputs:
-            inputs[i] = inputs[i].to(device)
-        res = model(**inputs, output_hidden_states=True)
-        res = torch.cat(res["hidden_states"][-3:-2], -1)[0].cpu()
-        
-    assert inputs["input_ids"].shape[-1] == len(word2ph)
-    word2phone = word2ph
-    phone_level_feature = []
-    for i in range(len(word2phone)):
-        repeat_feature = res[i].repeat(word2phone[i], 1)
-        phone_level_feature.append(repeat_feature)
-
-    phone_level_feature = torch.cat(phone_level_feature, dim=0)
-
-    return phone_level_feature.T

melo/text/english_utils/abbreviations.py

@@ -1,35 +0,0 @@
-import re
-
-# List of (regular expression, replacement) pairs for abbreviations in english:
-abbreviations_en = [
-    (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
-    for x in [
-        ("mrs", "misess"),
-        ("mr", "mister"),
-        ("dr", "doctor"),
-        ("st", "saint"),
-        ("co", "company"),
-        ("jr", "junior"),
-        ("maj", "major"),
-        ("gen", "general"),
-        ("drs", "doctors"),
-        ("rev", "reverend"),
-        ("lt", "lieutenant"),
-        ("hon", "honorable"),
-        ("sgt", "sergeant"),
-        ("capt", "captain"),
-        ("esq", "esquire"),
-        ("ltd", "limited"),
-        ("col", "colonel"),
-        ("ft", "fort"),
-    ]
-]
-
-def expand_abbreviations(text, lang="en"):
-    if lang == "en":
-        _abbreviations = abbreviations_en
-    else:
-        raise NotImplementedError()
-    for regex, replacement in _abbreviations:
-        text = re.sub(regex, replacement, text)
-    return text

melo/text/english_utils/number_norm.py

@@ -1,97 +0,0 @@
-""" from https://github.com/keithito/tacotron """
-
-import re
-from typing import Dict
-
-import inflect
-
-_inflect = inflect.engine()
-_comma_number_re = re.compile(r"([0-9][0-9\,]+[0-9])")
-_decimal_number_re = re.compile(r"([0-9]+\.[0-9]+)")
-_currency_re = re.compile(r"(£|\$|¥)([0-9\,\.]*[0-9]+)")
-_ordinal_re = re.compile(r"[0-9]+(st|nd|rd|th)")
-_number_re = re.compile(r"-?[0-9]+")
-
-
-def _remove_commas(m):
-    return m.group(1).replace(",", "")
-
-
-def _expand_decimal_point(m):
-    return m.group(1).replace(".", " point ")
-
-
-def __expand_currency(value: str, inflection: Dict[float, str]) -> str:
-    parts = value.replace(",", "").split(".")
-    if len(parts) > 2:
-        return f"{value} {inflection[2]}"  # Unexpected format
-    text = []
-    integer = int(parts[0]) if parts[0] else 0
-    if integer > 0:
-        integer_unit = inflection.get(integer, inflection[2])
-        text.append(f"{integer} {integer_unit}")
-    fraction = int(parts[1]) if len(parts) > 1 and parts[1] else 0
-    if fraction > 0:
-        fraction_unit = inflection.get(fraction / 100, inflection[0.02])
-        text.append(f"{fraction} {fraction_unit}")
-    if len(text) == 0:
-        return f"zero {inflection[2]}"
-    return " ".join(text)
-
-
-def _expand_currency(m: "re.Match") -> str:
-    currencies = {
-        "$": {
-            0.01: "cent",
-            0.02: "cents",
-            1: "dollar",
-            2: "dollars",
-        },
-        "€": {
-            0.01: "cent",
-            0.02: "cents",
-            1: "euro",
-            2: "euros",
-        },
-        "£": {
-            0.01: "penny",
-            0.02: "pence",
-            1: "pound sterling",
-            2: "pounds sterling",
-        },
-        "¥": {
-            # TODO rin
-            0.02: "sen",
-            2: "yen",
-        },
-    }
-    unit = m.group(1)
-    currency = currencies[unit]
-    value = m.group(2)
-    return __expand_currency(value, currency)
-
-
-def _expand_ordinal(m):
-    return _inflect.number_to_words(m.group(0))
-
-
-def _expand_number(m):
-    num = int(m.group(0))
-    if 1000 < num < 3000:
-        if num == 2000:
-            return "two thousand"
-        if 2000 < num < 2010:
-            return "two thousand " + _inflect.number_to_words(num % 100)
-        if num % 100 == 0:
-            return _inflect.number_to_words(num // 100) + " hundred"
-        return _inflect.number_to_words(num, andword="", zero="oh", group=2).replace(", ", " ")
-    return _inflect.number_to_words(num, andword="")
-
-
-def normalize_numbers(text):
-    text = re.sub(_comma_number_re, _remove_commas, text)
-    text = re.sub(_currency_re, _expand_currency, text)
-    text = re.sub(_decimal_number_re, _expand_decimal_point, text)
-    text = re.sub(_ordinal_re, _expand_ordinal, text)
-    text = re.sub(_number_re, _expand_number, text)
-    return text

melo/text/english_utils/time_norm.py

@@ -1,47 +0,0 @@
-import re
-
-import inflect
-
-_inflect = inflect.engine()
-
-_time_re = re.compile(
-    r"""\b
-                          ((0?[0-9])|(1[0-1])|(1[2-9])|(2[0-3]))  # hours
-                          :
-                          ([0-5][0-9])                            # minutes
-                          \s*(a\\.m\\.|am|pm|p\\.m\\.|a\\.m|p\\.m)? # am/pm
-                          \b""",
-    re.IGNORECASE | re.X,
-)
-
-
-def _expand_num(n: int) -> str:
-    return _inflect.number_to_words(n)
-
-
-def _expand_time_english(match: "re.Match") -> str:
-    hour = int(match.group(1))
-    past_noon = hour >= 12
-    time = []
-    if hour > 12:
-        hour -= 12
-    elif hour == 0:
-        hour = 12
-        past_noon = True
-    time.append(_expand_num(hour))
-
-    minute = int(match.group(6))
-    if minute > 0:
-        if minute < 10:
-            time.append("oh")
-        time.append(_expand_num(minute))
-    am_pm = match.group(7)
-    if am_pm is None:
-        time.append("p m" if past_noon else "a m")
-    else:
-        time.extend(list(am_pm.replace(".", "")))
-    return " ".join(time)
-
-
-def expand_time_english(text: str) -> str:
-    return re.sub(_time_re, _expand_time_english, text)

melo/text/es_phonemizer/base.py

@@ -1,140 +0,0 @@
-import abc
-from typing import List, Tuple
-
-from .punctuation import Punctuation
-
-
-class BasePhonemizer(abc.ABC):
-    """Base phonemizer class
-
-    Phonemization follows the following steps:
-        1. Preprocessing:
-            - remove empty lines
-            - remove punctuation
-            - keep track of punctuation marks
-
-        2. Phonemization:
-            - convert text to phonemes
-
-        3. Postprocessing:
-            - join phonemes
-            - restore punctuation marks
-
-    Args:
-        language (str):
-            Language used by the phonemizer.
-
-        punctuations (List[str]):
-            List of punctuation marks to be preserved.
-
-        keep_puncs (bool):
-            Whether to preserve punctuation marks or not.
-    """
-
-    def __init__(self, language, punctuations=Punctuation.default_puncs(), keep_puncs=False):
-        # ensure the backend is installed on the system
-        if not self.is_available():
-            raise RuntimeError("{} not installed on your system".format(self.name()))  # pragma: nocover
-
-        # ensure the backend support the requested language
-        self._language = self._init_language(language)
-
-        # setup punctuation processing
-        self._keep_puncs = keep_puncs
-        self._punctuator = Punctuation(punctuations)
-
-    def _init_language(self, language):
-        """Language initialization
-
-        This method may be overloaded in child classes (see Segments backend)
-
-        """
-        if not self.is_supported_language(language):
-            raise RuntimeError(f'language "{language}" is not supported by the ' f"{self.name()} backend")
-        return language
-
-    @property
-    def language(self):
-        """The language code configured to be used for phonemization"""
-        return self._language
-
-    @staticmethod
-    @abc.abstractmethod
-    def name():
-        """The name of the backend"""
-        ...
-
-    @classmethod
-    @abc.abstractmethod
-    def is_available(cls):
-        """Returns True if the backend is installed, False otherwise"""
-        ...
-
-    @classmethod
-    @abc.abstractmethod
-    def version(cls):
-        """Return the backend version as a tuple (major, minor, patch)"""
-        ...
-
-    @staticmethod
-    @abc.abstractmethod
-    def supported_languages():
-        """Return a dict of language codes -> name supported by the backend"""
-        ...
-
-    def is_supported_language(self, language):
-        """Returns True if `language` is supported by the backend"""
-        return language in self.supported_languages()
-
-    @abc.abstractmethod
-    def _phonemize(self, text, separator):
-        """The main phonemization method"""
-
-    def _phonemize_preprocess(self, text) -> Tuple[List[str], List]:
-        """Preprocess the text before phonemization
-
-        1. remove spaces
-        2. remove punctuation
-
-        Override this if you need a different behaviour
-        """
-        text = text.strip()
-        if self._keep_puncs:
-            # a tuple (text, punctuation marks)
-            return self._punctuator.strip_to_restore(text)
-        return [self._punctuator.strip(text)], []
-
-    def _phonemize_postprocess(self, phonemized, punctuations) -> str:
-        """Postprocess the raw phonemized output
-
-        Override this if you need a different behaviour
-        """
-        if self._keep_puncs:
-            return self._punctuator.restore(phonemized, punctuations)[0]
-        return phonemized[0]
-
-    def phonemize(self, text: str, separator="|", language: str = None) -> str:  # pylint: disable=unused-argument
-        """Returns the `text` phonemized for the given language
-
-        Args:
-            text (str):
-                Text to be phonemized.
-
-            separator (str):
-                string separator used between phonemes. Default to '_'.
-
-        Returns:
-            (str): Phonemized text
-        """
-        text, punctuations = self._phonemize_preprocess(text)
-        phonemized = []
-        for t in text:
-            p = self._phonemize(t, separator)
-            phonemized.append(p)
-        phonemized = self._phonemize_postprocess(phonemized, punctuations)
-        return phonemized
-
-    def print_logs(self, level: int = 0):
-        indent = "\t" * level
-        print(f"{indent}| > phoneme language: {self.language}")
-        print(f"{indent}| > phoneme backend: {self.name()}")

melo/text/es_phonemizer/cleaner.py

@@ -1,109 +0,0 @@
-"""Set of default text cleaners"""
-# TODO: pick the cleaner for languages dynamically
-
-import re
-
-# Regular expression matching whitespace:
-_whitespace_re = re.compile(r"\s+")
-
-rep_map = {
-    "：": ",",
-    "；": ",",
-    "，": ",",
-    "。": ".",
-    "！": "!",
-    "？": "?",
-    "\n": ".",
-    "·": ",",
-    "、": ",",
-    "...": ".",
-    "…": ".",
-    "$": ".",
-    "“": "'",
-    "”": "'",
-    "‘": "'",
-    "’": "'",
-    "（": "'",
-    "）": "'",
-    "(": "'",
-    ")": "'",
-    "《": "'",
-    "》": "'",
-    "【": "'",
-    "】": "'",
-    "[": "'",
-    "]": "'",
-    "—": "",
-    "～": "-",
-    "~": "-",
-    "「": "'",
-    "」": "'",
-}
-
-def replace_punctuation(text):
-    pattern = re.compile("|".join(re.escape(p) for p in rep_map.keys()))
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-    return replaced_text
-
-def lowercase(text):
-    return text.lower()
-
-
-def collapse_whitespace(text):
-    return re.sub(_whitespace_re, " ", text).strip()
-
-def remove_punctuation_at_begin(text):
-    return re.sub(r'^[,.!?]+', '', text)
-
-def remove_aux_symbols(text):
-    text = re.sub(r"[\<\>\(\)\[\]\"\«\»\']+", "", text)
-    return text
-
-
-def replace_symbols(text, lang="en"):
-    """Replace symbols based on the lenguage tag.
-
-    Args:
-      text:
-       Input text.
-      lang:
-        Lenguage identifier. ex: "en", "fr", "pt", "ca".
-
-    Returns:
-      The modified text
-      example:
-        input args:
-            text: "si l'avi cau, diguem-ho"
-            lang: "ca"
-        Output:
-            text: "si lavi cau, diguemho"
-    """
-    text = text.replace(";", ",")
-    text = text.replace("-", " ") if lang != "ca" else text.replace("-", "")
-    text = text.replace(":", ",")
-    if lang == "en":
-        text = text.replace("&", " and ")
-    elif lang == "fr":
-        text = text.replace("&", " et ")
-    elif lang == "pt":
-        text = text.replace("&", " e ")
-    elif lang == "ca":
-        text = text.replace("&", " i ")
-        text = text.replace("'", "")
-    elif lang== "es":
-        text=text.replace("&","y")
-        text = text.replace("'", "")
-    return text
-
-def spanish_cleaners(text):
-    """Basic pipeline for Portuguese text. There is no need to expand abbreviation and
-    numbers, phonemizer already does that"""
-    text = lowercase(text)
-    text = replace_symbols(text, lang="es")
-    text = replace_punctuation(text)
-    text = remove_aux_symbols(text)
-    text = remove_punctuation_at_begin(text)
-    text = collapse_whitespace(text)
-    text = re.sub(r'([^\.,!\?\-…])$', r'\1.', text)
-    return text
-

melo/text/es_phonemizer/es_symbols.json

@@ -1,79 +0,0 @@
-{
-    "symbols": [
-        "_",
-        ",",
-        ".",
-        "!",
-        "?",
-        "-",
-        "~",
-        "\u2026",
-        "N",
-        "Q",
-        "a",
-        "b",
-        "d",
-        "e",
-        "f",
-        "g",
-        "h",
-        "i",
-        "j",
-        "k",
-        "l",
-        "m",
-        "n",
-        "o",
-        "p",
-        "s",
-        "t",
-        "u",
-        "v",
-        "w",
-        "x",
-        "y",
-        "z",
-        "\u0251",
-        "\u00e6",
-        "\u0283",
-        "\u0291",
-        "\u00e7",
-        "\u026f",
-        "\u026a",
-        "\u0254",
-        "\u025b",
-        "\u0279",
-        "\u00f0",
-        "\u0259",
-        "\u026b",
-        "\u0265",
-        "\u0278",
-        "\u028a",
-        "\u027e",
-        "\u0292",
-        "\u03b8",
-        "\u03b2",
-        "\u014b",
-        "\u0266",
-        "\u207c",
-        "\u02b0",
-        "`",
-        "^",
-        "#",
-        "*",
-        "=",
-        "\u02c8",
-        "\u02cc",
-        "\u2192",
-        "\u2193",
-        "\u2191",
-        " ",
-        "\u0263",
-        "\u0261",
-        "r",
-        "\u0272",
-        "\u029d",
-        "\u028e",
-        "\u02d0"
-    ]
-}

melo/text/es_phonemizer/es_symbols.txt

@@ -1 +0,0 @@
-_,.!?-~…NQabdefghijklmnopstuvwxyzɑæʃʑçɯɪɔɛɹðəɫɥɸʊɾʒθβŋɦ⁼ʰ`^#*=ˈˌ→↓↑ ɡrɲʝɣʎː—¿¡

melo/text/es_phonemizer/es_symbols_v2.json

@@ -1,83 +0,0 @@
-{
-    "symbols": [
-        "_",
-        ",",
-        ".",
-        "!",
-        "?",
-        "-",
-        "~",
-        "\u2026",
-        "N",
-        "Q",
-        "a",
-        "b",
-        "d",
-        "e",
-        "f",
-        "g",
-        "h",
-        "i",
-        "j",
-        "k",
-        "l",
-        "m",
-        "n",
-        "o",
-        "p",
-        "s",
-        "t",
-        "u",
-        "v",
-        "w",
-        "x",
-        "y",
-        "z",
-        "\u0251",
-        "\u00e6",
-        "\u0283",
-        "\u0291",
-        "\u00e7",
-        "\u026f",
-        "\u026a",
-        "\u0254",
-        "\u025b",
-        "\u0279",
-        "\u00f0",
-        "\u0259",
-        "\u026b",
-        "\u0265",
-        "\u0278",
-        "\u028a",
-        "\u027e",
-        "\u0292",
-        "\u03b8",
-        "\u03b2",
-        "\u014b",
-        "\u0266",
-        "\u207c",
-        "\u02b0",
-        "`",
-        "^",
-        "#",
-        "*",
-        "=",
-        "\u02c8",
-        "\u02cc",
-        "\u2192",
-        "\u2193",
-        "\u2191",
-        " ",
-        "\u0261",
-        "r",
-        "\u0272",
-        "\u029d",
-        "\u0263",
-        "\u028e",
-        "\u02d0",
-        
-        "\u2014",
-        "\u00bf",
-        "\u00a1"
-    ]
-}

melo/text/es_phonemizer/es_to_ipa.py

@@ -1,12 +0,0 @@
-from .cleaner import spanish_cleaners
-from .gruut_wrapper import Gruut
-
-def es2ipa(text):
-    e = Gruut(language="es-es", keep_puncs=True, keep_stress=True, use_espeak_phonemes=True)
-    # text = spanish_cleaners(text)
-    phonemes = e.phonemize(text, separator="")
-    return phonemes
-
-
-if __name__ == '__main__':
-  print(es2ipa('¿Y a quién echaría de menos, en el mundo si no fuese a vos?'))

melo/text/es_phonemizer/gruut_wrapper.py

@@ -1,253 +0,0 @@
-import importlib
-from typing import List
-
-import gruut
-from gruut_ipa import IPA # pip install gruut_ipa
-
-from .base import BasePhonemizer
-from .punctuation import Punctuation
-
-# Table for str.translate to fix gruut/TTS phoneme mismatch
-GRUUT_TRANS_TABLE = str.maketrans("g", "ɡ")
-
-
-class Gruut(BasePhonemizer):
-    """Gruut wrapper for G2P
-
-    Args:
-        language (str):
-            Valid language code for the used backend.
-
-        punctuations (str):
-            Characters to be treated as punctuation. Defaults to `Punctuation.default_puncs()`.
-
-        keep_puncs (bool):
-            If true, keep the punctuations after phonemization. Defaults to True.
-
-        use_espeak_phonemes (bool):
-            If true, use espeak lexicons instead of default Gruut lexicons. Defaults to False.
-
-        keep_stress (bool):
-            If true, keep the stress characters after phonemization. Defaults to False.
-
-    Example:
-
-        >>> from TTS.tts.utils.text.phonemizers.gruut_wrapper import Gruut
-        >>> phonemizer = Gruut('en-us')
-        >>> phonemizer.phonemize("Be a voice, not an! echo?", separator="|")
-        'b|i| ə| v|ɔ|ɪ|s, n|ɑ|t| ə|n! ɛ|k|o|ʊ?'
-    """
-
-    def __init__(
-        self,
-        language: str,
-        punctuations=Punctuation.default_puncs(),
-        keep_puncs=True,
-        use_espeak_phonemes=False,
-        keep_stress=False,
-    ):
-        super().__init__(language, punctuations=punctuations, keep_puncs=keep_puncs)
-        self.use_espeak_phonemes = use_espeak_phonemes
-        self.keep_stress = keep_stress
-
-    @staticmethod
-    def name():
-        return "gruut"
-
-    def phonemize_gruut(self, text: str, separator: str = "|", tie=False) -> str:  # pylint: disable=unused-argument
-        """Convert input text to phonemes.
-
-        Gruut phonemizes the given `str` by seperating each phoneme character with `separator`, even for characters
-        that constitude a single sound.
-
-        It doesn't affect 🐸TTS since it individually converts each character to token IDs.
-
-        Examples::
-            "hello how are you today?" -> `h|ɛ|l|o|ʊ| h|a|ʊ| ɑ|ɹ| j|u| t|ə|d|e|ɪ`
-
-        Args:
-            text (str):
-                Text to be converted to phonemes.
-
-            tie (bool, optional) : When True use a '͡' character between
-                consecutive characters of a single phoneme. Else separate phoneme
-                with '_'. This option requires espeak>=1.49. Default to False.
-        """
-        ph_list = []
-        for sentence in gruut.sentences(text, lang=self.language, espeak=self.use_espeak_phonemes):
-            for word in sentence:
-                if word.is_break:
-                    # Use actual character for break phoneme (e.g., comma)
-                    if ph_list:
-                        # Join with previous word
-                        ph_list[-1].append(word.text)
-                    else:
-                        # First word is punctuation
-                        ph_list.append([word.text])
-                elif word.phonemes:
-                    # Add phonemes for word
-                    word_phonemes = []
-
-                    for word_phoneme in word.phonemes:
-                        if not self.keep_stress:
-                            # Remove primary/secondary stress
-                            word_phoneme = IPA.without_stress(word_phoneme)
-
-                        word_phoneme = word_phoneme.translate(GRUUT_TRANS_TABLE)
-
-                        if word_phoneme:
-                            # Flatten phonemes
-                            word_phonemes.extend(word_phoneme)
-
-                    if word_phonemes:
-                        ph_list.append(word_phonemes)
-
-        ph_words = [separator.join(word_phonemes) for word_phonemes in ph_list]
-        ph = f"{separator} ".join(ph_words)
-        return ph
-
-    def _phonemize(self, text, separator):
-        return self.phonemize_gruut(text, separator, tie=False)
-
-    def is_supported_language(self, language):
-        """Returns True if `language` is supported by the backend"""
-        return gruut.is_language_supported(language)
-
-    @staticmethod
-    def supported_languages() -> List:
-        """Get a dictionary of supported languages.
-
-        Returns:
-            List: List of language codes.
-        """
-        return list(gruut.get_supported_languages())
-
-    def version(self):
-        """Get the version of the used backend.
-
-        Returns:
-            str: Version of the used backend.
-        """
-        return gruut.__version__
-
-    @classmethod
-    def is_available(cls):
-        """Return true if ESpeak is available else false"""
-        return importlib.util.find_spec("gruut") is not None
-
-
-if __name__ == "__main__":
-    from es_to_ipa import es2ipa
-    import json
-
-    e = Gruut(language="es-es", keep_puncs=True, keep_stress=True, use_espeak_phonemes=True)
-    symbols = [
-        "_",
-        ",",
-        ".",
-        "!",
-        "?",
-        "-",
-        "~",
-        "\u2026",
-        "N",
-        "Q",
-        "a",
-        "b",
-        "d",
-        "e",
-        "f",
-        "g",
-        "h",
-        "i",
-        "j",
-        "k",
-        "l",
-        "m",
-        "n",
-        "o",
-        "p",
-        "s",
-        "t",
-        "u",
-        "v",
-        "w",
-        "x",
-        "y",
-        "z",
-        "\u0251",
-        "\u00e6",
-        "\u0283",
-        "\u0291",
-        "\u00e7",
-        "\u026f",
-        "\u026a",
-        "\u0254",
-        "\u025b",
-        "\u0279",
-        "\u00f0",
-        "\u0259",
-        "\u026b",
-        "\u0265",
-        "\u0278",
-        "\u028a",
-        "\u027e",
-        "\u0292",
-        "\u03b8",
-        "\u03b2",
-        "\u014b",
-        "\u0266",
-        "\u207c",
-        "\u02b0",
-        "`",
-        "^",
-        "#",
-        "*",
-        "=",
-        "\u02c8",
-        "\u02cc",
-        "\u2192",
-        "\u2193",
-        "\u2191",
-        " ",
-    ]
-    with open('./text/es_phonemizer/spanish_text.txt', 'r') as f:
-        lines = f.readlines()
-    
-
-    used_sym = []
-    not_existed_sym = []
-    phonemes = []
-
-    for line in lines[:400]:
-        text = line.split('|')[-1].strip()
-        ipa = es2ipa(text)
-        phonemes.append(ipa + '\n')
-        for s in ipa:
-            if s not in symbols:
-                if s not in not_existed_sym:
-                    print(f'not_existed char: {s}')
-                    not_existed_sym.append(s)
-            else:
-                if s not in used_sym:
-                    # print(f'used char: {s}')
-                    used_sym.append(s)
-    
-    print(used_sym)
-    print(not_existed_sym)
-
-
-    with open('./text/es_phonemizer/es_symbols.txt', 'w') as g:
-        g.writelines(symbols + not_existed_sym)
-        
-    with open('./text/es_phonemizer/example_ipa.txt', 'w') as g:
-        g.writelines(phonemes)
-        
-    data = {'symbols': symbols + not_existed_sym}
-    with open('./text/es_phonemizer/es_symbols_v2.json', 'w') as f:
-        json.dump(data, f, indent=4)
-
-
-
-
-

melo/text/es_phonemizer/punctuation.py

@@ -1,174 +0,0 @@
-import collections
-import re
-from enum import Enum
-
-import six
-
-_DEF_PUNCS = ';:,.!?¡¿—…"«»“”'
-
-_PUNC_IDX = collections.namedtuple("_punc_index", ["punc", "position"])
-
-
-class PuncPosition(Enum):
-    """Enum for the punctuations positions"""
-
-    BEGIN = 0
-    END = 1
-    MIDDLE = 2
-    ALONE = 3
-
-
-class Punctuation:
-    """Handle punctuations in text.
-
-    Just strip punctuations from text or strip and restore them later.
-
-    Args:
-        puncs (str): The punctuations to be processed. Defaults to `_DEF_PUNCS`.
-
-    Example:
-        >>> punc = Punctuation()
-        >>> punc.strip("This is. example !")
-        'This is example'
-
-        >>> text_striped, punc_map = punc.strip_to_restore("This is. example !")
-        >>> ' '.join(text_striped)
-        'This is example'
-
-        >>> text_restored = punc.restore(text_striped, punc_map)
-        >>> text_restored[0]
-        'This is. example !'
-    """
-
-    def __init__(self, puncs: str = _DEF_PUNCS):
-        self.puncs = puncs
-
-    @staticmethod
-    def default_puncs():
-        """Return default set of punctuations."""
-        return _DEF_PUNCS
-
-    @property
-    def puncs(self):
-        return self._puncs
-
-    @puncs.setter
-    def puncs(self, value):
-        if not isinstance(value, six.string_types):
-            raise ValueError("[!] Punctuations must be of type str.")
-        self._puncs = "".join(list(dict.fromkeys(list(value))))  # remove duplicates without changing the oreder
-        self.puncs_regular_exp = re.compile(rf"(\s*[{re.escape(self._puncs)}]+\s*)+")
-
-    def strip(self, text):
-        """Remove all the punctuations by replacing with `space`.
-
-        Args:
-            text (str): The text to be processed.
-
-        Example::
-
-            "This is. example !" -> "This is example "
-        """
-        return re.sub(self.puncs_regular_exp, " ", text).rstrip().lstrip()
-
-    def strip_to_restore(self, text):
-        """Remove punctuations from text to restore them later.
-
-        Args:
-            text (str): The text to be processed.
-
-        Examples ::
-
-            "This is. example !" -> [["This is", "example"], [".", "!"]]
-
-        """
-        text, puncs = self._strip_to_restore(text)
-        return text, puncs
-
-    def _strip_to_restore(self, text):
-        """Auxiliary method for Punctuation.preserve()"""
-        matches = list(re.finditer(self.puncs_regular_exp, text))
-        if not matches:
-            return [text], []
-        # the text is only punctuations
-        if len(matches) == 1 and matches[0].group() == text:
-            return [], [_PUNC_IDX(text, PuncPosition.ALONE)]
-        # build a punctuation map to be used later to restore punctuations
-        puncs = []
-        for match in matches:
-            position = PuncPosition.MIDDLE
-            if match == matches[0] and text.startswith(match.group()):
-                position = PuncPosition.BEGIN
-            elif match == matches[-1] and text.endswith(match.group()):
-                position = PuncPosition.END
-            puncs.append(_PUNC_IDX(match.group(), position))
-        # convert str text to a List[str], each item is separated by a punctuation
-        splitted_text = []
-        for idx, punc in enumerate(puncs):
-            split = text.split(punc.punc)
-            prefix, suffix = split[0], punc.punc.join(split[1:])
-            splitted_text.append(prefix)
-            # if the text does not end with a punctuation, add it to the last item
-            if idx == len(puncs) - 1 and len(suffix) > 0:
-                splitted_text.append(suffix)
-            text = suffix
-        while splitted_text[0] == '':
-            splitted_text = splitted_text[1:]
-        return splitted_text, puncs
-
-    @classmethod
-    def restore(cls, text, puncs):
-        """Restore punctuation in a text.
-
-        Args:
-            text (str): The text to be processed.
-            puncs (List[str]): The list of punctuations map to be used for restoring.
-
-        Examples ::
-
-            ['This is', 'example'], ['.', '!'] -> "This is. example!"
-
-        """
-        return cls._restore(text, puncs, 0)
-
-    @classmethod
-    def _restore(cls, text, puncs, num):  # pylint: disable=too-many-return-statements
-        """Auxiliary method for Punctuation.restore()"""
-        if not puncs:
-            return text
-
-        # nothing have been phonemized, returns the puncs alone
-        if not text:
-            return ["".join(m.punc for m in puncs)]
-
-        current = puncs[0]
-
-        if current.position == PuncPosition.BEGIN:
-            return cls._restore([current.punc + text[0]] + text[1:], puncs[1:], num)
-
-        if current.position == PuncPosition.END:
-            return [text[0] + current.punc] + cls._restore(text[1:], puncs[1:], num + 1)
-
-        if current.position == PuncPosition.ALONE:
-            return [current.mark] + cls._restore(text, puncs[1:], num + 1)
-
-        # POSITION == MIDDLE
-        if len(text) == 1:  # pragma: nocover
-            # a corner case where the final part of an intermediate
-            # mark (I) has not been phonemized
-            return cls._restore([text[0] + current.punc], puncs[1:], num)
-
-        return cls._restore([text[0] + current.punc + text[1]] + text[2:], puncs[1:], num)
-
-
-# if __name__ == "__main__":
-#     punc = Punctuation()
-#     text = "This is. This is, example!"
-
-#     print(punc.strip(text))
-
-#     split_text, puncs = punc.strip_to_restore(text)
-#     print(split_text, " ---- ", puncs)
-
-#     restored_text = punc.restore(split_text, puncs)
-#     print(restored_text)

melo/text/es_phonemizer/spanish_symbols.txt

@@ -1 +0,0 @@
-dˌaβˈiðkopeɾfjl unθsbmtʃwɛxɪŋʊɣɡrɲʝʎː

melo/text/es_phonemizer/test.ipynb

@@ -1,124 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ImportError",
-     "evalue": "attempted relative import with no known parent package",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
-      "\u001b[1;32m/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb Cell 1\u001b[0m line \u001b[0;36m5\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcatams4/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb#W0sdnNjb2RlLXJlbW90ZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mos\u001b[39;00m\u001b[39m,\u001b[39m \u001b[39msys\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcatams4/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb#W0sdnNjb2RlLXJlbW90ZQ%3D%3D?line=3'>4</a>\u001b[0m sys\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mappend(\u001b[39m'\u001b[39m\u001b[39m/home/xumin/workspace/MyShell-VC-Training/text/es_phonemizer/\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bcatams4/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb#W0sdnNjb2RlLXJlbW90ZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mes_to_ipa\u001b[39;00m \u001b[39mimport\u001b[39;00m es2ipa\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcatams4/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb#W0sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39msplit_sentences_en\u001b[39m(text, min_len\u001b[39m=\u001b[39m\u001b[39m10\u001b[39m):\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bcatams4/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb#W0sdnNjb2RlLXJlbW90ZQ%3D%3D?line=9'>10</a>\u001b[0m   \u001b[39m# 将文本中的换行符、空格和制表符替换为空格\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bcatams4/home/xumin/workspace/Bert-VITS2/text/es_phonemizer/test.ipynb#W0sdnNjb2RlLXJlbW90ZQ%3D%3D?line=10'>11</a>\u001b[0m   text \u001b[39m=\u001b[39m re\u001b[39m.\u001b[39msub(\u001b[39m'\u001b[39m\u001b[39m[\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\\t\u001b[39;00m\u001b[39m ]+\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m \u001b[39m\u001b[39m'\u001b[39m, text)\n",
-      "File \u001b[0;32m/data/workspace/Bert-VITS2/text/es_phonemizer/es_to_ipa.py:1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39mcleaner\u001b[39;00m \u001b[39mimport\u001b[39;00m spanish_cleaners\n\u001b[1;32m      2\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39mgruut_wrapper\u001b[39;00m \u001b[39mimport\u001b[39;00m Gruut\n\u001b[1;32m      4\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mes2ipa\u001b[39m(text):\n",
-      "\u001b[0;31mImportError\u001b[0m: attempted relative import with no known parent package"
-     ]
-    }
-   ],
-   "source": [
-    "import re\n",
-    "import os\n",
-    "import os, sys\n",
-    "sys.path.append('/home/xumin/workspace/MyShell-VC-Training/text/es_phonemizer/')\n",
-    "from es_to_ipa import es2ipa\n",
-    "\n",
-    "\n",
-    "\n",
-    "def split_sentences_en(text, min_len=10):\n",
-    "  # 将文本中的换行符、空格和制表符替换为空格\n",
-    "  text = re.sub('[\\n\\t ]+', ' ', text)\n",
-    "  # 在标点符号后添加一个空格\n",
-    "  text = re.sub('([¿—¡])', r'\\1 $#!', text)\n",
-    "  # 分隔句子并去除前后空格\n",
-    "  \n",
-    "  sentences = [s.strip() for s in text.split(' $#!')]\n",
-    "  if len(sentences[-1]) == 0: del sentences[-1]\n",
-    "\n",
-    "  new_sentences = []\n",
-    "  new_sent = []\n",
-    "  for ind, sent in enumerate(sentences):\n",
-    "    if sent in ['¿', '—', '¡']:\n",
-    "      new_sent.append(sent)\n",
-    "    else:\n",
-    "      new_sent.append(es2ipa(sent))\n",
-    "    \n",
-    "  \n",
-    "  new_sentences = ''.join(new_sent)\n",
-    "\n",
-    "  return new_sentences"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'—¿aβˈeis estˈaðo kasˈaða alɣˈuna bˈeθ?'"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "split_sentences_en('—¿Habéis estado casada alguna vez?')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'aβˈeis estˈaðo kasˈaða alɣˈuna bˈeθ?'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "es2ipa('—¿Habéis estado casada alguna vez?')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.18"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

melo/text/fr_phonemizer/base.py

@@ -1,140 +0,0 @@
-import abc
-from typing import List, Tuple
-
-from .punctuation import Punctuation
-
-
-class BasePhonemizer(abc.ABC):
-    """Base phonemizer class
-
-    Phonemization follows the following steps:
-        1. Preprocessing:
-            - remove empty lines
-            - remove punctuation
-            - keep track of punctuation marks
-
-        2. Phonemization:
-            - convert text to phonemes
-
-        3. Postprocessing:
-            - join phonemes
-            - restore punctuation marks
-
-    Args:
-        language (str):
-            Language used by the phonemizer.
-
-        punctuations (List[str]):
-            List of punctuation marks to be preserved.
-
-        keep_puncs (bool):
-            Whether to preserve punctuation marks or not.
-    """
-
-    def __init__(self, language, punctuations=Punctuation.default_puncs(), keep_puncs=False):
-        # ensure the backend is installed on the system
-        if not self.is_available():
-            raise RuntimeError("{} not installed on your system".format(self.name()))  # pragma: nocover
-
-        # ensure the backend support the requested language
-        self._language = self._init_language(language)
-
-        # setup punctuation processing
-        self._keep_puncs = keep_puncs
-        self._punctuator = Punctuation(punctuations)
-
-    def _init_language(self, language):
-        """Language initialization
-
-        This method may be overloaded in child classes (see Segments backend)
-
-        """
-        if not self.is_supported_language(language):
-            raise RuntimeError(f'language "{language}" is not supported by the ' f"{self.name()} backend")
-        return language
-
-    @property
-    def language(self):
-        """The language code configured to be used for phonemization"""
-        return self._language
-
-    @staticmethod
-    @abc.abstractmethod
-    def name():
-        """The name of the backend"""
-        ...
-
-    @classmethod
-    @abc.abstractmethod
-    def is_available(cls):
-        """Returns True if the backend is installed, False otherwise"""
-        ...
-
-    @classmethod
-    @abc.abstractmethod
-    def version(cls):
-        """Return the backend version as a tuple (major, minor, patch)"""
-        ...
-
-    @staticmethod
-    @abc.abstractmethod
-    def supported_languages():
-        """Return a dict of language codes -> name supported by the backend"""
-        ...
-
-    def is_supported_language(self, language):
-        """Returns True if `language` is supported by the backend"""
-        return language in self.supported_languages()
-
-    @abc.abstractmethod
-    def _phonemize(self, text, separator):
-        """The main phonemization method"""
-
-    def _phonemize_preprocess(self, text) -> Tuple[List[str], List]:
-        """Preprocess the text before phonemization
-
-        1. remove spaces
-        2. remove punctuation
-
-        Override this if you need a different behaviour
-        """
-        text = text.strip()
-        if self._keep_puncs:
-            # a tuple (text, punctuation marks)
-            return self._punctuator.strip_to_restore(text)
-        return [self._punctuator.strip(text)], []
-
-    def _phonemize_postprocess(self, phonemized, punctuations) -> str:
-        """Postprocess the raw phonemized output
-
-        Override this if you need a different behaviour
-        """
-        if self._keep_puncs:
-            return self._punctuator.restore(phonemized, punctuations)[0]
-        return phonemized[0]
-
-    def phonemize(self, text: str, separator="|", language: str = None) -> str:  # pylint: disable=unused-argument
-        """Returns the `text` phonemized for the given language
-
-        Args:
-            text (str):
-                Text to be phonemized.
-
-            separator (str):
-                string separator used between phonemes. Default to '_'.
-
-        Returns:
-            (str): Phonemized text
-        """
-        text, punctuations = self._phonemize_preprocess(text)
-        phonemized = []
-        for t in text:
-            p = self._phonemize(t, separator)
-            phonemized.append(p)
-        phonemized = self._phonemize_postprocess(phonemized, punctuations)
-        return phonemized
-
-    def print_logs(self, level: int = 0):
-        indent = "\t" * level
-        print(f"{indent}| > phoneme language: {self.language}")
-        print(f"{indent}| > phoneme backend: {self.name()}")

melo/text/fr_phonemizer/cleaner.py

@@ -1,122 +0,0 @@
-"""Set of default text cleaners"""
-# TODO: pick the cleaner for languages dynamically
-
-import re
-from .french_abbreviations import abbreviations_fr
-
-# Regular expression matching whitespace:
-_whitespace_re = re.compile(r"\s+")
-
-
-rep_map = {
-    "：": ",",
-    "；": ",",
-    "，": ",",
-    "。": ".",
-    "！": "!",
-    "？": "?",
-    "\n": ".",
-    "·": ",",
-    "、": ",",
-    "...": ".",
-    "…": ".",
-    "$": ".",
-    "“": "",
-    "”": "",
-    "‘": "",
-    "’": "",
-    "（": "",
-    "）": "",
-    "(": "",
-    ")": "",
-    "《": "",
-    "》": "",
-    "【": "",
-    "】": "",
-    "[": "",
-    "]": "",
-    "—": "",
-    "～": "-",
-    "~": "-",
-    "「": "",
-    "」": "",
-    "¿" : "",
-    "¡" : ""
-}
-
-
-def replace_punctuation(text):
-    pattern = re.compile("|".join(re.escape(p) for p in rep_map.keys()))
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-    return replaced_text
-
-def expand_abbreviations(text, lang="fr"):
-    if lang == "fr":
-        _abbreviations = abbreviations_fr
-    for regex, replacement in _abbreviations:
-        text = re.sub(regex, replacement, text)
-    return text
-
-
-def lowercase(text):
-    return text.lower()
-
-
-def collapse_whitespace(text):
-    return re.sub(_whitespace_re, " ", text).strip()
-
-def remove_punctuation_at_begin(text):
-    return re.sub(r'^[,.!?]+', '', text)
-
-def remove_aux_symbols(text):
-    text = re.sub(r"[\<\>\(\)\[\]\"\«\»]+", "", text)
-    return text
-
-
-def replace_symbols(text, lang="en"):
-    """Replace symbols based on the lenguage tag.
-
-    Args:
-      text:
-       Input text.
-      lang:
-        Lenguage identifier. ex: "en", "fr", "pt", "ca".
-
-    Returns:
-      The modified text
-      example:
-        input args:
-            text: "si l'avi cau, diguem-ho"
-            lang: "ca"
-        Output:
-            text: "si lavi cau, diguemho"
-    """
-    text = text.replace(";", ",")
-    text = text.replace("-", " ") if lang != "ca" else text.replace("-", "")
-    text = text.replace(":", ",")
-    if lang == "en":
-        text = text.replace("&", " and ")
-    elif lang == "fr":
-        text = text.replace("&", " et ")
-    elif lang == "pt":
-        text = text.replace("&", " e ")
-    elif lang == "ca":
-        text = text.replace("&", " i ")
-        text = text.replace("'", "")
-    elif lang== "es":
-        text=text.replace("&","y")
-        text = text.replace("'", "")
-    return text
-
-def french_cleaners(text):
-    """Pipeline for French text. There is no need to expand numbers, phonemizer already does that"""
-    text = expand_abbreviations(text, lang="fr")
-    # text = lowercase(text) # as we use the cased bert
-    text = replace_punctuation(text)
-    text = replace_symbols(text, lang="fr")
-    text = remove_aux_symbols(text)
-    text = remove_punctuation_at_begin(text)
-    text = collapse_whitespace(text)
-    text = re.sub(r'([^\.,!\?\-…])$', r'\1.', text)
-    return text
-

melo/text/fr_phonemizer/en_symbols.json

@@ -1,78 +0,0 @@
-{"symbols": [
-    "_",
-    ",",
-    ".",
-    "!",
-    "?",
-    "-",
-    "~",
-    "\u2026",
-    "N",
-    "Q",
-    "a",
-    "b",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "\u0251",
-    "\u00e6",
-    "\u0283",
-    "\u0291",
-    "\u00e7",
-    "\u026f",
-    "\u026a",
-    "\u0254",
-    "\u025b",
-    "\u0279",
-    "\u00f0",
-    "\u0259",
-    "\u026b",
-    "\u0265",
-    "\u0278",
-    "\u028a",
-    "\u027e",
-    "\u0292",
-    "\u03b8",
-    "\u03b2",
-    "\u014b",
-    "\u0266",
-    "\u207c",
-    "\u02b0",
-    "`",
-    "^",
-    "#",
-    "*",
-    "=",
-    "\u02c8",
-    "\u02cc",
-    "\u2192",
-    "\u2193",
-    "\u2191",
-    " ",
-    "ɣ",
-    "ɡ", 
-    "r", 
-    "ɲ", 
-    "ʝ", 
-    "ʎ",
-    "ː"
-  ]
-}

melo/text/fr_phonemizer/fr_symbols.json

@@ -1,89 +0,0 @@
-{
-    "symbols": [
-        "_",
-        ",",
-        ".",
-        "!",
-        "?",
-        "-",
-        "~",
-        "\u2026",
-        "N",
-        "Q",
-        "a",
-        "b",
-        "d",
-        "e",
-        "f",
-        "g",
-        "h",
-        "i",
-        "j",
-        "k",
-        "l",
-        "m",
-        "n",
-        "o",
-        "p",
-        "s",
-        "t",
-        "u",
-        "v",
-        "w",
-        "x",
-        "y",
-        "z",
-        "\u0251",
-        "\u00e6",
-        "\u0283",
-        "\u0291",
-        "\u00e7",
-        "\u026f",
-        "\u026a",
-        "\u0254",
-        "\u025b",
-        "\u0279",
-        "\u00f0",
-        "\u0259",
-        "\u026b",
-        "\u0265",
-        "\u0278",
-        "\u028a",
-        "\u027e",
-        "\u0292",
-        "\u03b8",
-        "\u03b2",
-        "\u014b",
-        "\u0266",
-        "\u207c",
-        "\u02b0",
-        "`",
-        "^",
-        "#",
-        "*",
-        "=",
-        "\u02c8",
-        "\u02cc",
-        "\u2192",
-        "\u2193",
-        "\u2191",
-        " ",
-        "\u0263",
-        "\u0261",
-        "r",
-        "\u0272",
-        "\u029d",
-        "\u028e",
-        "\u02d0",
-        
-        "\u0303",
-        "\u0153",
-        "\u00f8",
-        "\u0281",
-        "\u0252",
-        "\u028c",
-        "\u2014",
-        "\u025c",
-        "\u0250"
-    ]
-}

melo/text/fr_phonemizer/fr_to_ipa.py

@@ -1,30 +0,0 @@
-from .cleaner import french_cleaners
-from .gruut_wrapper import Gruut
-
-
-def remove_consecutive_t(input_str):
-    result = []
-    count = 0
-
-    for char in input_str:
-        if char == 't':
-            count += 1
-        else:
-            if count < 3:  
-                result.extend(['t'] * count)
-            count = 0
-            result.append(char)
-
-    if count < 3:
-        result.extend(['t'] * count)
-
-    return ''.join(result)
-
-def fr2ipa(text):
-    e = Gruut(language="fr-fr", keep_puncs=True, keep_stress=True, use_espeak_phonemes=True)
-    # text = french_cleaners(text)
-    phonemes = e.phonemize(text, separator="")
-    # print(phonemes)
-    phonemes = remove_consecutive_t(phonemes)
-    # print(phonemes)
-    return phonemes

melo/text/fr_phonemizer/french_abbreviations.py

@@ -1,48 +0,0 @@
-import re
-
-# List of (regular expression, replacement) pairs for abbreviations in french:
-abbreviations_fr = [
-    (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
-    for x in [
-        ("M", "monsieur"),
-        ("Mlle", "mademoiselle"),
-        ("Mlles", "mesdemoiselles"),
-        ("Mme", "Madame"),
-        ("Mmes", "Mesdames"),
-        ("N.B", "nota bene"),
-        ("M", "monsieur"),
-        ("p.c.q", "parce que"),
-        ("Pr", "professeur"),
-        ("qqch", "quelque chose"),
-        ("rdv", "rendez-vous"),
-        ("max", "maximum"),
-        ("min", "minimum"),
-        ("no", "numéro"),
-        ("adr", "adresse"),
-        ("dr", "docteur"),
-        ("st", "saint"),
-        ("co", "companie"),
-        ("jr", "junior"),
-        ("sgt", "sergent"),
-        ("capt", "capitain"),
-        ("col", "colonel"),
-        ("av", "avenue"),
-        ("av. J.-C", "avant Jésus-Christ"),
-        ("apr. J.-C", "après Jésus-Christ"),
-        ("art", "article"),
-        ("boul", "boulevard"),
-        ("c.-à-d", "c’est-à-dire"),
-        ("etc", "et cetera"),
-        ("ex", "exemple"),
-        ("excl", "exclusivement"),
-        ("boul", "boulevard"),
-    ]
-] + [
-    (re.compile("\\b%s" % x[0]), x[1])
-    for x in [
-        ("Mlle", "mademoiselle"),
-        ("Mlles", "mesdemoiselles"),
-        ("Mme", "Madame"),
-        ("Mmes", "Mesdames"),
-    ]
-]

melo/text/fr_phonemizer/french_symbols.txt

@@ -1 +0,0 @@
-_,.!?-~…NQabdefghijklmnopstuvwxyzɑæʃʑçɯɪɔɛɹðəɫɥɸʊɾʒθβŋɦ⁼ʰ`^#*=ˈˌ→↓↑ ɣɡrɲʝʎː̃œøʁɒʌ—ɜɐ

melo/text/fr_phonemizer/gruut_wrapper.py

@@ -1,258 +0,0 @@
-import importlib
-from typing import List
-
-import gruut
-from gruut_ipa import IPA # pip install gruut_ipa
-
-from .base import BasePhonemizer
-from .punctuation import Punctuation
-
-# Table for str.translate to fix gruut/TTS phoneme mismatch
-GRUUT_TRANS_TABLE = str.maketrans("g", "ɡ")
-
-
-class Gruut(BasePhonemizer):
-    """Gruut wrapper for G2P
-
-    Args:
-        language (str):
-            Valid language code for the used backend.
-
-        punctuations (str):
-            Characters to be treated as punctuation. Defaults to `Punctuation.default_puncs()`.
-
-        keep_puncs (bool):
-            If true, keep the punctuations after phonemization. Defaults to True.
-
-        use_espeak_phonemes (bool):
-            If true, use espeak lexicons instead of default Gruut lexicons. Defaults to False.
-
-        keep_stress (bool):
-            If true, keep the stress characters after phonemization. Defaults to False.
-
-    Example:
-
-        >>> from TTS.tts.utils.text.phonemizers.gruut_wrapper import Gruut
-        >>> phonemizer = Gruut('en-us')
-        >>> phonemizer.phonemize("Be a voice, not an! echo?", separator="|")
-        'b|i| ə| v|ɔ|ɪ|s, n|ɑ|t| ə|n! ɛ|k|o|ʊ?'
-    """
-
-    def __init__(
-        self,
-        language: str,
-        punctuations=Punctuation.default_puncs(),
-        keep_puncs=True,
-        use_espeak_phonemes=False,
-        keep_stress=False,
-    ):
-        super().__init__(language, punctuations=punctuations, keep_puncs=keep_puncs)
-        self.use_espeak_phonemes = use_espeak_phonemes
-        self.keep_stress = keep_stress
-
-    @staticmethod
-    def name():
-        return "gruut"
-
-    def phonemize_gruut(self, text: str, separator: str = "|", tie=False) -> str:  # pylint: disable=unused-argument
-        """Convert input text to phonemes.
-
-        Gruut phonemizes the given `str` by seperating each phoneme character with `separator`, even for characters
-        that constitude a single sound.
-
-        It doesn't affect 🐸TTS since it individually converts each character to token IDs.
-
-        Examples::
-            "hello how are you today?" -> `h|ɛ|l|o|ʊ| h|a|ʊ| ɑ|ɹ| j|u| t|ə|d|e|ɪ`
-
-        Args:
-            text (str):
-                Text to be converted to phonemes.
-
-            tie (bool, optional) : When True use a '͡' character between
-                consecutive characters of a single phoneme. Else separate phoneme
-                with '_'. This option requires espeak>=1.49. Default to False.
-        """
-        ph_list = []
-        for sentence in gruut.sentences(text, lang=self.language, espeak=self.use_espeak_phonemes):
-            for word in sentence:
-                if word.is_break:
-                    # Use actual character for break phoneme (e.g., comma)
-                    if ph_list:
-                        # Join with previous word
-                        ph_list[-1].append(word.text)
-                    else:
-                        # First word is punctuation
-                        ph_list.append([word.text])
-                elif word.phonemes:
-                    # Add phonemes for word
-                    word_phonemes = []
-
-                    for word_phoneme in word.phonemes:
-                        if not self.keep_stress:
-                            # Remove primary/secondary stress
-                            word_phoneme = IPA.without_stress(word_phoneme)
-
-                        word_phoneme = word_phoneme.translate(GRUUT_TRANS_TABLE)
-
-                        if word_phoneme:
-                            # Flatten phonemes
-                            word_phonemes.extend(word_phoneme)
-
-                    if word_phonemes:
-                        ph_list.append(word_phonemes)
-
-        ph_words = [separator.join(word_phonemes) for word_phonemes in ph_list]
-        ph = f"{separator} ".join(ph_words)
-        return ph
-
-    def _phonemize(self, text, separator):
-        return self.phonemize_gruut(text, separator, tie=False)
-
-    def is_supported_language(self, language):
-        """Returns True if `language` is supported by the backend"""
-        return gruut.is_language_supported(language)
-
-    @staticmethod
-    def supported_languages() -> List:
-        """Get a dictionary of supported languages.
-
-        Returns:
-            List: List of language codes.
-        """
-        return list(gruut.get_supported_languages())
-
-    def version(self):
-        """Get the version of the used backend.
-
-        Returns:
-            str: Version of the used backend.
-        """
-        return gruut.__version__
-
-    @classmethod
-    def is_available(cls):
-        """Return true if ESpeak is available else false"""
-        return importlib.util.find_spec("gruut") is not None
-
-
-if __name__ == "__main__":
-    from cleaner import french_cleaners
-    import json
-
-    e = Gruut(language="fr-fr", keep_puncs=True, keep_stress=True, use_espeak_phonemes=True)
-    symbols = [  # en + sp
-        "_",
-        ",",
-        ".",
-        "!",
-        "?",
-        "-",
-        "~",
-        "\u2026",
-        "N",
-        "Q",
-        "a",
-        "b",
-        "d",
-        "e",
-        "f",
-        "g",
-        "h",
-        "i",
-        "j",
-        "k",
-        "l",
-        "m",
-        "n",
-        "o",
-        "p",
-        "s",
-        "t",
-        "u",
-        "v",
-        "w",
-        "x",
-        "y",
-        "z",
-        "\u0251",
-        "\u00e6",
-        "\u0283",
-        "\u0291",
-        "\u00e7",
-        "\u026f",
-        "\u026a",
-        "\u0254",
-        "\u025b",
-        "\u0279",
-        "\u00f0",
-        "\u0259",
-        "\u026b",
-        "\u0265",
-        "\u0278",
-        "\u028a",
-        "\u027e",
-        "\u0292",
-        "\u03b8",
-        "\u03b2",
-        "\u014b",
-        "\u0266",
-        "\u207c",
-        "\u02b0",
-        "`",
-        "^",
-        "#",
-        "*",
-        "=",
-        "\u02c8",
-        "\u02cc",
-        "\u2192",
-        "\u2193",
-        "\u2191",
-        " ",
-        "ɣ",
-        "ɡ", 
-        "r", 
-        "ɲ", 
-        "ʝ", 
-        "ʎ",
-        "ː"
-    ]
-    with open('/home/xumin/workspace/VITS-Training-Multiling/230715_fr/metadata.txt', 'r') as f:
-        lines = f.readlines()
-    
-
-    used_sym = []
-    not_existed_sym = []
-    phonemes = []
-
-    for line in lines:
-        text = line.split('|')[-1].strip()
-        text = french_cleaners(text)
-        ipa =  e.phonemize(text, separator="")
-        phonemes.append(ipa)
-        for s in ipa:
-            if s not in symbols:
-                if s not in not_existed_sym:
-                    print(f'not_existed char: {s}')
-                    not_existed_sym.append(s)
-            else:
-                if s not in used_sym:
-                    # print(f'used char: {s}')
-                    used_sym.append(s)
-    
-    print(used_sym)
-    print(not_existed_sym)
-
-
-    with open('./text/fr_phonemizer/french_symbols.txt', 'w') as g:
-        g.writelines(symbols + not_existed_sym)
-        
-    with open('./text/fr_phonemizer/example_ipa.txt', 'w') as g:
-        g.writelines(phonemes)
-
-    data = {'symbols': symbols + not_existed_sym}
-
-    with open('./text/fr_phonemizer/fr_symbols.json', 'w') as f:
-        json.dump(data, f, indent=4)
-

melo/text/fr_phonemizer/punctuation.py

@@ -1,172 +0,0 @@
-import collections
-import re
-from enum import Enum
-
-import six
-
-_DEF_PUNCS = ';:,.!?¡¿—…"«»“”'
-
-_PUNC_IDX = collections.namedtuple("_punc_index", ["punc", "position"])
-
-
-class PuncPosition(Enum):
-    """Enum for the punctuations positions"""
-
-    BEGIN = 0
-    END = 1
-    MIDDLE = 2
-    ALONE = 3
-
-
-class Punctuation:
-    """Handle punctuations in text.
-
-    Just strip punctuations from text or strip and restore them later.
-
-    Args:
-        puncs (str): The punctuations to be processed. Defaults to `_DEF_PUNCS`.
-
-    Example:
-        >>> punc = Punctuation()
-        >>> punc.strip("This is. example !")
-        'This is example'
-
-        >>> text_striped, punc_map = punc.strip_to_restore("This is. example !")
-        >>> ' '.join(text_striped)
-        'This is example'
-
-        >>> text_restored = punc.restore(text_striped, punc_map)
-        >>> text_restored[0]
-        'This is. example !'
-    """
-
-    def __init__(self, puncs: str = _DEF_PUNCS):
-        self.puncs = puncs
-
-    @staticmethod
-    def default_puncs():
-        """Return default set of punctuations."""
-        return _DEF_PUNCS
-
-    @property
-    def puncs(self):
-        return self._puncs
-
-    @puncs.setter
-    def puncs(self, value):
-        if not isinstance(value, six.string_types):
-            raise ValueError("[!] Punctuations must be of type str.")
-        self._puncs = "".join(list(dict.fromkeys(list(value))))  # remove duplicates without changing the oreder
-        self.puncs_regular_exp = re.compile(rf"(\s*[{re.escape(self._puncs)}]+\s*)+")
-
-    def strip(self, text):
-        """Remove all the punctuations by replacing with `space`.
-
-        Args:
-            text (str): The text to be processed.
-
-        Example::
-
-            "This is. example !" -> "This is example "
-        """
-        return re.sub(self.puncs_regular_exp, " ", text).rstrip().lstrip()
-
-    def strip_to_restore(self, text):
-        """Remove punctuations from text to restore them later.
-
-        Args:
-            text (str): The text to be processed.
-
-        Examples ::
-
-            "This is. example !" -> [["This is", "example"], [".", "!"]]
-
-        """
-        text, puncs = self._strip_to_restore(text)
-        return text, puncs
-
-    def _strip_to_restore(self, text):
-        """Auxiliary method for Punctuation.preserve()"""
-        matches = list(re.finditer(self.puncs_regular_exp, text))
-        if not matches:
-            return [text], []
-        # the text is only punctuations
-        if len(matches) == 1 and matches[0].group() == text:
-            return [], [_PUNC_IDX(text, PuncPosition.ALONE)]
-        # build a punctuation map to be used later to restore punctuations
-        puncs = []
-        for match in matches:
-            position = PuncPosition.MIDDLE
-            if match == matches[0] and text.startswith(match.group()):
-                position = PuncPosition.BEGIN
-            elif match == matches[-1] and text.endswith(match.group()):
-                position = PuncPosition.END
-            puncs.append(_PUNC_IDX(match.group(), position))
-        # convert str text to a List[str], each item is separated by a punctuation
-        splitted_text = []
-        for idx, punc in enumerate(puncs):
-            split = text.split(punc.punc)
-            prefix, suffix = split[0], punc.punc.join(split[1:])
-            splitted_text.append(prefix)
-            # if the text does not end with a punctuation, add it to the last item
-            if idx == len(puncs) - 1 and len(suffix) > 0:
-                splitted_text.append(suffix)
-            text = suffix
-        return splitted_text, puncs
-
-    @classmethod
-    def restore(cls, text, puncs):
-        """Restore punctuation in a text.
-
-        Args:
-            text (str): The text to be processed.
-            puncs (List[str]): The list of punctuations map to be used for restoring.
-
-        Examples ::
-
-            ['This is', 'example'], ['.', '!'] -> "This is. example!"
-
-        """
-        return cls._restore(text, puncs, 0)
-
-    @classmethod
-    def _restore(cls, text, puncs, num):  # pylint: disable=too-many-return-statements
-        """Auxiliary method for Punctuation.restore()"""
-        if not puncs:
-            return text
-
-        # nothing have been phonemized, returns the puncs alone
-        if not text:
-            return ["".join(m.punc for m in puncs)]
-
-        current = puncs[0]
-
-        if current.position == PuncPosition.BEGIN:
-            return cls._restore([current.punc + text[0]] + text[1:], puncs[1:], num)
-
-        if current.position == PuncPosition.END:
-            return [text[0] + current.punc] + cls._restore(text[1:], puncs[1:], num + 1)
-
-        if current.position == PuncPosition.ALONE:
-            return [current.mark] + cls._restore(text, puncs[1:], num + 1)
-
-        # POSITION == MIDDLE
-        if len(text) == 1:  # pragma: nocover
-            # a corner case where the final part of an intermediate
-            # mark (I) has not been phonemized
-            return cls._restore([text[0] + current.punc], puncs[1:], num)
-
-        return cls._restore([text[0] + current.punc + text[1]] + text[2:], puncs[1:], num)
-
-
-# if __name__ == "__main__":
-#     punc = Punctuation()
-#     text = "This is. This is, example!"
-
-#     print(punc.strip(text))
-
-#     split_text, puncs = punc.strip_to_restore(text)
-#     print(split_text, " ---- ", puncs)
-
-#     restored_text = punc.restore(split_text, puncs)
-#     print(restored_text)

melo/text/french.py

@@ -1,94 +0,0 @@
-import pickle
-import os
-import re
-
-from . import symbols
-from .fr_phonemizer import cleaner as fr_cleaner
-from .fr_phonemizer import fr_to_ipa
-from transformers import AutoTokenizer
-
-
-def distribute_phone(n_phone, n_word):
-    phones_per_word = [0] * n_word
-    for task in range(n_phone):
-        min_tasks = min(phones_per_word)
-        min_index = phones_per_word.index(min_tasks)
-        phones_per_word[min_index] += 1
-    return phones_per_word
-
-def text_normalize(text):
-    text = fr_cleaner.french_cleaners(text)
-    return text
-
-model_id = 'dbmdz/bert-base-french-europeana-cased'
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-
-def g2p(text, pad_start_end=True, tokenized=None):
-    if tokenized is None:
-        tokenized = tokenizer.tokenize(text)
-    # import pdb; pdb.set_trace()
-    phs = []
-    ph_groups = []
-    for t in tokenized:
-        if not t.startswith("#"):
-            ph_groups.append([t])
-        else:
-            ph_groups[-1].append(t.replace("#", ""))
-    
-    phones = []
-    tones = []
-    word2ph = []
-    # print(ph_groups)
-    for group in ph_groups:
-        w = "".join(group)
-        phone_len = 0
-        word_len = len(group)
-        if w == '[UNK]':
-            phone_list = ['UNK']
-        else:
-            phone_list = list(filter(lambda p: p != " ", fr_to_ipa.fr2ipa(w)))
-        
-        for ph in phone_list:
-            phones.append(ph)
-            tones.append(0)
-            phone_len += 1
-        aaa = distribute_phone(phone_len, word_len)
-        word2ph += aaa
-        # print(phone_list, aaa)
-        # print('=' * 10)
-
-    if pad_start_end:
-        phones = ["_"] + phones + ["_"]
-        tones = [0] + tones + [0]
-        word2ph = [1] + word2ph + [1]
-    return phones, tones, word2ph
-
-def get_bert_feature(text, word2ph, device=None):
-    from text import french_bert
-    return french_bert.get_bert_feature(text, word2ph, device=device)
-
-if __name__ == "__main__":
-    ori_text = 'Ce service gratuit est“”"" 【disponible》 en chinois 【simplifié] et autres 123'
-    # ori_text = "Ils essayaient vainement de faire comprendre à ma mère qu'avec les cent mille francs que m'avait laissé mon père,"
-    # print(ori_text)
-    text = text_normalize(ori_text)
-    print(text)
-    phoneme = fr_to_ipa.fr2ipa(text)
-    print(phoneme)
-
-    
-    from TTS.tts.utils.text.phonemizers.multi_phonemizer import MultiPhonemizer
-    from text.cleaner_multiling import unicleaners
-
-    def text_normalize(text):
-        text = unicleaners(text, cased=True, lang='fr')
-        return text
-
-    # print(ori_text)
-    text = text_normalize(ori_text)
-    print(text)
-    phonemizer = MultiPhonemizer({"fr-fr": "espeak"})
-    # phonemizer.lang_to_phonemizer['fr'].keep_stress = True
-    # phonemizer.lang_to_phonemizer['fr'].use_espeak_phonemes = True
-    phoneme = phonemizer.phonemize(text, separator="", language='fr-fr')
-    print(phoneme)

melo/text/french_bert.py

@@ -1,39 +0,0 @@
-import torch
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-import sys
-
-model_id = 'dbmdz/bert-base-french-europeana-cased'
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-model = None
-
-def get_bert_feature(text, word2ph, device=None):
-    global model
-    if (
-        sys.platform == "darwin"
-        and torch.backends.mps.is_available()
-        and device == "cpu"
-    ):
-        device = "mps"
-    if not device:
-        device = "cuda"
-    if model is None:
-        model = AutoModelForMaskedLM.from_pretrained(model_id).to(
-            device
-        )
-    with torch.no_grad():
-        inputs = tokenizer(text, return_tensors="pt")
-        for i in inputs:
-            inputs[i] = inputs[i].to(device)
-        res = model(**inputs, output_hidden_states=True)
-        res = torch.cat(res["hidden_states"][-3:-2], -1)[0].cpu()
-        
-    assert inputs["input_ids"].shape[-1] == len(word2ph)
-    word2phone = word2ph
-    phone_level_feature = []
-    for i in range(len(word2phone)):
-        repeat_feature = res[i].repeat(word2phone[i], 1)
-        phone_level_feature.append(repeat_feature)
-
-    phone_level_feature = torch.cat(phone_level_feature, dim=0)
-
-    return phone_level_feature.T