mirror of
https://github.com/k2-fsa/sherpa-onnx.git
synced 2026-11-10 21:11:03 +08:00
120 lines
3.9 KiB
Rust
120 lines
3.9 KiB
Rust
// Copyright (c) 2026 Yujie Wu
|
|
//
|
|
// This file demonstrates how to use Whisper with sherpa-onnx's Rust API
|
|
// for offline speech recognition.
|
|
//
|
|
// See ../README.md for how to run it.
|
|
|
|
use clap::Parser;
|
|
use sherpa_onnx::{OfflineRecognizer, OfflineRecognizerConfig, OfflineWhisperModelConfig, Wave};
|
|
use std::time::Instant;
|
|
|
|
/// Whisper offline ASR example
|
|
#[derive(Parser, Debug)]
|
|
#[command(author, version, about, long_about = None)]
|
|
struct Args {
|
|
/// Path to encoder ONNX model
|
|
#[arg(long)]
|
|
encoder: String,
|
|
|
|
/// Path to decoder ONNX model
|
|
#[arg(long)]
|
|
decoder: String,
|
|
|
|
/// Path to tokens file
|
|
#[arg(long)]
|
|
tokens: String,
|
|
|
|
/// Path to input WAV file
|
|
#[arg(long)]
|
|
wav: String,
|
|
|
|
/// Recognition language, e.g. "en", "zh". Leave empty for auto-detection
|
|
#[arg(long, default_value = "")]
|
|
language: String,
|
|
|
|
/// Task type: "transcribe" or "translate" (translate to English)
|
|
#[arg(long, default_value = "transcribe")]
|
|
task: String,
|
|
|
|
/// Provider (default: cpu)
|
|
#[arg(long, default_value = "cpu")]
|
|
provider: String,
|
|
|
|
/// Enable debug logs
|
|
#[arg(long, default_value_t = false)]
|
|
debug: bool,
|
|
|
|
/// Number of threads
|
|
#[arg(long, default_value_t = 2)]
|
|
num_threads: i32,
|
|
}
|
|
|
|
fn main() {
|
|
let args = Args::parse();
|
|
|
|
let wave = Wave::read(&args.wav).expect("Failed to read WAV file");
|
|
let audio_duration = wave.samples().len() as f64 / wave.sample_rate() as f64;
|
|
|
|
// Create default recognizer config
|
|
let mut recognizer_config = OfflineRecognizerConfig::default();
|
|
|
|
// Set the Whisper model
|
|
recognizer_config.model_config.whisper = OfflineWhisperModelConfig {
|
|
encoder: Some(args.encoder.clone()),
|
|
decoder: Some(args.decoder.clone()),
|
|
language: Some(args.language.clone()),
|
|
task: Some(args.task.clone()),
|
|
tail_paddings: 0,
|
|
enable_token_timestamps: false,
|
|
enable_segment_timestamps: false,
|
|
};
|
|
|
|
recognizer_config.model_config.tokens = Some(args.tokens.clone());
|
|
recognizer_config.model_config.provider = Some(args.provider.clone());
|
|
recognizer_config.model_config.debug = args.debug;
|
|
recognizer_config.model_config.num_threads = args.num_threads;
|
|
|
|
// Measure recognizer creation time
|
|
println!("Creating recognizer ...");
|
|
let start_creation = Instant::now();
|
|
let recognizer =
|
|
OfflineRecognizer::create(&recognizer_config).expect("Failed to create OfflineRecognizer");
|
|
let creation_elapsed = start_creation.elapsed().as_secs_f64();
|
|
println!("Recognizer created in {:.3} seconds.", creation_elapsed);
|
|
|
|
let stream = recognizer.create_stream();
|
|
|
|
// Measure recognition time
|
|
let start_recognition = Instant::now();
|
|
stream.accept_waveform(wave.sample_rate(), wave.samples());
|
|
recognizer.decode(&stream);
|
|
let recognition_elapsed = start_recognition.elapsed().as_secs_f64();
|
|
|
|
// Get recognition result
|
|
if let Some(result) = stream.get_result() {
|
|
println!("Decoded text: {}", result.text);
|
|
|
|
let total_elapsed = creation_elapsed + recognition_elapsed;
|
|
let rtf = recognition_elapsed / audio_duration;
|
|
println!("\n=== Performance Summary ===");
|
|
println!("Audio duration : {:.3} seconds", audio_duration);
|
|
println!("Recognizer creation time: {:.3} seconds", creation_elapsed);
|
|
println!(
|
|
"Recognition time : {:.3} seconds",
|
|
recognition_elapsed
|
|
);
|
|
println!("Total elapsed time : {:.3} seconds", total_elapsed);
|
|
println!(
|
|
"Real-Time Factor (RTF) : {:.3} (recognition_elapsed / audio_duration = {:.3} / {:.3})",
|
|
rtf, recognition_elapsed, audio_duration
|
|
);
|
|
println!(
|
|
"Number of threads : {}",
|
|
recognizer_config.model_config.num_threads
|
|
);
|
|
} else {
|
|
eprintln!("Failed to get recognition result");
|
|
}
|
|
}
|