Procédure de déploiement express

Le modèle Qwen3-ASR-1.7B est conçu pour la transcription vocale de haute précision. Sa configuration initiale est conçue pour être accessible, même pour les développeurs moins expérimentés. Cette version de 1,7 milliard de paramètres offre une amélioration significative par rapport aux itérations antérieures, notamment dans la compréhension du contexte et du vocabulaire spécialisé.

1. Vérification des prérequis système

Assurez-vous que votre environnement remplit ces conditions :

• Système d'exploitation : Distribution Linux récente (Ubuntu 18.04+, CentOS 7+). Pour Windows, utilisez WSL2.
• Accélérateur graphique : Un GPU NVIDIA avec au moins 8 Go de mémoire VRAM (recommandé : RTX 3080 ou supérieur).
• Mémoire vive : 16 Go de RAM ou plus.
• Espace disque : Au moins 10 Go d'espace libre.

2. Configuration de l'environnement Python

Installez les dépendances et créez un environnement isolé avec les commandes suivantes :

# Mise à jour des dépôts et installation des paquets système
sudo apt-get update && sudo apt-get install -y python3-pip python3-venv ffmpeg

# Création et activation d'un environnement virtuel
python3 -m venv venv_qwen_asr
source venv_qwen_asr/bin/activate

# Installation des bibliothèques Python nécessaires
pip install torch torchaudio --extra-index-url https://download.pytorch.org/whl/cu118
pip install transformers soundfile numpy

3. Chargement du modèle et du processeur

Utilisez la bibliothèque transformers pour télécharger et charger automatiquement le modèle et son processeur associé.

from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
import torch

# Identifier le modèle à utiliser
model_id = "Qwen/Qwen3-ASR-1.7B"

# Charger le modèle avec les paramètres optimaux
asr_model = AutoModelForSpeechSeq2Seq.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Charger le processeur audio (feature_extractor + tokenizer)
speech_processor = AutoProcessor.from_pretrained(model_id)

print("Chargement du modèle Qwen3-ASR-1.7B terminé.")

4. Création d'un pipeline de transcription

Assemblez le modèle et le processeur dans un pipeline de traitement pour simplifier les appels.

from transformers import pipeline

# Déterminer le périphérique de calcul
calc_device = "cuda" if torch.cuda.is_available() else "cpu"

# Initialiser le pipeline de reconnaissance vocale
transcription_pipeline = pipeline(
    task="automatic-speech-recognition",
    model=asr_model,
    tokenizer=speech_processor.tokenizer,
    feature_extractor=speech_processor.feature_extractor,
    device=calc_device
)

print(f"Pipeline de transcription prêt. Périphérique utilisé : {calc_device}")

5. Transcription d'un fichier audio

Pour effecteur une transcription, chargez un fichier audio (format WAV recommandé) et passez-le au pipeline.

def transcrire_audio(fichier_audio, langue="zh"):
    """
    Transcrit le fichier audio spécifié.
    
    :param fichier_audio: Chemin vers le fichier audio (.wav, .mp3, etc.)
    :param langue: Code de la langue cible (ex: 'zh' pour chinois, 'en' pour anglais, 'auto' pour détection automatique)
    :return: Le texte transcrit
    """
    parametres_generation = {
        "language": langue,
        "task": "transcribe"
    }
    
    resultat = transcription_pipeline(
        fichier_audio,
        generate_kwargs=parametres_generation
    )
    
    return resultat["text"]

# Exemple d'utilisation
texte_transcrit = transcrire_audio("enregistrement.wav", langue="zh")
print("Transcription :", texte_transcrit)

6. Traitement par lots et optimisations

Pour améliorer l'efficacité lors du traitement de plusieurs fichiers ou d'enregistrements longs, certaines optimisations sont recommandées.

Transcription de plusieurs fichiers

import glob

def traiter_lot_audio(repertoire_entree, fichier_sortie="resultats.txt"):
    """
    Transcrit tous les fichiers WAV d'un répertoire.
    """
    fichiers_audio = glob.glob(f"{repertoire_entree}/*.wav")
    
    with open(fichier_sortie, "w", encoding="utf-8") as fichier_resultats:
        for chemin_fichier in fichiers_audio:
            texte = transcrire_audio(chemin_fichier, langue="auto")
            nom_fichier = chemin_fichier.split('/')[-1]
            ligne_resultat = f"{nom_fichier}:\n{texte}\n\n"
            fichier_resultats.write(ligne_resultat)
            print(f"Traité : {nom_fichier}")

# Exemple d'appel
traiter_lot_audio("./audio_dossier")

Paramètres pour la gestion de la mémoire et des longs enregistrements

Pour les enregistrements longs ou les environnements avec peu de mémoire, ajustez la taille des segments audio traités.

# Configuration pour la gestion de la mémoire
config_memoire = {
    "chunk_length_s": 20,   # Durée de chaque segment en secondes
    "stride_length_s": 5,   # Chevauchement entre les segments
    "batch_size": 4         # Nombre de segments traités en parallèle
}

# Appliquer lors de l'appel au pipeline
resultat_long = transcription_pipeline(
    "enregistrement_long.wav",
    **config_memoire,
    generate_kwargs={"language": "auto"}
)
print("Transcription de l'enregistrement long réussie.")