Introduction et prérequis

Le modèle Fun-ASR-MLT-Nano-2512 est un modèle de reconnaissance vocale multilingue développé par le laboratoire Tongyi d'Alibaba. Il prend en charge 31 langues avec une haute précision. Ce modèle de 800 millions de paramètres gère les langues principales comme le chinois, l'anglais, le japonais et le coréen, et offre des fonctionnalités spécifiques telles que la reconnaissance du cantonais, des paroles de chansons et du son en champ lointain.

Pour un déploiement stable en production, il est crucial de garantir la continutié du service. Voici les exigences de base du système :

• Système d'exploitation : Linux (Ubuntu 20.04 ou supérieur recommandé)
• Version de Python : 3.8 ou supérieure
• Mémoire vive : 8 Go minimum
• Espace disque : 5 Go d'espace libre minimum
• GPU : Facultatif mais recommandé pour l'accélération CUDA

Vérification rapide de l'environnement :

# Vérifier la version de Python
python3 --version

# Vérifier la mémoire disponible
free -h

# Vérifier l'espace disque
df -h

Installation des dépendances

Dépendances système

Installez d'abord les outils système nécessaires :

# Mise à jour de la liste des paquets
sudo apt-get update

# Installation de FFmpeg pour le traitement audio
sudo apt-get install -y ffmpeg

# Installation d'outils utilitaires
sudo apt-get install -y git wget curl

Dépendances Python

Depuis le répertoire du projet, installez les paquets Python requis :

# Navigation vers le répertoire du projet
cd /opt/modeles/fun-asr-nano

# Installation des dépendances listées
pip install -r requirements.txt

# Installation de PyTorch avec support CUDA (si nécessaire)
pip install torch torchaudio --extra-index-url https://download.pytorch.org/whl/cu116

Vérifiez l'installation :

python3 -c "import torch; print('Version de PyTorch :', torch.__version__)"
python3 -c "import gradio; print('Version de Gradio :', gradio.__version__)"

Schémas de déploiement initial

Lancement de base

Le démarrage le plus simple s'effectue directement en ligne de commande :

cd /opt/modeles/fun-asr-nano
python app.py

Cette méthode arrête le service à la fermeture du terminal, ce qui n'est pas adapté à la production.

Exécution en arrière-plan avec nohup

Une méthode plus robuste utilise nohup pour maintenir le processus :

cd /opt/modeles/fun-asr-nano
nohup python app.py > /var/log/asr/app.log 2>&1 &
echo $! > /var/run/asr/app.pid

Cette commande effectue trois actions : lance l'application en arrière-plan, redirige les sorties standard et d'erreur vers un fichier log, et enregistre l'identifiant du processus (PID) dans un fichier dédié.

Vérification de l'état du service

Après le démarrage, contrôlez le bon fonctionnement :

# Vérifier la présence du processus
ps aux | grep "python app.py"

# Consulter les dernières lignes du journal
tail -n 10 /var/log/asr/app.log

# Contrôler l'écoute du port
ss -tlnp | grep 7860

# Tester la réponse du service
curl http://localhost:7860

Suite complète de scripts de gestion

Script de démarrage

Créez un script de démarrage professionnel, par exemple /usr/local/bin/demarrer-asr :

#!/bin/bash
# Script de démarrage pour le service de reconnaissance vocale
NOM_APP="asr-nano"
REPERTOIRE_TRAVAIL="/opt/modeles/fun-asr-nano"
FICHIER_LOG="/var/log/asr/service.log"
FICHIER_PID="/var/run/asr/service.pid"

# Création des répertoires nécessaires
mkdir -p "$(dirname "$FICHIER_LOG")" "$(dirname "$FICHIER_PID")"

# Vérification si le service tourne déjà
if [ -f "$FICHIER_PID" ] && kill -0 "$(cat "$FICHIER_PID")" 2>/dev/null; then
    echo "Le service $NOM_APP est déjà actif (PID : $(cat "$FICHIER_PID"))"
    exit 1
fi

# Démarrage de l'application
cd "$REPERTOIRE_TRAVAIL" || exit 1
echo "Démarrage de $NOM_APP..."
nohup python app.py >> "$FICHIER_LOG" 2>&1 &
NOUVEAU_PID=$!

