Le projet Bark est un modèle de génération de voix développé par Suno AI, une start-up spécialisée dans les technologies d’intelligence artificielle. Bark a été publié en open-source sur GitHub, permettant à la communauté de l’utiliser, de l’améliorer et de l’intégrer dans divers projets. Il s’agit d’un modèle de génération de voix text-to-speech (TTS) qui peut non seulement générer des voix humaines dans plusieurs langues, mais aussi inclure des éléments comme des sons non verbaux (ex. des rires, des respirations) et des accents.
Contexte et histoire du projet
Origine : Suno AI a conçu Bark pour fournir un modèle de génération de voix plus riche et expressif que ceux déjà disponibles. Le but était de repousser les limites de la technologie TTS en créant des voix synthétiques qui ne se contentent pas de lire des textes, mais capturent également des nuances émotionnelles et contextuelles. Le projet s’inscrit dans la tendance des avancées de l’IA générative.
Objectif : Bark vise à faciliter la création de contenu vocal pour des applications variées, comme les assistants virtuels, les jeux vidéo, les podcasts, les livres audio, et d’autres projets nécessitant des voix réalistes. Contrairement à certains autres projets TTS, Bark ne se concentre pas uniquement sur la précision linguistique, mais sur la capacité à générer des voix qui sonnent plus naturelles et humaines.
Publication et open-source : Bark a été publié en open-source pour encourager la collaboration. Cela permet aux développeurs d’explorer et d’expérimenter avec les capacités vocales du modèle tout en bénéficiant des contributions de la communauté pour son amélioration. Le dépôt GitHub contient le code source, des modèles pré-entraînés, ainsi que des instructions pour déployer et ajuster le modèle selon les besoins des utilisateurs.
Ce projet est représentatif des progrès réalisés dans le domaine de l’intelligence artificielle générative, notamment dans le domaine de la synthèse vocale.
Bark supporte plus de 100 pré-réglages de haut-parleurs dans les
langues prises en charge.
Vous pourrez trouver une bibliothèque des
préréglages de voix ici.
Des démos sont également accessibles ici sur Huggingface ou chez Replicate.
Usages et applications
Les applications de Bark sont nombreuses et variées :
- Création de contenu audio : Idéal pour les podcasts, les livres audio ou les vidéos explicatives.
- Développement de jeux : Pour donner vie aux personnages avec des voix réalistes et des effets sonores.
- Assistance vocale : Pour créer des assistants virtuels plus naturels et expressifs.
- Apprentissage des langues : Pour générer des exemples de prononciation dans différentes langues.
- Doublage et voix off : Pour produire des voix de haute qualité dans plusieurs langues pour des vidéos ou des animations[5].
Installation de Bark
L’installation de Bark est relativement simple, même pour ceux qui ne sont pas experts en programmation. Suivez les étapes ci-dessous pour commencer à utiliser Bark :
- Clonez le dépôt GitHub de Bark en utilisant la commande suivante :
git clone https://github.com/suno-ai/bark.git - Créez un environnement Python 3 et installez les dépendances nécessaires en utilisant :
pip install -r requirements.txt. - Téléchargez les modèles pré-entraînés depuis la page des releases ou, si vous vous sentez aventureux, vous pouvez entraîner votre propre modèle en utilisant les scripts fournis.
- Lancez Bark en utilisant les options en ligne de commande qui vous conviennent le mieux, par exemple pour sélectionner la langue, le texte d’entrée et le format de sortie.
Ces étapes simples vous permettront de configurer Bark rapidement et de commencer à profiter de sa capacité à générer du texte et de l’audio en plusieurs langues.
Une fois installé, vous pouvez l’utiliser dans un script Python comme suit :
from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav
# Charger les modèles
preload_models()
# Générer l'audio à partir du texte
text_prompt = """
Bonjour, je m'appelle Pierre. Et, euh — j'adore la programmation [laughs]
"""
audio_array = generate_audio(text_prompt)
# Sauvegarder l'audio sur le disque
write_wav("generation_bark.wav", SAMPLE_RATE, audio_array)
Exemple de génération en français
Voici un exemple pour générer du texte en français avec Bark :
text_prompt = """
[WOMAN] Bonjour à tous ! Je suis ravie de vous présenter Bark, un modèle de synthèse vocale révolutionnaire.
Il peut même gérer des effets comme... [laughs] ou des pauses — comme celle-ci.
Et savez-vous quoi ? ♪ Il peut même chanter ! ♪
"""
audio_array = generate_audio(text_prompt)
Dans cet exemple, nous utilisons des balises spéciales comme [WOMAN] pour spécifier le genre de la voix, [laughs] pour ajouter des effets sonores, et ♪ pour indiquer le chant[1].
Fonctionnalités avancées
Bark offre plusieurs fonctionnalités avancées :
- Multilinguisme : Capable de gérer plusieurs langues dans un même texte avec des accents natifs.
- Effets sonores : Possibilité d’ajouter des rires, soupirs, musique, etc.
- Contrôle de l’intonation : Utilisation de majuscules pour accentuer certains mots.
- Voix préréglées : Plus de 100 préréglages de voix disponibles.
Bark représente une avancée significative dans le domaine de la synthèse vocale. Son approche innovante et ses capacités multilingues en font un outil précieux pour les développeurs, les créateurs de contenu et les chercheurs. Avec son code source ouvert et sa licence MIT, Bark ouvre la voie à de nouvelles possibilités passionnantes dans le domaine de la génération audio par IA[1].
Que vous soyez un créateur de contenu, un éducateur ou un développeur, Bark vous permet de franchir les barrières linguistiques et de donner une dimension internationale à vos projets. N’hésitez pas à suivre les étapes d’installation et à tester ses nombreuses fonctionnalités. Vous verrez rapidement à quel point cet outil peut transformer votre manière de travailler.
[1] https://korben.info/rencontre-bark-modele-texte-audio-multilingue.html
🌍🎙️
Vous souhaitez explorer toutes les possibilités offertes par l'Intelligence Artificielle ?
Envoyez un email à support@qo-op.com !
Apprenez à...
Créer un assistant vocal local avec Whisper, Ollama et Bark
L’intégration de Bark dans un assistant vocal local est une démonstration fascinante de la manière dont les technologies de reconnaissance et de synthèse vocale peuvent être combinées pour créer des interactions vocales intelligentes et autonomes. Voici comment vous pouvez construire votre propre assistant vocal en utilisant Whisper pour la reconnaissance vocale, Ollama pour le traitement du langage naturel, et Bark pour la synthèse vocale.
Architecture de l’application
L’application se compose de trois composants principaux :
- Reconnaissance vocale : Utilisation de Whisper d’OpenAI pour convertir la parole en texte. Whisper est entraîné sur des ensembles de données diversifiés, ce qui le rend efficace dans de nombreuses langues et dialectes.
- Chaîne conversationnelle : Utilisation du modèle de langage Llama-2 via l’interface Langchain, servi par Ollama, pour générer des réponses contextuelles et engageantes.
- Synthèse vocale : Transformation du texte en parole réalisée par Bark, reconnu pour sa production vocale réaliste.
Le flux de travail est simple : enregistrer la parole, la transcrire en texte, générer une réponse à l’aide d’un modèle de langage, et vocaliser la réponse avec Bark.
Mise en œuvre
Installation des dépendances
Commencez par configurer un environnement Python virtuel.
python3 -m venv envassist
source envassist/bin/activate
Installez ensuite les bibliothèques essentielles :
pip install rich openai-whisper suno-bark langchain sounddevice pyaudio speechrecognition
Service de synthèse vocale
Le service de synthèse vocale est basé sur Bark et utilise les méthodes suivantes pour générer de l’audio à partir de texte :
import torch
import numpy as np
from transformers import AutoProcessor, BarkModel
class TextToSpeechService:
def __init__(self, device: str = "cuda" if torch.cuda.is_available() else "cpu"):
self.device = device
self.processor = AutoProcessor.from_pretrained("suno/bark-small")
self.model = BarkModel.from_pretrained("suno/bark-small")
self.model.to(self.device)
def synthesize(self, text: str, voice_preset: str = "v2/fr_speaker_1"):
inputs = self.processor(text, voice_preset=voice_preset, return_tensors="pt")
inputs = {k: v.to(self.device) for k, v in inputs.items()}
with torch.no_grad():
audio_array = self.model.generate(**inputs, pad_token_id=10000)
return self.model.generation_config.sample_rate, audio_array.cpu().numpy().squeeze()
def long_form_synthesize(self, text: str, voice_preset: str = "v2/fr_speaker_1"):
pieces = []
sentences = nltk.sent_tokenize(text)
silence = np.zeros(int(0.25 * self.model.generation_config.sample_rate))
for sent in sentences:
sample_rate, audio_array = self.synthesize(sent, voice_preset)
pieces += [audio_array, silence.copy()]
return self.model.generation_config.sample_rate, np.concatenate(pieces)
Configuration du serveur Ollama
Pour utiliser le modèle de langage Llama-2, vous devez configurer le serveur Ollama :
ollama pull llama2
ollama serve
Implémentation de l’application
L’application utilise les composants suivants :
- Console Rich pour une interface utilisateur interactive.
- Whisper pour la transcription vocale.
- Bark pour la synthèse vocale.
- Langchain pour gérer le flux conversationnel avec Llama-2.
Voici un extrait de code pour initialiser ces composants et gérer le flux de l’application :
import whisper
import sounddevice as sd
from queue import Queue
from rich.console import Console
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain_community.llms import Ollama
console = Console()
stt = whisper.load_model("base.en")
tts = TextToSpeechService()
template = """
You are a helpful and friendly AI assistant. You are polite, respectful, and aim to provide concise responses of less
than 20 words.
The conversation transcript is as follows:
{history}
And here is the user's follow-up: {input}
Your response:
"""
PROMPT = PromptTemplate(input_variables=["history", "input"], template=template)
chain = ConversationChain(
prompt=PROMPT,
verbose=False,
memory=ConversationBufferMemory(ai_prefix="Assistant:"),
llm=Ollama(),
)
def record_audio(stop_event, data_queue):
def callback(indata, frames, time, status):
if status:
console.print(status)
data_queue.put(bytes(indata))
with sd.RawInputStream(samplerate=16000, dtype="int16", channels=1, callback=callback):
while not stop_event.is_set():
time.sleep(0.1)
def transcribe(audio_np: np.ndarray) -> str:
result = stt.transcribe(audio_np, fp16=False)
return result["text"].strip()
def get_llm_response(text: str) -> str:
response = chain.predict(input=text)
return response[len("Assistant:") :].strip() if response.startswith("Assistant:") else response
def play_audio(sample_rate, audio_array):
sd.play(audio_array, sample_rate)
sd.wait()
if __name__ == "__main__":
console.print("[cyan]Assistant started! Press Ctrl+C to exit.")
try:
while True:
console.input("Press Enter to start recording, then press Enter again to stop.")
data_queue = Queue()
stop_event = threading.Event()
recording_thread = threading.Thread(target=record_audio, args=(stop_event, data_queue))
recording_thread.start()
input()
stop_event.set()
recording_thread.join()
audio_data = b"".join(list(data_queue.queue))
audio_np = np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
if audio_np.size > 0:
with console.status("Transcribing...", spinner="earth"):
text = transcribe(audio_np)
console.print(f"[yellow]You: {text}")
with console.status("Generating response...", spinner="earth"):
response = get_llm_response(text)
sample_rate, audio_array = tts.long_form_synthesize(response)
console.print(f"[cyan]Assistant: {response}")
play_audio(sample_rate, audio_array)
else:
console.print("[red]No audio recorded. Please ensure your microphone is working.")
except KeyboardInterrupt:
console.print("\n[red]Exiting...")
console.print("[blue]Session ended.")
Conclusion
En combinant Whisper, Ollama, et Bark, vous pouvez créer un assistant vocal local qui fonctionne de manière autonome sur votre ordinateur. Cette application démontre comment les technologies de reconnaissance vocale, de modélisation du langage, et de synthèse vocale peuvent être intégrées pour offrir une expérience utilisateur fluide et engageante[1)
Citations:
[1] https://hackernoon.com/how-to-build-your-own-voice-assistant-and-run-it-locally-using-whisper-ollama-bark
Bark : Un Modèle Polyvalent pour la Génération de Texte et d’Audio Multilingue
créer un assistant vocal local qui fonctionne de manière autonome sur votre ordinateur