use burn::{
store::{
FloatCastAdapter,
ModuleAdapter,
ModuleSnapshot,
PyTorchToBurnAdapter,
burn_pack::Tensor as PackTensor,
},
tensor::DType,
};
use crate::errors::{
BunsenError,
BunsenResult,
};
#[derive(Clone, Debug, Default)]
pub struct NamedTensorsApplied {
pub applied: Vec<String>,
pub unused: Vec<String>,
}
pub fn apply_named_tensors<M: ModuleSnapshot>(
module: &mut M,
tensors: impl IntoIterator<Item = PackTensor>,
rename: impl Fn(&str) -> Option<String>,
) -> BunsenResult<NamedTensorsApplied> {
apply_named_tensors_as(module, tensors, rename, None)
}
pub fn apply_named_tensors_as<M: ModuleSnapshot>(
module: &mut M,
tensors: impl IntoIterator<Item = PackTensor>,
rename: impl Fn(&str) -> Option<String>,
float_dtype: Option<DType>,
) -> BunsenResult<NamedTensorsApplied> {
let mut renamed = Vec::new();
let mut dropped = Vec::new();
for mut tensor in tensors {
match rename(&tensor.name) {
Some(path) => {
tensor.name = path;
renamed.push(tensor);
}
None => dropped.push(tensor.name),
}
}
let adapter: Box<dyn ModuleAdapter> = match float_dtype {
Some(dtype) => Box::new(PyTorchToBurnAdapter.chain(FloatCastAdapter::to(dtype))),
None => Box::new(PyTorchToBurnAdapter),
};
let result = module.apply(renamed, None, Some(adapter), true);
if !result.errors.is_empty() {
let details: Vec<String> = result.errors.iter().map(|e| format!("{e:?}")).collect();
return Err(BunsenError::invalid_resource(format!(
"{} tensors do not fit the model",
details.len()
))
.with_details(details.join("\n")));
}
if !result.missing.is_empty() {
let missing: Vec<&str> = result.missing.iter().map(|(p, _)| p.as_str()).collect();
return Err(BunsenError::invalid_resource(format!(
"the tensors lack {} of the model's parameters: {}",
missing.len(),
missing
.iter()
.take(8)
.copied()
.collect::<Vec<_>>()
.join(", ")
))
.with_details(missing.join("\n")));
}
let mut unused = result.unused;
unused.extend(dropped);
Ok(NamedTensorsApplied {
applied: result.applied,
unused,
})
}