# Enregistrement du PID
echo "$NOUVEAU_PID" > "$FICHIER_PID"
echo "$NOM_APP démarré avec succès. PID : $NOUVEAU_PID"
echo "Journal des événements : $FICHIER_LOG"

Rendez-le exécutable : chmod +x /usr/local/bin/demarrer-asr

Script d'arrêt

Créez le script d'arrêt correspondant /usr/local/bin/arreter-asr :

#!/bin/bash
FICHIER_PID="/var/run/asr/service.pid"

if [ ! -f "$FICHIER_PID" ]; then
    echo "Fichier PID introuvable. Le service n'est peut-être pas lancé."
    exit 1
fi

PID_CIBLE=$(cat "$FICHIER_PID")
if kill -0 "$PID_CIBLE" 2>/dev/null; then
    echo "Arrêt du service (PID : $PID_CIBLE)..."
    kill "$PID_CIBLE"
    sleep 2
    # Vérification et arrêt forcé si nécessaire
    if kill -0 "$PID_CIBLE" 2>/dev/null; then
        echo "Arrêt forcé en cours..."
        kill -9 "$PID_CIBLE"
    fi
    rm -f "$FICHIER_PID"
    echo "Service arrêté."
else
    echo "Processus introuvable. Nettoyage du fichier PID."
    rm -f "$FICHIER_PID"
fi

Script de redémarrage

Le script de redémarrage /usr/local/bin/redemarrer-asr combine les deux précédents :

#!/bin/bash
echo "Redémarrage du service de reconnaissance vocale..."
/usr/local/bin/arreter-asr
sleep 3
/usr/local/bin/demarrer-asr

Script de vérification d'état

Le script /usr/local/bin/statut-asr fournit un aperçu rapide :

#!/bin/bash
FICHIER_PID="/var/run/asr/service.pid"
FICHIER_LOG="/var/log/asr/service.log"

if [ -f "$FICHIER_PID" ]; then
    PID_CIBLE=$(cat "$FICHIER_PID")
    if kill -0 "$PID_CIBLE" 2>/dev/null; then
        DUREE=$(ps -p "$PID_CIBLE" -o etime= | xargs)
        MEMOIRE=$(ps -p "$PID_CIBLE" -o rss= | awk '{printf "%.1f Mo\n", $1/1024}')
        echo "✅ Service actif (PID : $PID_CIBLE)"
        echo "⏱  Durée d'exécution : $DUREE"
        echo "📊 Utilisation mémoire : $MEMOIRE"
        
        # Vérification du port
        if ss -tln | grep -q ":7860"; then
            echo "🌐 Écoute sur le port 7860 confirmée."
        else
            echo "❌ Port 7860 non en écoute."
        fi
    else
        echo "❌ Fichier PID présent mais processus absent."
        rm -f "$FICHIER_PID"
    fi
else
    echo "❌ Service non actif (fichier PID manquant)."
fi

echo ""
echo "📝 Dernières lignes du journal :"
tail -n 5 "$FICHIER_LOG" 2>/dev/null || echo "Fichier de log introuvable."

Gestion avancée des journaux

Configuration de la rotation des logs

Pour éviter l'occupation excessive de l'espace disque, configurez la rotation via /etc/logrotate.d/asr-nano :

/var/log/asr/service.log {
    daily
    missingok
    rotate 7
    compress
    delaycompress
    notifempty
    copytruncate
    create 644 root root
}

Cette configuration effectue une rotation quotidienne, conserve 7 fichiers de log, compresse les anciens et n'interrompt pas le service en cours.

Journalisation améliorée au démarrage

Enrichissez le script de démarrage pour consigner des métriques système :

#!/bin/bash
# ... variables inchangées ...
FICHIER_LOG_SYSTEME="/var/log/asr/startup-metrics.log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$FICHIER_LOG_SYSTEME"
}

log "Début de la séquence de démarrage."
# ... vérification et arrêt d'un service existant ...

cd "$REPERTOIRE_TRAVAIL" || exit 1
nohup python app.py >> "$FICHIER_LOG" 2>&1 &
NOUVEAU_PID=$!
sleep 5

