Kimi-Audio : traitement audio open source et modèle de base de dialogue

Introduction générale

Kimi-Audio est un modèle de base audio open source développé par Moonshot AI qui se concentre sur la compréhension, la génération et le dialogue audio. Il prend en charge un large éventail de tâches de traitement audio telles que la reconnaissance vocale, les questions-réponses audio et la reconnaissance des émotions vocales. Le modèle a été pré-entraîné sur plus de 13 millions d'heures de données audio et, combiné à une architecture hybride innovante, il est performant dans de nombreux benchmarks audio. kimi-Audio fournit les poids du modèle, le code d'inférence et une boîte à outils d'évaluation pour les développeurs afin qu'ils puissent facilement l'intégrer dans leurs recherches et applications. Il est adapté aux scénarios nécessitant un traitement audio efficace et des capacités de dialogue, avec une documentation claire, un support pour le déploiement Docker, une communauté active et des mises à jour continues.

Liste des fonctions

• Reconnaissance vocale (ASR) : convertit les données audio en texte et prend en charge la transcription vocale multilingue.
• Audio Question and Answer (AQA) : répondre aux questions des utilisateurs sur la base du contenu audio et comprendre le contexte audio.
• Sous-titrage audio (AAC) : génère des sous-titres ou des descriptions précises pour les fichiers audio.
• Speech Emotion Recognition (SER) : analyse les états émotionnels dans l'audio, comme la joie ou la tristesse.
• Classification des événements sonores et des scènes (SEC/ASC) : identifie des événements ou des scènes spécifiques dans le son, tels que les bruits de voiture ou les environnements intérieurs.
• Synthèse vocale (TTS) : convertit le texte en parole naturelle, prend en charge plusieurs tonalités.
• Conversion vocale (VC) : modifier le timbre ou le style de la voix pour générer un son personnalisé.
• Dialogue vocal de bout en bout : permet une interaction vocale continue, simulant un dialogue naturel.
• Génération de flux audio : génération de flux audio à faible latence par le biais d'un décodeur de flux par morceaux.
• Boîte à outils d'évaluation : fournit des outils d'évaluation standardisés pour faciliter la comparaison des performances des différents modèles.

Utiliser l'aide

Processus d'installation

Docker est recommandé pour le déploiement de Kimi-Audio afin de garantir un environnement cohérent et une installation facile. Voici les étapes détaillées de l'installation :

1. entrepôt de clones
   Exécutez la commande suivante dans le terminal pour obtenir le code et les sous-modules de Kimi-Audio :

   git clone https://github.com/MoonshotAI/Kimi-Audio.git
   cd Kimi-Audio
   git submodule update --init --recursive

2. Installation des dépendances
   Installer les dépendances Python, l'environnement Python 3.10 est recommandé :

   pip install -r requirements.txt
   

   Assurer l'installation torch répondre en chantant soundfileSi vous disposez d'un support GPU, vous devez installer la version CUDA de PyTorch.

3. Construire une image Docker
   Construisez l'image Docker dans le répertoire Kimi-Audio :

   docker build -t kimi-audio:v0.1 .
   

   Ou utilisez une image officielle préconstruite :

   docker pull moonshotai/kimi-audio:v0.1
   

4. Exécution des conteneurs
   Démarrez le conteneur Docker et montez le répertoire de travail local :

   docker run -it -v $(pwd):/app kimi-audio:v0.1 bash
   

5. Télécharger le modèle de poids
   Kimi-Audio propose deux modèles principaux :Kimi-Audio-7B(modèle de base) et Kimi-Audio-7B-Instruct(Instructions pour affiner le modèle). Téléchargé de Hugging Face :
   • moonshotai/Kimi-Audio-7B-InstructLes produits de cette catégorie sont les suivants : ils conviennent à une utilisation directe.
   • moonshotai/Kimi-Audio-7BLes résultats de l'enquête ont été publiés sous la forme d'un rapport de synthèse.
     Utilisez le CLI Hugging Face pour vous connecter et télécharger :

   huggingface-cli login
   

   Le modèle est automatiquement téléchargé sur le chemin spécifié.

Utilisation

Les fonctions principales de Kimi-Audio sont mises en œuvre par le biais d'appels à l'API Python. Voici le déroulement détaillé des principales fonctions :

1. la reconnaissance vocale (ASR)

fichier audio en texte. Exemple de code :

import soundfile as sf
from kimia_infer.api.kimia import KimiAudio
# 加载模型
model_path = "moonshotai/Kimi-Audio-7B-Instruct"
model = KimiAudio(model_path=model_path, load_detokenizer=True)
# 设置采样参数
sampling_params = {
"audio_temperature": 0.8,
"audio_top_k": 10,
"text_temperature": 0.0,
"text_top_k": 5,
"audio_repetition_penalty": 1.0,
"audio_repetition_window_size": 64,
"text_repetition_penalty": 1.0,
"text_repetition_window_size": 16,
}
# 准备输入
asr_audio_path = "asr_example.wav"  # 确保文件存在
messages_asr = [
{"role": "user", "message_type": "text", "content": "请转录以下音频："},
{"role": "user", "message_type": "audio", "content": asr_audio_path}
]
# 生成文本输出
_, text_output = model.generate(messages_asr, **sampling_params, output_type="text")
print("转录结果：", text_output)

procédure: :

• Préparer un fichier audio au format WAV.
• mettre en place messages_asr Spécifier la tâche comme transcription.
• Exécutez le code et obtenez le texte en sortie.

