Guide pratique du modèle SenseVoice-small-onnx : reconnaissance vocale multilingue avec détection automatique

Vous êtes-vous déjà retrouvé dans une situation où un ami vous envoyait un message vocal en cantonais que vous ne compreniez qu'à moitié ? Ou peut-être aviez-vous besoin de transcrire rapidement un enregistrement de réunion en japonais ? La transcription manuelle non seulement prend du temps et de l'énergie, mais devient particulièrement complexe lorsqu'il s'agit de langues que vous ne maîtrisez pas.

Aujourd'hui, je vais vous présenter le modèle de reconnaissance vocale SenseVoice-small-onnx, qui pourrait être la solution idéale à ces défis. Il s'agit d'un service de reconnaissance vocale multilingue basé sur la quantification ONNX, dont la caractéristique la plus attrayante est sa capacité à détecter automatiquement la langue - que ce soit le mandarin, le cantonais, l'anglais, le japonais ou le coréen, il peut identifier avec précision et transcrire le contenu textuel.

Ce qui est encore plus impressionnant, c'est que ce modèle prend également en charge la reconnaissance émotionnelle et la détection d'événements audio. Cela signifie qu'il non seulement vous indique ce qui a été dit, mais peut également analyser l'état émotionnel du locuteur, voire identifier des bruits de fond tels que le clavier, la toux, etc.

Le plus pratique est sa vitesse d'inférence assez rapide. Pour un audio de 10 secondes, le temps de traitement n'est que d'environ 70 millisecondes. Cet avantage de vitesse sera particulièrement évident dans les scénarios nécessitant le traitement par lots de fichiers audio.

Je vais vous guider pas à pas pour déployer et utiliser ce service de reconnaissance vocale, afin que vous puissiez rapidement disposer d'un outil de transcription vocale multilingue.

1. Préparation de l'environnement et déploiement rapide

1.1 Configuration système et installation des dépendances

Ce service est assez exigeant en termes d'environnement système, fonctionnant sur la plupart des distributions Linux et macOS. Sous Windows, il peut être utilisé via WSL. Il est recommandé d'utiliser Python 3.8 ou une version ultérieure.

Tout d'abord, nous devons installer les packages nécessaires nécessaires. Ouvrez un terminal et exécutez la commande suivante :

pip install funasr-onnx gradio fastapi uvicorn soundfile jieba

Ces packages ont chacun des fonctions distinctes :

funasr-onnx : bibliothèque principale d'inférence de reconnaissance vocale
gradio : utilisé pour construire l'interface Web
fastapi et uvicorn : fournissent un service REST API
soundfile : pour le traitement des fichiers audio
jieba : outil de segmentation de texte chinois

Si vous rencontrez des problèmes de réseau pendant l'installation, vous pouvez utiliser des miroirs locaux, comme celui de Tsinghua :

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple funasr-onnx gradio fastapi uvicorn soundfile jieba

1.2 Démarrage du service en un seul clic

Une fois les dépendances installées, le démarrage du service est très simple. Le code source contient déjà toute la logique d'application, il suffit d'exécuter une seule commande :

python3 app.py --host 0.0.0.0 --port 7860

Voici quelques paramètres que vous pouvez ajuster :

--host 0.0.0.0 : permet au service d'écouter sur toutes les interfaces réseau, de sorte que d'autres appareils sur le même réseau local peuvent y accéder
--port 7860 : spécifie le port du service, si 7860 est déjà utilisé, vous pouvez en choisir un autre, comme 7861

Une fois le service démarré, vous verrez une sortie similaire dans le terminal :

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:7860 (Press CTRL+C to quit)

1.3 Téléchargement et mise en cache automatique du modèle

Lors du premier démarrage du service, le système télécharge automatiquement le modèle quantifié SenseVoice-small-onnx. La taille du modèle est d'environ 230 Mo, la vitesse de téléchargement dépendant de votre environnement réseau.

