use alloc::{
format,
sync::Arc,
vec::Vec,
};
use core::fmt::Debug;
use burn::{
config::Config,
store::burn_pack::Tensor as PackTensor,
tensor::{
Device,
FloatDType,
},
};
use super::{
LmConstruct,
LmPolicy,
};
use crate::{
blocks::transformers::models::language_decoder::LmDecoderHolder,
burner::module::{
CanonicalKeys,
ModuleInit,
Rekey,
},
data::{
builds::{
BuildRef,
CONFIG,
ConstructInit,
},
catalog::presets::ResolvedPresetSet,
formats::{
LoadPolicy,
NamedTensorsApplied,
SafetensorsCheckpoint,
stored_float_dtype,
},
resources::{
LoadedResourceSet,
ResourceSet,
SAFETENSORS,
SAFETENSORS_INDEX,
},
},
errors::{
BunsenError,
BunsenResult,
sys_at,
},
kits::support::model_config::{
TransformersConfigJson,
resolve_ref_presets,
},
};
pub trait TransformersLmKit: Default {
const KIT: &'static str;
const NAME: &'static str;
const CHECKPOINT: &'static str;
type Config: 'static + Config + Debug + Clone + ModuleInit<Self::Model>;
type Model: burn::module::Module;
fn config_from_transformers(json: &str) -> BunsenResult<Self::Config>;
fn load_tensors(
model: &mut Self::Model,
tensors: Vec<PackTensor>,
dtype: FloatDType,
) -> BunsenResult<NamedTensorsApplied>;
fn probed(loaded: &LoadedResourceSet) -> BunsenResult<ResolvedPresetSet>;
}
impl<K: TransformersLmKit> ConstructInit for K {
type Construct = LmConstruct<K::Model>;
const KIT: &'static str = K::KIT;
const RESOLVES_PRESETS: bool = true;
fn applied_presets(
construct: &Self::Construct
) -> Option<crate::data::catalog::presets::PresetSelection> {
Some(construct.presets.clone())
}
fn for_resource_set(map: &ResourceSet) -> BunsenResult<Self> {
let index = format!("{}.index", K::CHECKPOINT);
let checkpoint = match map.get(&index) {
Some(index) => index,
None => map.try_get(K::CHECKPOINT)?,
};
match checkpoint.format.as_deref() {
Some(SAFETENSORS | SAFETENSORS_INDEX) => Ok(Self::default()),
other => Err(BunsenError::unsupported(format!(
"no {} reader for a checkpoint of kind {other:?}",
K::NAME
))),
}
}
fn try_init(
&self,
model: &BuildRef,
loaded: &LoadedResourceSet,
device: &Device,
policy: LoadPolicy,
) -> BunsenResult<Arc<LmConstruct<K::Model>>> {
let (config, max_positions) = match loaded.get(CONFIG) {
Some(part) => {
let json =
std::fs::read_to_string(&part.path).map_err(sys_at("read", &part.path))?;
let config = K::config_from_transformers(&json)
.map_err(|e| e.context(part.path.display()))?;
let root = TransformersConfigJson::parse(&json)?;
let text = root.section("text_config").unwrap_or(root);
let max_positions = text.usize("max_position_embeddings").ok();
(config, max_positions)
}
None => {
return Err(BunsenError::invalid_resource(format!(
"a {} checkpoint without a config.json",
K::NAME
))
.context(&loaded.map.name));
}
};
let tensors = SafetensorsCheckpoint::from_loaded(loaded, K::CHECKPOINT)?.tensors()?;
let stored = stored_float_dtype(&tensors).unwrap_or(FloatDType::F32);
let dtype = policy.resolve(stored, device, |d| d != FloatDType::F16)?;
let mut lm: K::Model = config.try_init(device)?;
K::load_tensors(&mut lm, tensors, dtype)?;
let policy = resolve_ref_presets(&LmPolicy::default(), model, &K::probed(loaded)?)?;
let mut bundle = LmConstruct::new(lm)
.with_max_positions(max_positions)
.with_policy(policy.config.clone(), policy.applied());
for (key, part) in &loaded.parts {
bundle = bundle.with_file(key, &part.path);
}
Ok(Arc::new(bundle))
}
}
pub fn load_lm_rekeyed<W: LmDecoderHolder>(
model: &mut W,
tensors: impl IntoIterator<Item = PackTensor>,
rekey: Rekey,
dtype: Option<FloatDType>,
) -> BunsenResult<NamedTensorsApplied> {
let lm = model.lm_mut();
let rekey = rekey.then(lm.canonical_rekey());
rekey.load(lm, tensors, dtype)
}