if kill -0 "$NOUVEAU_PID" 2>/dev/null; then
    echo "$NOUVEAU_PID" > "$FICHIER_PID"
    log "Démarrage réussi. PID : $NOUVEAU_PID"
    # Enregistrement des métriques
    {
        echo "Métriques système :"
        echo "CPU : $(nproc) cœurs"
        echo "RAM : $(free -h | awk '/Mem:/{print $2}')"
        echo "Disque (racine) : $(df -h / | awk 'NR==2{print $4}') libre"
    } >> "$FICHIER_LOG_SYSTEME"
else
    log "Échec du démarrage. Consulter $FICHIER_LOG"
    exit 1
fi

Intégration au système avec systemd

Création du fichier de service

Pour une gestion native du système, créez /etc/systemd/system/asr-nano.service :

[Unit]
Description=Service de reconnaissance vocale ASR Nano
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/opt/modeles/fun-asr-nano
ExecStart=/usr/bin/python3 app.py
Restart=on-failure
RestartSec=15
StandardOutput=append:/var/log/asr/service.log
StandardError=append:/var/log/asr/service-error.log
Environment=PYTHONUNBUFFERED=1

[Install]
WantedBy=multi-user.target

Commandes de gestion systemd

# Recharger la configuration systemd
sudo systemctl daemon-reload

# Démarrer le service
sudo systemctl start asr-nano

# Activer le démarrage automatique au boot
sudo systemctl enable asr-nano

# Vérifier le statut
sudo systemctl status asr-nano

# Suivre les logs en temps réel
sudo journalctl -u asr-nano -f

Script de supervision

Créez un script de surveillance /opt/scripts/surveiller-asr.sh pour vérifier périodiquement l'état via systemd :

#!/bin/bash
NOM_SERVICE="asr-nano"
INTERVALLE=60
MAX_REDEMARRAGES=3
compteur_redemarrages=0

while true; do
    if ! systemctl is-active --quiet "$NOM_SERVICE"; then
        echo "[$(date)] Service anormal. Tentative de redémarrage..."
        systemctl restart "$NOM_SERVICE"
        ((compteur_redemarrages++))
        echo "[$(date)] Nombre de redémarrages : $compteur_redemarrages/$MAX_REDEMARRAGES"
        
        if [ "$compteur_redemarrages" -ge "$MAX_REDEMARRAGES" ]; then
            echo "[$(date)] Nombre maximum de redémarrages atteint. Arrêt de la surveillance."
            # Ici, on pourrait envoyer une alerte (email, webhook, etc.)
            break
        fi
    else
        compteur_redemarrages=0
    fi
    sleep "$INTERVALLE"
done

Résolution de problèmes courants

Échec au démarrage

Si le service démarre mal, suivez cette procédure de diagnostic :

# 1. Vérifier les dépendances Python installées
pip list | grep -E "torch|gradio|funasr"

# 2. Lancer manuellement pour voir les erreurs
cd /opt/modeles/fun-asr-nano && python app.py

# 3. Vérifier les conflits de port
ss -tlnp | grep 7860

# 4. S'assurer que le fichier modèle est présent et valide
ls -lh model.pt

# 5. Tester la disponibilité de CUDA
python3 -c "import torch; print('CUDA disponible :', torch.cuda.is_available())"

Optimisation des performances

Si le service manque de réactivité, envisagez ces optimisations :

# 1. Forcer l'utilisation du GPU
export CUDA_VISIBLE_DEVICES=0

# 2. (Dans app.py) Augmenter la taille des lots de traitement (batch_size)

# 3. Installer FFmpeg pour un décodage audio accéléré
sudo apt-get install -y ffmpeg

# 4. Surveiller la charge en temps réel
top -p $(cat /var/run/asr/service.pid)

Analyse des journaux

Utilitaires pour analyser les fichiers de log :

# Suivre le flux en temps réel
tail -f /var/log/asr/service.log

# Rechercher des erreurs
grep -i "error\|exception" /var/log/asr/service.log

# Compter les requêtes traitées
grep -c "Traitement terminé" /var/log/asr/service.log

# Extraire les temps de réponse
grep "Temps de traitement" /var/log/asr/service.log