La tecnología de texto a voz (TTS) ha evolucionado dramáticamente en los últimos años, desde voces de sonido robótico hasta síntesis de voz altamente natural. Bark es un impresionante modelo TTS de código abierto desarrollado por Suno que puede generar un discurso notablemente humano en múltiples idiomas, completo con sonidos no verbales como risas, suspiros y llantas.
En este tutorial, implementaremos LADRAR Usando la biblioteca de Transformers de Hugging Face en un entorno de Google Colab. Al final, podrás:
- Configurar y ejecutar la corteza en Colab
- Generar discurso a partir de la entrada de texto
- Experimente con diferentes voces y estilos de habla
- Crear aplicaciones TTS prácticas
La corteza es fascinante porque es un modelo de texto a audio totalmente generativo que puede producir un habla natural, música, ruido de fondo y efectos de sonido simples. A diferencia de muchos otros sistemas TTS que se basan en un extenso preprocesamiento de audio y clonación de voz, la corteza puede generar diversas voces sin capacitación específica de altavoces.
¡Comencemos!
Pasos de implementación
Paso 1: Configuración del entorno
Primero, necesitamos instalar las bibliotecas necesarias. La corteza requiere la biblioteca de transformadores de la cara abrazada, junto con algunas otras dependencias:
# Install the required libraries
!pip install transformers==4.31.0
!pip install accelerate
!pip install scipy
!pip install torch
!pip install torchaudio
A continuación, importaremos las bibliotecas que usaremos:
import torch
import numpy as np
import IPython.display as ipd
from transformers import BarkModel, BarkProcessor
# Check if GPU is available
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")
Paso 2: Cargando el modelo de corteza
Ahora, cargamos el modelo de corteza y el procesador de la cara abrazada:
# Load the model and processor
model = BarkModel.from_pretrained("suno/bark")
processor = BarkProcessor.from_pretrained("suno/bark")
# Move model to GPU if available
model = model.to(device)
La corteza es un modelo relativamente grande, por lo que este paso puede tardar un minuto o dos en completarse, ya que descarga los pesos del modelo.
Paso 3: Generar discurso básico
Comencemos con un ejemplo simple para generar discurso a partir del texto:
# Define text input
text = "Hello! My name is BARK. I'm an AI text to speech model. It's nice to meet you!"
# Preprocess text
inputs = processor(text, return_tensors="pt").to(device)
# Generate speech
speech_output = model.generate(**inputs)
# Convert to audio
sampling_rate = model.generation_config.sample_rate
audio_array = speech_output.cpu().numpy().squeeze()
# Play the audio
ipd.display(ipd.Audio(audio_array, rate=sampling_rate))
# Save the audio file
from scipy.io.wavfile import write
write("basic_speech.wav", sampling_rate, audio_array)
print("Audio saved to basic_speech.wav")
Salida: para escuchar el audio, consulte amablemente al cuaderno (busque el enlace adjunto al final
Paso 4: Uso de diferentes presets de altavoces
La corteza viene con varios presets de altavoces predefinidos en diferentes idiomas. Exploremos cómo usarlos:
# List available English speaker presets
english_speakers = [
"v2/en_speaker_0",
"v2/en_speaker_1",
"v2/en_speaker_2",
"v2/en_speaker_3",
"v2/en_speaker_4",
"v2/en_speaker_5",
"v2/en_speaker_6",
"v2/en_speaker_7",
"v2/en_speaker_8",
"v2/en_speaker_9"
]
# Choose a speaker preset
speaker = english_speakers[3] # Using the fourth English speaker preset
# Define text input
text = "BARK can generate speech in different voices. This is an example of a different speaker preset."
# Add speaker preset to the input
inputs = processor(text, return_tensors="pt", voice_preset=speaker).to(device)
# Generate speech
speech_output = model.generate(**inputs)
# Convert to audio
audio_array = speech_output.cpu().numpy().squeeze()
# Play the audio
ipd.display(ipd.Audio(audio_array, rate=sampling_rate))
Paso 5: Generación de discursos multilingües
La corteza admite varios idiomas fuera de la caja. Generemos el habla en diferentes idiomas:
# Define texts in different languages
texts = {
"English": "Hello, how are you doing today?",
"Spanish": "¡Hola! ¿Cómo estás hoy?",
"French": "Bonjour! Comment allez-vous aujourd'hui?",
"German": "Hallo! Wie geht es Ihnen heute?",
"Chinese": "你好!今天你好吗?",
"Japanese": "こんにちは!今日の調子はどうですか?"
}
# Generate speech for each language
for language, text in texts.items():
print(f"\nGenerating speech in {language}...")
# Choose appropriate voice preset if available
voice_preset = None
if language == "English":
voice_preset = "v2/en_speaker_1"
elif language == "Spanish":
voice_preset = "v2/es_speaker_1"
elif language == "German":
voice_preset = "v2/de_speaker_1"
elif language == "French":
voice_preset = "v2/fr_speaker_1"
elif language == "Chinese":
voice_preset = "v2/zh_speaker_1"
elif language == "Japanese":
voice_preset = "v2/ja_speaker_1"
# Process text with language-specific voice preset if available
if voice_preset:
inputs = processor(text, return_tensors="pt", voice_preset=voice_preset).to(device)
else:
inputs = processor(text, return_tensors="pt").to(device)
# Generate speech
speech_output = model.generate(**inputs)
# Convert to audio
audio_array = speech_output.cpu().numpy().squeeze()
# Play the audio
ipd.display(ipd.Audio(audio_array, rate=sampling_rate))
write("basic_speech_multilingual.wav", sampling_rate, audio_array)
print("Audio saved to basic_speech_multilingual.wav")
Paso 6: Creación de una aplicación práctica – Generador de audiolibros
Construyamos un generador de audiolibro simple que pueda convertir los párrafos de texto en discurso:
def generate_audiobook(text, speaker_preset="v2/en_speaker_2", chunk_size=250):
"""
Generate an audiobook from a long text by splitting it into chunks
and processing each chunk separately.
Args:
text (str): The text to convert to speech
speaker_preset (str): The speaker preset to use
chunk_size (int): Maximum number of characters per chunk
Returns:
numpy.ndarray: The generated audio as a numpy array
"""
# Split text into sentences
import re
sentences = re.split(r'(?<=[.!?])\s+', text)
chunks = []
current_chunk = ""
# Group sentences into chunks
for sentence in sentences:
if len(current_chunk) + len(sentence) < chunk_size:
current_chunk += sentence + " "
else:
chunks.append(current_chunk.strip())
current_chunk = sentence + " "
# Add the last chunk if it's not empty
if current_chunk:
chunks.append(current_chunk.strip())
print(f"Split text into {len(chunks)} chunks")
# Process each chunk
audio_arrays = []
for i, chunk in enumerate(chunks):
print(f"Processing chunk {i+1}/{len(chunks)}")
# Process text
inputs = processor(chunk, return_tensors="pt", voice_preset=speaker_preset).to(device)
# Generate speech
speech_output = model.generate(**inputs)
# Convert to audio
audio_array = speech_output.cpu().numpy().squeeze()
audio_arrays.append(audio_array)
# Concatenate audio arrays
import numpy as np
full_audio = np.concatenate(audio_arrays)
return full_audio
# Example usage with a short excerpt from a book
book_excerpt = """
Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do. Once or twice she had peeped into the book her sister was reading, but it had no pictures or conversations in it, "and what is the use of a book," thought Alice, "without pictures or conversations?"
So she was considering in her own mind (as well as she could, for the hot day made her feel very sleepy and stupid), whether the pleasure of making a daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly a White Rabbit with pink eyes ran close by her.
"""
# Generate audiobook
audiobook = generate_audiobook(book_excerpt)
# Play the audio
ipd.display(ipd.Audio(audiobook, rate=sampling_rate))
# Save the audio file
write("alice_audiobook.wav", sampling_rate, audiobook)
print("Audiobook saved to alice_audiobook.wav")
En este tutorial, hemos implementado con éxito el modelo de texto a voz de la corteza utilizando la Biblioteca Transformers de Hugging Face en Google Colab. En este tutorial, hemos aprendido a:
- Configure y cargue el modelo de corteza en un entorno de Colab
- Generar discurso básico a partir de la entrada de texto
- Use diferentes presets de altavoces para la variedad
- Crear discurso multilingüe
- Cree una aplicación de generador de audiolibros práctico
Bark representa un avance impresionante en la tecnología de texto a voz, que ofrece una generación expresiva de voz expresiva sin la necesidad de una amplia capacitación o ajuste fino.
Experimentación futura que puedes probar
Algunos posibles pasos próximos para explorar y extender más su trabajo con la corteza:
- Clonación de voz: Experimente con técnicas de clonación de voz para generar discursos que imitan a los hablantes específicos.
- Integración con otros sistemas: Combine la corteza con otros modelos de IA, como modelos de idiomas para asistentes de voz personalizados en dinámicas como restaurantes y recepción, generación de contenido, sistemas de traducción, etc.
- Aplicación web: Cree una interfaz web para su sistema TTS para que sea más accesible.
- Ajuste personalizado: Explore técnicas para ajustar la corteza en dominios o estilos de habla específicos.
- Optimización del rendimiento: Investigue los métodos para optimizar la velocidad de inferencia para aplicaciones en tiempo real. Este será un aspecto importante para cualquier aplicación en la producción porque el tiempo de inferencia para procesar incluso una pequeña porción de texto, estos modelos gigantes toman un tiempo significativo debido a su generalización para una gran cantidad de casos de uso.
- Evaluación de calidad: Implemente métricas de evaluación objetiva y subjetiva para evaluar la calidad del habla generada.
El campo del texto a la voz está evolucionando rápidamente, y proyectos como Bark están empujando los límites de lo que es posible. A medida que continúe explorando esta tecnología, descubrirá aplicaciones y mejoras aún más emocionantes.
Aquí está el Cuaderno de colab. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro Subreddit de 80k+ ml.
Asjad es consultor interno en MarktechPost. Está persiguiendo B.Tech en Ingeniería Mecánica en el Instituto de Tecnología Indio, Kharagpur. Asjad es un entusiasta de aprendizaje automático y aprendizaje profundo que siempre está investigando las aplicaciones del aprendizaje automático en la atención médica.