use std::sync::Arc;
use burn::prelude::Backend;
#[cfg(feature = "store_safetensors")]
use crate::data::pretrained::SafetensorsCheckpoint;
#[cfg(not(feature = "store_safetensors"))]
use crate::kits::speech::whisper::Whisper;
#[cfg(feature = "store_safetensors")]
use crate::kits::speech::whisper::{
Whisper,
pretrained::SafetensorsWhisperScanner,
};
use crate::{
data::pretrained::{
Construct,
Fuse,
GIVEN_NAMESPACE,
LoadedResources,
PretrainedCache,
PretrainedRef,
ResourceMap,
SAFETENSORS,
},
errors::{
BunsenError,
BunsenResult,
},
kits::{
speech::whisper::{
WhisperApiConfig,
WhisperGeometry,
driver::WhisperBundle,
pretrained::{
CHECKPOINT,
PytorchWhisperScanner,
VOCABULARY,
WHISPER_KIT,
WHISPER_PREFABS,
WhisperVocabulary,
},
},
tokens::TiktokenRanks,
},
};
#[derive(Clone, Debug)]
pub enum WhisperReader {
Pytorch(PytorchWhisperScanner),
#[cfg(feature = "store_safetensors")]
Safetensors(SafetensorsWhisperScanner),
}
impl Default for WhisperReader {
fn default() -> Self {
Self::Pytorch(PytorchWhisperScanner::new())
}
}
impl WhisperReader {
pub fn for_kind(kind: Option<&str>) -> BunsenResult<Self> {
match kind {
None => Ok(Self::default()),
Some(kind) if kind.starts_with("pytorch") => Ok(Self::default()),
#[cfg(feature = "store_safetensors")]
Some(kind) if kind.starts_with(SAFETENSORS) => {
Ok(Self::Safetensors(SafetensorsWhisperScanner::new()))
}
#[cfg(not(feature = "store_safetensors"))]
Some(kind) if kind.starts_with(SAFETENSORS) => Err(BunsenError::Invalid(format!(
"no reader for a {kind:?} checkpoint without the `store_safetensors` feature"
))),
Some(kind) => Err(BunsenError::Invalid(format!(
"no reader for a {kind:?} checkpoint; the Whisper kit reads PyTorch and safetensors checkpoints"
))),
}
}
pub fn scan_cfg(
&self,
loaded: &LoadedResources,
) -> BunsenResult<WhisperApiConfig> {
match self {
Self::Pytorch(scanner) => Ok(scanner.scan_cfg(loaded.expect(CHECKPOINT)?)?.1),
#[cfg(feature = "store_safetensors")]
Self::Safetensors(scanner) => {
scanner.scan_cfg(&SafetensorsCheckpoint::from_loaded(loaded, CHECKPOINT)?)
}
}
}
pub fn load<B: Backend>(
&self,
loaded: &LoadedResources,
device: &B::Device,
) -> BunsenResult<(Whisper<B>, WhisperApiConfig)> {
match self {
Self::Pytorch(scanner) => scanner.load::<B, _>(loaded.expect(CHECKPOINT)?, device),
#[cfg(feature = "store_safetensors")]
Self::Safetensors(scanner) => scanner.load::<B>(
&SafetensorsCheckpoint::from_loaded(loaded, CHECKPOINT)?,
device,
),
}
}
}
#[derive(Clone, Debug)]
pub struct WhisperConstruct {
pub reader: WhisperReader,
pub expected: Option<WhisperGeometry>,
}
impl Default for WhisperConstruct {
fn default() -> Self {
Self::new()
}
}
impl WhisperConstruct {
pub fn new() -> Self {
Self {
reader: WhisperReader::default(),
expected: None,
}
}
pub fn with_reader(
mut self,
reader: WhisperReader,
) -> Self {
self.reader = reader;
self
}
pub fn with_scanner(
self,
scanner: PytorchWhisperScanner,
) -> Self {
self.with_reader(WhisperReader::Pytorch(scanner))
}
pub fn with_expected(
mut self,
expected: Option<WhisperGeometry>,
) -> Self {
self.expected = expected;
self
}
pub fn expected_for(
&self,
model: &PretrainedRef,
) -> Option<WhisperGeometry> {
self.expected.or_else(|| {
model
.prefab(&WHISPER_PREFABS)
.map(|prefab| prefab.to_config().geometry())
})
}
pub fn scan(
&self,
model: &PretrainedRef,
loaded: &LoadedResources,
) -> BunsenResult<WhisperApiConfig> {
let cfg = self.reader.scan_cfg(loaded)?;
self.check(model, &cfg.geometry())?;
Ok(cfg)
}
fn check(
&self,
model: &PretrainedRef,
found: &WhisperGeometry,
) -> BunsenResult<()> {
match self.expected_for(model) {
Some(expected) if expected != *found => Err(BunsenError::Invalid(format!(
"{}: the checkpoint's geometry is {found:?}, not the promised {expected:?}",
model.id()
))),
_ => Ok(()),
}
}
}
impl Construct for WhisperConstruct {
type Built<B: Backend> = WhisperBundle<B>;
const KIT: &'static str = WHISPER_KIT;
fn for_map(map: &ResourceMap) -> BunsenResult<Self> {
let family = map.family(CHECKPOINT);
let Some(first) = family.resources.values().next() else {
map.try_get(CHECKPOINT)?;
unreachable!("an empty family is a missing key");
};
let reader = WhisperReader::for_kind(first.kind.as_deref()).map_err(|e| match e {
BunsenError::Invalid(m) => BunsenError::Invalid(format!("{}: {m}", first.key)),
e => e,
})?;
Ok(Self::new().with_reader(reader))
}
fn plan(
&self,
model: &PretrainedRef,
cache: &PretrainedCache,
) -> BunsenResult<ResourceMap> {
let map = model.to_map();
let checkpoint = map.family(CHECKPOINT);
if checkpoint.is_empty() {
map.try_get(CHECKPOINT)?;
}
let loaded = cache.load(WHISPER_KIT, &checkpoint)?;
let cfg = self.scan(model, &loaded)?;
let ids = *cfg.token_layout.policy_for_vocab(cfg.vocab_size)?.ids();
let rule = WhisperVocabulary::for_layout(&ids).map().to_map();
match map.get(VOCABULARY).cloned() {
None => map.fuse(rule, Fuse::Strict),
Some(given) if given.namespace == GIVEN_NAMESPACE => Ok(map),
Some(declared) => {
let selected = rule.try_get(VOCABULARY)?;
if declared.file != selected.file || declared.sha256 != selected.sha256 {
return Err(BunsenError::Invalid(format!(
"{}: declares the vocabulary {} but the checkpoint's layout selects {}",
map.name, declared.file, selected.file
)));
}
Ok(map)
}
}
}
fn construct<B: Backend>(
&self,
_model: &PretrainedRef,
loaded: &LoadedResources,
device: &B::Device,
) -> BunsenResult<Arc<WhisperBundle<B>>> {
let (model, cfg) = self.reader.load::<B>(loaded, device)?;
let layout = cfg.token_layout.policy_for_vocab(cfg.vocab_size)?;
let mut bundle = WhisperBundle::new(model, layout);
if let Some(part) = loaded.get(VOCABULARY) {
bundle = bundle.with_ranks(TiktokenRanks::load(&part.path)?);
}
bundle.validate()?;
Ok(Arc::new(bundle))
}
}
#[cfg(test)]
mod reader_tests {
use super::*;
use crate::data::pretrained::Deferred;
#[test]
fn test_the_kind_chooses_the_reader() {
let mut map = ResourceMap::given("mine", CHECKPOINT, "/no/such/model.safetensors");
let hook = WhisperConstruct::for_map(&map).unwrap();
assert!(matches!(hook.reader, WhisperReader::Pytorch(_)));
map.resources.get_mut(CHECKPOINT).unwrap().kind = Some("pytorch fp16".to_string());
let hook = WhisperConstruct::for_map(&map).unwrap();
assert!(matches!(hook.reader, WhisperReader::Pytorch(_)));
map.resources.get_mut(CHECKPOINT).unwrap().kind = Some(SAFETENSORS.to_string());
#[cfg(feature = "store_safetensors")]
{
let hook = WhisperConstruct::for_map(&map).unwrap();
assert!(matches!(hook.reader, WhisperReader::Safetensors(_)));
assert!(Deferred::<WhisperConstruct>::from_map(map.clone()).is_ok());
}
#[cfg(not(feature = "store_safetensors"))]
{
let err = WhisperConstruct::for_map(&map).unwrap_err();
assert!(
matches!(&err, BunsenError::Invalid(m) if m.contains("store_safetensors")),
"{err}"
);
}
let mut sharded = ResourceMap::new("sharded");
for key in ["checkpoint.00001", "checkpoint.00002", "checkpoint.index"] {
let mut r = crate::data::pretrained::Resource::given(key, format!("/no/such/{key}"));
r.kind = Some(if key.ends_with("index") {
crate::data::pretrained::SAFETENSORS_INDEX.to_string()
} else {
SAFETENSORS.to_string()
});
sharded.insert(r);
}
#[cfg(feature = "store_safetensors")]
assert!(matches!(
WhisperConstruct::for_map(&sharded).unwrap().reader,
WhisperReader::Safetensors(_)
));
#[cfg(not(feature = "store_safetensors"))]
assert!(WhisperConstruct::for_map(&sharded).is_err());
map.resources.get_mut(CHECKPOINT).unwrap().kind = Some("burnpack".to_string());
let err = WhisperConstruct::for_map(&map).unwrap_err();
assert!(
matches!(&err, BunsenError::Invalid(m) if m.starts_with("checkpoint: no reader for a \"burnpack\"")),
"{err}"
);
assert!(matches!(
Deferred::<WhisperConstruct>::from_map(map),
Err(BunsenError::Invalid(_))
));
let err = WhisperConstruct::for_map(&ResourceMap::new("empty")).unwrap_err();
assert!(matches!(err, BunsenError::ResourceNotFound(_)), "{err}");
}
}
#[cfg(all(test, feature = "whisper-weights"))]
mod tests {
use serial_test::serial;
use super::*;
use crate::{
data::pretrained::Provenance,
kits::speech::whisper::{
WhisperMeta,
pretrained::{
BASE_CHECKPOINT,
GPT2_VOCABULARY,
default_whisper_factory,
testing::offline_cache,
},
},
support::testing::{
PerformanceBackend,
default_device,
},
};
fn resolve_model(spec: &str) -> BunsenResult<PretrainedRef> {
Ok(default_whisper_factory()?
.resolve(spec, &offline_cache())?
.model)
}
fn loaded(path: &std::path::Path) -> LoadedResources {
offline_cache()
.load(WHISPER_KIT, &ResourceMap::given("given", CHECKPOINT, path))
.unwrap()
}
fn geometry_of(prefab: &str) -> WhisperGeometry {
WHISPER_PREFABS
.expect_lookup_prefab(prefab)
.to_config()
.geometry()
}
#[test]
#[serial]
fn test_the_factory_builds_the_bundle() {
let cache = offline_cache();
let loaded = default_whisper_factory()
.unwrap()
.load::<PerformanceBackend>("openai/base", &cache, &default_device())
.unwrap();
assert_eq!(loaded.name, "well-known:openai/base");
assert_eq!(loaded.resources.keys(), [CHECKPOINT, VOCABULARY]);
for (key, part) in loaded.resources.iter() {
assert_eq!(part.provenance, Provenance::Cached, "{key}");
}
let bundle = &loaded.handle;
assert_eq!(bundle.model.vocab_size(), 51865);
assert_eq!(bundle.model.n_mels(), 80);
assert!(bundle.layout.ids().is_multilingual());
assert_eq!(bundle.ranks.as_ref().map(|r| r.len()), Some(50257));
assert!(!bundle.default_filters().is_empty());
assert_eq!(Arc::strong_count(&loaded.handle), 1);
}
#[test]
fn test_plan_derives_a_paths_vocabulary() {
let cache = offline_cache();
let given = PretrainedRef::from(ResourceMap::given(
"base",
CHECKPOINT,
bunsen_bundled_whisper::base_pt(),
));
let planned = WhisperConstruct::new().plan(&given, &cache).unwrap();
assert_eq!(planned.name, "base");
assert_eq!(planned.keys(), [CHECKPOINT, VOCABULARY]);
assert_eq!(
planned.get(VOCABULARY).unwrap().file,
"multilingual.tiktoken"
);
}
#[test]
fn test_plan_checks_a_declared_vocabulary() {
let cache = offline_cache();
let wrong = BASE_CHECKPOINT
.to_map()
.fuse(GPT2_VOCABULARY.to_map(), Fuse::Strict)
.unwrap();
let err = WhisperConstruct::new()
.plan(&PretrainedRef::from(wrong), &cache)
.unwrap_err();
assert!(
matches!(&err, BunsenError::Invalid(m) if m.contains("gpt2.tiktoken") && m.contains("multilingual.tiktoken")),
"{err}"
);
let overridden = PretrainedRef::from(BASE_CHECKPOINT.to_map())
.with_overlay(ResourceMap::given(
"--vocab",
VOCABULARY,
bunsen_bundled_whisper::gpt2_tiktoken(),
))
.unwrap();
let planned = WhisperConstruct::new().plan(&overridden, &cache).unwrap();
assert_eq!(planned.get(VOCABULARY).unwrap().file, "gpt2.tiktoken");
}
#[test]
fn test_plan_accepts_a_bundled_rows_vocabulary() {
use crate::data::{
cache::BunsenDiskCacheOptions,
pretrained::{
PretrainedCacheOptions,
Source,
},
};
let dir = tempfile::tempdir().unwrap();
let cache = PretrainedCache::new(
PretrainedCacheOptions::default()
.with_disk(
BunsenDiskCacheOptions::default()
.with_cache_dir(Some(dir.path().join("cache")))
.without_transfer_observers(),
)
.with_offline(true),
)
.unwrap();
let model = default_whisper_factory()
.unwrap()
.resolve("bundled:openai/base", &cache)
.unwrap()
.model;
let planned = WhisperConstruct::new().plan(&model, &cache).unwrap();
assert_eq!(planned.keys(), [CHECKPOINT, VOCABULARY]);
let vocabulary = planned.get(VOCABULARY).unwrap();
assert_eq!(vocabulary.file, "multilingual.tiktoken");
assert!(
matches!(vocabulary.sources.as_slice(), [Source::LocalDir { name, .. }] if name == "bundled"),
"the row's own sources stand: {:?}",
vocabulary.sources
);
assert!(!dir.path().join("cache").exists(), "nothing was written");
}
#[test]
fn test_plan_checks_the_prefab_a_name_promises() {
let cache = offline_cache();
let base_pt = bunsen_bundled_whisper::base_pt();
let given = PretrainedRef::from(BASE_CHECKPOINT.to_map());
let named = resolve_model("openai/base").unwrap();
let hook = WhisperConstruct::new();
assert_eq!(hook.expected_for(&given), None);
assert_eq!(hook.expected_for(&named), Some(geometry_of("base")));
hook.plan(&named, &cache).unwrap();
hook.plan(&given, &cache).unwrap();
let tiny = hook.clone().with_expected(Some(geometry_of("tiny")));
let err = tiny.plan(&given, &cache).unwrap_err();
assert!(
matches!(&err, BunsenError::Invalid(m) if m.contains("promised")),
"{err}"
);
let wrong_name = resolve_model("openai/tiny").unwrap();
let base = loaded(base_pt);
assert!(hook.scan(&wrong_name, &base).is_err());
let explicit = hook.clone().with_expected(Some(geometry_of("base")));
assert_eq!(
explicit.expected_for(&wrong_name),
Some(geometry_of("base"))
);
explicit.scan(&wrong_name, &base).unwrap();
}
#[test]
fn test_the_bundled_base_scans_as_the_base_prefab() {
let model = resolve_model("openai/base").unwrap();
let cfg = WhisperConstruct::new()
.scan(&model, &loaded(bunsen_bundled_whisper::base_pt()))
.unwrap();
let geometry = cfg.geometry();
assert_eq!(geometry.prefab().map(|p| p.name), Some("base"));
assert_eq!(geometry.n_heads(), 8);
}
#[test]
fn test_scan_honors_the_scanner() {
let base = bunsen_bundled_whisper::base_pt();
let hook =
WhisperConstruct::new().with_scanner(PytorchWhisperScanner::new().with_d_head(32));
let named = resolve_model("openai/base").unwrap();
let err = hook.scan(&named, &loaded(base)).unwrap_err();
assert!(matches!(err, BunsenError::Invalid(_)), "{err}");
let given = PretrainedRef::from(ResourceMap::given("base", CHECKPOINT, base));
let cfg = hook.scan(&given, &loaded(base)).unwrap();
assert_eq!(cfg.geometry().d_head, 32);
assert_eq!(cfg.geometry().n_heads(), 16);
}
#[test]
fn test_a_checkpoint_under_the_wrong_name_is_rejected() {
let model = resolve_model("openai/tiny").unwrap();
let err = WhisperConstruct::new()
.scan(&model, &loaded(bunsen_bundled_whisper::base_pt()))
.unwrap_err();
assert!(matches!(err, BunsenError::Invalid(_)), "{err}");
assert!(err.to_string().contains("openai/tiny"), "{err}");
}
}