first commit

.gitignore

@@ -0,0 +1,3 @@
+.ipynb_checkpoints/
+flagged/
+__pycache__/

app.py

@@ -0,0 +1,24 @@
+import logging
+
+import gradio as gr
+from config import BaseConfig
+from predict import inputs, outputs, predict
+
+if __name__ == "__main__":
+    logging.basicConfig(format="[%(asctime)s] %(levelname)s: %(message)s")
+    config = BaseConfig()
+
+    app = gr.Interface(
+        predict,
+        inputs=inputs,
+        outputs=outputs,
+        title="Text-to-Meow",
+        description="Ever thought of whether your cat understands your words? It no longer matters! Now you get to speak in their language!",
+    )
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=config.port,
+        enable_queue=True,
+        share=True
+    )

config.py

@@ -0,0 +1,17 @@
+from pydantic import BaseSettings, Field
+
+class BaseConfig(BaseSettings):
+    """Define any config here.
+    See here for documentation:
+    https://pydantic-docs.helpmanual.io/usage/settings/
+    """
+    # KNative assigns a $PORT environment variable to the container
+    port: int = Field(default=8080, env="PORT",description="Gradio App Server Port")
+
+    manifest_path: str = 'meows/manifest.json'
+    sample_rate: int = 16000
+    init_factor: float = 0.3
+    add_factor: float = 0.2
+    power_factor: float = 0.8
+
+config = BaseConfig()

meows/manifest.json

@@ -0,0 +1,10 @@
+{"audio_filepath": "data/meow1.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow2.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow3.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow4.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow5.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow6.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow7.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow8.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow9.wav", "text": "meow", "weight": 1.0}
+{"audio_filepath": "data/meow10.wav", "text": "meow with bold", "weight": 0.01}

predict.py

@@ -0,0 +1,57 @@
+import os
+import json
+import random
+import librosa
+import numpy as np
+import gradio as gr
+from typing import Any, List, Dict, Tuple
+
+from utils import meow_stretch, get_word_lengths
+from config import config, BaseConfig
+
+''' Gradio Input/Output Configurations '''
+inputs: str = 'text'
+outputs: gr.Audio = gr.Audio()
+
+def load_meows(cfg: BaseConfig) -> List[Dict[str, Any]]:
+
+    meow_dir = os.path.dirname(cfg.manifest_path)
+
+    with open(cfg.manifest_path, mode='r') as fr:
+        lines = fr.readlines()
+
+    items = []
+    for line in lines:
+        item = json.loads(line)
+        item['audio'], item['rate'] = librosa.load(os.path.join(meow_dir, item['audio_filepath']), sr=None)
+        items.append(item)
+
+    return items
+
+def extract_meows_weights(items: List[Dict[str, Any]]) -> Tuple[List[np.ndarray], List[float]]:
+    meows = [item['audio'] for item in items]
+    weights = [item['weight'] for item in items]
+    return meows, weights
+
+''' Load meows '''
+meow_items = load_meows(config)
+meows, weights = extract_meows_weights(meow_items)
+
+def predict(text: str) -> str:
+
+    word_lengths = get_word_lengths(text)
+    selected_meows = random.choices(meows, weights=weights, k=len(word_lengths))
+    transformed_meows = [
+        meow_stretch(
+            meow, wl,
+            init_factor=config.init_factor,
+            add_factor=config.add_factor,
+            power_factor=config.power_factor
+        ) for meow, wl in zip(selected_meows, word_lengths)
+    ]
+
+    result_meows = np.concatenate(transformed_meows, axis=0)
+
+    return (config.sample_rate, result_meows)
+
+

requirements.txt

@@ -0,0 +1,3 @@
+gradio==3.24.1
+librosa==0.10.0.post2
+numpy==1.23.5

utils.py

@@ -0,0 +1,57 @@
+import string
+import librosa
+import numpy as np
+
+from typing import List
+
+def stretch(x: np.ndarray, factor: float, nfft: int = 2048) -> np.ndarray:
+    '''
+    @author: Gagandeep Singh, 29 Oct, 2018
+    https://github.com/gaganbahga/time_stretch
+    
+    stretch an audio sequence by a factor using FFT of size nfft converting to frequency domain
+    :param x: np.ndarray, audio array in PCM float32 format
+    :param factor: float, stretching or shrinking factor, depending on if its > or < 1 respectively
+    :return: np.ndarray, time stretched audio
+    '''
+    stft = librosa.core.stft(x, n_fft=nfft).transpose()  # i prefer time-major fashion, so transpose
+    stft_rows = stft.shape[0]
+    stft_cols = stft.shape[1]
+
+    times = np.arange(0, stft.shape[0], factor)  # times at which new FFT to be calculated
+    hop = nfft/4                                 # frame shift
+    stft_new = np.zeros((len(times), stft_cols), dtype=np.complex_)
+    phase_adv = (2 * np.pi * hop * np.arange(0, stft_cols))/ nfft
+    phase = np.angle(stft[0])
+
+    stft = np.concatenate( (stft, np.zeros((1, stft_cols))), axis=0)
+
+    for i, time in enumerate(times):
+        left_frame = int(np.floor(time))
+        local_frames = stft[[left_frame, left_frame + 1], :]
+        right_wt = time - np.floor(time)                        # weight on right frame out of 2
+        local_mag = (1 - right_wt) * np.absolute(local_frames[0, :]) + right_wt * np.absolute(local_frames[1, :])
+        local_dphi = np.angle(local_frames[1, :]) - np.angle(local_frames[0, :]) - phase_adv
+        local_dphi = local_dphi - 2 * np.pi * np.floor(local_dphi/(2 * np.pi))
+        stft_new[i, :] =  local_mag * np.exp(phase*1j)
+        phase += local_dphi + phase_adv
+
+    return librosa.core.istft(stft_new.transpose())
+
+def meow_stretch(
+    x: np.ndarray, character_len: int, 
+    init_factor: float = 0.3, add_factor: float = 0.2,
+    power_factor: float = 0.8, nfft: int = 2048
+) -> np.ndarray:
+    '''
+    Stretch the meows based on word length, with a reducing power to prevent incredibly long meows
+    '''
+    
+    factor = init_factor + (add_factor * character_len) ** power_factor
+    return stretch(x, 1/factor, nfft=nfft)
+
+def get_word_lengths(text_input: str) -> List[int]:
+    text_input = text_input.translate(str.maketrans('', '', string.punctuation))
+    word_list = text_input.split()
+    
+    return [len(word) for word in word_list]