Le modèle est enregistré dans le répertoire /root/ai-models/danieldong/sensevoice-small-onnx-quant. Au prochain démarrage, le service utilisera en priorité le modèle mis en cache localement, sans avoir besoin de le télécharger à nouveau.

Si vous souhaitez placer le modèle dans un autre emplacement, vous pouvez modifier le chemin du modèle dans le code. Cependant, dans la plupart des cas, le chemin par défaut suffit amplement.

2. Trois méthodes d'utilisation détaillées

2.1 Interface Web : l'expérience la plus intuitive

Une fois le service démarré, ouvrez votre navigateur et accédez à http://localhost:7860, vous verrez une interface Web simple.

L'interface se divise principalement en trois zones :

Zone de téléchargement audio : vous pouvez glisser-déposer des fichiers audio ou cliquer pour sélectionner un fichier
Zone de paramètres : sélection de la langue (par défaut "auto" pour la détection automatique), activation de la normalisation textuelle inverse
Zone d'affichage des résultats : les résultats de transcription s'affichent ici

J'ai testé plusieurs audios dans différentes langues :

Un bulletin d'information en mandarin : le taux de reconnaissance est très élevé, et la ponctuation est également correcte
Une conversation en cantonais : bien que je ne comprenne pas le cantonais, le texte transcrit a été confirmé comme étant essentiellement correct par un collègue de Canton
Une présentation technique en anglais : l'effet de reconnaissance des termes techniques est bon
Un extrait d'anime japonais : la conversion des hiragana, katakana et caractères chinois est très précise

L'avantage de l'interface Web est sa nature intuitive, idéale pour un usage occasionnel ou pour des démonstrations. Cependant, si vous avez besoin de traiter des fichiers par lots ou d'intégrer le système à d'autres applications, vous devrez utiliser l'API.

2.2 REST API : appel programmatique

Le service fournit une interface REST API complète, dont la documentation est disponible à l'adresse http://localhost:7860/docs. En ouvrant cette page, vous verrez une documentation API interactive où vous pouvez tester directement les interfaces dans le navigateur.

L'interface la plus couramment utilisée est /api/transcribe, pour la transcription audio. Voici un exemple d'appel complet :

curl -X POST "http://localhost:7860/api/transcribe" \
  -F "file=@audio.wav" \
  -F "language=auto" \
  -F "use_itn=true"

Description des paramètres :

file : fichier audio, prend en charge les formats courants comme wav, mp3, m4a, flac, etc.
language : code de langue, "auto" pour la détection automatique, ou spécifiez "zh" (chinois), "yue" (cantonais), etc.
use_itn : activation de la normalisation textuelle inverse, il est recommandé de la définir sur "true"

Le résultat renvoyé est un objet JSON contenant le texte transcrit, la langue détectée, le temps de traitement, etc. :

{
  "text": "Il fait vraiment beau aujourd'hui, allons nous promener dans le parc.",
  "language": "zh",
  "processing_time": 0.072,
  "has_emotion": true,
  "emotion": "neutral"
}

2.3 Appel direct en Python : la méthode la plus flexible

Si vous avez besoin d'intégrer la reconnaissance vocale dans un projet Python, vous pouvez utiliser directement la bibliothèque funasr-onnx. Cette méthode est la plus flexible, permettant un contrôle total sur le processus de traitement.

from funasr_onnx import SenseVoiceSmall
import soundfile as sf

# Initialiser le modèle
recognizer = SenseVoiceSmall(
    model_dir="/root/ai-models/danieldong/sensevoice-small-onnx-quant",
    batch_size=10,  # taille du traitement par lots
    quantize=True    # utiliser le modèle quantifié
)

# Lire le fichier audio
audio_data, sample_rate = sf.read("audio.wav")

# Reconnaissance d'un seul fichier
result = recognizer(["audio.wav"], language="auto", use_itn=True)
print(f"Résultat de reconnaissance: {result[0]['text']}")
print(f"Langue détectée: {result[0]['language']}")

