Antes de instalar el modelo de reconocimiento de voz Qwen3-ASR-0.6B, es fundamental preparar el entorno adecuado. Comencemos actualizando los repositorios del sistema e instalando los paquetes esenciales para la compilación y el menejo de multimedia.

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3.8 python3.8-venv python3.8-dev python3-pip build-essential git wget ffmpeg

Configuración del entorno de aceleración por GPU

El modelo requiere una GPU NVIDIA compatible con CUDA para un rendimiento óptimo. Primero, instalaremos los controladores gráficos recomendados. Utiliza el comando ubuntu-drivers devices para identificar la versión sugerida para tu hardware y procede con su instalación.

sudo apt install nvidia-driver-535
sudo reboot

Tras reiniciar, confirma que el controlador está operativo inspeccionando la información de la GPU con nvidia-smi. El siguiente paso es instalar el toolkit de CUDA, por ejemplo, la versión 11.8, descargando el instalador oficial y ejecutándolo sin seleccionar el componente del controlador.

wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run
sudo sh cuda_11.8.0_520.61.05_linux.run

Configura las variables de entorno necesarias para que el sistema localice las herramientas de CUDA y las bibliotecas.

echo 'export PATH=/usr/local/cuda-11.8/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

Preparación del entorno de Python e instalación del modelo

Para aislar las dependencias del proyecto, crea y activa un entorno virtual dedicado.

python3.8 -m venv entorno_asr
source entorno_asr/bin/activate
pip install --upgrade pip

Procede a instalar el paquete principal del modelo. Este comando gestionará las dependencias base como PyTorch y Transformers.

pip install qwen-asr

Para obtener tiempos de inferencia más reducidos, es altamente recomendable instalar soporte para vLLM y la optimización FlashAttention.

pip install qwen-asr[vllm]
pip install flash-attn --no-build-isolation

Verificación del entorno y descarga de pesos

Crea un script de verificación rápida para comprobar la disponibilidad de CUDA y la capacidad de cargar el modelo. Guarda el siguiente contenido en comprobar.py:

import torch
from qwen_asr import Qwen3ASRModel

dispositivo = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Dispositivo de cómputo: {dispositivo}")
if dispositivo == "cuda":
    print(f"Nombre de la GPU: {torch.cuda.get_device_name(0)}")

try:
    modelo_prueba = Qwen3ASRModel.from_pretrained("Qwen/Qwen3-ASR-0.6B", device_map="auto", torch_dtype=torch.float16)
    print("La carga del modelo fue exitosa.")
except Exception as error:
    print(f"Error al cargar el modelo: {error}")

Ejecuta el script con python comprobar.py. Una vez validado, descarga los pesos completos del modelo usando la utilidad de Hugging Face Hub.

pip install huggingface-hub
python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='Qwen/Qwen3-ASR-0.6B', local_dir='./pesos_qwen3_asr')"

Ejemplo práctico de transcripción

Finalmente, prueba el modelo con un archivo de audio. El siguiente código descarga una muestra de audio en inglés y realiza la transcripción.

import torch
from qwen_asr import Qwen3ASRModel
import requests

ruta_pesos = "./pesos_qwen3_asr"
red = Qwen3ASRModel.from_pretrained(ruta_pesos, device_map="auto", torch_dtype=torch.float16)

url_audio = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav"
nombre_archivo = "audio_prueba.wav"
with open(nombre_archivo, "wb") as archivo:
    archivo.write(requests.get(url_audio).content)

salida = red.transcribe(audio=nombre_archivo, language=None)
print(f"Idioma detectado: {salida[0].language}")
print(f"Texto transcrito: {salida[0].text}")

Para aplicaciones en tiempo real, el modelo ofrece un método de transmisión en flujo (stream_transcribe) que entrega resultados parciales progresivamente. Para procesar múltiples archivos de manera eficiente, puedes pasar una lista de rutas al método transcribe, lo que aprovechará el procesamiento por lotes.

Resolución de problemas comunes

Si encuentras errores de incompatibilidad de versiones de CUDA con PyTorch, reinstala los binarios específicos de tu versión de toolkit. En caso de que la memoria de la GPU sea limitada, puedes ajustar el parámetro max_memory en la carga del modelo o utilizar explícitamente torch.float16 como se muestra en los ejemplos. Para conflictos de dependencias, recrear el entorno virtual suele ser la solución más efectiva.