use burn::{
store::{
FloatCastAdapter,
ModuleAdapter,
ModuleSnapshot,
PyTorchToBurnAdapter,
burn_pack::Tensor as PackTensor,
},
tensor::DType,
};
use crate::{
burner::module::{
Rekey,
Target,
},
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,
})
}
pub fn apply_rekeyed_tensors<M: ModuleSnapshot>(
module: &mut M,
tensors: impl IntoIterator<Item = PackTensor>,
rekey: &Rekey,
) -> BunsenResult<NamedTensorsApplied> {
apply_rekeyed_tensors_as(module, tensors, rekey, None)
}
pub fn apply_rekeyed_tensors_as<M: ModuleSnapshot>(
module: &mut M,
tensors: impl IntoIterator<Item = PackTensor>,
rekey: &Rekey,
float_dtype: Option<DType>,
) -> BunsenResult<NamedTensorsApplied> {
let tensors: Vec<PackTensor> = tensors.into_iter().collect();
let module_paths = module
.collect(None, None, true)
.into_iter()
.map(|t| t.name)
.collect();
let plan = rekey.plan_for(tensors.iter().map(|t| t.name.as_str()), &module_paths);
plan.check()?;
let mut placed = Vec::new();
let mut dropped = Vec::new();
for (mut tensor, (_, target)) in tensors.into_iter().zip(plan.targets) {
match target {
None => dropped.push(tensor.name),
Some(Target {
path,
transform: None,
}) => {
tensor.name = path;
placed.push(tensor);
}
Some(Target {
path,
transform: Some(f),
}) => {
let (name, param_id) = (tensor.name.clone(), tensor.param_id);
let data = burn::store::bridge::into_data(tensor).map_err(|e| {
BunsenError::invalid_resource(format!("cannot read {name}: {e:?}"))
})?;
placed.push(burn::store::bridge::from_data(f(data), path, param_id));
}
}
}
let mut applied =
apply_named_tensors_as(module, placed, |name| Some(name.to_string()), float_dtype)?;
applied.unused.extend(dropped);
Ok(applied)
}