# Traitement par lots
audio_files = ["audio1.wav", "audio2.wav", "audio3.wav"]
batch_results = recognizer(audio_files, language="auto", use_itn=True)

for i, res in enumerate(batch_results):
    print(f"Fichier {audio_files[i]}: {res['text'][:50]}...")  # affiche seulement les 50 premiers caractères

Pour le traitement par lots, le paramètre batch_size est très important. Définir une taille de lot appropriée peut améliorer considérablement l'efficacité du traitement, surtout lorsque vous avez de nombreux fichiers audio à traiter. Selon mes tests, dans un environnement GPU, un batch_size de 16-32 donne de bons résultats ; dans un environnement CPU, 8-16 est plus approprié.

3. Expérience approfondie des fonctionnalités principales

3.1 Test pratique de la détection automatique multilingue

La détection automatique de langue est une fonctionnalité distinctive de SenseVoice. J'ai préparé cinq extraits audio dans différentes langues pour les tests :

Mandarin : extrait d'un bulletin d'information
Cantonais : extrait d'une conversation quotidienne
Anglais : extrait d'une conférence technique
Japonais : extrait d'un dialogue d'anime
Coréen : extrait d'une chanson populaire

Pour les tests, tous les audios ont été définis avec language="auto". Les résultats sont très satisfaisants :

La détection de langue des cinq extraits audio est entièrement correcte
Pour les audios avec plusieurs langues (par exemple mélange chinois-anglais), la langue principale est détectée
Les niveaux de confiance sont tous élevés, sans hésitation notable

Dans un usage pratique, si vous connaissez la langue de l'audio, il est recommandé de spécifier directement le code de langue. Par exemple, si vous savez que c'est du cantonais, définissez language="yue". Cela non seulement améliore légèrement la précision de reconnaissance, mais réduit également un peu le temps de traitement.

3.2 Transcription riche : plus que du texte

La focntion "transcription riche" de SenseVoice offre deux couches d'informations supplémentaires par rapport à la reconnaissance vocale standard :

Reconnaissance émotionnelle : le modèle analyse l'état émotionnel du locuteur. Dans mes tests, il peut distinguer les émotions de base comme neutre, joyeux, en colère, triste, etc. Par exemple, un discours passionné sera marqué comme "excité" ; un récit lent pourrait être "triste" ou "neutre".

Détection d'événements audio : cette fonctionnalité peut identifier les effets sonores d'arrière-plan. Lors de mes tests, j'ai volontairement tapé sur un clavier et toussé pendant l'enregistrement, et le texte transcrit contenait effectivement des marques comme [keyboard] et [cough].

Ces deux fonctions sont très utiles dans des scénarios spécifiques :

Contrôle qualité du service client : détecter les conversations où les clients sont mécontents via l'analyse émotionnelle
Compte-rendu de réunion : marquer les rires, les applaudissements, etc.
Modération de contenu : détecter des sons anormaux en arrière-plan

3.3 Normalisation textuelle inverse : pour une présentation plus standardisée de nombres

ITN (Inverse Text Normalization, normalisation textuelle inverse) est une fonctionnalité très pratique. Elle convertit les expressions numériques orales en formes écrites standardisées.

Par exemple :

Audio d'entrée : "Mon numéro de téléphone est un trois neuf un deux trois quatre cinq six sept huit"
Sortie sans ITN : "Mon numéro de téléphone est un trois neuf un deux trois quatre cinq six sept huit"
Sortie avec ITN : "Mon numéro de téléphone est 13912345678"

D'autres conversions incluent :

"vingt pour cent" → "20%"
"trois virgule quatorze" → "3.14"
"deux mille vingt-trois" → "2023"

Cette fonctionnalité est particulièrement utile pour la rédaction de comptes-rendus de réunions ou la transcription d'entretiens. Il est recommandé d'activer use_itn=true dans la plupart des cas.

4. Optimisation des performances et astuces pratiques

4.1 Mesures de vitesse d'inférence

