use std::{
path::{
Path,
PathBuf,
},
sync::Arc,
};
use bunsen::{
data::{
builds::DeferredBuild,
resources::{
ResourceCache,
ResourceCacheOptions,
ResourceSet,
},
},
errors::{
BunsenResult,
ResultContext,
},
kits::speech::asr::{
driver::TranscriptSegment,
whisper::{
driver::{
WhisperConstruct,
WhisperStreamDriver,
WhisperStreamDriverConfig,
},
pretrained::{
CHECKPOINT,
OPENAI_LOCAL_DIR,
VOCABULARY,
WhisperConstructConfig,
default_whisper_factory,
},
},
},
};
use burn::tensor::Device;
use crate::asr::{
Emission,
Segment,
Transcript,
segment_speaker,
speaker_turns,
stream,
};
#[derive(clap::Args, Debug, Default)]
pub struct WhisperFlags {
#[arg(long)]
pub vocab: Option<PathBuf>,
#[arg(long)]
pub upstream_cache_dir: Option<PathBuf>,
}
impl WhisperFlags {
pub fn cache_options(
&self,
options: ResourceCacheOptions,
) -> ResourceCacheOptions {
match &self.upstream_cache_dir {
Some(dir) => options.with_local_dir(OPENAI_LOCAL_DIR, dir.clone()),
None => options,
}
}
}
pub fn resolve(
spec: &str,
flags: Option<&WhisperFlags>,
cache: &ResourceCache,
) -> BunsenResult<DeferredBuild<WhisperConstructConfig>> {
let path = Path::new(spec);
let mut model = if path.is_file() {
DeferredBuild::from_resource_set(ResourceSet::given(spec, CHECKPOINT, path)).as_policy()?
} else {
default_whisper_factory()?
.resolve(spec, cache)
.as_policy()?
};
if let Some(vocab) = flags.and_then(|f| f.vocab.as_ref()) {
model = model
.with_overlay(ResourceSet::given("--vocab", VOCABULARY, vocab))
.as_policy()?;
}
Ok(model)
}
pub fn driver(
bundle: Arc<WhisperConstruct>,
emission: Emission,
device: &Device,
) -> BunsenResult<WhisperStreamDriver> {
let mut policy = bundle.policy.clone();
if !bundle.layout.ids().is_multilingual()
&& let Some(language) = policy.language.take()
{
log::warn!("English-only checkpoint: language {language} does not apply");
}
let driver: WhisperStreamDriver = WhisperStreamDriverConfig::new()
.with_policy(&policy)
.with_emission(emission.into())
.init_from_construct(bundle, device)
.as_policy()?;
Ok(driver)
}
pub fn transcribe(
driver: &WhisperStreamDriver,
samples: &[f32],
chunk: usize,
) -> BunsenResult<(Transcript, Vec<TranscriptSegment>)> {
let (committed, ctx) = stream::stream(driver, samples, chunk)?;
let segments = committed
.iter()
.map(|s| Segment {
start: s.start,
end: s.end,
text: s.text.as_deref().unwrap_or("").trim().to_string(),
tokens: s.tokens.clone(),
speaker: segment_speaker(s),
})
.collect();
let transcript = Transcript {
text: stream::join_text(&committed),
turns: driver.speakers().map(|_| speaker_turns(&committed)),
language: ctx.language().map(String::from),
words: None,
segments: Some(segments),
};
Ok((transcript, committed))
}