Fixed errors from moving sparse

Author: McArthur-Alford

crates/burn-sparse/src/backend/kind.rs

@@ -58,4 +58,98 @@ impl<B: SparseBackend> BasicOps<B> for Sparse {
     ) -> Self::Primitive<D1> {
         B::sparse_slice(tensor, ranges)
     }
+
+    fn reshape<const D1: usize, const D2: usize>(
+        tensor: Self::Primitive<D1>,
+        shape: Shape<D2>,
+    ) -> Self::Primitive<D2> {
+        todo!()
+    }
+
+    fn transpose<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D> {
+        todo!()
+    }
+
+    fn swap_dims<const D: usize>(
+        tensor: Self::Primitive<D>,
+        dim1: usize,
+        dim2: usize,
+    ) -> Self::Primitive<D> {
+        todo!()
+    }
+
+    fn permute<const D: usize>(tensor: Self::Primitive<D>, axes: [usize; D]) -> Self::Primitive<D> {
+        todo!()
+    }
+
+    fn flip<const D: usize>(tensor: Self::Primitive<D>, axes: &[usize]) -> Self::Primitive<D> {
+        todo!()
+    }
+
+    fn slice_assign<const D1: usize, const D2: usize>(
+        tensor: Self::Primitive<D1>,
+        ranges: [Range<usize>; D2],
+        value: Self::Primitive<D1>,
+    ) -> Self::Primitive<D1> {
+        todo!()
+    }
+
+    fn repeat<const D: usize>(
+        tensor: Self::Primitive<D>,
+        dim: usize,
+        times: usize,
+    ) -> Self::Primitive<D> {
+        todo!()
+    }
+
+    fn cat<const D: usize>(vectors: Vec<Self::Primitive<D>>, dim: usize) -> Self::Primitive<D> {
+        todo!()
+    }
+
+    fn equal<const D: usize>(
+        lhs: Self::Primitive<D>,
+        rhs: Self::Primitive<D>,
+    ) -> burn_tensor::Tensor<B, D, burn_tensor::Bool> {
+        todo!()
+    }
+
+    fn not_equal<const D: usize>(
+        lhs: Self::Primitive<D>,
+        rhs: Self::Primitive<D>,
+    ) -> burn_tensor::Tensor<B, D, burn_tensor::Bool> {
+        todo!()
+    }
+
+    fn any<const D: usize>(
+        tensor: Self::Primitive<D>,
+    ) -> burn_tensor::Tensor<B, 1, burn_tensor::Bool> {
+        todo!()
+    }
+
+    fn any_dim<const D: usize>(
+        tensor: Self::Primitive<D>,
+        dim: usize,
+    ) -> burn_tensor::Tensor<B, D, burn_tensor::Bool> {
+        todo!()
+    }
+
+    fn all<const D: usize>(
+        tensor: Self::Primitive<D>,
+    ) -> burn_tensor::Tensor<B, 1, burn_tensor::Bool> {
+        todo!()
+    }
+
+    fn all_dim<const D: usize>(
+        tensor: Self::Primitive<D>,
+        dim: usize,
+    ) -> burn_tensor::Tensor<B, D, burn_tensor::Bool> {
+        todo!()
+    }
+
+    fn expand<const D1: usize, const D2: usize>(
+        tensor: Self::Primitive<D1>,
+        shape: Shape<D2>,
+    ) -> Self::Primitive<D2> {
+        todo!()
+    }
 }

crates/burn-sparse/src/decorator/sparse_coo.rs

@@ -1,8 +1,9 @@
+use crate::backend::SparseBackend;
+use crate::backend::SparseTensor;
 use crate::decorator::SparseCOO;
 use crate::decorator::SparseDecorator;
 use burn_tensor::{
-    backend::Backend, ops::SparseTensor, sparse_backend::SparseBackend, ElementConversion, Float,
-    Int, Shape, Tensor, TensorData, TensorPrimitive,
+    backend::Backend, ElementConversion, Float, Int, Shape, Tensor, TensorData, TensorPrimitive,
 };
 
 #[derive(Clone, Debug)]