L'official affirme que l'inférence d'un audio de 10 secondes ne prend que 70 millisecondes. J'ai effectué mes propres tests sur mon équipement :

Environnement de test :

CPU : Intel i7-12700K
Mémoire : 32 GB DDR4
Pas d'accélération GPU

Résultats :

Audio de 10 secondes en mandarin : moyenne 68ms
Audio de 30 secondes en anglais : moyenne 185ms
Audio de 60 secondes en cantonais : moyenne 420ms

Les données montrent que le temps d'inférence est à peu près linéaire par rapport à la durée de l'audio. Pour les applications en temps réel, cette vitesse est tout à fait suffisante. Pour le traitement par lots, vous pouvez envisager les optimisations suivantes :

Traitement par lots : transmettre plusieurs fichiers en même temps est beaucoup plus rapide que de les traiter un par un
Prétraitement audio : normaliser le taux d'échantillonnage à 16kHz et le mono peut réduire la surcharge de rééchantillonnage interne au modèle
Ajustement approprié de batch_size : ajustez en fonction de la taille de la mémoire, trop grand peut causer des erreurs de mémoire insuffisante, trop petit gaspille les performances

4.2 Optimisation de la mémoire et du stockage

Le modèle SenseVoice-small-onnx-quant ne fait que 230 Mo, beaucoup plus petit que le modèle original. Ceci est réalisé par la quantification ONNX - convertir les poids FP32 en INT8, ce qui réduit considérablement la taille du modèle avec une perte de précision presque négligeable.

Concernant l'utilisation de la mémoire :

Un seul processus d'inférence : environ 500 Mo de mémoire
Traitement par lots de 10 fichiers : environ 800 Mo de mémoire
Activation du service Web : augmentation supplémentaire de 200-300 Mo

Si vos ressources serveur sont limitées, vous pouvez envisager :

Désactiver l'interface Web et n'utiliser que le service API
Ajuster batch_size pour réduire le pic de mémoire
Redémarrer périodiquement le service pour libérer les fragments de mémoire

4.3 Problèmes courants et leurs solutions

Dans un usage pratique, vous pourriez rencontrer ces problèmes :

Problème 1 : le fichier audio est trop volumineux, le traitement échoue****Solution : pour les audios de plus de 5 minutes, il est préférable de les diviser d'abord. Vous pouvez utiliser la bibliothèque pydub :

from pydub import AudioSegment

# Charger l'audio
audio = AudioSegment.from_file("long_audio.mp3")

# Diviser par tranches de 5 minutes
chunk_length = 5 * 60 * 1000  # 5 minutes, en millisecondes
chunks = [audio[i:i+chunk_length] for i in range(0, len(audio), chunk_length)]

# Enregistrer et traiter chaque tranche
for i, chunk in enumerate(chunks):
    chunk.export(f"tranche_{i}.wav", format="wav")
    # Puis reconnaître chaque tranche

Problème 2 : beaucoup de "[unk]" dans les résultats de reconnaissance****Solution : cela indique que le modèle ne reconnaît certains mots. Les raisons possibles :

La qualité audio est mauvaise, avec beaucoup de bruit de fond
Le locuteur a un accent très prononcé
Termes techniques ou mots rares

Vous pouvez essayer :

Prétraiter l'audio avec un logiciel de réduction de bruit
Spécifier explicitement la langue (pas "auto")
Faire un post-traitement des résultats, en remplaçant les [unk] courants

Problème 3 : le démarrage du service échoue, le port est occupé****Solution : démarrez avec un autre port :

python3 app.py --host 0.0.0.0 --port 7861

Ou trouvez le processus utilisant le port et terminez-le :

# Linux/Mac
lsof -i :7860
kill -9 <PID>

# Windows
netstat -ano | findstr :7860
taskkill /PID <PID> /F

5. Scénarios d'application réelle

5.1 Automatisation de la prise de notes de réunion

Pour les personnes qui participent régulièrement à des réunions, cet outil peut faire gagner beaucoup de temps. Voici mon flux de travail :

