use burn::{
Tensor,
module::Param,
prelude::Backend,
};
pub fn repair_pytorch_strided_weight<B: Backend>(
param: Param<Tensor<B, 2>>
) -> Param<Tensor<B, 2>> {
param
.load_mapper(|tensor: Tensor<B, 2>| {
B::sync(&tensor.device()).unwrap();
let dims = tensor.dims();
let tensor = tensor.transpose().reshape(dims);
B::sync(&tensor.device()).unwrap();
tensor
})
.save_mapper(|tensor: Tensor<B, 2>| {
B::sync(&tensor.device()).unwrap();
let [rows, cols] = tensor.dims();
let tensor = tensor.reshape([cols, rows]).transpose();
B::sync(&tensor.device()).unwrap();
tensor
})
}
#[cfg(test)]
mod tests {
use burn::{
nn::LinearConfig,
prelude::TensorData,
tensor::{
Tolerance,
backend::BackendTypes,
},
};
use super::*;
use crate::{
burner::tensor::TensorElemOpExt,
support::testing::{
CpuBackend,
default_device,
},
};
type B = CpuBackend;
type F = <B as BackendTypes>::FloatElem;
#[test]
fn test_repair_preserves_the_live_value() {
let device = default_device();
let linear = LinearConfig::new(3, 5).with_bias(false).init::<B>(&device);
let before = linear.weight.val();
let mapped = repair_pytorch_strided_weight(linear.weight);
assert_eq!(mapped.val().dims(), [3, 5]);
mapped
.val()
.to_data_as::<F>()
.assert_approx_eq::<F>(&before.to_data_as::<F>(), Tolerance::default());
}
#[test]
fn test_load_then_save_round_trips() {
let device = default_device();
let stored: Tensor<B, 2> = Tensor::from_data(
TensorData::new((0..15).map(|v| v as f64).collect::<Vec<_>>(), [5, 3]),
&device,
);
let transposed = stored.clone().transpose();
assert_eq!(transposed.dims(), [3, 5]);
transposed
.transpose()
.to_data_as::<F>()
.assert_approx_eq::<F>(&stored.to_data_as::<F>(), Tolerance::default());
}
}