2) Quiz audio (AQA)

Répondez aux questions en vous basant sur l'audio. Exemple :

qa_audio_path = "qa_example.wav"
messages_qa = [
{"role": "user", "message_type": "text", "content": "音频中说了什么？"},
{"role": "user", "message_type": "audio", "content": qa_audio_path}
]
_, text_output = model.generate(messages_qa, **sampling_params, output_type="text")
print("回答：", text_output)

procédure: :

• Télécharger un fichier audio contenant des informations.
• existent messages_qa Poser des questions spécifiques dans le
• Obtenir des réponses textuelles du modèle.

3. la synthèse vocale (TTS)

Convertit le texte en sortie vocale. Exemple :

messages_tts = [
{"role": "user", "message_type": "text", "content": "请将以下文本转为语音：你好，欢迎使用 Kimi-Audio！"}
]
audio_output, _ = model.generate(messages_tts, **sampling_params, output_type="audio")
sf.write("output.wav", audio_output, samplerate=16000)

procédure: :

• Saisissez le texte à convertir.
• mettre en place output_type="audio" Obtenir des données audio.
• utiliser soundfile Enregistrer en tant que fichier WAV.

4. dialogue vocal de bout en bout

Prend en charge l'interaction vocale continue. Exemple :

messages_conversation = [
{"role": "user", "message_type": "audio", "content": "conversation_example.wav"},
{"role": "user", "message_type": "text", "content": "请回复一段语音，介绍你的功能。"}
]
audio_output, text_output = model.generate(messages_conversation, **sampling_params, output_type="both")
sf.write("response.wav", audio_output, samplerate=16000)
print("文本回复：", text_output)

procédure: :

• Fournit la saisie vocale initiale et les commandes de texte.
• mettre en place output_type="both" Obtenir des réponses vocales et textuelles.
• Sauvegarder la sortie audio et afficher le texte.

5. l'utilisation de la boîte à outils d'évaluation

Avec l'aimable autorisation de Kimi-Audio Kimi-Audio-Evalkit Pour l'évaluation des performances du modèle. Installation :

git clone https://github.com/MoonshotAI/Kimi-Audio-Evalkit.git
cd Kimi-Audio-Evalkit
pip install -r requirements.txt

Évaluation opérationnelle :

bash run_audio.sh --model Kimi-Audio --dataset all

procédure: :

• Télécharger le jeu de données dans le répertoire spécifié.
• configurer config.yaml Spécifie le chemin d'accès au jeu de données.
• Exécutez le script pour générer le rapport d'évaluation.

mise en garde

• Assurez-vous que le format du fichier audio est WAV avec une fréquence d'échantillonnage de 16 kHz.
• L'environnement GPU accélère l'inférence et CUDA 12.4 est recommandé.
• Le chargement du modèle nécessite une grande quantité de mémoire, il est recommandé d'avoir au moins 16 Go de mémoire graphique.
• Les déploiements sans docker nécessitent l'installation manuelle des dépendances du système, voir la documentation GitHub.

scénario d'application

1. Service client intelligent
   Kimi-Audio peut être utilisé pour créer des systèmes de service à la clientèle pour l'interaction vocale. Il transcrit les questions des utilisateurs par reconnaissance vocale, combine des questions-réponses audio pour fournir des réponses et génère des réponses vocales naturelles. Il convient aux plateformes de commerce électronique ou aux scénarios d'assistance technique afin d'améliorer l'expérience de l'utilisateur.
2. Aides pédagogiques
   Dans le cadre de l'apprentissage des langues, Kimi-Audio transcrit la prononciation des élèves, analyse les émotions et l'intonation, et fournit un retour d'information. Il transcrit également les textes d'enseignement en paroles pour générer des supports d'écoute, ce qui le rend adapté aux plates-formes d'enseignement en ligne.
3. création de contenu
   Les producteurs de vidéos peuvent utiliser Kimi-Audio pour générer des sous-titres ou des doublages. Il peut générer automatiquement des sous-titres précis pour les vidéos ou convertir des scripts en paroles avec plusieurs tons pour simplifier la post-production.
4. dossier médical
   Les médecins peuvent saisir des cas par la voix, Kimi-Audio les transcrit en texte et classe les émotions pour aider à diagnostiquer l'état émotionnel du patient. Convient aux systèmes d'information des hôpitaux.

QA

1. Quelles sont les langues prises en charge par Kimi-Audio ?
   Kimi-Audio prend en charge la reconnaissance et la génération de la parole en plusieurs langues, en particulier en anglais et en chinois. Pour les autres langues, veuillez vous référer à la documentation officielle.
2. Comment optimiser la vitesse de raisonnement ?
   Pour utiliser l'accélération GPU, installez flash-attn bibliothèque, set torch_dtype=torch.bfloat16. En outre, les ajustements audio_top_k répondre en chantant text_top_k Les paramètres permettent d'équilibrer la vitesse et la qualité.
3. Le modèle permet-il un dialogue en temps réel ?
   Oui, le décodeur de streaming de Kimi-Audio prend en charge la génération audio à faible latence pour une interaction vocale en temps réel.
4. Comment ajouter un jeu de données personnalisé pour l'évaluation ?
   existent Kimi-Audio-Evalkit Créer un fichier JSONL dans le répertoire index,audio_path répondre en chantant question champ. Modifier config.yaml Il suffit de spécifier le chemin d'accès au jeu de données et d'exécuter le script d'évaluation.