use std::{
fmt::Debug,
ops::Deref,
};
use burn::{
Tensor,
prelude::{
Shape,
TensorData,
},
tensor::{
DType,
kind::{
Basic,
TensorKind,
},
},
};
use crate::burner::descriptors::{
ParamDesc,
TensorKindDesc,
};
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct TensorRankType {
kind: TensorKindDesc,
dtype: DType,
rank: usize,
}
impl TensorRankType {
pub fn from_tensor<const R: usize, K>(tensor: &Tensor<R, K>) -> Self
where
K: Basic + TensorKind,
{
Self {
kind: TensorKindDesc::for_kind::<K>(),
dtype: tensor.dtype(),
rank: tensor.rank(),
}
}
pub fn from_tensor_data(data: &TensorData) -> Self {
Self::new(data.dtype(), data.shape().rank())
}
}
impl<const R: usize, K> From<&Tensor<R, K>> for TensorRankType
where
K: Basic + TensorKind,
{
fn from(tensor: &Tensor<R, K>) -> Self {
Self::from_tensor(tensor)
}
}
impl From<&TensorData> for TensorRankType {
fn from(data: &TensorData) -> Self {
Self::from_tensor_data(data)
}
}
impl TensorRankType {
pub fn new(
dtype: DType,
rank: usize,
) -> Self {
let kind = dtype.into();
Self { kind, dtype, rank }
}
pub fn kind(&self) -> TensorKindDesc {
self.kind
}
pub fn dtype(&self) -> DType {
self.dtype
}
pub fn rank(&self) -> usize {
self.rank
}
pub fn size_estimate(
&self,
num_elements: usize,
) -> usize {
num_elements * self.dtype.size()
}
pub fn to_desc(
&self,
shape: impl Into<Shape>,
) -> TensorDesc {
let shape = shape.into();
assert_eq!(shape.rank(), self.rank);
TensorDesc {
kind: self.kind,
dtype: self.dtype,
shape,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct TensorDesc {
kind: TensorKindDesc,
dtype: DType,
shape: Shape,
}
impl TensorDesc {
pub fn from_tensor<const R: usize, K>(tensor: &Tensor<R, K>) -> Self
where
K: Basic + TensorKind,
{
Self {
kind: TensorKindDesc::for_kind::<K>(),
dtype: tensor.dtype(),
shape: tensor.shape(),
}
}
pub fn from_tensor_data(data: &TensorData) -> Self {
Self::new(data.dtype(), data.shape().clone())
}
}
impl<const R: usize, K> From<&Tensor<R, K>> for TensorDesc
where
K: Basic + TensorKind,
{
fn from(param: &Tensor<R, K>) -> Self {
Self::from_tensor(param)
}
}
impl From<&TensorData> for TensorDesc {
fn from(data: &TensorData) -> Self {
Self::from_tensor_data(data)
}
}
impl Deref for TensorDesc {
type Target = Shape;
fn deref(&self) -> &Self::Target {
&self.shape
}
}
impl From<TensorDesc> for TensorRankType {
fn from(desc: TensorDesc) -> Self {
desc.to_rank_type()
}
}
impl From<&TensorDesc> for TensorRankType {
fn from(desc: &TensorDesc) -> Self {
desc.to_rank_type()
}
}
impl TensorDesc {
pub fn new(
dtype: DType,
shape: Shape,
) -> Self {
let kind = dtype.into();
Self { kind, dtype, shape }
}
pub fn kind(&self) -> TensorKindDesc {
self.kind
}
pub fn dtype(&self) -> DType {
self.dtype
}
pub fn shape(&self) -> &Shape {
&self.shape
}
pub fn size_estimate(&self) -> usize {
self.num_elements() * self.dtype.size()
}
pub fn to_rank_type(&self) -> TensorRankType {
TensorRankType {
kind: self.kind,
dtype: self.dtype,
rank: self.rank(),
}
}
}
pub type TensorParamDesc = ParamDesc<TensorDesc>;
#[cfg(test)]
#[allow(unused)]
mod tests {
use burn::prelude::{
Bool,
Float,
Int,
};
use super::*;
use crate::support::testing::{
DeviceMemoryGuard,
performance_device,
};
#[test]
fn test_is_send() {
fn is_send<T: Send>(obj: &T) {}
is_send(&TensorDesc {
kind: TensorKindDesc::Float,
dtype: DType::F32,
shape: Shape::new([2, 3]),
});
}
#[test]
fn test_is_sync() {
fn is_sync<T: Sync>(obj: &T) {}
is_sync(&TensorDesc {
kind: TensorKindDesc::Float,
dtype: DType::F32,
shape: Shape::new([2, 3]),
});
}
#[test]
fn test_tensor_rank_desc() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
{
let tensor: Tensor<2> = Tensor::ones([2, 3], &device);
{
let dtype = tensor.dtype();
let rank_desc: TensorRankType = TensorRankType::from(&tensor);
assert_eq!(rank_desc.kind(), TensorKindDesc::Float);
assert_eq!(rank_desc.dtype(), dtype);
assert_eq!(rank_desc.rank(), 2);
assert_eq!(rank_desc.size_estimate(6), dtype.size() * 2 * 3);
let desc = rank_desc.to_desc(Shape::new([2, 3]));
assert_eq!(desc.to_rank_type(), rank_desc);
assert_eq!(desc.kind(), TensorKindDesc::Float);
assert_eq!(desc.dtype(), dtype);
assert_eq!(desc.shape(), &Shape::new([2, 3]));
assert_eq!(desc.rank(), 2);
assert_eq!(desc.size_estimate(), dtype.size() * 2 * 3);
}
let data: TensorData = tensor.to_data();
{
let dtype = data.dtype();
let rank_desc: TensorRankType = TensorRankType::from(&data);
assert_eq!(rank_desc.kind(), TensorKindDesc::Float);
assert_eq!(rank_desc.dtype(), dtype);
assert_eq!(rank_desc.rank(), 2);
assert_eq!(rank_desc.size_estimate(6), dtype.size() * 2 * 3);
let desc = rank_desc.to_desc(Shape::new([2, 3]));
assert_eq!(desc.to_rank_type(), rank_desc);
assert_eq!(desc.kind(), TensorKindDesc::Float);
assert_eq!(desc.dtype(), dtype);
assert_eq!(desc.shape(), &Shape::new([2, 3]));
assert_eq!(desc.rank(), 2);
assert_eq!(desc.size_estimate(), dtype.size() * 2 * 3);
}
}
{
let tensor: Tensor<2, Int> = Tensor::ones([2, 3], &device);
{
let dtype = tensor.dtype();
let rank_desc: TensorRankType = TensorRankType::from(&tensor);
assert_eq!(rank_desc.kind(), TensorKindDesc::Int);
assert_eq!(rank_desc.dtype(), dtype);
assert_eq!(rank_desc.rank(), 2);
assert_eq!(rank_desc.size_estimate(6), dtype.size() * 2 * 3);
let desc = rank_desc.to_desc(Shape::new([2, 3]));
assert_eq!(desc.to_rank_type(), rank_desc);
assert_eq!(desc.kind(), TensorKindDesc::Int);
assert_eq!(desc.dtype(), dtype);
assert_eq!(desc.shape(), &Shape::new([2, 3]));
assert_eq!(desc.rank(), 2);
assert_eq!(desc.size_estimate(), dtype.size() * 2 * 3);
}
let data = tensor.to_data();
{
let dtype = data.dtype();
let rank_desc: TensorRankType = TensorRankType::from(&data);
assert_eq!(rank_desc.kind(), TensorKindDesc::Int);
assert_eq!(rank_desc.dtype(), dtype);
assert_eq!(rank_desc.rank(), 2);
assert_eq!(rank_desc.size_estimate(6), dtype.size() * 2 * 3);
let desc = rank_desc.to_desc(Shape::new([2, 3]));
assert_eq!(desc.to_rank_type(), rank_desc);
assert_eq!(desc.kind(), TensorKindDesc::Int);
assert_eq!(desc.dtype(), dtype);
assert_eq!(desc.shape(), &Shape::new([2, 3]));
assert_eq!(desc.rank(), 2);
assert_eq!(desc.size_estimate(), dtype.size() * 2 * 3);
}
}
{
let tensor: Tensor<2, Bool> = Tensor::zeros([2, 3], &device);
{
let dtype = tensor.dtype();
let rank_desc: TensorRankType = TensorRankType::from(&tensor);
assert_eq!(rank_desc.kind(), TensorKindDesc::Bool);
assert_eq!(rank_desc.dtype(), dtype);
assert_eq!(rank_desc.rank(), 2);
assert_eq!(rank_desc.size_estimate(6), dtype.size() * 2 * 3);
let desc = rank_desc.to_desc(Shape::new([2, 3]));
assert_eq!(desc.to_rank_type(), rank_desc);
assert_eq!(desc.kind(), TensorKindDesc::Bool);
assert_eq!(desc.dtype(), dtype);
assert_eq!(desc.shape(), &Shape::new([2, 3]));
assert_eq!(desc.rank(), 2);
assert_eq!(desc.size_estimate(), dtype.size() * 2 * 3);
}
let data = tensor.to_data();
{
let dtype = data.dtype();
let rank_desc: TensorRankType = TensorRankType::from(&data);
assert_eq!(rank_desc.kind(), TensorKindDesc::Bool);
assert_eq!(rank_desc.dtype(), dtype);
assert_eq!(rank_desc.rank(), 2);
assert_eq!(rank_desc.size_estimate(6), dtype.size() * 2 * 3);
let desc = rank_desc.to_desc(Shape::new([2, 3]));
assert_eq!(desc.to_rank_type(), rank_desc);
assert_eq!(desc.kind(), TensorKindDesc::Bool);
assert_eq!(desc.dtype(), dtype);
assert_eq!(desc.shape(), &Shape::new([2, 3]));
assert_eq!(desc.rank(), 2);
assert_eq!(desc.size_estimate(), dtype.size() * 2 * 3);
}
}
}
}