@@ -174,9 +175,9 @@ where
     }
 
     fn sparse_to_device<const D: usize>(
-        tensor: burn_tensor::ops::SparseTensor<Self, D>,
+        tensor: SparseTensor<Self, D>,
         device: &burn_tensor::Device<Self>,
-    ) -> burn_tensor::ops::SparseTensor<Self, D> {
+    ) -> SparseTensor<Self, D> {
         SparseCOOTensor {
             coordinates: tensor.coordinates.to_device(device),
             values: tensor.values.to_device(device),
@@ -193,7 +194,7 @@ where
     fn sparse_empty<const D: usize>(
         shape: burn_tensor::Shape<D>,
         device: &burn_tensor::Device<B>,
-    ) -> burn_tensor::ops::SparseTensor<Self, D> {
+    ) -> SparseTensor<Self, D> {
         SparseCOOTensor {
             coordinates: Tensor::from_primitive(B::int_empty(
                 burn_tensor::Shape::new([0, 0]),
@@ -210,7 +211,7 @@ where
     fn sparse_slice<const D1: usize, const D2: usize>(
         tensor: Self::SparseTensorPrimitive<D1>,
         indices: [std::ops::Range<usize>; D2],
-    ) -> burn_tensor::ops::SparseTensor<Self, D1> {
+    ) -> SparseTensor<Self, D1> {
         let SparseCOOTensor {
             coordinates,
             values,
@@ -259,13 +260,13 @@ where
     fn sparse_from_data<const D: usize>(
         data: TensorData,
         device: &burn_tensor::Device<Self>,
-    ) -> burn_tensor::ops::SparseTensor<Self, D> {
+    ) -> SparseTensor<Self, D> {
         let dense = B::float_from_data(data, &device);
         Self::sparse_to_sparse(dense)
     }
 
     fn sparse_into_data<const D: usize>(
-        tensor: burn_tensor::ops::SparseTensor<Self, D>,
+        tensor: SparseTensor<Self, D>,
     ) -> impl std::future::Future<Output = TensorData> + Send {
         // TODO this could be way better
         B::float_into_data(Self::sparse_to_dense(tensor))

crates/burn-sparse/src/decorator/sparse_csr.rs

@@ -1,6 +1,8 @@
+use crate::backend::SparseBackend;
+use crate::backend::SparseTensor;
 use crate::decorator::SparseCSR;
 use crate::decorator::SparseDecorator;
-use burn_tensor::{backend::Backend, sparse_backend::SparseBackend};
+use burn_tensor::backend::Backend;
 use core::marker::PhantomData;
 
 #[derive(Debug, Default, Clone)]
@@ -17,7 +19,7 @@ where
     fn sparse_empty<const D: usize>(
         shape: burn_tensor::Shape<D>,
         device: &burn_tensor::Device<Self>,
-    ) -> burn_tensor::ops::SparseTensor<Self, D> {
+    ) -> SparseTensor<Self, D> {
         todo!()
     }
 
@@ -48,41 +50,37 @@ where
     }
 
     fn sparse_slice<const D1: usize, const D2: usize>(
-        tensor: burn_tensor::ops::SparseTensor<Self, D1>,
+        tensor: SparseTensor<Self, D1>,
         indices: [std::ops::Range<usize>; D2],
-    ) -> burn_tensor::ops::SparseTensor<Self, D1> {
+    ) -> SparseTensor<Self, D1> {
         todo!()
     }
 
-    fn sparse_device<const D: usize>(
-        tensor: &burn_tensor::ops::SparseTensor<Self, D>,
-    ) -> burn_tensor::Device<Self> {
+    fn sparse_device<const D: usize>(tensor: &SparseTensor<Self, D>) -> burn_tensor::Device<Self> {
         todo!()
     }
 
     fn sparse_to_device<const D: usize>(
-        tensor: burn_tensor::ops::SparseTensor<Self, D>,
+        tensor: SparseTensor<Self, D>,
         device: &burn_tensor::Device<Self>,
-    ) -> burn_tensor::ops::SparseTensor<Self, D> {
+    ) -> SparseTensor<Self, D> {
         todo!()
     }
 
-    fn sparse_shape<const D: usize>(
-        tensor: &burn_tensor::ops::SparseTensor<Self, D>,
-    ) -> burn_tensor::Shape<D> {
+    fn sparse_shape<const D: usize>(tensor: &SparseTensor<Self, D>) -> burn_tensor::Shape<D> {
         todo!()
     }
 
     fn sparse_into_data<const D: usize>(
-        tensor: burn_tensor::ops::SparseTensor<Self, D>,
+        tensor: SparseTensor<Self, D>,
     ) -> impl std::future::Future<Output = burn_tensor::TensorData> + Send {
         async { todo!() }
     }
 
     fn sparse_from_data<const D: usize>(
         data: burn_tensor::TensorData,
         device: &burn_tensor::Device<Self>,
-    ) -> burn_tensor::ops::SparseTensor<Self, D> {
+    ) -> SparseTensor<Self, D> {
         todo!()
     }
 }