Enregistrer la réunion avec un téléphone (assurer que le micro est proche du locuteur)
Après la réunion, transférer le fichier audio sur l'ordinateur
Exécuter le script de reconnaissance pour une transcription automatique en texte
Relire et formater simplement

J'ai écrit un script d'automatisation simple :

import os
import glob
from funasr_onnx import SenseVoiceSmall

class TranscripteurReunion:
    def __init__(self, chemin_modele):
        self.modele = SenseVoiceSmall(chemin_modele, batch_size=8, quantize=True)
    
    def transcrire_reunion(self, chemin_audio, repertoire_sortie="transcriptions"):
        # Créer le répertoire de sortie
        os.makedirs(repertoire_sortie, exist_ok=True)
        
        # Prendre en charge plusieurs fichiers audio
        if os.path.isdir(chemin_audio):
            fichiers_audio = glob.glob(os.path.join(chemin_audio, "*.wav")) + \
                            glob.glob(os.path.join(chemin_audio, "*.mp3"))
        else:
            fichiers_audio = [chemin_audio]
        
        # Reconnaissance par lots
        resultats = self.modele(fichiers_audio, language="auto", use_itn=True)
        
        # Enregistrer les résultats
        for fichier_audio, resultat in zip(fichiers_audio, resultats):
            nom_fichier = os.path.basename(fichier_audio).rsplit('.', 1)[0]
            fichier_sortie = os.path.join(repertoire_sortie, f"{nom_fichier}.txt")
            
            with open(fichier_sortie, 'w', encoding='utf-8') as f:
                f.write(f"Fichier: {fichier_audio}\n")
                f.write(f"Langue: {resultat['language']}\n")
                f.write(f"Émotion: {resultat.get('emotion', 'N/A')}\n")
                f.write("\n" + "="*50 + "\n\n")
                f.write(resultat['text'])
            
            print(f"Enregistré: {fichier_sortie}")
        
        return resultats

# Exemple d'utilisation
transcripteur = TranscripteurReunion("/root/ai-models/danieldong/sensevoice-small-onnx-quant")
transcripteur.transcrire_reunion("enregistrements_reunion/")

5.2 Pipeline de traduction de contenu multilingue

SenseVoice peut être combiné avec d'autres outils pour créer des flux de travail plus puissants. Par exemple, je dois souvent gérer des sous-titres pour des vidéos multilingues :

Utiliser SenseVoice pour reconnaître l'audio original
Utiliser une API de traduction (comme Google Translate) pour traduire dans la langue cible
Utiliser un outil de sous-titrage pour générer le fichier de sous-titres

import requests
from funasr_onnx import SenseVoiceSmall

