use alloc::{
fmt,
string::{
String,
ToString,
},
sync::Arc,
vec::Vec,
};
use burn::tensor::TensorData;
use crate::burner::tensor::{
permute_data,
reshape_data,
split_rows_data,
};
pub type TensorTransform = Arc<dyn Fn(TensorData) -> TensorData + Send + Sync>;
#[derive(Clone)]
pub struct TensorLoadTransform {
name: String,
f: TensorTransform,
}
impl fmt::Debug for TensorLoadTransform {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
f.debug_tuple("TensorLoadTransform")
.field(&self.name)
.finish()
}
}
fn f32_values(data: TensorData) -> (Vec<f32>, Vec<usize>) {
let shape = data.shape().as_slice().to_vec();
let values = data
.convert::<f32>()
.try_into_vec::<f32>()
.expect("float values");
(values, shape)
}
impl TensorLoadTransform {
pub fn new(
name: impl Into<String>,
f: impl Fn(TensorData) -> TensorData + Send + Sync + 'static,
) -> Self {
Self {
name: name.into(),
f: Arc::new(f),
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn transform(&self) -> TensorTransform {
self.f.clone()
}
pub fn apply(
&self,
data: TensorData,
) -> TensorData {
(self.f)(data)
}
pub fn then(
self,
next: TensorLoadTransform,
) -> Self {
let (a, b) = (self.f, next.f);
Self {
name: format!("{} then {}", self.name, next.name),
f: Arc::new(move |data| b(a(data))),
}
}
pub fn zero_centered_gain() -> Self {
Self::new("zero_centered_gain", |data| {
let (values, shape) = f32_values(data);
TensorData::new(values.into_iter().map(|w| 1.0 + w).collect(), shape)
})
}
pub fn scale(k: f64) -> Self {
Self::new(format!("scale({k})"), move |data| {
let (values, shape) = f32_values(data);
TensorData::new(
values
.into_iter()
.map(|w| (f64::from(w) * k) as f32)
.collect(),
shape,
)
})
}
pub fn transpose() -> Self {
Self::new("transpose", |data| permute_data(data, &[1, 0]))
}
pub fn regroup_columns(
a: usize,
b: usize,
) -> Self {
Self::new(format!("regroup_columns({a}, {b})"), move |data| {
let rows = data.shape().num_elements() / (a * b);
let data = reshape_data(data, vec![rows, a, b]);
reshape_data(permute_data(data, &[0, 2, 1]), vec![rows, b * a])
})
}
pub fn interleaved_to_halves(block: usize) -> Self {
assert!(block.is_multiple_of(2), "an even block: {block}");
Self::new(format!("interleaved_to_halves({block})"), move |data| {
let shape = data.shape().as_slice().to_vec();
let rows = shape[0];
assert!(
rows.is_multiple_of(block),
"{block} does not divide {rows} rows"
);
let rest: usize = shape[1..].iter().product();
let data = reshape_data(data, vec![rows / block, block / 2, 2, rest]);
reshape_data(permute_data(data, &[0, 2, 1, 3]), shape)
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Select {
Exact(String),
Suffix(String),
}
impl Select {
pub fn suffix(suffix: impl Into<String>) -> Self {
Self::Suffix(suffix.into())
}
pub fn matches(
&self,
path: &str,
) -> bool {
match self {
Self::Exact(p) => p == path,
Self::Suffix(s) => path.ends_with(s.as_str()),
}
}
}
impl fmt::Display for Select {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
match self {
Self::Exact(p) => f.write_str(p),
Self::Suffix(s) => write!(f, "*{s}"),
}
}
}
impl From<&str> for Select {
fn from(path: &str) -> Self {
Self::Exact(path.to_string())
}
}
impl From<String> for Select {
fn from(path: String) -> Self {
Self::Exact(path)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TensorLoadRowSplit {
suffix: String,
parts: Vec<(String, Option<usize>)>,
}
impl TensorLoadRowSplit {
pub fn equal<S: Into<String>>(
suffix: impl Into<String>,
parts: impl IntoIterator<Item = S>,
) -> Self {
Self {
suffix: suffix.into(),
parts: parts.into_iter().map(|p| (p.into(), None)).collect(),
}
}
pub fn sized<S: Into<String>>(
suffix: impl Into<String>,
parts: impl IntoIterator<Item = (S, usize)>,
) -> Self {
Self {
suffix: suffix.into(),
parts: parts
.into_iter()
.map(|(p, r)| (p.into(), Some(r)))
.collect(),
}
}
pub fn suffix(&self) -> &str {
&self.suffix
}
pub fn name(&self) -> String {
let parts: Vec<&str> = self.parts.iter().map(|(p, _)| p.as_str()).collect();
format!("split_rows(*{} -> {})", self.suffix, parts.join(", "))
}
pub fn split(
&self,
name: &str,
data: TensorData,
) -> Option<Result<Vec<(String, TensorData)>, String>> {
let stem = name.strip_suffix(self.suffix.as_str())?;
let shape = data.shape().as_slice().to_vec();
let Some(&total) = shape.first() else {
return Some(Err(format!("{name}: {} of a scalar", self.name())));
};
let rows: Vec<usize> = if self.parts.iter().all(|(_, r)| r.is_none()) {
let n = self.parts.len();
if n == 0 || !total.is_multiple_of(n) {
return Some(Err(format!(
"{name}: {total} rows do not split into {n} equal parts"
)));
}
vec![total / n; n]
} else {
match self
.parts
.iter()
.map(|(_, r)| *r)
.collect::<Option<Vec<_>>>()
{
Some(rows) if rows.iter().sum::<usize>() == total => rows,
_ => {
return Some(Err(format!(
"{name}: {total} rows do not split as {}",
self.name()
)));
}
}
};
Some(Ok(self
.parts
.iter()
.zip(split_rows_data(data, &rows))
.map(|((part, _), data)| (format!("{stem}{part}"), data))
.collect()))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn data(
values: &[f32],
shape: &[usize],
) -> TensorData {
TensorData::new(values.to_vec(), shape.to_vec())
}
fn values(data: TensorData) -> Vec<f32> {
data.convert::<f32>().try_into_vec().unwrap()
}
#[test]
fn test_zero_centered_gain() {
let a = TensorLoadTransform::zero_centered_gain();
assert_eq!(a.name(), "zero_centered_gain");
assert_eq!(
values(a.apply(data(&[0.0, -0.25, 0.5], &[3]))),
[1.0, 0.75, 1.5]
);
let w = burn::tensor::bf16::from_f32(2f32.powi(-9));
let folded = a.apply(TensorData::new(vec![w], [1]));
assert_eq!(folded.dtype(), burn::tensor::DType::F32);
assert_eq!(values(folded), [1.0 + 2f32.powi(-9)]);
}
#[test]
fn test_scale() {
let a = TensorLoadTransform::scale(0.5);
assert_eq!(a.name(), "scale(0.5)");
assert_eq!(values(a.apply(data(&[2.0, -4.0], &[2]))), [1.0, -2.0]);
}
#[test]
fn test_transpose() {
let m = data(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
let t = TensorLoadTransform::transpose().apply(m.clone());
assert_eq!(t.shape().as_slice(), [3, 2]);
assert_eq!(values(t.clone()), [1.0, 4.0, 2.0, 5.0, 3.0, 6.0]);
assert_eq!(values(TensorLoadTransform::transpose().apply(t)), values(m));
}
#[test]
fn test_regroup_columns() {
let m = data(&[0.0, 1.0, 2.0, 10.0, 11.0, 12.0], &[1, 6]);
let r = TensorLoadTransform::regroup_columns(2, 3).apply(m.clone());
assert_eq!(values(r.clone()), [0.0, 10.0, 1.0, 11.0, 2.0, 12.0]);
assert_eq!(
values(TensorLoadTransform::regroup_columns(3, 2).apply(r)),
values(m)
);
}
#[test]
fn test_interleaved_to_halves() {
let rows: Vec<f32> = [0.0, 100.0, 1.0, 101.0, 2.0, 102.0, 3.0, 103.0]
.iter()
.flat_map(|&r| [r, r + 0.5])
.collect();
let m = data(&rows, &[8, 2]);
let h = TensorLoadTransform::interleaved_to_halves(4).apply(m);
assert_eq!(h.shape().as_slice(), [8, 2]);
let firsts: Vec<f32> = values(h).chunks(2).map(|r| r[0]).collect();
assert_eq!(firsts, [0.0, 1.0, 100.0, 101.0, 2.0, 3.0, 102.0, 103.0]);
}
#[test]
fn test_then() {
let a = TensorLoadTransform::zero_centered_gain().then(TensorLoadTransform::scale(2.0));
assert_eq!(a.name(), "zero_centered_gain then scale(2)");
assert_eq!(values(a.apply(data(&[0.5], &[1]))), [3.0]);
}
#[test]
fn test_select() {
assert!(Select::from("a.norm.weight").matches("a.norm.weight"));
assert!(!Select::from("a.norm.weight").matches("b.norm.weight"));
let norms = Select::suffix("norm.weight");
assert!(norms.matches("stack.layers.3.attn_post_norm.weight"));
assert!(norms.matches("stack.norm.weight"));
assert!(!norms.matches("stack.layers.3.attn.c_q.weight"));
assert_eq!(norms.to_string(), "*norm.weight");
}
#[test]
fn test_row_split_equal() {
let split =
TensorLoadRowSplit::equal(".Wqkv.weight", [".Wq.weight", ".Wk.weight", ".Wv.weight"]);
assert_eq!(
split.name(),
"split_rows(*.Wqkv.weight -> .Wq.weight, .Wk.weight, .Wv.weight)"
);
let fused = data(&(0..12).map(|v| v as f32).collect::<Vec<_>>(), &[6, 2]);
let parts = split
.split("layers.0.attn.Wqkv.weight", fused.clone())
.unwrap()
.unwrap();
let names: Vec<&str> = parts.iter().map(|(n, _)| n.as_str()).collect();
assert_eq!(
names,
[
"layers.0.attn.Wq.weight",
"layers.0.attn.Wk.weight",
"layers.0.attn.Wv.weight"
]
);
assert_eq!(values(parts[1].1.clone()), [4.0, 5.0, 6.0, 7.0]);
let back =
crate::burner::tensor::concat_rows_data(parts.into_iter().map(|(_, d)| d).collect());
assert_eq!(values(back), values(fused.clone()));
let bias = TensorLoadRowSplit::equal(".in_proj_bias", [".q.bias", ".k.bias", ".v.bias"]);
let parts = bias
.split("attn.in_proj_bias", data(&[1.0, 2.0, 3.0], &[3]))
.unwrap()
.unwrap();
assert_eq!(values(parts[2].1.clone()), [3.0]);
assert!(split.split("layers.0.attn.Wo.weight", fused).is_none());
}
#[test]
fn test_row_split_sized() {
let split = TensorLoadRowSplit::sized(
".qkv.weight",
[(".q.weight", 4), (".k.weight", 1), (".v.weight", 1)],
);
let parts = split
.split("a.qkv.weight", data(&[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], &[6]))
.unwrap()
.unwrap();
assert_eq!(values(parts[0].1.clone()), [0.0, 1.0, 2.0, 3.0]);
assert_eq!(values(parts[2].1.clone()), [5.0]);
let err = split
.split("a.qkv.weight", data(&[0.0; 5], &[5]))
.unwrap()
.unwrap_err();
assert!(err.starts_with("a.qkv.weight: 5 rows"), "{err}");
let err = TensorLoadRowSplit::equal(".w", [".a", ".b"])
.split("x.w", data(&[0.0; 3], &[3]))
.unwrap()
.unwrap_err();
assert_eq!(err, "x.w: 3 rows do not split into 2 equal parts");
}
}