Muy buenas, les saluda Miguel y para hoy les traigo un nuevo post.
Recientemente, los bots de charla se han utilizado en muchos servicios de nuestra vida cotidiana. Estos bots se pueden construir para responder un conjunto de preguntas predefinidas o incluso para desarrollar una conversación similar a la humana.
Por un lado, estos bots son muy útiles en servicios basados ​​en texto como asistentes virtuales, responder dudas, hacer citas, confirmar la entrega, etc.
Por otro lado, la naturaleza dependiente del texto de estos chatterbots conlleva algunas limitaciones relacionadas a la interacción humana y la accesibilidad.
De esta manera, para potenciar estas capacidades han surgido los sistemas de texto a voz (TTS), que es una tecnologÃa para convertir el lenguaje escrito en habla humana, en consecuencia, los sistemas TTS pueden usarse no solo como interfaces de tecnologÃa humana para computadoras servicios, sino también como accesibilidad para las personas con discapacidad visual.
En este escenario,  WAVY que es una empresa lÃder especializada en mejorar la experiencia del cliente a través de sistemas conversacionales basados ​​en inteligencia artificial y chatbots, inició una investigación para implementar sistemas TTS para permitir servicios más eficientes e inclusivos.
Los sistemas TTS
Estos sistemas se entrenan con conjuntos de datos compuestos por textos y audios, por lo tanto, el sistema aprende el sonido (por ejemplo, la forma de onda) de palabras, sÃlabas y letras.
Sin embargo, la voz resultante es la misma que la presentada en el conjunto de datos de entrenamiento, lo que significa que para producir una voz especÃfica, el sistema TTS debe entrenarse con la voz objetivo.
Para superar este inconveniente, el sistema de clonación de voz introdujo métodos para extraer caracterÃsticas especÃficas de una voz objetivo (es decir, tono, asentimiento, etc.) y aplicarlas a formas de onda de un habla diferente, lo que permitió cambiar la voz resultante de la forma de onda anterior.
Estas notables tecnologÃas se hicieron realidad gracias a los avances de los modelos de Deep Learning y la informática de alto rendimiento, que allanan el camino para resolver problemas complejos en el momento adecuado.
Motivado por la combinación de las tecnologÃas antes mencionadas, Jia et al. [1] propuso SV2TTS (Transfer Learning from Speaker Verification to Multispeaker Text-to-Speech Synthesis), un sistema TTS capaz de generar audio de voz en la voz de diferentes hablantes, incluidos los que no se ven durante el entrenamiento.
Descripción general de SSVTTS
El sistema está compuesto por tres redes neuronales entrenadas de forma independiente, ilustradas en la Figura 1:
(i) Un codificador de hablante recurrente, entrenado en una tarea de verificación de hablante utilizando un conjunto de datos independiente de habla ruidosa sin transcripciones de miles de hablantes, para generar una dimensión fija incrustación de vectores de solo segundos de discurso de referencia de un hablante objetivo.
(ii) Un sintetizador secuencia a secuencia, que se basa en Tacotron 2 que predice un espectrograma mel a partir del texto, condicionado a la incrustación del hablante.
(iii) Un codificador de voz WaveNet autorregresivo , que convierte el espectrograma en formas de onda en el dominio del tiempo.
En resumen, SV2TTS aborda especÃficamente una configuración de aprendizaje de disparo cero, donde se utilizan unos pocos segundos de audio de referencia no transcrito de un orador objetivo para sintetizar un nuevo discurso en la voz de ese orador, sin actualizar ningún parámetro del modelo.
Para obtener más detalles sobre la arquitectura y los métodos empleados por SV2TTS, consulte [1].
Demostración: TTS con clonación de voz en tiempo real
Corentin Jemine desarrolló un marco basado en [1] para proporcionar un TTS con clonación de voz en tiempo real. El marco está disponible en su GitHub repositorio con un modelo previamente entrenado para el TTS.
Para realizar la demostración utilizaremos Colabs de Google medio ambiente. Para hacerlo, cree un nuevo documento de Colabs y asegúrese de que GPU esté habilitado en tiempo de ejecución verificando la siguiente configuración Cambiar tipo de tiempo de ejecución -> Acelerador de hardware -> GPU. Empecemos.
Primero, necesitamos copiar el marco de Corentin Jemine repositorio Git.
!git clone https://github.com/CorentinJ/Real-Time-Voice-Cloning.git
Luego, necesitamos ingresar al repositorio e instalar las dependencias del framework.
cd Real-Time-Voice-Cloning/# Install dependencies !pip install -q -r requirements.txt !apt-get install -qq libportaudio2
Descargue el modelo previamente entrenado y descomprÃmalo.
!gdown https://tinyurl.com/yyut93rd !unzip pretrained.zip
Para realizar la clonación de voz, necesitamos grabar un audio corto como ejemplo de la voz deseada. De esta forma, necesitamos grabar una muestra de audio desde el navegador usando el siguiente código:
# Code for recording audio from the browser
from IPython.display import Javascript
from google.colab import output
from base64 import b64decode
import IPython
import uuid
from google.colab import output
class InvokeButton(object):
def __init__(self, title, callback):
self._title = title
self._callback = callback
def _repr_html_(self):
from google.colab import output
callback_id = 'button-' + str(uuid.uuid4())
output.register_callback(callback_id, self._callback)
template = """<button id="{callback_id}" style="cursor:pointer;background-color:#EEEEEE;border-color:#E0E0E0;padding:5px 15px;font-size:14px">{title}</button>
<script>
document.querySelector("#{callback_id}").onclick = (e) => {{
google.colab.kernel.invokeFunction('{callback_id}', [], {{}})
e.preventDefault();
}};
</script>"""
html = template.format(title=self._title, callback_id=callback_id)
return html
RECORD = """
const sleep = time => new Promise(resolve => setTimeout(resolve, time))
const b2text = blob => new Promise(resolve => {
const reader = new FileReader()
reader.onloadend = e => resolve(e.srcElement.result)
reader.readAsDataURL(blob)
})
var record = time => new Promise(async resolve => {
stream = await navigator.mediaDevices.getUserMedia({ audio: true })
recorder = new MediaRecorder(stream)
chunks = []
recorder.ondataavailable = e => chunks.push(e.data)
recorder.start()
await sleep(time)
recorder.onstop = async ()=>{
blob = new Blob(chunks)
text = await b2text(blob)
resolve(text)
}
recorder.stop()
})
"""
def record(sec=3):
display(Javascript(RECORD))
s = output.eval_js('record(%d)' % (sec*1000))
b = b64decode(s.split(',')[1])
with open('audio.wav','wb+') as f:
f.write(b)
return 'audio.wav'
Establecer los pesos preentrenados al modelo.
from IPython.display import Audio
from IPython.utils import io
from synthesizer.inference import Synthesizer
from encoder import inference as encoder
from vocoder import inference as vocoder
from pathlib import Path
import numpy as np
import librosa
encoder_weights = Path("encoder/saved_models/pretrained.pt")
vocoder_weights = Path("vocoder/saved_models/pretrained/pretrained.pt")
syn_dir = Path("synthesizer/saved_models/logs-pretrained/taco_pretrained")
encoder.load_model(encoder_weights)
synthesizer = Synthesizer(syn_dir)
vocoder.load_model(vocoder_weights)
Con todo listo, para realizar el TTS y también grabar su voz para la clonación en tiempo real, necesitamos ejecutar el siguiente código:
#@title Deep vocoder
def synth():
text = "This is being said in my own voice. The computer has learned to do an impression of me." #@param {type:"string"}
print("Now recording for 10 seconds, say what you will...")
record(10)
print("Audio recording complete")
in_fpath = Path("audio.wav")
reprocessed_wav = encoder.preprocess_wav(in_fpath)
original_wav, sampling_rate = librosa.load(in_fpath)
preprocessed_wav = encoder.preprocess_wav(original_wav, sampling_rate)
embed = encoder.embed_utterance(preprocessed_wav)
print("Synthesizing new audio...")
with io.capture_output() as captured:
specs = synthesizer.synthesize_spectrograms([text], [embed])
generated_wav = vocoder.infer_waveform(specs[0])
generated_wav = np.pad(generated_wav, (0, synthesizer.sample_rate), mode="constant")
display(Audio(generated_wav, rate=synthesizer.sample_rate))
InvokeButton('Start recording', synth)
Durante la ejecución, primero debemos proporcionar el texto de entrada que se sintetizará. Luego, debemos hacer clic en el botón de inicio de grabación para grabar nuestra propia voz.
Finalmente, el marco extraerá las caracterÃsticas de su voz y las aplicará a la forma de onda preentrenada. La voz resultante se puede escuchar haciendo clic en el botón de reproducción.
El código completo se puede encontrar en el siguiente Colab cuaderno. Para ejecutar el código, vaya al menú Runtime y haga clic en Ejecutar todo, o simplemente presione Ctrl + F9.
Espero que le haya sido de utilidad. Gracias por leer este post.
Añadir comentario