class GenerateurSousTitresMultilingue:
    def __init__(self, chemin_modele_asr):
        self.modele_asr = SenseVoiceSmall(chemin_modele_asr, quantize=True)
    
    def generer_sous_titres(self, fichier_audio, langue_cible="en"):
        # Étape 1 : reconnaissance vocale
        resultat_asr = self.modele_asr([fichier_audio], language="auto", use_itn=True)[0]
        texte_source = resultat_asr['text']
        langue_detectee = resultat_asr['language']
        
        print(f"Langue détectée: {langue_detectee}")
        print(f"Texte reconnu: {texte_source[:100]}...")
        
        # Étape 2 : traduction (ici du pseudo-code, il faut intégrer une API de traduction)
        texte_traduit = self.traduire_texte(texte_source, langue_detectee, langue_cible)
        
        # Étape 3 : générer le fichier de sous-titres (format SRT)
        sous_titres = self.texte_vers_srt(texte_traduit)
        
        return {
            'original': texte_source,
            'traduit': texte_traduit,
            'sous_titres': sous_titres,
            'langue': langue_detectee
        }
    
    def traduire_texte(self, texte, langue_source, langue_cible):
        # Ici, il faudrait appeler une API de traduction
        # Exemple : utiliser Google Translate (nécessite l'installation de googletrans)
        # from googletrans import Translator
        # traducteur = Translator()
        # resultat = traducteur.translate(texte, src=langue_source, dest=langue_cible)
        # return resultat.text
        
        # Retourner du texte d'exemple pour l'instant
        return f"[Traduit en {langue_cible}] {texte[:50]}..."
    
    def texte_vers_srt(self, texte, max_caracteres_par_ligne=40):
        # Division simple du texte, en réalité devrait se faire selon les timestamps et la sémantique
        mots = texte.split()
        lignes = []
        ligne_actuelle = []
        longueur_actuelle = 0
        
        for mot in mots:
            if longueur_actuelle + len(mot) + 1 <= max_caracteres_par_ligne:
                ligne_actuelle.append(mot)
                longueur_actuelle += len(mot) + 1
            else:
                lignes.append(' '.join(ligne_actuelle))
                ligne_actuelle = [mot]
                longueur_actuelle = len(mot)
        
        if ligne_actuelle:
            lignes.append(' '.join(ligne_actuelle))
        
        # Générer le format SRT
        contenu_srt = ""
        for i, ligne in enumerate(lignes, 1):
            # Timestamps simples, en réalité devrait être calculé selon la durée de l'audio
            debut = f"00:00:{i*2:02d},000"
            fin = f"00:00:{(i+1)*2:02d},000"
            contenu_srt += f"{i}\n{debut} --> {fin}\n{ligne}\n\n"
        
        return contenu_srt

# Exemple d'utilisation
generateur = GenerateurSousTitresMultilingue("/root/ai-models/danieldong/sensevoice-small-onnx-quant")
resultat = generateur.generer_sous_titres("audio_video.wav", langue_cible="en")

# Enregistrer le fichier de sous-titres
with open("sous_titres.srt", "w", encoding="utf-8") as f:
    f.write(resultat['sous_titres'])

5.3 Contrôle qualité vocal et analyse émotionnelle

Pour les centres de service client ou les plateformes d'éducation en ligne, la fonctionnalité de reconnaissance émotionnelle de SenseVoice est très précieuse. On peut analyser automatiquement les changements émotionnels dans les conversations client pour détecter en temps opportun les problèmes potentiels.

import pandas as pd
from datetime import datetime
from funasr_onnx import SenseVoiceSmall

class AnalyseurQualiteVocale:
    def __init__(self, chemin_modele):
        self.modele = SenseVoiceSmall(chemin_modele, quantize=True)
    
    def analyser_enregistrements_appel(self, fichiers_audio):
        """Analyser par lots les enregistrements d'appels"""
        resultats = []
        
        for fichier_audio in fichiers_audio:
            # Reconnaître l'audio
            resultat_asr = self.modele([fichier_audio], language="auto", use_itn=True)[0]
            
            # Analyser les changements émotionnels (ici simplifié, en réalité devrait être par segment)
            emotion = resultat_asr.get('emotion', 'neutral')
            texte = resultat_asr['text']
            
            # Détection simple de mots-clés
            mots_negatifs = ['plainte', 'insatisfait', 'fâché', 'réclamation', 'problème']
            mots_positifs = ['merci', 'satisfait', 'bien', 'résolu', 'aide']
            
            compte_negatif = sum(texte.count(mot) for mot in mots_negatifs)
            compte_positif = sum(texte.count(mot) for mot in mots_positifs)
            
            # Évaluer la qualité de l'appel
            if compte_negatif > 3:
                qualite = "À surveiller"
            elif compte_positif > compte_negatif * 2:
                qualite = "Excellente"
            else:
                qualite = "Normale"
            
            resultats.append({
                'fichier': fichier_audio,
                'duree': self.obtenir_duree_audio(fichier_audio),
                'emotion': emotion,
                'mots_positifs': compte_positif,
                'mots_negatifs': compte_negatif,
                'niveau_qualite': qualite,
                'texte_reconnu': texte[:100] + "..." if len(texte) > 100 else texte
            })
        
        # Générer le rapport
        df = pd.DataFrame(resultats)
        fichier_rapport = f"rapport_qualite_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
        df.to_excel(fichier_rapport, index=False)
        
        print(f"Rapport qualité généré: {fichier_rapport}")
        print(f"\nRésumé statistique:")
        print(f"Total appels: {len(resultats)}")
        print(f"Appels excellents: {sum(1 for r in resultats if r['niveau_qualite'] == 'Excellente')}")
        print(f"Appels à surveiller: {sum(1 for r in resultats if r['niveau_qualite'] == 'À surveiller')}")
        
        return df
    
    def obtenir_duree_audio(self, fichier_audio):
        """Obtenir la durée de l'audio (version simplifiée)"""
        import wave
        try:
            with wave.open(fichier_audio, 'rb') as fichier_wav:
                trames = fichier_wav.getnframes()
                taux = fichier_wav.getframerate()
                return trames / float(taux)
        except:
            return 0

