1. 首页
  2. 技术文章

如何使用 NVIDIA Canary-1B-v2 在 Python 中实现 ASR、翻译和自动 SRT 字幕导出

AIGC • • 技术文章

本文将使用NVIDIA Canary-1B-v2构建一个语音识别和翻译工作流程。首先，我们将设置所需的音频、NeMo、NumPy 和 SciPy 依赖项，然后在支持 GPU 的运行时环境中加载 Canary 模型以进行高效推理。接下来，把音频处理成干净的 16 kHz 单声道格式，执行英语自动语音识别 (ASR)，将语音翻译成多种语言，生成单词和片段时间戳，将翻译后的字幕导出为 SRT 文件，测试长文本转录，运行批量处理，并测试推理速度。最终，我们将获得一个完整的多语言 ASR 和语音翻译流程，该流程可以应用于真实音频文件、字幕生成和大规模转录实验。

如何使用 NVIDIA Canary-1B-v2 在 Python 中实现 ASR、翻译和自动 SRT 字幕导出

安装 NeMo、音频库、NumPy 和 SciPy 依赖项

import os, subprocess, sys
SENTINEL = "/content/.canary_setup_done"
if not os.path.exists(SENTINEL):
   def sh(c):
       print("$", c); subprocess.run(c, shell=True, check=False)
   print(">>> PHASE 1: installing dependencies (one-time)...\n")
   sh("apt-get -qq update")
   sh("apt-get -qq install -y libsndfile1 ffmpeg > /dev/null")
   sh('pip install -q "nemo_toolkit[asr]"')
   sh("pip install -q librosa soundfile pydub")
   sh('pip install -q --force-reinstall --no-cache-dir "numpy>=2.2,<2.4" "scipy>=1.15"')
   open(SENTINEL, "w").write("done")
   print("\n Setup complete. Restarting the runtime now.")
   print("   When it reconnects, RUN THIS CELL AGAIN to start the tutorial.")
   os.kill(os.getpid(), 9)

我们为 NVIDIA Canary-1B-v2 教程搭建了环境，安装了所需的系统软件包、NeMo ASR 工具包、音频库以及兼容的 NumPy 和 SciPy 版本。然后创建了一个设置标记并重启运行时环境，以便在运行主教程之前正确加载更新后的依赖项。

正在加载 NVIDIA Canary-1B-v2 并检查 GPU 可用性

import time, json, gc, math, urllib.request
import torch, numpy as np, soundfile as sf, librosa
print(">>> PHASE 2: running tutorial\n")
print("NumPy:", np.__version__, "| PyTorch:", torch.__version__)
print("CUDA available:", torch.cuda.is_available())
if torch.cuda.is_available():
   print("GPU:", torch.cuda.get_device_name(0),
         f"| VRAM: {torch.cuda.get_device_properties(0).total_memory/1e9:.1f} GB")
else:
   print("  No GPU — will run on CPU (very slow). "
         "Set Runtime > Change runtime type > GPU.")
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
LANGS = {
   "bg":"Bulgarian","hr":"Croatian","cs":"Czech","da":"Danish","nl":"Dutch",
   "en":"English","et":"Estonian","fi":"Finnish","fr":"French","de":"German",
   "el":"Greek","hu":"Hungarian","it":"Italian","lv":"Latvian","lt":"Lithuanian",
   "mt":"Maltese","pl":"Polish","pt":"Portuguese","ro":"Romanian","sk":"Slovak",
   "sl":"Slovenian","es":"Spanish","sv":"Swedish","ru":"Russian","uk":"Ukrainian",
}
print(f"\nSupported languages ({len(LANGS)}):", ", ".join(LANGS.keys()))
from nemo.collections.asr.models import ASRModel
print("\nLoading nvidia/canary-1b-v2 ...")
t0 = time.time()
asr_model = ASRModel.from_pretrained(model_name="nvidia/canary-1b-v2").to(DEVICE).eval()
print(f"Model loaded in {time.time()-t0:.1f}s")

导入主要库并检查 CUDA 是否可用于 GPU 加速。定义支持的语言词典，以使 Canary 能够处理多语言 ASR 和翻译任务。然后从 NeMo 加载 NVIDIA Canary-1B-v2 模型，并将其移动到可用设备进行推理。

准备 16 kHz 音频并运行带翻译功能的英语自动语音识别

TARGET_SR = 16000
def prepare_audio(path_or_url, out_path=None):
   if str(path_or_url).startswith(("http://", "https://")):
       local = "/content/_dl_" + os.path.basename(path_or_url.split("?")[0])
       urllib.request.urlretrieve(path_or_url, local)
       path_or_url = local
   audio, _ = librosa.load(path_or_url, sr=TARGET_SR, mono=True)
   if out_path is None:
       base = os.path.splitext(os.path.basename(path_or_url))[0]
       out_path = f"/content/{base}_16k_mono.wav"
   sf.write(out_path, audio, TARGET_SR, subtype="PCM_16")
   dur = len(audio) / TARGET_SR
   print(f"Prepared: {out_path}  ({dur:.1f}s, 16kHz, mono)")
   return out_path, dur
SAMPLE_URL = "https://dldata-public.s3.us-east-2.amazonaws.com/2086-149220-0033.wav"
sample_wav, sample_dur = prepare_audio(SAMPLE_URL)
def transcribe(files, source_lang="en", target_lang="en", timestamps=False, batch_size=1):
   if isinstance(files, str):
       files = [files]
   return asr_model.transcribe(files, source_lang=source_lang, target_lang=target_lang,
                               timestamps=timestamps, batch_size=batch_size)
print("\n=== 1) BASIC ASR (English) ===")
res = transcribe(sample_wav, source_lang="en", target_lang="en")
print("Transcript:", res[0].text)
print("\n=== 2) TRANSLATION (EN audio -> X) ===")
for tgt in ["fr", "de", "es", "it"]:
   out = transcribe(sample_wav, source_lang="en", target_lang=tgt)
   print(f"  EN -> {LANGS[tgt]:<10} ({tgt}): {out[0].text}")
  • 创建一个可复用的音频准备函数，该函数会在需要时下载音频并将其转换为 16 kHz 单声道 WAV 格式。
  • 加载示例音频文件，并定义一个用于转录和翻译的辅助函数。
  • 运行基本的英语自动语音识别 (ASR) 功能，并将同一段英语语音翻译成法语、德语、西班牙语和意大利语。

生成单词和片段时间戳并导出 SRT 字幕

print("\n=== 3) TIMESTAMPS (ASR) ===")
ts_out = transcribe(sample_wav, source_lang="en", target_lang="en", timestamps=True)
word_ts = ts_out[0].timestamp.get("word", [])
seg_ts  = ts_out[0].timestamp.get("segment", [])
print("Segments:")
for s in seg_ts:
   print(f"  [{s['start']:6.2f}s - {s['end']:6.2f}s]  {s['segment']}")
print("First 10 words:")
for w in word_ts[:10]:
   print(f"  [{w['start']:6.2f}s - {w['end']:6.2f}s]  {w['word']}")
def _srt_time(t):
   h=int(t//3600); m=int((t%3600)//60); s=int(t%60); ms=int(round((t-int(t))*1000))
   return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
def segments_to_srt(segments, out_path="/content/output.srt"):
   lines=[]
   for i, seg in enumerate(segments, 1):
       lines += [str(i), f"{_srt_time(seg['start'])} --> {_srt_time(seg['end'])}",
                 seg["segment"].strip(), ""]
   open(out_path, "w", encoding="utf-8").write("\n".join(lines))
   print(f"Saved SRT: {out_path}")
   return out_path
print("\n=== 4) SRT EXPORT (translated French subtitles) ===")
fr_ts = transcribe(sample_wav, source_lang="en", target_lang="fr", timestamps=True)
segments_to_srt(fr_ts[0].timestamp["segment"], "/content/subtitles_fr.srt")
print(open("/content/subtitles_fr.srt").read())
  • 启用带时间戳的转录功能，以提取片段级和词级的时间信息。
  • 打印转录片段和前几个词的时间戳，以检查模型如何将文本与音频对齐。
  • 将翻译后的法语片段转换为 SRT 字幕文件并显示生成的字幕。

运行长篇转录、批量处理和速度基准测试

print("\n=== 5) LONG-FORM (sample tiled x6) ===")
long_audio, _ = librosa.load(sample_wav, sr=TARGET_SR, mono=True)
long_audio = np.tile(long_audio, 6)
sf.write("/content/long.wav", long_audio, TARGET_SR, subtype="PCM_16")
print(f"Long clip duration: {len(long_audio)/TARGET_SR:.1f}s")
long_out = transcribe("/content/long.wav", source_lang="en", target_lang="en", batch_size=1)
print("Long transcript (first 300 chars):", long_out[0].text[:300], "...")
print("\n=== 6) BATCH ===")
for name in ["clip_a", "clip_b"]:
   sf.write(f"/content/{name}.wav",
            librosa.load(sample_wav, sr=TARGET_SR, mono=True)[0], TARGET_SR, subtype="PCM_16")
batch = transcribe(["/content/clip_a.wav", "/content/clip_b.wav"],
                  source_lang="en", target_lang="en", batch_size=2)
for i, b in enumerate(batch):
   print(f"  file {i}: {b.text}")
print("\n=== 7) BENCHMARK ===")
t0 = time.time(); _ = transcribe(sample_wav, source_lang="en", target_lang="en")
elapsed = time.time()-t0
print(f"Audio: {sample_dur:.2f}s | Compute: {elapsed:.2f}s | RTFx ≈ {sample_dur/elapsed:.1f}x")
print("\n Done. Change source_lang/target_lang from the LANGS dict to try other languages.")
  • 通过多次重复播放示例音频并将较长的片段输入模型来测试长音频转录能力。
  • 创建两个相同的音频片段，以演示批量大小为 2 的批量转录。
  • 通过比较音频时长和计算时间来评估模型性能，并报告实时速度。

结论

我们完成了一个完整的端到端工作流程，将 NVIDIA Canary-1B-v2 用作多语言自动语音识别 (ASR) 和语音翻译系统。处理了原始音频，生成了准确的转录文本，将语音翻译成不同的目标语言，提取了时间戳，创建了字幕文件，处理了更长的音频片段，并通过简单的基准测试比较了运行时性能。现在，我们拥有一个可复用的、可在 Colab 上运行的流程，未来还可以通过自定义上传、支持更多语言、处理更大批量以及进行生产级音频处理等方式进一步扩展该流程。

作者：Sana Hassan
完整代码：https://github.com/MARKTECHPOST-AI-MEDIA-INC/AI-Agents-Projects-Tutorials/blob/main/Voice%20AI/nvidia_canary_1b_v2_asr_translation_tutorial_marktechpost.py

本文来自作者投稿，版权归原作者所有。如需转载，请注明出处：https://www.nxrte.com/jishu/68531.html

赞 (0)
AIGC的头像AIGC
0

相关推荐