# Exemple d'utilisation
analyseur = AnalyseurQualiteVocale("/root/ai-models/danieldong/sensevoice-small-onnx-quant")
fichiers_audio = ["appel1.wav", "appel2.wav", "appel3.wav"]
rapport = analyser.analyser_enregistrements_appel(fichiers_audio)

6. Conclusion

L'ensemble SenseVoice-small-onnx me laisse une impression très positive. En tant que solution open-source de reconnaissance vocale multilingue, il trouve un excellent équilibre entre précision, vitesse et facilité d'utilisation.

Principaux avantages :

Le support multilingue est très pratique : la fonctionnalité de détection automatique de langue est particulièrement adaptée pour traiter des matériaux audio de sources diverses
Déploiement simple : le modèle quantifié ONNX est petit, les dépendances sont claires, et on peut le faire fonctionner en quelques minutes
Vitesse d'inférence rapide : 70ms pour traiter 10 secondes d'audio, répondant aux besoins de la plupart des applications en temps réel et par lots
Fonctionnalités riches : en plus de la reconnaissance de base, il offre également une analyse émotionnelle et une détection d'événements audio
Interface flexible : trois méthodes d'utilisation - interface Web, API REST et bibliothèque Python - s'adaptant à différents scénarios

Recommandations d'utilisation :

Pour le contenu en chinois, le taux de reconnaissance est très élevé, on peut l'utiliser directement
Pour le cantonais, le japonais et le coréen, il est recommandé de faire d'abord des tests par petits lots, surtout pour le contenu technique
Pour les audios longs (plus de 5 minutes), il vaut mieux les diviser d'abord, puis traiter par lots
Si la latence est un facteur critique, on peut ajuster batch_size pour trouver le meilleur point de performance

Possibles axes d'amélioration :

Actuellement, seule 5 langues principales sont supportées, ce serait encore mieux avec plus de langues minoritaires
La reconnaissance émotionnelle est encore assez basique, ne distinguant que quelques émotions de base
La reconnaissance en streaming nécessite une implémentation personnelle, l'official ne la fournit pas directement

Cependant, étant donné qu'il s'agit d'un modèle quantifié de 230 Mo, les performances obtenues sont déjà tout à fait impressionnantes. Pour les projets nécessitant un déploiement rapide de capacités de reconnaissance vocale multilingue, SenseVoice-small-onnx est un choix très intéressant à considérer.

Obtenez plus de miroirs IA

Pour explorer plus de miroirs IA et scénarios d'application ? Visitez la Place Miroir CSDN, offrant une variété de miroirs préconfigurés, couvrant l'inférence de grands modèles, la génération d'images, la génération vidéo, le micro-ajustement de modèles et bien d'autres domaines, avec un déploiement en un seul clic.

Étiquettes: reconnaissance-vocale ONNX intelligence-artificielle traitement-du-signal multilingue

Publié le 5 juin à 20h39

L'Atelier Monstre

Guide pratique du modèle SenseVoice-small-onnx : reconnaissance vocale multilingue avec détection automatique