diff --git a/backend-comparison/benches/binary.rs b/backend-comparison/benches/binary.rs
index b06a1ccd4..aa1792577 100644
--- a/backend-comparison/benches/binary.rs
+++ b/backend-comparison/benches/binary.rs
@@ -23,8 +23,8 @@ impl<B: Backend, const D: usize> Benchmark for BinaryBenchmark<B, D> {
     }
 
     fn prepare(&self) -> Self::Args {
-        let lhs = Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device);
-        let rhs = Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device);
+        let lhs = Tensor::random(self.shape.clone(), Distribution::Default, &self.device);
+        let rhs = Tensor::random(self.shape.clone(), Distribution::Default, &self.device);
 
         (lhs, rhs)
     }
diff --git a/backend-comparison/benches/custom_gelu.rs b/backend-comparison/benches/custom_gelu.rs
index 33ad9d17c..e81f154b3 100644
--- a/backend-comparison/benches/custom_gelu.rs
+++ b/backend-comparison/benches/custom_gelu.rs
@@ -39,7 +39,7 @@ impl<B: Backend, const D: usize> Benchmark for CustomGeluBenchmark<B, D> {
     }
 
     fn prepare(&self) -> Self::Args {
-        Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device)
+        Tensor::random(self.shape.clone(), Distribution::Default, &self.device)
     }
 
     fn sync(&self) {
diff --git a/backend-comparison/benches/data.rs b/backend-comparison/benches/data.rs
index 571a08b23..850da7305 100644
--- a/backend-comparison/benches/data.rs
+++ b/backend-comparison/benches/data.rs
@@ -24,7 +24,7 @@ impl<B: Backend, const D: usize> Benchmark for ToDataBenchmark<B, D> {
     }
 
     fn prepare(&self) -> Self::Args {
-        Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device)
+        Tensor::random(self.shape.clone(), Distribution::Default, &self.device)
     }
 
     fn sync(&self) {
@@ -48,7 +48,7 @@ impl<B: Backend, const D: usize> Benchmark for FromDataBenchmark<B, D> {
 
     fn execute(&self, (data, device): Self::Args) {
         for _ in 0..self.num_repeats {
-            let _data = Tensor::<B, D>::from_data_device(data.clone(), &device);
+            let _data = Tensor::<B, D>::from_data(data.clone(), &device);
         }
     }
 
diff --git a/backend-comparison/benches/matmul.rs b/backend-comparison/benches/matmul.rs
index 24f39eeed..bba7458df 100644
--- a/backend-comparison/benches/matmul.rs
+++ b/backend-comparison/benches/matmul.rs
@@ -32,10 +32,8 @@ impl<B: Backend, const D: usize> Benchmark for MatmulBenchmark<B, D> {
     }
 
     fn prepare(&self) -> Self::Args {
-        let lhs =
-            Tensor::random_device(self.shape_lhs.clone(), Distribution::Default, &self.device);
-        let rhs =
-            Tensor::random_device(self.shape_rhs.clone(), Distribution::Default, &self.device);
+        let lhs = Tensor::random(self.shape_lhs.clone(), Distribution::Default, &self.device);
+        let rhs = Tensor::random(self.shape_rhs.clone(), Distribution::Default, &self.device);
 
         (lhs, rhs)
     }
diff --git a/backend-comparison/benches/unary.rs b/backend-comparison/benches/unary.rs
index 924d7a3b3..b35370de2 100644
--- a/backend-comparison/benches/unary.rs
+++ b/backend-comparison/benches/unary.rs
@@ -25,7 +25,7 @@ impl<B: Backend, const D: usize> Benchmark for UnaryBenchmark<B, D> {
     }
 
     fn prepare(&self) -> Self::Args {
-        Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device)
+        Tensor::random(self.shape.clone(), Distribution::Default, &self.device)
     }
 
     fn sync(&self) {
diff --git a/burn-autodiff/src/tests/abs.rs b/burn-autodiff/src/tests/abs.rs
index 02c40d135..05fde3daa 100644
--- a/burn-autodiff/src/tests/abs.rs
+++ b/burn-autodiff/src/tests/abs.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, -1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, -10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().abs());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/adaptive_avgpool1d.rs b/burn-autodiff/src/tests/adaptive_avgpool1d.rs
index 60caee893..ca497ea33 100644
--- a/burn-autodiff/src/tests/adaptive_avgpool1d.rs
+++ b/burn-autodiff/src/tests/adaptive_avgpool1d.rs
@@ -13,7 +13,7 @@ mod tests {
             output_size: 3,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.5000, 0.8333, 0.3333, 0.8333, 0.5000],
             [0.5000, 0.8333, 0.3333, 0.8333, 0.5000],
         ]]));
@@ -29,8 +29,8 @@ mod tests {
     impl AdaptiveAvgPool1dTestCase {
         fn assert_output(self, x_grad: TestTensor<3>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.length]);
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/adaptive_avgpool2d.rs b/burn-autodiff/src/tests/adaptive_avgpool2d.rs
index 4e09a6389..612197ea2 100644
--- a/burn-autodiff/src/tests/adaptive_avgpool2d.rs
+++ b/burn-autodiff/src/tests/adaptive_avgpool2d.rs
@@ -15,7 +15,7 @@ mod tests {
             output_size_2: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [0.2500, 0.5000, 0.2500],
                 [0.4167, 0.8333, 0.4167],
@@ -45,8 +45,8 @@ mod tests {
     impl AdaptiveAvgPool2dTestCase {
         fn assert_output(self, x_grad: TestTensor<4>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.height, self.width]);
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/add.rs b/burn-autodiff/src/tests/add.rs
index 884ced38a..6fb8ded4e 100644
--- a/burn-autodiff/src/tests/add.rs
+++ b/burn-autodiff/src/tests/add.rs
@@ -5,8 +5,8 @@ mod tests {
 
     #[test]
     fn should_diff_add() {
-        let tensor_1 = TestAutodiffTensor::from_floats([2.0, 5.0]).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_floats([4.0, 1.0]).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_floats_devauto([2.0, 5.0]).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_floats_devauto([4.0, 1.0]).require_grad();
 
         let tensor_3 = tensor_1.clone() + tensor_2.clone();
         let grads = tensor_3.backward();
@@ -23,7 +23,7 @@ mod tests {
     fn should_diff_add_scalar() {
         let data = Data::from([2.0, 10.0]);
 
-        let tensor = TestAutodiffTensor::from_data(data).require_grad();
+        let tensor = TestAutodiffTensor::from_data_devauto(data).require_grad();
         let tensor_out = tensor.clone().add_scalar(5.0);
         let grads = tensor_out.backward();
 
@@ -39,9 +39,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[2.0, 2.0], [2.0, 2.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().add(tensor_2.clone());
         let tensor_5 = tensor_4
diff --git a/burn-autodiff/src/tests/aggregation.rs b/burn-autodiff/src/tests/aggregation.rs
index a546a0146..7d1349f7a 100644
--- a/burn-autodiff/src/tests/aggregation.rs
+++ b/burn-autodiff/src/tests/aggregation.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [-2.0, -3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, -7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_1.clone().mul(tensor_3.mean().unsqueeze());
@@ -31,8 +31,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [-2.0, -3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, -7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_1.clone().mul(tensor_3.sum().unsqueeze());
@@ -54,8 +54,8 @@ mod tests {
         let data_1 = Data::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.clone().sum_dim(1);
@@ -78,8 +78,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [-2.0, -3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, -7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_1.clone().mul(tensor_3.mean_dim(1).unsqueeze());
@@ -101,8 +101,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [-2.0, -3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, -7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_1.clone().mul(tensor_3.sum_dim(1).unsqueeze());
diff --git a/burn-autodiff/src/tests/avgpool1d.rs b/burn-autodiff/src/tests/avgpool1d.rs
index a0224cf11..3792b40a5 100644
--- a/burn-autodiff/src/tests/avgpool1d.rs
+++ b/burn-autodiff/src/tests/avgpool1d.rs
@@ -16,7 +16,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             0.3333, 0.6667, 1.0000, 1.0000, 0.6667, 0.3333,
         ]]]));
     }
@@ -33,7 +33,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.3333, 0.6667, 0.3333, 0.6667, 0.3333, 0.3333],
             [0.3333, 0.6667, 0.3333, 0.6667, 0.3333, 0.3333],
         ]]));
@@ -51,7 +51,7 @@ mod tests {
             count_include_pad: false,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.5000, 0.8333, 0.3333, 0.6667, 0.3333, 0.3333],
             [0.5000, 0.8333, 0.3333, 0.6667, 0.3333, 0.3333],
         ]]));
@@ -70,8 +70,8 @@ mod tests {
     impl AvgPool1dTestCase {
         fn assert_output(self, x_grad: TestTensor<3>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.length]);
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/avgpool2d.rs b/burn-autodiff/src/tests/avgpool2d.rs
index 5ad2aa50a..df40db3dc 100644
--- a/burn-autodiff/src/tests/avgpool2d.rs
+++ b/burn-autodiff/src/tests/avgpool2d.rs
@@ -20,7 +20,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [0.1111, 0.2222, 0.3333, 0.3333, 0.2222, 0.1111],
             [0.2222, 0.4444, 0.6667, 0.6667, 0.4444, 0.2222],
             [0.3333, 0.6667, 1.0000, 1.0000, 0.6667, 0.3333],
@@ -46,7 +46,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [0.3333, 0.3333, 0.3333, 0.3333, 0.3333, 0.3333],
             [0.5000, 0.5000, 0.5000, 0.5000, 0.5000, 0.5000],
             [0.5000, 0.5000, 0.5000, 0.5000, 0.5000, 0.5000],
@@ -70,7 +70,7 @@ mod tests {
             count_include_pad: false,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [0.6250, 0.6250, 0.4167, 0.4167, 0.6250, 0.6250],
             [0.8750, 0.8750, 0.5833, 0.5833, 0.8750, 0.8750],
             [0.8750, 0.8750, 0.5833, 0.5833, 0.8750, 0.8750],
@@ -95,8 +95,8 @@ mod tests {
     impl AvgPool2dTestCase {
         fn assert_output(self, x_grad: TestTensor<4>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.height, self.width]);
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/backward.rs b/burn-autodiff/src/tests/backward.rs
index ca25e71da..5a6a523f2 100644
--- a/burn-autodiff/src/tests/backward.rs
+++ b/burn-autodiff/src/tests/backward.rs
@@ -11,9 +11,9 @@ mod tests {
             [[1.0, 2.0], [4.0, 5.0], [3.0, 4.0]],
             [[4.0, 5.0], [8.0, 5.0], [1.0, 9.0]],
         ]);
-        let weights = Tensor::<TestAutodiffBackend, 2>::from_data(weights).require_grad();
-        let indices = Tensor::<TestAutodiffBackend, 2, Int>::from_data(indices);
-        let x = Tensor::<TestAutodiffBackend, 3>::from_data(x).require_grad();
+        let weights = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(weights).require_grad();
+        let indices = Tensor::<TestAutodiffBackend, 2, Int>::from_data_devauto(indices);
+        let x = Tensor::<TestAutodiffBackend, 3>::from_data_devauto(x).require_grad();
 
         let output = embedding(weights.clone(), indices);
         let output = output.matmul(x);
diff --git a/burn-autodiff/src/tests/broadcast.rs b/burn-autodiff/src/tests/broadcast.rs
index 324c538d9..f81674bb3 100644
--- a/burn-autodiff/src/tests/broadcast.rs
+++ b/burn-autodiff/src/tests/broadcast.rs
@@ -37,8 +37,8 @@ mod tests {
     where
         F: Fn(TestAutodiffTensor<3>, TestAutodiffTensor<3>) -> TestAutodiffTensor<3>,
     {
-        let w = TestAutodiffTensor::zeros([16, 5, 5]).require_grad();
-        let x = TestAutodiffTensor::zeros([4, 5, 5]).require_grad();
+        let w = TestAutodiffTensor::zeros_devauto([16, 5, 5]).require_grad();
+        let x = TestAutodiffTensor::zeros_devauto([4, 5, 5]).require_grad();
 
         // Slice isn't a broadcastable operation, so it will fail when the previous backward pass
         // of an operation that support broadcast doesn't support it during the backward pass.
diff --git a/burn-autodiff/src/tests/cat.rs b/burn-autodiff/src/tests/cat.rs
index 3a27c4213..30723ee3e 100644
--- a/burn-autodiff/src/tests/cat.rs
+++ b/burn-autodiff/src/tests/cat.rs
@@ -5,8 +5,10 @@ mod tests {
 
     #[test]
     fn should_diff_cat() {
-        let tensor_1 = TestAutodiffTensor::from_data([[2.0, -1.0], [5.0, 2.0]]).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data([[5.0, 4.0], [-1.0, 4.0]]).require_grad();
+        let tensor_1 =
+            TestAutodiffTensor::from_data_devauto([[2.0, -1.0], [5.0, 2.0]]).require_grad();
+        let tensor_2 =
+            TestAutodiffTensor::from_data_devauto([[5.0, 4.0], [-1.0, 4.0]]).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let grads = tensor_3.backward();
@@ -57,9 +59,10 @@ mod tests {
 
     #[test]
     fn should_diff_cat_more_than_1_dim() {
-        let tensor_1 = TestAutodiffTensor::from_data([[2.0, -1.0], [5.0, 2.0]]).require_grad();
-        let tensor_2 =
-            TestAutodiffTensor::from_data([[5.0, 4.0], [-1.0, 4.0], [4.0, 1.0]]).require_grad();
+        let tensor_1 =
+            TestAutodiffTensor::from_data_devauto([[2.0, -1.0], [5.0, 2.0]]).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto([[5.0, 4.0], [-1.0, 4.0], [4.0, 1.0]])
+            .require_grad();
 
         // Concat a tensor [2, 2] with another tensor [3, 2] along dim 0.
         // The resulting tensor should be [5, 2]
diff --git a/burn-autodiff/src/tests/complex.rs b/burn-autodiff/src/tests/complex.rs
index aa15d5321..8c291268b 100644
--- a/burn-autodiff/src/tests/complex.rs
+++ b/burn-autodiff/src/tests/complex.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1: Data<f32, 2> = Data::from([[1.0, 7.0], [13.0, -3.0]]);
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.matmul(tensor_1.clone());
@@ -35,8 +35,8 @@ mod tests {
         let data_1: Data<f32, 2> = Data::from([[1.0, 7.0], [13.0, -3.0]]);
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.matmul(tensor_1.clone());
@@ -59,8 +59,8 @@ mod tests {
         let data_1: Data<f32, 2> = Data::from([[1.0, 7.0], [13.0, -3.0]]);
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.matmul(tensor_1.clone());
diff --git a/burn-autodiff/src/tests/conv1d.rs b/burn-autodiff/src/tests/conv1d.rs
index 3ff44aa0d..784e0ca68 100644
--- a/burn-autodiff/src/tests/conv1d.rs
+++ b/burn-autodiff/src/tests/conv1d.rs
@@ -17,15 +17,15 @@ mod tests {
             length: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[14., 24., 24., 18.], [26., 42., 42., 30.]],
                 [[14., 24., 24., 18.], [26., 42., 42., 30.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[30., 44., 36.], [54., 76., 60.]],
                 [[30., 44., 36.], [54., 76., 60.]],
             ]),
-            bias: TestTensor::from_floats([8., 8.]),
+            bias: TestTensor::from_floats_devauto([8., 8.]),
         };
         test.assert_grads(grads);
     }
@@ -44,16 +44,16 @@ mod tests {
             length: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[39., 63., 63., 45.], [57., 90., 90., 63.]],
                 [[39., 63., 63., 45.], [57., 90., 90., 63.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[30., 44., 36.], [54., 76., 60.]],
                 [[30., 44., 36.], [54., 76., 60.]],
                 [[30., 44., 36.], [54., 76., 60.]],
             ]),
-            bias: TestTensor::from_floats([8., 8., 8.]),
+            bias: TestTensor::from_floats_devauto([8., 8., 8.]),
         };
         test.assert_grads(grads);
     }
@@ -72,15 +72,15 @@ mod tests {
             length: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[24., 24., 24., 24.], [42., 42., 42., 42.]],
                 [[24., 24., 24., 24.], [42., 42., 42., 42.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[44., 44., 44.], [76., 76., 76.]],
                 [[44., 44., 44.], [76., 76., 76.]],
             ]),
-            bias: TestTensor::from_floats([12., 12.]),
+            bias: TestTensor::from_floats_devauto([12., 12.]),
         };
         test.assert_grads(grads);
     }
@@ -99,15 +99,15 @@ mod tests {
             length: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[8., 16., 8., 10.], [14., 28., 14., 16.]],
                 [[8., 16., 8., 10.], [14., 28., 14., 16.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[10., 20., 24.], [18., 36., 40.]],
                 [[10., 20., 24.], [18., 36., 40.]],
             ]),
-            bias: TestTensor::from_floats([4., 4.]),
+            bias: TestTensor::from_floats_devauto([4., 4.]),
         };
         test.assert_grads(grads);
     }
@@ -126,15 +126,15 @@ mod tests {
             length: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[6., 8., 8., 10.], [12., 14., 14., 16.]],
                 [[6., 8., 8., 10.], [12., 14., 14., 16.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[8., 22., 14.], [16., 38., 22.]],
                 [[8., 22., 14.], [16., 38., 22.]],
             ]),
-            bias: TestTensor::from_floats([4., 4.]),
+            bias: TestTensor::from_floats_devauto([4., 4.]),
         };
         test.assert_grads(grads);
     }
@@ -153,12 +153,12 @@ mod tests {
             length: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[1., 3., 3., 3.], [7., 12., 12., 9.]],
                 [[1., 3., 3., 3.], [7., 12., 12., 9.]],
             ]),
-            weight: TestTensor::from_floats([[[30., 44., 36.]], [[54., 76., 60.]]]),
-            bias: TestTensor::from_floats([8., 8.]),
+            weight: TestTensor::from_floats_devauto([[[30., 44., 36.]], [[54., 76., 60.]]]),
+            bias: TestTensor::from_floats_devauto([8., 8.]),
         };
         test.assert_grads(grads);
     }
@@ -189,21 +189,21 @@ mod tests {
                 self.channels_in / self.groups,
                 self.kernel_size,
             ]);
-            let weight = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_weight.num_elements())
+            let weight = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weight.num_elements())
                     .reshape(shape_weight)
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let bias = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..self.channels_out)
+            let bias = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels_out)
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/conv2d.rs b/burn-autodiff/src/tests/conv2d.rs
index 7e6d2a801..251379753 100644
--- a/burn-autodiff/src/tests/conv2d.rs
+++ b/burn-autodiff/src/tests/conv2d.rs
@@ -22,7 +22,7 @@ mod tests {
             width: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [
                     [
                         [88., 138., 138., 96.],
@@ -52,7 +52,7 @@ mod tests {
                     ],
                 ],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[378., 516., 396.], [552., 752., 576.], [450., 612., 468.]],
                     [[666., 900., 684.], [936., 1264., 960.], [738., 996., 756.]],
@@ -62,7 +62,7 @@ mod tests {
                     [[666., 900., 684.], [936., 1264., 960.], [738., 996., 756.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([32., 32.]),
+            bias: TestTensor::from_floats_devauto([32., 32.]),
         };
         test.assert_grads(grads);
     }
@@ -86,7 +86,7 @@ mod tests {
             width: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [
                     [
                         [240., 369., 369., 252.],
@@ -116,7 +116,7 @@ mod tests {
                     ],
                 ],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[378., 516., 396.], [552., 752., 576.], [450., 612., 468.]],
                     [[666., 900., 684.], [936., 1264., 960.], [738., 996., 756.]],
@@ -130,7 +130,7 @@ mod tests {
                     [[666., 900., 684.], [936., 1264., 960.], [738., 996., 756.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([32., 32., 32.]),
+            bias: TestTensor::from_floats_devauto([32., 32., 32.]),
         };
         test.assert_grads(grads);
     }
@@ -154,7 +154,7 @@ mod tests {
             width: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [116., 180., 192., 132.],
                     [198., 306., 324., 222.],
@@ -168,7 +168,7 @@ mod tests {
                     [244., 372., 384., 260.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [
                         [27., 45., 54., 39.],
@@ -194,7 +194,7 @@ mod tests {
                     ],
                 ],
             ]),
-            bias: TestTensor::from_floats([12., 12.]),
+            bias: TestTensor::from_floats_devauto([12., 12.]),
         };
         test.assert_grads(grads);
     }
@@ -218,7 +218,7 @@ mod tests {
             width: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [138., 138., 138., 138.],
                     [234., 234., 234., 234.],
@@ -232,7 +232,7 @@ mod tests {
                     [282., 282., 282., 282.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[66., 66., 66.], [120., 120., 120.], [114., 114., 114.]],
                     [[258., 258., 258.], [376., 376., 376.], [306., 306., 306.]],
@@ -242,7 +242,7 @@ mod tests {
                     [[258., 258., 258.], [376., 376., 376.], [306., 306., 306.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([24., 24.]),
+            bias: TestTensor::from_floats_devauto([24., 24.]),
         };
         test.assert_grads(grads);
     }
@@ -266,7 +266,7 @@ mod tests {
             width: 5,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [88., 138., 138., 138., 96.],
                     [150., 234., 234., 234., 162.],
@@ -280,7 +280,7 @@ mod tests {
                     [184., 282., 282., 282., 192.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[78., 105., 90.], [144., 190., 160.], [138., 180., 150.]],
                     [[318., 405., 330.], [464., 590., 480.], [378., 480., 390.]],
@@ -290,7 +290,7 @@ mod tests {
                     [[318., 405., 330.], [464., 590., 480.], [378., 480., 390.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([20., 20.]),
+            bias: TestTensor::from_floats_devauto([20., 20.]),
         };
         test.assert_grads(grads);
     }
@@ -314,7 +314,7 @@ mod tests {
             width: 6,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [26., 52., 26., 52., 26., 28.],
                     [52., 104., 52., 104., 52., 56.],
@@ -332,7 +332,7 @@ mod tests {
                     [50., 100., 50., 100., 50., 52.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[56., 84., 90.], [84., 126., 135.], [120., 180., 189.]],
                     [[200., 300., 306.], [300., 450., 459.], [336., 504., 513.]],
@@ -342,7 +342,7 @@ mod tests {
                     [[200., 300., 306.], [300., 450., 459.], [336., 504., 513.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([9., 9.]),
+            bias: TestTensor::from_floats_devauto([9., 9.]),
         };
         test.assert_grads(grads);
     }
@@ -366,7 +366,7 @@ mod tests {
             width: 8,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [50., 78., 78., 78., 78., 78., 78., 54.],
                     [62., 96., 96., 96., 96., 96., 96., 66.],
@@ -388,7 +388,7 @@ mod tests {
                     [98., 150., 150., 150., 150., 150., 150., 102.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[434., 504., 448.], [567., 660., 588.], [735., 852., 756.]],
                     [
@@ -406,7 +406,7 @@ mod tests {
                     ],
                 ],
             ]),
-            bias: TestTensor::from_floats([24., 24.]),
+            bias: TestTensor::from_floats_devauto([24., 24.]),
         };
         test.assert_grads(grads);
     }
@@ -430,7 +430,7 @@ mod tests {
             width: 6,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [18., 38., 38., 42., 42., 22.],
                     [42., 88., 88., 96., 96., 50.],
@@ -448,7 +448,7 @@ mod tests {
                     [48., 98., 98., 102., 102., 52.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[63., 102., 90.], [192., 280., 228.], [225., 318., 252.]],
                     [[387., 534., 414.], [624., 856., 660.], [549., 750., 576.]],
@@ -458,7 +458,7 @@ mod tests {
                     [[387., 534., 414.], [624., 856., 660.], [549., 750., 576.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([16., 16.]),
+            bias: TestTensor::from_floats_devauto([16., 16.]),
         };
         test.assert_grads(grads);
     }
@@ -482,7 +482,7 @@ mod tests {
             width: 6,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [18., 0., 20., 20., 0., 22.],
                     [42., 0., 46., 46., 0., 50.],
@@ -500,7 +500,7 @@ mod tests {
                     [48., 0., 50., 50., 0., 52.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[18., 51., 33.], [60., 140., 80.], [72., 159., 87.]],
                     [[126., 267., 141.], [204., 428., 224.], [180., 375., 195.]],
@@ -510,7 +510,7 @@ mod tests {
                     [[126., 267., 141.], [204., 428., 224.], [180., 375., 195.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([8., 8.]),
+            bias: TestTensor::from_floats_devauto([8., 8.]),
         };
         test.assert_grads(grads);
     }
@@ -534,7 +534,7 @@ mod tests {
             width: 5,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [0., 1., 3., 3., 2.],
                     [3., 8., 15., 12., 7.],
@@ -550,11 +550,11 @@ mod tests {
                     [15., 31., 48., 33., 17.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[[54., 63., 72.], [99., 108., 117.], [144., 153., 162.]]],
                 [[[279., 288., 297.], [324., 333., 342.], [369., 378., 387.]]],
             ]),
-            bias: TestTensor::from_floats([9., 9.]),
+            bias: TestTensor::from_floats_devauto([9., 9.]),
         };
         test.assert_grads(grads);
     }
@@ -578,7 +578,7 @@ mod tests {
             width: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [9., 20., 24., 13.],
                     [24., 52., 60., 32.],
@@ -598,7 +598,7 @@ mod tests {
                     [93., 188., 192., 97.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[[10., 14., 18.], [26., 30., 34.], [42., 46., 50.]]],
                 [[[10., 14., 18.], [26., 30., 34.], [42., 46., 50.]]],
                 [[[74., 78., 82.], [90., 94., 98.], [106., 110., 114.]]],
@@ -606,7 +606,7 @@ mod tests {
                 [[[138., 142., 146.], [154., 158., 162.], [170., 174., 178.]]],
                 [[[138., 142., 146.], [154., 158., 162.], [170., 174., 178.]]],
             ]),
-            bias: TestTensor::from_floats([4., 4., 4., 4., 4., 4.]),
+            bias: TestTensor::from_floats_devauto([4., 4., 4., 4., 4., 4.]),
         };
         test.assert_grads(grads);
     }
@@ -630,7 +630,7 @@ mod tests {
             width: 5,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [36., 39., 0., 39., 42.],
                     [81., 87., 0., 87., 93.],
@@ -644,7 +644,7 @@ mod tests {
                     [63., 66., 0., 66., 69.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[15., 42., 27.], [30., 72., 42.]],
                     [[75., 162., 87.], [90., 192., 102.]],
@@ -658,7 +658,7 @@ mod tests {
                     [[75., 162., 87.], [90., 192., 102.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([8., 8., 8.]),
+            bias: TestTensor::from_floats_devauto([8., 8., 8.]),
         };
         test.assert_grads(grads);
     }
@@ -695,21 +695,21 @@ mod tests {
                 self.kernel_size_1,
                 self.kernel_size_2,
             ]);
-            let weight = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_weight.num_elements())
+            let weight = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weight.num_elements())
                     .reshape(shape_weight)
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let bias = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..self.channels_out)
+            let bias = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels_out)
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/conv_transpose1d.rs b/burn-autodiff/src/tests/conv_transpose1d.rs
index 4f05a447d..b76c30827 100644
--- a/burn-autodiff/src/tests/conv_transpose1d.rs
+++ b/burn-autodiff/src/tests/conv_transpose1d.rs
@@ -17,15 +17,15 @@ mod tests {
             size: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[15.0, 15.0, 15.0, 15.0], [51.0, 51.0, 51.0, 51.0]],
                 [[15.0, 15.0, 15.0, 15.0], [51.0, 51.0, 51.0, 51.0]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[44.0, 44.0, 44.0], [44.0, 44.0, 44.0]],
                 [[76.0, 76.0, 76.0], [76.0, 76.0, 76.0]],
             ]),
-            bias: TestTensor::from_floats([12., 12.]),
+            bias: TestTensor::from_floats_devauto([12., 12.]),
         };
         test.assert_grads(grads);
     }
@@ -44,15 +44,15 @@ mod tests {
             size: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[7., 12., 8., 3.], [19., 36., 32., 15.]],
                 [[7., 12., 8., 3.], [19., 36., 32., 15.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[26., 22., 18.], [26., 22., 18.]],
                 [[42., 38., 34.], [42., 38., 34.]],
             ]),
-            bias: TestTensor::from_floats([4., 4.]),
+            bias: TestTensor::from_floats_devauto([4., 4.]),
         };
         test.assert_grads(grads);
     }
@@ -71,15 +71,15 @@ mod tests {
             size: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[15., 15., 15., 15.], [51., 51., 51., 51.]],
                 [[15., 15., 15., 15.], [51., 51., 51., 51.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[44., 44., 44.], [44., 44., 44.]],
                 [[76., 76., 76.], [76., 76., 76.]],
             ]),
-            bias: TestTensor::from_floats([18., 18.]),
+            bias: TestTensor::from_floats_devauto([18., 18.]),
         };
         test.assert_grads(grads);
     }
@@ -98,15 +98,15 @@ mod tests {
             size: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[15., 15., 15., 15.], [51., 51., 51., 51.]],
                 [[15., 15., 15., 15.], [51., 51., 51., 51.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[44., 44., 44.], [44., 44., 44.]],
                 [[76., 76., 76.], [76., 76., 76.]],
             ]),
-            bias: TestTensor::from_floats([20., 20.]),
+            bias: TestTensor::from_floats_devauto([20., 20.]),
         };
         test.assert_grads(grads);
     }
@@ -125,15 +125,15 @@ mod tests {
             size: 4,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [[15., 15., 15., 15.], [51., 51., 51., 51.]],
                 [[15., 15., 15., 15.], [51., 51., 51., 51.]],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[44., 44., 44.], [44., 44., 44.]],
                 [[76., 76., 76.], [76., 76., 76.]],
             ]),
-            bias: TestTensor::from_floats([16., 16.]),
+            bias: TestTensor::from_floats_devauto([16., 16.]),
         };
         test.assert_grads(grads);
     }
@@ -152,7 +152,7 @@ mod tests {
             size: 8,
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [
                     [12.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0],
                     [36.0, 51.0, 51.0, 51.0, 51.0, 51.0, 51.0, 51.0],
@@ -162,11 +162,11 @@ mod tests {
                     [36.0, 51.0, 51.0, 51.0, 51.0, 51.0, 51.0, 51.0],
                 ],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[168.0, 184.0, 184.0], [168.0, 184.0, 184.0]],
                 [[280.0, 312.0, 312.0], [280.0, 312.0, 312.0]],
             ]),
-            bias: TestTensor::from_floats([36.0, 36.0, 36.0, 36.0]),
+            bias: TestTensor::from_floats_devauto([36.0, 36.0, 36.0, 36.0]),
         };
         test.assert_grads(grads);
     }
@@ -197,21 +197,21 @@ mod tests {
                 self.channels[1] / self.groups,
                 self.kernel_size,
             ]);
-            let weight = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_weight.num_elements())
+            let weight = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weight.num_elements())
                     .reshape(shape_weight)
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let bias = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..self.channels[1])
+            let bias = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels[1])
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/conv_transpose2d.rs b/burn-autodiff/src/tests/conv_transpose2d.rs
index 138afbf5f..3e42c25d9 100644
--- a/burn-autodiff/src/tests/conv_transpose2d.rs
+++ b/burn-autodiff/src/tests/conv_transpose2d.rs
@@ -17,7 +17,7 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [
                     [
                         [153., 153., 153., 153.],
@@ -47,7 +47,7 @@ mod tests {
                     ],
                 ],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[752., 752., 752.], [752., 752., 752.], [752., 752., 752.]],
                     [[752., 752., 752.], [752., 752., 752.], [752., 752., 752.]],
@@ -65,7 +65,7 @@ mod tests {
                     ],
                 ],
             ]),
-            bias: TestTensor::from_floats([72., 72.]),
+            bias: TestTensor::from_floats_devauto([72., 72.]),
         };
         test.assert_grads(grads);
     }
@@ -84,18 +84,18 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[[
+            x: TestTensor::from_floats_devauto([[[
                 [13., 24., 20., 9.],
                 [15., 27., 21., 9.],
                 [15., 27., 21., 9.],
                 [7., 12., 8., 3.],
             ]]]),
-            weight: TestTensor::from_floats([[[
+            weight: TestTensor::from_floats_devauto([[[
                 [63., 57., 51.],
                 [68., 60., 52.],
                 [39., 33., 27.],
             ]]]),
-            bias: TestTensor::from_floats([8.]),
+            bias: TestTensor::from_floats_devauto([8.]),
         };
         test.assert_grads(grads);
     }
@@ -114,18 +114,18 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[[
+            x: TestTensor::from_floats_devauto([[[
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
             ]]]),
-            weight: TestTensor::from_floats([[[
+            weight: TestTensor::from_floats_devauto([[[
                 [120., 120., 120.],
                 [120., 120., 120.],
                 [120., 120., 120.],
             ]]]),
-            bias: TestTensor::from_floats([108.]),
+            bias: TestTensor::from_floats_devauto([108.]),
         };
         test.assert_grads(grads);
     }
@@ -144,18 +144,18 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[[
+            x: TestTensor::from_floats_devauto([[[
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
             ]]]),
-            weight: TestTensor::from_floats([[[
+            weight: TestTensor::from_floats_devauto([[[
                 [120., 120., 120.],
                 [120., 120., 120.],
                 [120., 120., 120.],
             ]]]),
-            bias: TestTensor::from_floats([140.]),
+            bias: TestTensor::from_floats_devauto([140.]),
         };
         test.assert_grads(grads);
     }
@@ -174,18 +174,18 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[[
+            x: TestTensor::from_floats_devauto([[[
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
                 [36., 36., 36., 36.],
             ]]]),
-            weight: TestTensor::from_floats([[[
+            weight: TestTensor::from_floats_devauto([[[
                 [120., 120., 120.],
                 [120., 120., 120.],
                 [120., 120., 120.],
             ]]]),
-            bias: TestTensor::from_floats([80.]),
+            bias: TestTensor::from_floats_devauto([80.]),
         };
         test.assert_grads(grads);
     }
@@ -204,7 +204,7 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [351., 351., 351., 351.],
                     [351., 351., 351., 351.],
@@ -218,7 +218,7 @@ mod tests {
                     [1080., 1080., 1080., 1080.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[120., 120., 120.], [120., 120., 120.], [120., 120., 120.]],
                     [[120., 120., 120.], [120., 120., 120.], [120., 120., 120.]],
@@ -230,7 +230,7 @@ mod tests {
                     [[376., 376., 376.], [376., 376., 376.], [376., 376., 376.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([36., 36., 36.]),
+            bias: TestTensor::from_floats_devauto([36., 36., 36.]),
         };
         test.assert_grads(grads);
     }
@@ -249,7 +249,7 @@ mod tests {
             size: [6, 6],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[[
+            x: TestTensor::from_floats_devauto([[[
                 [105., 105., 105., 105., 105., 105.],
                 [105., 105., 105., 105., 105., 105.],
                 [105., 105., 105., 105., 105., 105.],
@@ -257,12 +257,12 @@ mod tests {
                 [105., 105., 105., 105., 105., 105.],
                 [105., 105., 105., 105., 105., 105.],
             ]]]),
-            weight: TestTensor::from_floats([[[
+            weight: TestTensor::from_floats_devauto([[[
                 [630., 630., 630., 630., 630.],
                 [630., 630., 630., 630., 630.],
                 [630., 630., 630., 630., 630.],
             ]]]),
-            bias: TestTensor::from_floats([80.]),
+            bias: TestTensor::from_floats_devauto([80.]),
         };
         test.assert_grads(grads);
     }
@@ -281,7 +281,7 @@ mod tests {
             size: [4, 4],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [36., 36., 36., 36.],
                     [36., 36., 36., 36.],
@@ -295,11 +295,11 @@ mod tests {
                     [117., 117., 117., 117.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[[120., 120., 120.], [120., 120., 120.], [120., 120., 120.]]],
                 [[[376., 376., 376.], [376., 376., 376.], [376., 376., 376.]]],
             ]),
-            bias: TestTensor::from_floats([36., 36.]),
+            bias: TestTensor::from_floats_devauto([36., 36.]),
         };
         test.assert_grads(grads);
     }
@@ -318,7 +318,7 @@ mod tests {
             size: [6, 8],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([
+            x: TestTensor::from_floats_devauto([
                 [
                     [
                         [600., 735., 735., 735., 735., 735., 735., 735.],
@@ -356,7 +356,7 @@ mod tests {
                     ],
                 ],
             ]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [
                         [5320., 6040., 6040., 6040., 6040.],
@@ -392,7 +392,7 @@ mod tests {
                     ],
                 ],
             ]),
-            bias: TestTensor::from_floats([896., 896., 896.]),
+            bias: TestTensor::from_floats_devauto([896., 896., 896.]),
         };
         test.assert_grads(grads);
     }
@@ -411,7 +411,7 @@ mod tests {
             size: [10, 10],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [30., 42., 42., 42., 42., 42., 42., 42., 42., 42.],
                     [48., 66., 66., 66., 66., 66., 66., 66., 66., 66.],
@@ -461,7 +461,7 @@ mod tests {
                     [336., 498., 498., 498., 498., 498., 498., 498., 498., 498.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [
                     [[4455., 4905., 4905.], [4500., 4950., 4950.]],
                     [[4455., 4905., 4905.], [4500., 4950., 4950.]],
@@ -479,7 +479,7 @@ mod tests {
                     [[28755., 31905., 31905.], [31500., 34950., 34950.]],
                 ],
             ]),
-            bias: TestTensor::from_floats([570., 570.]),
+            bias: TestTensor::from_floats_devauto([570., 570.]),
         };
         test.assert_grads(grads);
     }
@@ -498,7 +498,7 @@ mod tests {
             size: [10, 10],
         };
         let grads = Grads {
-            x: TestTensor::from_floats([[
+            x: TestTensor::from_floats_devauto([[
                 [
                     [9., 12., 12., 12., 12., 12., 12., 12., 12., 12.],
                     [12., 15., 15., 15., 15., 15., 15., 15., 15., 15.],
@@ -548,13 +548,13 @@ mod tests {
                     [84., 123., 123., 123., 123., 123., 123., 123., 123., 123.],
                 ],
             ]]),
-            weight: TestTensor::from_floats([
+            weight: TestTensor::from_floats_devauto([
                 [[[4455., 4905., 4905.], [4500., 4950., 4950.]]],
                 [[[12555., 13905., 13905.], [13500., 14950., 14950.]]],
                 [[[20655., 22905., 22905.], [22500., 24950., 24950.]]],
                 [[[28755., 31905., 31905.], [31500., 34950., 34950.]]],
             ]),
-            bias: TestTensor::from_floats([570., 570.]),
+            bias: TestTensor::from_floats_devauto([570., 570.]),
         };
         test.assert_grads(grads);
     }
@@ -591,21 +591,21 @@ mod tests {
                 self.kernel_size[0],
                 self.kernel_size[1],
             ]);
-            let weight = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_weight.num_elements())
+            let weight = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weight.num_elements())
                     .reshape(shape_weight)
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let bias = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..self.channels[1])
+            let bias = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels[1])
                     .into_data()
                     .convert(),
             )
             .require_grad();
-            let x = TestAutodiffTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestAutodiffTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-autodiff/src/tests/cos.rs b/burn-autodiff/src/tests/cos.rs
index af42104e8..ec4007d53 100644
--- a/burn-autodiff/src/tests/cos.rs
+++ b/burn-autodiff/src/tests/cos.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().cos());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/cross_entropy.rs b/burn-autodiff/src/tests/cross_entropy.rs
index f898f6b2f..588ceecfd 100644
--- a/burn-autodiff/src/tests/cross_entropy.rs
+++ b/burn-autodiff/src/tests/cross_entropy.rs
@@ -9,10 +9,10 @@ mod tests {
         let data_2 = Data::from([[6.0, 7.0], [9.0, 10.0]]);
         let data_targets = Data::from([[0.8, 0.2], [0.9, 0.1]]);
 
-        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data(data_1).require_grad();
-        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data(data_2).require_grad();
+        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_1).require_grad();
+        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_2).require_grad();
         let tensor_targets =
-            Tensor::<TestAutodiffBackend, 2>::from_data(data_targets).require_grad();
+            Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_targets).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = loss::cross_entropy_with_logits(tensor_3, tensor_targets);
diff --git a/burn-autodiff/src/tests/div.rs b/burn-autodiff/src/tests/div.rs
index 7ab447092..821f20958 100644
--- a/burn-autodiff/src/tests/div.rs
+++ b/burn-autodiff/src/tests/div.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::from([1.0, 7.0]);
         let data_2 = Data::from([4.0, 7.0]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().div(tensor_2.clone());
         let grads = tensor_3.backward();
@@ -29,7 +29,7 @@ mod tests {
     fn should_diff_div_scalar() {
         let data = Data::from([1.0, 7.0]);
 
-        let tensor = TestAutodiffTensor::from_data(data).require_grad();
+        let tensor = TestAutodiffTensor::from_data_devauto(data).require_grad();
         let tensor_out = tensor.clone().div_scalar(4.0);
 
         let grads = tensor_out.backward();
@@ -44,9 +44,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[2.0, 2.0], [2.0, 2.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().div(tensor_2.clone());
         let tensor_5 = tensor_4.div(tensor_3);
@@ -69,8 +69,8 @@ mod tests {
         let data_1 = Data::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.div(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/erf.rs b/burn-autodiff/src/tests/erf.rs
index bd80c347a..43e76ef56 100644
--- a/burn-autodiff/src/tests/erf.rs
+++ b/burn-autodiff/src/tests/erf.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().erf());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/exp.rs b/burn-autodiff/src/tests/exp.rs
index bba159bb6..c491f95af 100644
--- a/burn-autodiff/src/tests/exp.rs
+++ b/burn-autodiff/src/tests/exp.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [-2.0, -3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, -7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().exp());
         let grads = tensor_3.backward();
diff --git a/burn-autodiff/src/tests/gather_scatter.rs b/burn-autodiff/src/tests/gather_scatter.rs
index 3557f11c8..a2ef1b197 100644
--- a/burn-autodiff/src/tests/gather_scatter.rs
+++ b/burn-autodiff/src/tests/gather_scatter.rs
@@ -6,9 +6,9 @@ mod tests {
     #[test]
     fn test_gather_grad() {
         let tensor_1 =
-            TestAutodiffTensor::from_data(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
+            TestAutodiffTensor::from_data_devauto(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
                 .require_grad();
-        let indices = Tensor::<TestAutodiffBackend, 2, Int>::from_data(Data::from([
+        let indices = Tensor::<TestAutodiffBackend, 2, Int>::from_data_devauto(Data::from([
             [2, 1, 0, 1, 2],
             [1, 0, 2, 1, 0],
         ]));
@@ -30,12 +30,15 @@ mod tests {
     #[test]
     fn test_scatter_grad() {
         let tensor_1 =
-            TestAutodiffTensor::from_data(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
+            TestAutodiffTensor::from_data_devauto(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
                 .require_grad();
-        let values = TestAutodiffTensor::from_data(Data::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]))
-            .require_grad();
-        let indices =
-            Tensor::<TestAutodiffBackend, 2, Int>::from_data(Data::from([[2, 1, 0], [2, 0, 1]]));
+        let values =
+            TestAutodiffTensor::from_data_devauto(Data::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]))
+                .require_grad();
+        let indices = Tensor::<TestAutodiffBackend, 2, Int>::from_data_devauto(Data::from([
+            [2, 1, 0],
+            [2, 0, 1],
+        ]));
 
         let tensor_2 = tensor_1.clone().matmul(tensor_1.clone().transpose());
         let tensor_3 = tensor_1.clone().scatter(1, indices, values.clone());
diff --git a/burn-autodiff/src/tests/gelu.rs b/burn-autodiff/src/tests/gelu.rs
index fec6eb3aa..fecd07995 100644
--- a/burn-autodiff/src/tests/gelu.rs
+++ b/burn-autodiff/src/tests/gelu.rs
@@ -5,8 +5,10 @@ mod tests {
 
     #[test]
     fn should_diff_gelu() {
-        let tensor_1 = TestAutodiffTensor::from_floats([[0.0, 1.0], [-3.0, 4.0]]).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_floats([[6.0, -0.5], [9.0, 10.0]]).require_grad();
+        let tensor_1 =
+            TestAutodiffTensor::from_floats_devauto([[0.0, 1.0], [-3.0, 4.0]]).require_grad();
+        let tensor_2 =
+            TestAutodiffTensor::from_floats_devauto([[6.0, -0.5], [9.0, 10.0]]).require_grad();
 
         let x = tensor_1.clone().matmul(activation::gelu(tensor_2.clone()));
         let x = tensor_1.clone().matmul(x);
diff --git a/burn-autodiff/src/tests/gradients.rs b/burn-autodiff/src/tests/gradients.rs
index a1f6eda3c..69096a3f9 100644
--- a/burn-autodiff/src/tests/gradients.rs
+++ b/burn-autodiff/src/tests/gradients.rs
@@ -5,8 +5,9 @@ mod tests {
 
     #[test]
     fn should_update_tensor_when_grad_replace() {
-        let tensor_1 = TestAutodiffTensor::random([32, 32], Distribution::Default).require_grad();
-        let tensor_2 = TestAutodiffTensor::random([32, 32], Distribution::Default);
+        let tensor_1 =
+            TestAutodiffTensor::random_devauto([32, 32], Distribution::Default).require_grad();
+        let tensor_2 = TestAutodiffTensor::random_devauto([32, 32], Distribution::Default);
 
         let x = tensor_1.clone().matmul(activation::gelu(tensor_2));
         let mut grads = x.backward();
@@ -14,7 +15,7 @@ mod tests {
         let grad_1 = tensor_1.grad(&grads).unwrap();
 
         let grad_1_updated =
-            TestAutodiffTensor::random([32, 32], Distribution::Default).require_grad();
+            TestAutodiffTensor::random_devauto([32, 32], Distribution::Default).require_grad();
         tensor_1.grad_replace(&mut grads, grad_1_updated.clone().inner());
 
         let grad_1_new = tensor_1.grad(&grads).unwrap();
diff --git a/burn-autodiff/src/tests/log.rs b/burn-autodiff/src/tests/log.rs
index 9c7766da9..7b21bb14d 100644
--- a/burn-autodiff/src/tests/log.rs
+++ b/burn-autodiff/src/tests/log.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().log());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/log1p.rs b/burn-autodiff/src/tests/log1p.rs
index d94f5aa17..0bd1a89b8 100644
--- a/burn-autodiff/src/tests/log1p.rs
+++ b/burn-autodiff/src/tests/log1p.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().log1p());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/mask.rs b/burn-autodiff/src/tests/mask.rs
index d400149cf..7f4f57b20 100644
--- a/burn-autodiff/src/tests/mask.rs
+++ b/burn-autodiff/src/tests/mask.rs
@@ -9,9 +9,9 @@ mod tests {
         let data_2 = Data::<f32, 2>::from([[4.0, 7.0], [2.0, 3.0]]);
         let mask = Data::<bool, 2>::from([[true, false], [false, true]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let mask = Tensor::<TestAutodiffBackend, 2, Bool>::from_bool(mask);
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let mask = Tensor::<TestAutodiffBackend, 2, Bool>::from_bool_devauto(mask);
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.mask_fill(mask, 2.0);
@@ -26,11 +26,16 @@ mod tests {
 
     #[test]
     fn should_diff_mask_where() {
-        let tensor_1 = TestAutodiffTensor::from_data([[1.0, 7.0], [2.0, 3.0]]).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data([[4.0, 7.0], [2.0, 3.0]]).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data([[8.8, 9.8], [10.8, 11.8]]).require_grad();
-        let mask =
-            Tensor::<TestAutodiffBackend, 2, Bool>::from_data([[true, false], [false, true]]);
+        let tensor_1 =
+            TestAutodiffTensor::from_data_devauto([[1.0, 7.0], [2.0, 3.0]]).require_grad();
+        let tensor_2 =
+            TestAutodiffTensor::from_data_devauto([[4.0, 7.0], [2.0, 3.0]]).require_grad();
+        let tensor_3 =
+            TestAutodiffTensor::from_data_devauto([[8.8, 9.8], [10.8, 11.8]]).require_grad();
+        let mask = Tensor::<TestAutodiffBackend, 2, Bool>::from_data_devauto([
+            [true, false],
+            [false, true],
+        ]);
 
         let tensor_4 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_5 = tensor_4.clone().matmul(tensor_3.clone());
diff --git a/burn-autodiff/src/tests/matmul.rs b/burn-autodiff/src/tests/matmul.rs
index 7f5de915e..f4b4e53b9 100644
--- a/burn-autodiff/src/tests/matmul.rs
+++ b/burn-autodiff/src/tests/matmul.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1: Data<f32, 2> = Data::from([[1.0, 7.0], [2.0, 3.0]]);
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let grads = tensor_3.backward();
@@ -31,9 +31,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[2.0, 2.0], [2.0, 2.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_5 = tensor_4.matmul(tensor_3);
@@ -53,9 +53,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[2.0, 2.0], [2.0, 2.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_5 = tensor_4.matmul(tensor_3.clone());
diff --git a/burn-autodiff/src/tests/maxmin.rs b/burn-autodiff/src/tests/maxmin.rs
index 3edab63f6..5c833dad7 100644
--- a/burn-autodiff/src/tests/maxmin.rs
+++ b/burn-autodiff/src/tests/maxmin.rs
@@ -5,8 +5,10 @@ mod tests {
 
     #[test]
     fn should_diff_max_dim() {
-        let tensor_1 = TestAutodiffTensor::from_floats([[1.0, 7.0], [-2.0, -3.0]]).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_floats([[4.0, -7.0], [2.0, 3.0]]).require_grad();
+        let tensor_1 =
+            TestAutodiffTensor::from_floats_devauto([[1.0, 7.0], [-2.0, -3.0]]).require_grad();
+        let tensor_2 =
+            TestAutodiffTensor::from_floats_devauto([[4.0, -7.0], [2.0, 3.0]]).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_1.clone().mul(tensor_3.max_dim(1).unsqueeze());
@@ -25,8 +27,10 @@ mod tests {
 
     #[test]
     fn should_diff_min_dim() {
-        let tensor_1 = TestAutodiffTensor::from_floats([[1.0, 7.0], [-2.0, -3.0]]).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_floats([[4.0, -7.0], [2.0, 3.0]]).require_grad();
+        let tensor_1 =
+            TestAutodiffTensor::from_floats_devauto([[1.0, 7.0], [-2.0, -3.0]]).require_grad();
+        let tensor_2 =
+            TestAutodiffTensor::from_floats_devauto([[4.0, -7.0], [2.0, 3.0]]).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_1.clone().mul(tensor_3.min_dim(1).unsqueeze());
diff --git a/burn-autodiff/src/tests/maxpool1d.rs b/burn-autodiff/src/tests/maxpool1d.rs
index 2ccceafd2..cac732a35 100644
--- a/burn-autodiff/src/tests/maxpool1d.rs
+++ b/burn-autodiff/src/tests/maxpool1d.rs
@@ -10,10 +10,11 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x =
-            TestAutodiffTensor::from_floats([[[0.9861, 0.5474, 0.4477, 0.0732, 0.3548, 0.8221]]])
-                .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[1., 1., 0., 0., 0., 1.]]]);
+        let x = TestAutodiffTensor::from_floats_devauto([[[
+            0.9861, 0.5474, 0.4477, 0.0732, 0.3548, 0.8221,
+        ]]])
+        .require_grad();
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[1., 1., 0., 0., 0., 1.]]]);
 
         let output = max_pool1d(x.clone(), kernel_size, stride, padding, dilation);
         let grads = output.backward();
@@ -32,13 +33,13 @@ mod tests {
         let stride = 1;
         let dilation = 2;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             0.5388, 0.0676, 0.7122, 0.8316, 0.0653, 0.9154, 0.1536, 0.9089, 0.8016, 0.7518, 0.2073,
             0.0501, 0.8811, 0.5604, 0.5075, 0.4384, 0.9963, 0.9698, 0.4988, 0.2609, 0.3391, 0.2230,
             0.4610, 0.5365, 0.6880,
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             0., 0., 1., 0., 0., 3., 0., 1., 2., 1., 0., 0., 2., 0., 0., 0., 4., 4., 0., 0., 0., 0.,
             0., 0., 1.,
         ]]]);
@@ -60,13 +61,13 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             0.5388, 0.0676, 0.7122, 0.8316, 0.0653, 0.9154, 0.1536, 0.9089, 0.8016, 0.7518, 0.2073,
             0.0501, 0.8811, 0.5604, 0.5075, 0.4384, 0.9963, 0.9698, 0.4988, 0.2609, 0.3391, 0.2230,
             0.4610, 0.5365, 0.6880,
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             0., 0., 0., 2., 0., 4., 0., 2., 1., 0., 0., 0., 4., 0., 0., 0., 4., 1., 1., 0., 0., 0.,
             1., 1., 1.,
         ]]]);
@@ -88,13 +89,13 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             0.5388, 0.0676, 0.7122, 0.8316, 0.0653, 0.9154, 0.1536, 0.9089, 0.8016, 0.7518, 0.2073,
             0.0501, 0.8811, 0.5604, 0.5075, 0.4384, 0.9963, 0.9698, 0.4988, 0.2609, 0.3391, 0.2230,
             0.4610, 0.5365, 0.6880,
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             1., 0., 1., 2., 0., 4., 0., 2., 1., 0., 0., 0., 4., 0., 0., 0., 4., 1., 1., 0., 0., 0.,
             1., 1., 3.,
         ]]]);
diff --git a/burn-autodiff/src/tests/maxpool2d.rs b/burn-autodiff/src/tests/maxpool2d.rs
index 49d66212a..e8dff3751 100644
--- a/burn-autodiff/src/tests/maxpool2d.rs
+++ b/burn-autodiff/src/tests/maxpool2d.rs
@@ -14,14 +14,14 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             [0.2479, 0.6386, 0.3166, 0.5742],
             [0.7065, 0.1940, 0.6305, 0.8959],
             [0.5416, 0.8602, 0.8129, 0.1662],
             [0.3358, 0.3059, 0.8293, 0.0990],
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             [0.0, 0.0, 0.0, 0.0],
             [0.0, 0.0, 0.0, 2.0],
             [0.0, 2.0, 0.0, 0.0],
@@ -55,14 +55,14 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             [0.2479, 0.6386, 0.3166, 0.5742],
             [0.7065, 0.1940, 0.6305, 0.8959],
             [0.5416, 0.8602, 0.8129, 0.1662],
             [0.3358, 0.3059, 0.8293, 0.0990],
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             [1., 3., 0., 2.],
             [3., 0., 0., 4.],
             [1., 4., 0., 1.],
@@ -96,14 +96,14 @@ mod tests {
         let dilation_1 = 2;
         let dilation_2 = 2;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             [0.2479, 0.6386, 0.3166, 0.5742],
             [0.7065, 0.1940, 0.6305, 0.8959],
             [0.5416, 0.8602, 0.8129, 0.1662],
             [0.3358, 0.3059, 0.8293, 0.0990],
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             [0., 0., 0., 0.],
             [1., 1., 1., 2.],
             [0., 4., 4., 0.],
@@ -137,7 +137,7 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestAutodiffTensor::from_floats([[[
+        let x = TestAutodiffTensor::from_floats_devauto([[[
             [0.5388, 0.0676, 0.7122, 0.8316, 0.0653],
             [0.9154, 0.1536, 0.9089, 0.8016, 0.7518],
             [0.2073, 0.0501, 0.8811, 0.5604, 0.5075],
@@ -145,7 +145,7 @@ mod tests {
             [0.3391, 0.2230, 0.4610, 0.5365, 0.6880],
         ]]])
         .require_grad();
-        let x_grad_expected = TestAutodiffTensor::from_floats([[[
+        let x_grad_expected = TestAutodiffTensor::from_floats_devauto([[[
             [0., 0., 0., 3., 0.],
             [4., 0., 2., 1., 0.],
             [0., 0., 0., 0., 0.],
diff --git a/burn-autodiff/src/tests/mul.rs b/burn-autodiff/src/tests/mul.rs
index 85eec4049..ac49697bf 100644
--- a/burn-autodiff/src/tests/mul.rs
+++ b/burn-autodiff/src/tests/mul.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::from([1.0, 7.0]);
         let data_2 = Data::from([4.0, 7.0]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1.clone()).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2.clone()).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1.clone()).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2.clone()).require_grad();
 
         let tensor_3 = tensor_1.clone().mul(tensor_2.clone());
         let grads = tensor_3.backward();
@@ -26,7 +26,7 @@ mod tests {
     fn should_diff_mul_scalar() {
         let data = Data::from([2.0, 5.0]);
 
-        let tensor = TestAutodiffTensor::from_data(data).require_grad();
+        let tensor = TestAutodiffTensor::from_data_devauto(data).require_grad();
         let tensor_out = tensor.clone().mul_scalar(4.0);
 
         let grads = tensor_out.backward();
@@ -42,9 +42,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[2.0, 2.0], [2.0, 2.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().mul(tensor_2.clone());
         let tensor_5 = tensor_4.mul(tensor_3);
diff --git a/burn-autodiff/src/tests/multithread.rs b/burn-autodiff/src/tests/multithread.rs
index 041572da6..f72557ad6 100644
--- a/burn-autodiff/src/tests/multithread.rs
+++ b/burn-autodiff/src/tests/multithread.rs
@@ -9,8 +9,8 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
 
         let with_move = || {
-            let tensor_1 = TestAutodiffTensor::from_data(data_1.clone()).require_grad();
-            let tensor_2 = TestAutodiffTensor::from_data(data_2.clone()).require_grad();
+            let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1.clone()).require_grad();
+            let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2.clone()).require_grad();
 
             let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
             let tensor_4 = tensor_3.clone().matmul(tensor_2.clone());
@@ -51,8 +51,8 @@ mod tests {
             (grad_1, grad_2)
         };
         let without_move = || {
-            let tensor_1 = TestAutodiffTensor::from_data(data_1.clone()).require_grad();
-            let tensor_2 = TestAutodiffTensor::from_data(data_2.clone()).require_grad();
+            let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1.clone()).require_grad();
+            let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2.clone()).require_grad();
 
             let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
             let tensor_4 = tensor_3.clone().matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/neg.rs b/burn-autodiff/src/tests/neg.rs
index 83657ea1f..929976a38 100644
--- a/burn-autodiff/src/tests/neg.rs
+++ b/burn-autodiff/src/tests/neg.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [2.0, 3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, 7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().neg());
         let tensor_4 = tensor_3.neg();
diff --git a/burn-autodiff/src/tests/pow.rs b/burn-autodiff/src/tests/pow.rs
index 7321951dd..4a84d7ff4 100644
--- a/burn-autodiff/src/tests/pow.rs
+++ b/burn-autodiff/src/tests/pow.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().powf(0.4));
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/recip.rs b/burn-autodiff/src/tests/recip.rs
index c77579e27..70d6b6b03 100644
--- a/burn-autodiff/src/tests/recip.rs
+++ b/burn-autodiff/src/tests/recip.rs
@@ -7,7 +7,7 @@ mod tests {
     fn should_diff_recip() {
         let data = Data::from([2.0, 5.0, 0.4]);
 
-        let tensor = TestAutodiffTensor::from_data(data).require_grad();
+        let tensor = TestAutodiffTensor::from_data_devauto(data).require_grad();
         let tensor_out = tensor.clone().recip();
 
         let grads = tensor_out.backward();
diff --git a/burn-autodiff/src/tests/relu.rs b/burn-autodiff/src/tests/relu.rs
index 57cfd51ba..5d24e5d03 100644
--- a/burn-autodiff/src/tests/relu.rs
+++ b/burn-autodiff/src/tests/relu.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [-2.0, -3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, -7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = activation::relu(tensor_3);
diff --git a/burn-autodiff/src/tests/reshape.rs b/burn-autodiff/src/tests/reshape.rs
index 057241aba..85ceca7a9 100644
--- a/burn-autodiff/src/tests/reshape.rs
+++ b/burn-autodiff/src/tests/reshape.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1: Data<f32, 2> = Data::from([[1.0, 7.0], [2.0, 3.0]]);
         let data_2: Data<f32, 1> = Data::from([4.0, 7.0, 2.0, 3.0]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_2.clone().reshape([2, 2]);
         let tensor_4 = tensor_1.clone().matmul(tensor_3);
diff --git a/burn-autodiff/src/tests/select.rs b/burn-autodiff/src/tests/select.rs
index 21c49f524..174c24ece 100644
--- a/burn-autodiff/src/tests/select.rs
+++ b/burn-autodiff/src/tests/select.rs
@@ -6,9 +6,9 @@ mod tests {
     #[test]
     fn test_select_grad() {
         let tensor_1 =
-            TestAutodiffTensor::from_data(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
+            TestAutodiffTensor::from_data_devauto(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
                 .require_grad();
-        let indices = Tensor::<TestAutodiffBackend, 1, Int>::from_data(Data::from([1, 0]));
+        let indices = Tensor::<TestAutodiffBackend, 1, Int>::from_data_devauto(Data::from([1, 0]));
 
         let tensor_2 = tensor_1.clone().matmul(tensor_1.clone().transpose());
         let tensor_3 = tensor_1.clone().select(0, indices);
@@ -27,11 +27,12 @@ mod tests {
     #[test]
     fn test_select_assign_grad() {
         let tensor_1 =
-            TestAutodiffTensor::from_data(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
+            TestAutodiffTensor::from_data_devauto(Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]))
                 .require_grad();
-        let values = TestAutodiffTensor::from_data(Data::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]))
-            .require_grad();
-        let indices = Tensor::<TestAutodiffBackend, 1, Int>::from_data(Data::from([1, 0]));
+        let values =
+            TestAutodiffTensor::from_data_devauto(Data::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]))
+                .require_grad();
+        let indices = Tensor::<TestAutodiffBackend, 1, Int>::from_data_devauto(Data::from([1, 0]));
 
         let tensor_2 = tensor_1.clone().matmul(tensor_1.clone().transpose());
         let tensor_3 = tensor_1.clone().select_assign(0, indices, values.clone());
diff --git a/burn-autodiff/src/tests/sin.rs b/burn-autodiff/src/tests/sin.rs
index 8462893d9..310b62d1d 100644
--- a/burn-autodiff/src/tests/sin.rs
+++ b/burn-autodiff/src/tests/sin.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().sin());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/slice.rs b/burn-autodiff/src/tests/slice.rs
index 6b8b46d70..88138bc8f 100644
--- a/burn-autodiff/src/tests/slice.rs
+++ b/burn-autodiff/src/tests/slice.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1: Data<f32, 2> = Data::from([[1.0, 7.0], [2.0, 3.0]]);
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0, 100.0], [2.0, 3.0, 15.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_2.clone().slice([0..2, 0..2]);
         let tensor_4 = tensor_1.clone().matmul(tensor_3);
@@ -31,9 +31,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_assigned: Data<f32, 2> = Data::from([[9.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_assigned = TestAutodiffTensor::from_data(data_assigned).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_assigned = TestAutodiffTensor::from_data_devauto(data_assigned).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = tensor_3.slice_assign([0..1, 0..1], tensor_assigned);
@@ -54,9 +54,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[9.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_5 = tensor_2.clone().slice([0..1, 0..1]);
diff --git a/burn-autodiff/src/tests/softmax.rs b/burn-autodiff/src/tests/softmax.rs
index d282a4be4..8e600eb6d 100644
--- a/burn-autodiff/src/tests/softmax.rs
+++ b/burn-autodiff/src/tests/softmax.rs
@@ -7,8 +7,8 @@ mod tests {
     fn test_softmax_grad() {
         let data_1 = Data::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::from([[6.0, 7.0], [9.0, 10.0]]);
-        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data(data_1).require_grad();
-        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data(data_2).require_grad();
+        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_1).require_grad();
+        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = activation::softmax(tensor_3, 1).matmul(tensor_2.clone());
@@ -29,8 +29,8 @@ mod tests {
     fn test_log_softmax_grad() {
         let data_1 = Data::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::from([[6.0, 7.0], [9.0, 10.0]]);
-        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data(data_1).require_grad();
-        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data(data_2).require_grad();
+        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_1).require_grad();
+        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = activation::log_softmax(tensor_3, 1).matmul(tensor_2.clone());
@@ -52,8 +52,8 @@ mod tests {
         let data_1 = Data::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data(data_1).require_grad();
-        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data(data_2).require_grad();
+        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_1).require_grad();
+        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone());
         let tensor_4 = activation::softmax(tensor_3, 1).matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/sqrt.rs b/burn-autodiff/src/tests/sqrt.rs
index c9d075fed..b2812b331 100644
--- a/burn-autodiff/src/tests/sqrt.rs
+++ b/burn-autodiff/src/tests/sqrt.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().sqrt());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/sub.rs b/burn-autodiff/src/tests/sub.rs
index 50beae42f..3b30d34c6 100644
--- a/burn-autodiff/src/tests/sub.rs
+++ b/burn-autodiff/src/tests/sub.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::from([2.0, 5.0]);
         let data_2 = Data::from([4.0, 1.0]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().sub(tensor_2.clone());
         let grads = tensor_3.backward();
@@ -25,7 +25,7 @@ mod tests {
     #[test]
     fn should_diff_sub_scalar() {
         let data = Data::from([2.0, 10.0]);
-        let tensor = TestAutodiffTensor::from_data(data).require_grad();
+        let tensor = TestAutodiffTensor::from_data_devauto(data).require_grad();
         let tensor_out = tensor.clone().sub_scalar(5.0);
         let grads = tensor_out.backward();
 
@@ -41,9 +41,9 @@ mod tests {
         let data_2: Data<f32, 2> = Data::from([[4.0, 7.0], [2.0, 3.0]]);
         let data_3: Data<f32, 2> = Data::from([[2.0, 2.0], [2.0, 2.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
-        let tensor_3 = TestAutodiffTensor::from_data(data_3).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
+        let tensor_3 = TestAutodiffTensor::from_data_devauto(data_3).require_grad();
 
         let tensor_4 = tensor_1.clone().sub(tensor_2.clone());
         let tensor_5 = tensor_4.sub(tensor_3).sub_scalar(5.0);
diff --git a/burn-autodiff/src/tests/tanh.rs b/burn-autodiff/src/tests/tanh.rs
index db1b884ba..cb60055ab 100644
--- a/burn-autodiff/src/tests/tanh.rs
+++ b/burn-autodiff/src/tests/tanh.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0], [3.0, 4.0]]);
         let data_2 = Data::<f32, 2>::from([[6.0, 7.0], [9.0, 10.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().tanh());
         let tensor_4 = tensor_3.matmul(tensor_2.clone());
diff --git a/burn-autodiff/src/tests/transpose.rs b/burn-autodiff/src/tests/transpose.rs
index bead7b467..6b674b7f9 100644
--- a/burn-autodiff/src/tests/transpose.rs
+++ b/burn-autodiff/src/tests/transpose.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::<f32, 2>::from([[1.0, 7.0], [2.0, 3.0]]);
         let data_2 = Data::<f32, 2>::from([[4.0, 7.0], [2.0, 3.0]]);
 
-        let tensor_1 = TestAutodiffTensor::from_data(data_1).require_grad();
-        let tensor_2 = TestAutodiffTensor::from_data(data_2).require_grad();
+        let tensor_1 = TestAutodiffTensor::from_data_devauto(data_1).require_grad();
+        let tensor_2 = TestAutodiffTensor::from_data_devauto(data_2).require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().transpose());
         let tensor_4 = tensor_3.transpose();
@@ -24,12 +24,16 @@ mod tests {
 
     #[test]
     fn should_diff_swap_dims() {
-        let tensor_1 =
-            TestAutodiffTensor::from_floats([[[0.0, 1.0], [3.0, 4.0]], [[6.0, 7.0], [9.0, 10.0]]])
-                .require_grad();
-        let tensor_2 =
-            TestAutodiffTensor::from_floats([[[1.0, 4.0], [2.0, 5.0]], [[7.0, 10.0], [8.0, 11.0]]])
-                .require_grad();
+        let tensor_1 = TestAutodiffTensor::from_floats_devauto([
+            [[0.0, 1.0], [3.0, 4.0]],
+            [[6.0, 7.0], [9.0, 10.0]],
+        ])
+        .require_grad();
+        let tensor_2 = TestAutodiffTensor::from_floats_devauto([
+            [[1.0, 4.0], [2.0, 5.0]],
+            [[7.0, 10.0], [8.0, 11.0]],
+        ])
+        .require_grad();
 
         let tensor_3 = tensor_1.clone().matmul(tensor_2.clone().swap_dims(0, 2));
         let tensor_4 = tensor_3.matmul(tensor_2.clone().swap_dims(1, 2));
diff --git a/burn-book/src/basic-workflow/data.md b/burn-book/src/basic-workflow/data.md
index 637ba6fc4..31fabe60a 100644
--- a/burn-book/src/basic-workflow/data.md
+++ b/burn-book/src/basic-workflow/data.md
@@ -47,7 +47,7 @@ impl<B: Backend> Batcher<MNISTItem, MNISTBatch<B>> for MNISTBatcher<B> {
         let images = items
             .iter()
             .map(|item| Data::<f32, 2>::from(item.image))
-            .map(|data| Tensor::<B, 2>::from_data(data.convert()))
+            .map(|data| Tensor::<B, 2>::from_data_devauto(data.convert()))
             .map(|tensor| tensor.reshape([1, 28, 28]))
             // Normalize: make between [0,1] and make the mean=0 and std=1
             // values mean=0.1307,std=0.3081 are from the PyTorch MNIST example
@@ -57,7 +57,7 @@ impl<B: Backend> Batcher<MNISTItem, MNISTBatch<B>> for MNISTBatcher<B> {
 
         let targets = items
             .iter()
-            .map(|item| Tensor::<B, 1, Int>::from_data(Data::from([(item.label as i64).elem()])))
+            .map(|item| Tensor::<B, 1, Int>::from_data_devauto(Data::from([(item.label as i64).elem()])))
             .collect();
 
         let images = Tensor::cat(images, 0).to_device(&self.device);
diff --git a/burn-book/src/basic-workflow/model.md b/burn-book/src/basic-workflow/model.md
index 720ddc282..ed4285d99 100644
--- a/burn-book/src/basic-workflow/model.md
+++ b/burn-book/src/basic-workflow/model.md
@@ -77,14 +77,14 @@ pub struct ModelConfig {
 
 impl ModelConfig {
     /// Returns the initialized model.
-    pub fn init<B: Backend>(&self) -> Model<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Model<B> {
         Model {
-            conv1: Conv2dConfig::new([1, 8], [3, 3]).init(),
-            conv2: Conv2dConfig::new([8, 16], [3, 3]).init(),
+            conv1: Conv2dConfig::new([1, 8], [3, 3]).init(device),
+            conv2: Conv2dConfig::new([8, 16], [3, 3]).init(device),
             pool: AdaptiveAvgPool2dConfig::new([8, 8]).init(),
             activation: ReLU::new(),
-            linear1: LinearConfig::new(16 * 8 * 8, self.hidden_size).init(),
-            linear2: LinearConfig::new(self.hidden_size, self.num_classes).init(),
+            linear1: LinearConfig::new(16 * 8 * 8, self.hidden_size).init(device),
+            linear2: LinearConfig::new(self.hidden_size, self.num_classes).init(device),
             dropout: DropoutConfig::new(self.dropout).init(),
         }
     }
diff --git a/burn-book/src/building-blocks/config.md b/burn-book/src/building-blocks/config.md
index 6c07b1e1f..5f9f327b2 100644
--- a/burn-book/src/building-blocks/config.md
+++ b/burn-book/src/building-blocks/config.md
@@ -47,9 +47,9 @@ config. Therefore, initialization methods should be implemented on the config st
 ```rust, ignore
 impl MyModuleConfig {
     /// Create a module with random weights.
-    pub fn init(&self) -> MyModule {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> MyModule {
         MyModule {
-            linear: LinearConfig::new(self.d_model, self.d_ff).init(),
+            linear: LinearConfig::new(self.d_model, self.d_ff).init(device),
             dropout: DropoutConfig::new(self.dropout).init(),
         }
     }
@@ -70,5 +70,7 @@ impl MyModuleConfig {
 Then we could add this line to the above `main`:
 
 ```rust, ignore
-let my_module = config.init();
+use burn::backend::Wgpu;
+let device = Default::default();
+let my_module = config.init::<Wgpu>(&device);
 ```
diff --git a/burn-book/src/building-blocks/tensor.md b/burn-book/src/building-blocks/tensor.md
index ab8920e7b..3874c0ea1 100644
--- a/burn-book/src/building-blocks/tensor.md
+++ b/burn-book/src/building-blocks/tensor.md
@@ -38,8 +38,8 @@ Those operations are available for all tensor kinds: `Int`, `Float`, and `Bool`.
 
 | Burn                                     | PyTorch Equivalent                   |
 | ---------------------------------------- | ------------------------------------ |
-| `Tensor::empty(shape)`                   | `torch.empty(shape)`                 |
-| `Tensor::empty_device(shape, device)`    | `torch.empty(shape, device=device)`  |
+| `Tensor::empty_devauto(shape)`           | `torch.empty(shape)`                 |
+| `Tensor::empty(shape, device)`           | `torch.empty(shape, device=device)`  |
 | `tensor.dims()`                          | `tensor.size()`                      |
 | `tensor.shape()`                         | `tensor.shape`                       |
 | `tensor.reshape(shape)`                  | `tensor.view(shape)`                 |
@@ -58,8 +58,8 @@ Those operations are available for all tensor kinds: `Int`, `Float`, and `Bool`.
 | `Tensor::cat(tensors, dim)`              | `torch.cat(tensors, dim)`            |
 | `tensor.into_data()`                     | N/A                                  |
 | `tensor.to_data()`                       | N/A                                  |
-| `Tensor::from_data(data)`                | N/A                                  |
-| `Tensor::from_data_device(data, device)` | N/A                                  |
+| `Tensor::from_data_devauto(data)`        | N/A                                  |
+| `Tensor::from_data(data, device)`        | N/A                                  |
 | `tensor.into_primitive()`                | N/A                                  |
 | `Tensor::from_primitive(primitive)`      | N/A                                  |
 | `Tensor::stack(tensors, dim)`            | torch.stack(tensors, dim)`           |
@@ -81,11 +81,11 @@ Those operations are available for numeric tensor kinds: `Float` and `Int`.
 | `tensor * scalar` or `tensor.mul_scalar(scalar)` | `tensor * scalar`                              |
 | `-tensor` or `tensor.neg()`                      | `-tensor`                                      |
 | `Tensor::zeros(shape)`                           | `torch.zeros(shape)`                           |
-| `Tensor::zeros_device(shape, device)`            | `torch.zeros(shape, device=device)`            |
-| `Tensor::ones(shape)`                            | `torch.ones(shape)`                            |
-| `Tensor::ones_device(shape, device)`             | `torch.ones(shape, device=device)`             |
-| `Tensor::full(shape, fill_value)`                | `torch.full(shape, fill_value)`                |
-| `Tensor::full_device(shape, fill_value, device)` | `torch.full(shape, fill_value, device=device)` |
+| `Tensor::zeros(shape, device)`                   | `torch.zeros(shape, device=device)`            |
+| `Tensor::ones_devauto(shape)`                    | `torch.ones(shape)`                            |
+| `Tensor::ones(shape, device)`                    | `torch.ones(shape, device=device)`             |
+| `Tensor::full_devauto(shape, fill_value)`        | `torch.full(shape, fill_value)`                |
+| `Tensor::full(shape, fill_value, device)`        | `torch.full(shape, fill_value, device=device)` |
 | `tensor.mean()`                                  | `tensor.mean()`                                |
 | `tensor.sum()`                                   | `tensor.sum()`                                 |
 | `tensor.mean_dim(dim)`                           | `tensor.mean(dim)`                             |
@@ -136,7 +136,8 @@ Those operations are only available for `Float` tensors.
 | `tensor.cos()`                                      | `tensor.cos()`                     |
 | `tensor.sin()`                                      | `tensor.sin()`                     |
 | `tensor.tanh()`                                     | `tensor.tanh()`                    |
-| `tensor.from_floats(floats)`                        | N/A                                |
+| `tensor.from_floats_devauto(floats)`                | N/A                                |
+| `tensor.from_floats(floats, device)`                | N/A                                |
 | `tensor.int()`                                      | Similar to `tensor.to(torch.long)` |
 | `tensor.zeros_like()`                               | `torch.zeros_like(tensor)`         |
 | `tensor.ones_like()`                                | `torch.ones_like(tensor)`          |
@@ -149,8 +150,8 @@ Those operations are only available for `Float` tensors.
 | `tensor.var_bias(dim)`                              | N/A                                |
 | `tensor.var_mean(dim)`                              | N/A                                |
 | `tensor.var_mean_bias(dim)`                         | N/A                                |
-| `tensor.random(shape, distribution)`                | N/A                                |
-| `tensor.random_device(shape, distribution, device)` | N/A                                |
+| `tensor.random_devauto(shape, distribution)`        | N/A                                |
+| `tensor.random(shape, distribution, device)`        | N/A                                |
 | `tensor.to_full_precision()`                        | `tensor.to(torch.float)`           |
 | `tensor.from_full_precision(tensor)`                | N/A                                |
 
@@ -162,10 +163,10 @@ Those operations are only available for `Int` tensors.
 | --------------------------------------------- | ------------------------------------------------------- |
 | `tensor.from_ints(ints)`                      | N/A                                                     |
 | `tensor.float()`                              | Similar to `tensor.to(torch.float)`                     |
-| `tensor.arange(5..10)`                        | `tensor.arange(start=5, end=10)`                        |
-| `tensor.arange_device(5..10, device)`         | `tensor.arange(start=5, end=10, device=device)`         |
-| `tensor.arange_step(5..10, 2)`                | `tensor.arange(start=5, end=10, step=2)`                |
-| `tensor.arange_step_device(5..10, 2, device)` | `tensor.arange(start=5, end=10, step=2, device=device)` |
+| `tensor.arange_devauto(5..10)`                | `tensor.arange(start=5, end=10)`                        |
+| `tensor.arange(5..10, device)       `         | `tensor.arange(start=5, end=10, device=device)`         |
+| `tensor.arange_step_devauto(5..10, 2)`        | `tensor.arange(start=5, end=10, step=2)`                |
+| `tensor.arange_step(5..10, 2, device)`        | `tensor.arange(start=5, end=10, step=2, device=device)` |
 
 # Bool Operations
 
diff --git a/burn-book/src/custom-training-loop.md b/burn-book/src/custom-training-loop.md
index eeb3ec145..95682987e 100644
--- a/burn-book/src/custom-training-loop.md
+++ b/burn-book/src/custom-training-loop.md
@@ -27,7 +27,7 @@ pub struct MnistTrainingConfig {
     pub optimizer: AdamConfig,
 }
 
-pub fn run<B: AutodiffBackend>(device: B::Device) {
+pub fn run<B: AutodiffBackend>(device: &B::Device) {
     // Create the configuration.
     let config_model = ModelConfig::new(10, 1024);
     let config_optimizer = AdamConfig::new();
@@ -36,7 +36,7 @@ pub fn run<B: AutodiffBackend>(device: B::Device) {
     B::seed(config.seed);
 
     // Create the model and optimizer.
-    let mut model = config.model.init();
+    let mut model = config.model.init(device);
     let mut optim = config.optimizer.init();
 
     // Create the batcher.
diff --git a/burn-book/src/getting-started.md b/burn-book/src/getting-started.md
index b1ce3cb70..36928b4f7 100644
--- a/burn-book/src/getting-started.md
+++ b/burn-book/src/getting-started.md
@@ -54,7 +54,7 @@ type Backend = Wgpu;
 
 fn main() {
     // Creation of two tensors, the first with explicit values and the second one with ones, with the same shape as the first
-    let tensor_1 = Tensor::<Backend, 2>::from_data([[2., 3.], [4., 5.]]);
+    let tensor_1 = Tensor::<Backend, 2>::from_data_devauto([[2., 3.], [4., 5.]]);
     let tensor_2 = Tensor::<Backend, 2>::ones_like(&tensor_1);
 
     // Print the element-wise addition (done with the WGPU backend) of the two tensors.
diff --git a/burn-book/src/import/onnx-model.md b/burn-book/src/import/onnx-model.md
index 51ac9098f..23fa10a17 100644
--- a/burn-book/src/import/onnx-model.md
+++ b/burn-book/src/import/onnx-model.md
@@ -102,15 +102,16 @@ Here's how to use the imported model in your application:
 mod model;
 
 use burn::tensor;
-use burn_ndarray::NdArray;
+use burn_ndarray::{NdArray, NdArrayDevice};
 use model::mnist::Model;
 
 fn main() {
     // Initialize a new model instance
-    let model: Model<NdArray<f32>> = Model::new();
+    let device = NdArrayDevice::default();
+    let model: Model<NdArray<f32>> = Model::new(&device);
 
     // Create a sample input tensor (zeros for demonstration)
-    let input = tensor::Tensor::<NdArray<f32>, 4>::zeros([1, 1, 28, 28]);
+    let input = tensor::Tensor::<NdArray<f32>, 4>::zeros([1, 1, 28, 28], &device);
 
     // Perform inference
     let output = model.forward(input);
diff --git a/burn-candle/src/ops/tensor.rs b/burn-candle/src/ops/tensor.rs
index a225e604d..c1c71fd03 100644
--- a/burn-candle/src/ops/tensor.rs
+++ b/burn-candle/src/ops/tensor.rs
@@ -137,8 +137,17 @@ impl<F: FloatCandleElement, I: IntCandleElement> TensorOps<Self> for Candle<F, I
         lhs: FloatTensor<Self, D>,
         rhs: FloatTensor<Self, D>,
     ) -> FloatTensor<Self, D> {
-        let rhs_contiguous = rhs.tensor.contiguous().unwrap();
-        CandleTensor::new(lhs.tensor.broadcast_matmul(&rhs_contiguous).unwrap())
+        let lhs_contiguous = if !lhs.tensor.is_contiguous() {
+            lhs.tensor.contiguous().unwrap()
+        } else {
+            lhs.tensor
+        };
+        let rhs_contiguous = if !rhs.tensor.is_contiguous() {
+            rhs.tensor.contiguous().unwrap()
+        } else {
+            rhs.tensor
+        };
+        CandleTensor::new(lhs_contiguous.broadcast_matmul(&rhs_contiguous).unwrap())
     }
 
     fn swap_dims<const D: usize>(
diff --git a/burn-core/src/grad_clipping/base.rs b/burn-core/src/grad_clipping/base.rs
index 91a6be069..02933dee3 100644
--- a/burn-core/src/grad_clipping/base.rs
+++ b/burn-core/src/grad_clipping/base.rs
@@ -113,7 +113,7 @@ mod tests {
 
     #[test]
     fn test_clip_by_value() {
-        let gradient: Tensor<TestBackend, 2> = Tensor::from_floats([
+        let gradient: Tensor<TestBackend, 2> = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ]);
@@ -128,7 +128,7 @@ mod tests {
 
     #[test]
     fn test_clip_by_norm() {
-        let gradient: Tensor<TestBackend, 2> = Tensor::from_floats([
+        let gradient: Tensor<TestBackend, 2> = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ]);
diff --git a/burn-core/src/module/param/constant.rs b/burn-core/src/module/param/constant.rs
index 5625f170b..5d0c4e55d 100644
--- a/burn-core/src/module/param/constant.rs
+++ b/burn-core/src/module/param/constant.rs
@@ -226,7 +226,7 @@ mod tests {
 
     #[test]
     fn tensor_load_record_setting() {
-        let tensor = Tensor::<TestAutodiffBackend, 2>::ones([3, 3]);
+        let tensor = Tensor::<TestAutodiffBackend, 2>::ones_devauto([3, 3]);
 
         let byte_recorder = BinBytesRecorder::<FullPrecisionSettings>::default();
         let bytes = byte_recorder
diff --git a/burn-core/src/module/param/tensor.rs b/burn-core/src/module/param/tensor.rs
index b8c8ae35a..7d13ce8ce 100644
--- a/burn-core/src/module/param/tensor.rs
+++ b/burn-core/src/module/param/tensor.rs
@@ -228,7 +228,7 @@ mod tests {
 
     #[test]
     fn test_load_record_setting() {
-        let tensor = Tensor::<TestAutodiffBackend, 2>::ones([3, 3]);
+        let tensor = Tensor::<TestAutodiffBackend, 2>::ones_devauto([3, 3]);
 
         let byte_recorder = BinBytesRecorder::<FullPrecisionSettings>::default();
         let bytes = byte_recorder
@@ -253,7 +253,8 @@ mod tests {
     #[test]
     fn test_init_with_record_setting() {
         let config = LinearConfig::new(32, 32);
-        let module_init = config.init::<TestAutodiffBackend>();
+        let device = Default::default();
+        let module_init = config.init::<TestAutodiffBackend>(&device);
 
         let record = module_init.clone().into_record();
         let module_init_with = config.init_with::<TestAutodiffBackend>(record);
diff --git a/burn-core/src/nn/attention/mask.rs b/burn-core/src/nn/attention/mask.rs
index b59f3a4f0..473407569 100644
--- a/burn-core/src/nn/attention/mask.rs
+++ b/burn-core/src/nn/attention/mask.rs
@@ -10,10 +10,10 @@ pub fn generate_autoregressive_mask<B: Backend>(
     seq_length: usize,
     device: &B::Device,
 ) -> Tensor<B, 3, Bool> {
-    let mut mask = Tensor::<B, 3, Int>::zeros([1, seq_length, seq_length]);
+    let mut mask = Tensor::<B, 3, Int>::zeros([1, seq_length, seq_length], device);
 
     for i in 0..(seq_length - 1) {
-        let values = Tensor::<B, 3, Int>::ones([1, 1, seq_length - (i + 1)]);
+        let values = Tensor::<B, 3, Int>::ones_devauto([1, 1, seq_length - (i + 1)]);
         mask = mask.slice_assign([0..1, i..i + 1, i + 1..seq_length], values);
     }
 
@@ -54,7 +54,7 @@ pub fn generate_padding_mask<B: Backend>(
         }
     }
 
-    let mut tensor = Tensor::zeros([batch_size, max_size]);
+    let mut tensor = Tensor::zeros([batch_size, max_size], device);
     tensor = tensor.add_scalar(pad_token as i64);
 
     for (index, tokens) in tokens_list.into_iter().enumerate() {
@@ -70,7 +70,7 @@ pub fn generate_padding_mask<B: Backend>(
 
         tensor = tensor.slice_assign(
             [index..index + 1, 0..tokens.len()],
-            Tensor::from_data(Data::new(
+            Tensor::from_data_devauto(Data::new(
                 tokens.into_iter().map(|e| (e as i64).elem()).collect(),
                 Shape::new([1, seq_length]),
             )),
diff --git a/burn-core/src/nn/attention/mha.rs b/burn-core/src/nn/attention/mha.rs
index 16ed02508..9887f6e5b 100644
--- a/burn-core/src/nn/attention/mha.rs
+++ b/burn-core/src/nn/attention/mha.rs
@@ -73,12 +73,19 @@ pub struct MhaInput<B: Backend> {
 }
 
 impl MultiHeadAttentionConfig {
+    /// Initialize a new [multihead attention](MultiHeadAttention) module
+    /// on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> MultiHeadAttention<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [multihead attention](MultiHeadAttention) module.
-    pub fn init<B: Backend>(&self) -> MultiHeadAttention<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> MultiHeadAttention<B> {
         let linear = |config: &Self| {
             nn::LinearConfig::new(config.d_model, config.d_model)
                 .with_initializer(self.initializer.clone())
-                .init()
+                .init(device)
         };
 
         MultiHeadAttention {
@@ -340,8 +347,8 @@ mod tests {
     #[test]
     fn test_self_attention_shapes() {
         let [batch_size, seq_length, d_model, n_heads] = [7, 13, 32, 4];
-        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init::<TestBackend>();
-        let input = MhaInput::self_attn(Tensor::random(
+        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init_devauto::<TestBackend>();
+        let input = MhaInput::self_attn(Tensor::random_devauto(
             [batch_size, seq_length, d_model],
             Distribution::Default,
         ));
@@ -363,11 +370,12 @@ mod tests {
     #[test]
     fn test_generic_mha_shapes() {
         let [batch_size, seq_length_1, seq_length_2, d_model, n_heads] = [7, 13, 15, 32, 4];
-        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init::<TestBackend>();
+        let mha = MultiHeadAttentionConfig::new(d_model, n_heads)
+            .init::<TestBackend>(&Default::default());
         let input = MhaInput::new(
-            Tensor::random([batch_size, seq_length_1, d_model], Distribution::Default),
-            Tensor::random([batch_size, seq_length_2, d_model], Distribution::Default),
-            Tensor::random([batch_size, seq_length_2, d_model], Distribution::Default),
+            Tensor::random_devauto([batch_size, seq_length_1, d_model], Distribution::Default),
+            Tensor::random_devauto([batch_size, seq_length_2, d_model], Distribution::Default),
+            Tensor::random_devauto([batch_size, seq_length_2, d_model], Distribution::Default),
         );
 
         let output = mha.forward(input);
@@ -387,19 +395,22 @@ mod tests {
     #[test]
     fn test_self_attention_mask_pad() {
         let [batch_size, seq_length, d_model, n_heads, num_padded] = [3, 6, 32, 2, 2];
-        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init::<TestBackend>();
+        let device = Default::default();
+        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init::<TestBackend>(&device);
 
         // Create a padding mask
-        let mask_pad: Tensor<TestBackend, 2, Int> = Tensor::zeros([batch_size, seq_length]);
+        let mask_pad: Tensor<TestBackend, 2, Int> =
+            Tensor::zeros([batch_size, seq_length], &device);
         let mask_pad = mask_pad.slice_assign(
             [0..batch_size, seq_length - num_padded..seq_length],
-            Tensor::ones([batch_size, num_padded]),
+            Tensor::ones_devauto([batch_size, num_padded]),
         );
-        let mask_pad = mask_pad.equal_elem(1);
+        let mask_pad = mask_pad.equal_elem(1).to_device(&device);
 
         let tensor_1 = Tensor::<TestBackend, 3>::random(
             [batch_size, seq_length, d_model],
             Distribution::Default,
+            &device,
         );
         // Change the end of the tensor
         let tensor_2 = tensor_1.clone().slice_assign(
@@ -408,7 +419,11 @@ mod tests {
                 seq_length - num_padded..seq_length,
                 0..d_model,
             ],
-            Tensor::random([batch_size, num_padded, d_model], Distribution::Default),
+            Tensor::random(
+                [batch_size, num_padded, d_model],
+                Distribution::Default,
+                &device,
+            ),
         );
 
         let input_1 = MhaInput::self_attn(tensor_1).mask_pad(mask_pad.clone());
@@ -434,11 +449,13 @@ mod tests {
     #[test]
     fn test_autoregressive_mask_should_have_same_output_as_autoregressive_decoding() {
         let [batch_size, seq_length, d_model, n_heads] = [3, 4, 12, 2];
-        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init::<TestBackend>();
+        let device = Default::default();
+        let mha = MultiHeadAttentionConfig::new(d_model, n_heads).init::<TestBackend>(&device);
 
         let tensor = Tensor::<TestBackend, 3>::random(
             [batch_size, seq_length, d_model],
             Distribution::Default,
+            &device,
         );
         let mask_attn = generate_autoregressive_mask(batch_size, seq_length, &tensor.device());
         let input = MhaInput::self_attn(tensor.clone()).mask_attn(mask_attn);
diff --git a/burn-core/src/nn/conv/conv1d.rs b/burn-core/src/nn/conv/conv1d.rs
index 8a5b79bb7..66e22efc9 100644
--- a/burn-core/src/nn/conv/conv1d.rs
+++ b/burn-core/src/nn/conv/conv1d.rs
@@ -60,8 +60,14 @@ pub struct Conv1d<B: Backend> {
 }
 
 impl Conv1dConfig {
+    /// Initialize a new [conv1d](Conv1d) module on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> Conv1d<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [conv1d](Conv1d) module.
-    pub fn init<B: Backend>(&self) -> Conv1d<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Conv1d<B> {
         checks::checks_channels_div_groups(self.channels_in, self.channels_out, self.groups);
 
         let shape = [
@@ -71,14 +77,17 @@ impl Conv1dConfig {
         ];
 
         let fan_in: usize = self.channels_in / self.groups * self.kernel_size;
-        let weight = self.initializer.init_with(shape, Some(fan_in), None);
+        let weight = self
+            .initializer
+            .init_with(shape, Some(fan_in), None, device);
         let mut bias = None;
 
         if self.bias {
-            bias = Some(
-                self.initializer
-                    .init_with([self.channels_out], Some(fan_in), None),
-            );
+            bias =
+                Some(
+                    self.initializer
+                        .init_with([self.channels_out], Some(fan_in), None, device),
+                );
         }
 
         Conv1d {
@@ -140,7 +149,7 @@ mod tests {
         let config = Conv1dConfig::new(5, 5, 5);
         let k = (config.channels_in * config.kernel_size) as f64;
         let k = sqrt(config.groups as f64 / k) as f32;
-        let conv = config.init::<TestBackend>();
+        let conv = config.init_devauto::<TestBackend>();
 
         conv.weight.to_data().assert_within_range(-k..k);
     }
@@ -150,7 +159,7 @@ mod tests {
         TestBackend::seed(0);
 
         let config = Conv1dConfig::new(5, 5, 5).with_initializer(Initializer::Zeros);
-        let conv = config.init::<TestBackend>();
+        let conv = config.init::<TestBackend>(&Default::default());
 
         assert_eq!(config.initializer, Initializer::Zeros);
         conv.weight
diff --git a/burn-core/src/nn/conv/conv2d.rs b/burn-core/src/nn/conv/conv2d.rs
index ed27f3a8a..469e27902 100644
--- a/burn-core/src/nn/conv/conv2d.rs
+++ b/burn-core/src/nn/conv/conv2d.rs
@@ -59,8 +59,14 @@ pub struct Conv2d<B: Backend> {
 }
 
 impl Conv2dConfig {
+    /// Initialize a new [conv2d](Conv2d) module on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> Conv2d<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [conv2d](Conv2d) module.
-    pub fn init<B: Backend>(&self) -> Conv2d<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Conv2d<B> {
         checks::checks_channels_div_groups(self.channels[0], self.channels[1], self.groups);
 
         let shape = [
@@ -71,13 +77,15 @@ impl Conv2dConfig {
         ];
 
         let fan_in = self.channels[0] / self.groups * self.kernel_size.iter().product::<usize>();
-        let weight = self.initializer.init_with(shape, Some(fan_in), None);
+        let weight = self
+            .initializer
+            .init_with(shape, Some(fan_in), None, device);
         let mut bias = None;
 
         if self.bias {
             bias = Some(
                 self.initializer
-                    .init_with([self.channels[1]], Some(fan_in), None),
+                    .init_with([self.channels[1]], Some(fan_in), None, device),
             );
         }
 
@@ -140,7 +148,7 @@ mod tests {
         let config = Conv2dConfig::new([5, 1], [5, 5]);
         let k = (config.channels[0] * config.kernel_size[0] * config.kernel_size[1]) as f64;
         let k = sqrt(config.groups as f64 / k) as f32;
-        let conv = config.init::<TestBackend>();
+        let conv = config.init_devauto::<TestBackend>();
 
         conv.weight.to_data().assert_within_range(-k..k);
     }
@@ -150,7 +158,8 @@ mod tests {
         TestBackend::seed(0);
 
         let config = Conv2dConfig::new([5, 2], [5, 5]).with_initializer(Initializer::Zeros);
-        let conv = config.init::<TestBackend>();
+        let device = Default::default();
+        let conv = config.init::<TestBackend>(&device);
 
         assert_eq!(config.initializer, Initializer::Zeros);
         conv.weight
diff --git a/burn-core/src/nn/conv/conv_transpose1d.rs b/burn-core/src/nn/conv/conv_transpose1d.rs
index fb25d6f3e..6ead1ca98 100644
--- a/burn-core/src/nn/conv/conv_transpose1d.rs
+++ b/burn-core/src/nn/conv/conv_transpose1d.rs
@@ -62,8 +62,15 @@ pub struct ConvTranspose1d<B: Backend> {
 }
 
 impl ConvTranspose1dConfig {
+    /// Initialize a new [conv transpose 1d](ConvTranspose1d) module
+    /// on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> ConvTranspose1d<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [conv transpose 1d](ConvTranspose1d) module.
-    pub fn init<B: Backend>(&self) -> ConvTranspose1d<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> ConvTranspose1d<B> {
         checks::checks_channels_div_groups(self.channels[0], self.channels[1], self.groups);
 
         let shape = [
@@ -73,13 +80,15 @@ impl ConvTranspose1dConfig {
         ];
 
         let fan_in = self.channels[1] / self.groups * self.kernel_size;
-        let weight = self.initializer.init_with(shape, Some(fan_in), None);
+        let weight = self
+            .initializer
+            .init_with(shape, Some(fan_in), None, device);
         let mut bias = None;
 
         if self.bias {
             bias = Some(
                 self.initializer
-                    .init_with([self.channels[1]], Some(fan_in), None),
+                    .init_with([self.channels[1]], Some(fan_in), None, device),
             );
         }
 
@@ -146,7 +155,7 @@ mod tests {
         let config = ConvTranspose1dConfig::new([5, 1], 5);
         let k = (config.channels[1] * config.kernel_size) as f64;
         let k = sqrt(config.groups as f64 / k) as f32;
-        let conv = config.init::<TestBackend>();
+        let conv = config.init_devauto::<TestBackend>();
 
         conv.weight.to_data().assert_within_range(-k..k);
     }
@@ -156,7 +165,7 @@ mod tests {
         TestBackend::seed(0);
 
         let config = ConvTranspose1dConfig::new([5, 2], 5).with_initializer(Initializer::Zeros);
-        let conv = config.init::<TestBackend>();
+        let conv = config.init::<TestBackend>(&Default::default());
 
         assert_eq!(config.initializer, Initializer::Zeros);
         conv.weight
diff --git a/burn-core/src/nn/conv/conv_transpose2d.rs b/burn-core/src/nn/conv/conv_transpose2d.rs
index af4a249e6..a20193f4b 100644
--- a/burn-core/src/nn/conv/conv_transpose2d.rs
+++ b/burn-core/src/nn/conv/conv_transpose2d.rs
@@ -62,8 +62,15 @@ pub struct ConvTranspose2d<B: Backend> {
 }
 
 impl ConvTranspose2dConfig {
+    /// Initialize a new [conv transpose 2d](ConvTranspose2d) module
+    /// on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> ConvTranspose2d<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [conv transpose 2d](ConvTranspose2d) module.
-    pub fn init<B: Backend>(&self) -> ConvTranspose2d<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> ConvTranspose2d<B> {
         checks::checks_channels_div_groups(self.channels[0], self.channels[1], self.groups);
 
         let shape = [
@@ -74,13 +81,15 @@ impl ConvTranspose2dConfig {
         ];
 
         let fan_in = self.channels[1] / self.groups * self.kernel_size.iter().product::<usize>();
-        let weight = self.initializer.init_with(shape, Some(fan_in), None);
+        let weight = self
+            .initializer
+            .init_with(shape, Some(fan_in), None, device);
         let mut bias = None;
 
         if self.bias {
             bias = Some(
                 self.initializer
-                    .init_with([self.channels[1]], Some(fan_in), None),
+                    .init_with([self.channels[1]], Some(fan_in), None, device),
             );
         }
 
@@ -147,7 +156,7 @@ mod tests {
         let config = ConvTranspose2dConfig::new([5, 1], [5, 5]);
         let k = (config.channels[1] * config.kernel_size[0] * config.kernel_size[1]) as f64;
         let k = sqrt(config.groups as f64 / k) as f32;
-        let conv = config.init::<TestBackend>();
+        let conv = config.init_devauto::<TestBackend>();
 
         conv.weight.to_data().assert_within_range(-k..k);
     }
@@ -158,7 +167,7 @@ mod tests {
 
         let config =
             ConvTranspose2dConfig::new([5, 2], [5, 5]).with_initializer(Initializer::Zeros);
-        let conv = config.init::<TestBackend>();
+        let conv = config.init::<TestBackend>(&Default::default());
 
         assert_eq!(config.initializer, Initializer::Zeros);
         conv.weight
diff --git a/burn-core/src/nn/dropout.rs b/burn-core/src/nn/dropout.rs
index 109040e56..09ad61b0c 100644
--- a/burn-core/src/nn/dropout.rs
+++ b/burn-core/src/nn/dropout.rs
@@ -64,7 +64,7 @@ mod tests {
     #[cfg(feature = "std")]
     #[test]
     fn with_ad_backend_should_mark_input() {
-        let tensor = Tensor::<TestAutodiffBackend, 2>::ones(Shape::new([100, 100]));
+        let tensor = Tensor::<TestAutodiffBackend, 2>::ones_devauto(Shape::new([100, 100]));
         let dropout = DropoutConfig::new(0.5).init();
 
         let output = dropout.forward(tensor.clone());
@@ -74,7 +74,7 @@ mod tests {
 
     #[test]
     fn without_ad_backend_should_not_change_input() {
-        let tensor = Tensor::<TestBackend, 2>::ones(Shape::new([100, 100]));
+        let tensor = Tensor::<TestBackend, 2>::ones_devauto(Shape::new([100, 100]));
         let dropout = DropoutConfig::new(0.5).init();
 
         let output = dropout.forward(tensor.clone());
diff --git a/burn-core/src/nn/embedding.rs b/burn-core/src/nn/embedding.rs
index 49f26eb72..aa6ba6066 100644
--- a/burn-core/src/nn/embedding.rs
+++ b/burn-core/src/nn/embedding.rs
@@ -33,16 +33,23 @@ pub struct Embedding<B: Backend> {
 
 impl EmbeddingConfig {
     /// Initialize a new [embedding](Embedding) module.
-    pub fn init<B: Backend>(&self) -> Embedding<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Embedding<B> {
         let weight = self
             .initializer
-            .init([self.n_embedding, self.d_model])
+            .init([self.n_embedding, self.d_model], device)
             .require_grad();
 
         Embedding {
             weight: Param::from(weight),
         }
     }
+
+    /// Initialize a new [embedding](Embedding) module on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> Embedding<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [embedding](Embedding) module with a [record](EmbeddingRecord).
     pub fn init_with<B: Backend>(&self, record: EmbeddingRecord<B>) -> Embedding<B> {
         Embedding {
@@ -74,7 +81,7 @@ mod tests {
         TestBackend::seed(0);
 
         let config = EmbeddingConfig::new(100, 10);
-        let embed = config.init::<TestBackend>();
+        let embed = config.init_devauto::<TestBackend>();
         let weights = embed.weight.val().reshape([1000]);
         let (var_act, mean_act) = weights.var_mean(0);
 
@@ -96,7 +103,7 @@ mod tests {
         TestBackend::seed(0);
 
         let config = EmbeddingConfig::new(5, 5).with_initializer(Initializer::Zeros);
-        let embed = config.init::<TestBackend>();
+        let embed = config.init::<TestBackend>(&Default::default());
 
         assert_eq!(config.initializer, Initializer::Zeros);
         embed
diff --git a/burn-core/src/nn/initializer.rs b/burn-core/src/nn/initializer.rs
index 3682fadc6..ff7175e18 100644
--- a/burn-core/src/nn/initializer.rs
+++ b/burn-core/src/nn/initializer.rs
@@ -73,8 +73,12 @@ impl Initializer {
     /// # Params
     ///
     /// - shape: Shape of the initiated tensor.
-    pub fn init<B: Backend, const D: usize, S: Into<Shape<D>>>(&self, shape: S) -> Tensor<B, D> {
-        self.init_with(shape, None, None)
+    pub fn init<B: Backend, const D: usize, S: Into<Shape<D>>>(
+        &self,
+        shape: S,
+        device: &B::Device,
+    ) -> Tensor<B, D> {
+        self.init_with(shape, None, None, device)
     }
 
     /// Inits a tensor of given shape with values depending on initializer kind, with the possibility
@@ -90,29 +94,30 @@ impl Initializer {
         shape: S,
         fan_in: Option<usize>,
         fan_out: Option<usize>,
+        device: &B::Device,
     ) -> Tensor<B, D> {
         let shape = shape.into();
         match self {
-            Initializer::Constant { value } => Tensor::<B, D>::full(shape, *value),
-            Initializer::Ones => Tensor::<B, D>::ones(shape),
-            Initializer::Zeros => Tensor::<B, D>::zeros(shape),
-            Initializer::Uniform { min, max } => uniform_draw(shape, *min, *max),
-            Initializer::Normal { mean, std } => normal_draw(shape, *mean, *std),
+            Initializer::Constant { value } => Tensor::<B, D>::full(shape, *value, device),
+            Initializer::Ones => Tensor::<B, D>::ones(shape, device),
+            Initializer::Zeros => Tensor::<B, D>::zeros(shape, device),
+            Initializer::Uniform { min, max } => uniform_draw(shape, *min, *max, device),
+            Initializer::Normal { mean, std } => normal_draw(shape, *mean, *std, device),
             Initializer::KaimingUniform { gain, fan_out_only } => {
                 let a = sqrt(3.0) * *gain * self.kaiming_std(*fan_out_only, fan_in, fan_out);
-                uniform_draw(shape, -a, a)
+                uniform_draw(shape, -a, a, device)
             }
             Initializer::KaimingNormal { gain, fan_out_only } => {
                 let std = *gain * self.kaiming_std(*fan_out_only, fan_in, fan_out);
-                normal_draw(shape, 0.0, std)
+                normal_draw(shape, 0.0, std, device)
             }
             Initializer::XavierUniform { gain } => {
                 let a = sqrt(3.0) * *gain * self.xavier_std(fan_in, fan_out);
-                uniform_draw(shape, -a, a)
+                uniform_draw(shape, -a, a, device)
             }
             Initializer::XavierNormal { gain } => {
                 let std = *gain * self.xavier_std(fan_in, fan_out);
-                normal_draw(shape, 0.0, std)
+                normal_draw(shape, 0.0, std, device)
             }
         }
     }
@@ -148,18 +153,20 @@ fn uniform_draw<B: Backend, const D: usize, S: Into<Shape<D>>>(
     shape: S,
     low: f64,
     high: f64,
+    device: &B::Device,
 ) -> Tensor<B, D> {
     let distribution = Distribution::Uniform(low, high);
-    Tensor::<B, D>::random(shape, distribution)
+    Tensor::<B, D>::random(shape, distribution, device)
 }
 
 fn normal_draw<B: Backend, const D: usize, S: Into<Shape<D>>>(
     shape: S,
     mean: f64,
     std: f64,
+    device: &B::Device,
 ) -> Tensor<B, D> {
     let distribution = Distribution::Normal(mean, std);
-    Tensor::<B, D>::random(shape, distribution)
+    Tensor::<B, D>::random(shape, distribution, device)
 }
 
 #[cfg(test)]
@@ -194,7 +201,7 @@ mod tests {
 
         let (min, max) = (0.0, 1.0);
         let uniform = Initializer::Uniform { min, max };
-        let tensor: Tensor<TB, 4> = uniform.init([2, 2, 2, 2]);
+        let tensor: Tensor<TB, 4> = uniform.init([2, 2, 2, 2], &Default::default());
 
         tensor.into_data().assert_within_range(min..max);
     }
@@ -204,7 +211,8 @@ mod tests {
         // seed random generator
         TB::seed(0);
         let (mean, std) = (0.0, 1.0);
-        let normal: Tensor<TB, 1> = Initializer::Normal { mean, std }.init([1000]);
+        let normal: Tensor<TB, 1> =
+            Initializer::Normal { mean, std }.init([1000], &Default::default());
         let (var_act, mean_act) = normal.var_mean(0);
 
         let var_act: f32 = var_act.into_scalar().elem();
@@ -223,7 +231,8 @@ mod tests {
     #[test]
     fn initializer_constant_init() {
         let value = 5.0;
-        let constants: Tensor<TB, 4> = Initializer::Constant { value }.init([2, 2, 2, 2]);
+        let constants: Tensor<TB, 4> =
+            Initializer::Constant { value }.init([2, 2, 2, 2], &Default::default());
         constants
             .sum()
             .to_data()
@@ -232,7 +241,7 @@ mod tests {
 
     #[test]
     fn initializer_zeros_init() {
-        let zeros: Tensor<TB, 4> = Initializer::Zeros.init([2, 2, 2, 2]);
+        let zeros: Tensor<TB, 4> = Initializer::Zeros.init([2, 2, 2, 2], &Default::default());
         zeros
             .sum()
             .to_data()
@@ -241,7 +250,7 @@ mod tests {
 
     #[test]
     fn initializer_ones_init() {
-        let ones: Tensor<TB, 4> = Initializer::Ones.init([2, 2, 2, 2]);
+        let ones: Tensor<TB, 4> = Initializer::Ones.init([2, 2, 2, 2], &Default::default());
         ones.sum()
             .to_data()
             .assert_approx_eq(&Data::from([16.0]), 3);
@@ -259,7 +268,7 @@ mod tests {
             gain,
             fan_out_only: false,
         }
-        .init_with([fan_out, fan_in], Some(fan_in), None);
+        .init_with([fan_out, fan_in], Some(fan_in), None, &Default::default());
         tensor.into_data().assert_within_range(-k..k);
     }
 
@@ -276,7 +285,7 @@ mod tests {
             gain,
             fan_out_only: false,
         }
-        .init_with([fan_out, fan_in], Some(fan_in), None);
+        .init_with([fan_out, fan_in], Some(fan_in), None, &Default::default());
         assert_normal_init(expected_mean, expected_var, &tensor)
     }
 
@@ -293,7 +302,7 @@ mod tests {
             gain,
             fan_out_only: false,
         }
-        .init_with(shape, Some(fan_in), None);
+        .init_with(shape, Some(fan_in), None, &Default::default());
         tensor.into_data().assert_within_range(-k..k);
     }
 
@@ -309,7 +318,7 @@ mod tests {
             gain,
             fan_out_only: true,
         }
-        .init_with([fan_out, fan_in], None, Some(fan_out));
+        .init_with([fan_out, fan_in], None, Some(fan_out), &Default::default());
         tensor.into_data().assert_within_range(-k..k);
     }
 
@@ -325,7 +334,7 @@ mod tests {
             gain,
             fan_out_only: false,
         }
-        .init([fan_out, fan_in]);
+        .init([fan_out, fan_in], &Default::default());
     }
 
     #[test]
@@ -339,6 +348,7 @@ mod tests {
             [fan_out, fan_in],
             Some(fan_in),
             Some(fan_out),
+            &Default::default(),
         );
 
         tensor.into_data().assert_within_range(-bound..bound);
@@ -357,6 +367,7 @@ mod tests {
             [fan_out, fan_in],
             Some(fan_in),
             Some(fan_out),
+            &Default::default(),
         );
         assert_normal_init(expected_mean, expected_var, &tensor)
     }
@@ -368,6 +379,7 @@ mod tests {
 
         let gain = 2.;
         let (fan_in, fan_out) = (5, 6);
-        let _: Tensor<TB, 2> = Initializer::XavierUniform { gain }.init([fan_out, fan_in]);
+        let _: Tensor<TB, 2> =
+            Initializer::XavierUniform { gain }.init([fan_out, fan_in], &Default::default());
     }
 }
diff --git a/burn-core/src/nn/linear.rs b/burn-core/src/nn/linear.rs
index 0b3ef20db..bfbe6bf88 100644
--- a/burn-core/src/nn/linear.rs
+++ b/burn-core/src/nn/linear.rs
@@ -37,17 +37,24 @@ pub struct Linear<B: Backend> {
 }
 
 impl LinearConfig {
+    /// Initialize a new [linear](Linear) module on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> Linear<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [linear](Linear) module.
-    pub fn init<B: Backend>(&self) -> Linear<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Linear<B> {
         let shape = [self.d_input, self.d_output];
-        let weight = self
-            .initializer
-            .init_with(shape, Some(self.d_input), Some(self.d_output));
+        let weight =
+            self.initializer
+                .init_with(shape, Some(self.d_input), Some(self.d_output), device);
         let bias = if self.bias {
             Some(self.initializer.init_with(
                 [self.d_output],
                 Some(self.d_input),
                 Some(self.d_output),
+                device,
             ))
         } else {
             None
@@ -98,7 +105,7 @@ mod tests {
 
         let config = LinearConfig::new(5, 5);
         let k = sqrt(1.0 / config.d_input as f64) as f32;
-        let linear = config.init::<TestBackend>();
+        let linear = config.init_devauto::<TestBackend>();
 
         assert_eq!(
             config.initializer,
@@ -115,7 +122,8 @@ mod tests {
         TestBackend::seed(0);
 
         let config = LinearConfig::new(5, 5).with_initializer(Initializer::Zeros);
-        let linear = config.init::<TestBackend>();
+        let device = Default::default();
+        let linear = config.init::<TestBackend>(&device);
 
         assert_eq!(config.initializer, Initializer::Zeros);
         linear
@@ -132,11 +140,12 @@ mod tests {
         let config = LinearConfig::new(2, 3)
             .with_initializer(Initializer::Constant { value })
             .with_bias(false);
-        let linear = config.init();
+        let device = Default::default();
+        let linear = config.init::<TestBackend>(&device);
 
-        let input = Tensor::<TestBackend, 2>::ones(Shape::new([1, 2]));
+        let input = Tensor::<TestBackend, 2>::ones(Shape::new([1, 2]), &device);
         let result = linear.forward(input);
-        let expected_result = Tensor::<TestBackend, 2>::from_data([[4., 4., 4.]]);
+        let expected_result = Tensor::<TestBackend, 2>::from_data([[4., 4., 4.]], &device);
 
         assert_eq!(result.into_data(), expected_result.into_data());
     }
@@ -145,13 +154,15 @@ mod tests {
     fn test_linear_forward_with_bias() {
         TestBackend::seed(0);
 
+        let device = Default::default();
+
         let value = 2.;
         let config = LinearConfig::new(2, 3).with_initializer(Initializer::Constant { value });
-        let linear = config.init();
+        let linear = config.init::<TestBackend>(&device);
 
-        let input = Tensor::<TestBackend, 2>::ones(Shape::new([1, 2]));
+        let input = Tensor::<TestBackend, 2>::ones(Shape::new([1, 2]), &device);
         let result = linear.forward(input);
-        let expected_result = Tensor::<TestBackend, 2>::from_data([[6., 6., 6.]]);
+        let expected_result = Tensor::<TestBackend, 2>::from_data([[6., 6., 6.]], &device);
 
         assert_eq!(result.into_data(), expected_result.into_data());
     }
diff --git a/burn-core/src/nn/loss/binary_cross_entropy.rs b/burn-core/src/nn/loss/binary_cross_entropy.rs
index 37d346932..e4e79f419 100644
--- a/burn-core/src/nn/loss/binary_cross_entropy.rs
+++ b/burn-core/src/nn/loss/binary_cross_entropy.rs
@@ -36,7 +36,7 @@ impl BinaryCrossEntropyLossConfig {
             weights: self
                 .weights
                 .as_ref()
-                .map(|e| Tensor::<B, 1>::from_floats(e.as_slice())),
+                .map(|e| Tensor::<B, 1>::from_floats_devauto(e.as_slice())),
             smoothing: self.smoothing,
             logits: self.logits,
         }
@@ -46,8 +46,7 @@ impl BinaryCrossEntropyLossConfig {
         if let Some(alpha) = self.smoothing {
             assert!(
                 (0.0..=1.).contains(&alpha),
-                "Alpha of Cross-entropy loss with smoothed labels should be in interval [0, 1]. \
-                 Got {}",
+                "Alpha of Cross-entropy loss with smoothed labels should be in interval [0, 1]. Got {}",
                 alpha
             );
         };
@@ -123,8 +122,9 @@ mod tests {
     #[test]
     fn test_binary_cross_entropy() {
         let [batch_size] = [4];
-        let logits = Tensor::<TestBackend, 1>::random([batch_size], Distribution::Normal(0., 1.0));
-        let targets = Tensor::<TestBackend, 1, Int>::from_data(Data::from([0, 1, 0, 1]));
+        let logits =
+            Tensor::<TestBackend, 1>::random_devauto([batch_size], Distribution::Normal(0., 1.0));
+        let targets = Tensor::<TestBackend, 1, Int>::from_data_devauto(Data::from([0, 1, 0, 1]));
 
         let loss_1 = BinaryCrossEntropyLossConfig::new()
             .init()
@@ -139,8 +139,9 @@ mod tests {
     #[test]
     fn test_binary_cross_entropy_with_weights() {
         let [batch_size] = [4];
-        let logits = Tensor::<TestBackend, 1>::random([batch_size], Distribution::Normal(0., 1.0));
-        let targets = Tensor::<TestBackend, 1, Int>::from_data(Data::from([0, 1, 0, 1]));
+        let logits =
+            Tensor::<TestBackend, 1>::random_devauto([batch_size], Distribution::Normal(0., 1.0));
+        let targets = Tensor::<TestBackend, 1, Int>::from_data_devauto(Data::from([0, 1, 0, 1]));
         let weights = [3., 7.];
 
         let loss_1 = BinaryCrossEntropyLossConfig::new()
@@ -151,7 +152,7 @@ mod tests {
         let loss_2 = targets.clone().float() * logits.clone().log()
             + (-targets.float() + 1) * (-logits + 1).log();
 
-        let loss_2 = loss_2 * Tensor::from_floats([3., 7., 3., 7.]);
+        let loss_2 = loss_2 * Tensor::from_floats_devauto([3., 7., 3., 7.]);
         let loss_2 = loss_2.neg().sum() / (3. + 3. + 7. + 7.);
         loss_1.into_data().assert_approx_eq(&loss_2.into_data(), 3);
     }
@@ -159,8 +160,9 @@ mod tests {
     #[test]
     fn test_binary_cross_entropy_with_smoothing() {
         let [batch_size] = [4];
-        let logits = Tensor::<TestBackend, 1>::random([batch_size], Distribution::Normal(0., 1.0));
-        let targets = Tensor::<TestBackend, 1, Int>::from_data(Data::from([0, 1, 0, 1]));
+        let logits =
+            Tensor::<TestBackend, 1>::random_devauto([batch_size], Distribution::Normal(0., 1.0));
+        let targets = Tensor::<TestBackend, 1, Int>::from_data_devauto(Data::from([0, 1, 0, 1]));
 
         let loss_1 = BinaryCrossEntropyLossConfig::new()
             .with_smoothing(Some(0.1))
diff --git a/burn-core/src/nn/loss/cross_entropy.rs b/burn-core/src/nn/loss/cross_entropy.rs
index 10cabe7d1..2dce886c2 100644
--- a/burn-core/src/nn/loss/cross_entropy.rs
+++ b/burn-core/src/nn/loss/cross_entropy.rs
@@ -44,7 +44,7 @@ impl CrossEntropyLossConfig {
             weights: self
                 .weights
                 .as_ref()
-                .map(|e| Tensor::<B, 1>::from_floats(e.as_slice())),
+                .map(|e| Tensor::<B, 1>::from_floats_devauto(e.as_slice())),
             smoothing: self.smoothing,
             logits: self.logits,
         }
@@ -54,8 +54,7 @@ impl CrossEntropyLossConfig {
         if let Some(alpha) = self.smoothing {
             assert!(
                 (0.0..=1.).contains(&alpha),
-                "Alpha of Cross-entropy loss with smoothed labels should be in interval [0, 1]. \
-                 Got {}",
+                "Alpha of Cross-entropy loss with smoothed labels should be in interval [0, 1]. Got {}",
                 alpha
             );
         };
@@ -168,10 +167,10 @@ impl<B: Backend> CrossEntropyLoss<B> {
     ) -> Tensor<B, 2> {
         let [batch_size, nr_classes] = shape;
         let device = &targets.device();
-        let targets_matrix = Tensor::<B, 2>::zeros_device(shape, device).scatter(
+        let targets_matrix = Tensor::<B, 2>::zeros(shape, device).scatter(
             1,
             targets.reshape([batch_size, 1]),
-            Tensor::ones_device([batch_size, 1], device),
+            Tensor::ones([batch_size, 1], device),
         );
         targets_matrix * (1. - alpha) + alpha / nr_classes as f32
     }
@@ -227,12 +226,13 @@ mod tests {
     macro_rules! setup {
         () => {{
             let [batch_size, num_targets] = [4, 5];
-            let logits = Tensor::<TestBackend, 2>::random(
+            let logits = Tensor::<TestBackend, 2>::random_devauto(
                 [batch_size, num_targets],
                 Distribution::Normal(0., 1.0),
             );
-            let targets = Tensor::<TestBackend, 1, Int>::from_data(Data::from([2, 0, 4, 1]));
-            let targets_logits = Tensor::<TestBackend, 2>::from_data(Data::from([
+            let targets =
+                Tensor::<TestBackend, 1, Int>::from_data_devauto(Data::from([2, 0, 4, 1]));
+            let targets_logits = Tensor::<TestBackend, 2>::from_data_devauto(Data::from([
                 [0.0, 0.0, 1.0, 0.0, 0.0],
                 [1.0, 0.0, 0.0, 0.0, 0.0],
                 [0.0, 0.0, 0.0, 0.0, 1.0],
@@ -245,14 +245,14 @@ mod tests {
     macro_rules! setup_padded {
         () => {{
             let [batch_size, num_targets, pad_index] = [4, 5, 1];
-            let logits = Tensor::<TestBackend, 2>::random(
+            let logits = Tensor::<TestBackend, 2>::random_devauto(
                 [batch_size, num_targets],
                 Distribution::Normal(0., 1.0),
             );
-            let targets = Tensor::<TestBackend, 1, Int>::from_data(
+            let targets = Tensor::<TestBackend, 1, Int>::from_data_devauto(
                 Data::<i64, 1>::from([2, 0, 4, pad_index as i64]).convert(),
             );
-            let targets_logits = Tensor::<TestBackend, 2>::from_data(Data::from([
+            let targets_logits = Tensor::<TestBackend, 2>::from_data_devauto(Data::from([
                 [0.0, 0.0, 0.0, 0.0, 0.0],
                 [1.0, 0.0, 0.0, 0.0, 0.0],
                 [0.0, 0.0, 0.0, 0.0, 1.0],
@@ -273,7 +273,7 @@ mod tests {
         let tensor = log_softmax(logits, 1);
         let loss_2 = tensor
             * targets_logits
-            * Tensor::<TestBackend, 1>::from_floats(weights.as_slice())
+            * Tensor::<TestBackend, 1>::from_floats_devauto(weights.as_slice())
                 .unsqueeze()
                 .repeat(0, 4);
         let loss_2 = loss_2.sum().neg() / (1. + 2. + 3. + 5.);
@@ -358,7 +358,7 @@ mod tests {
         let (logits, targets, _) = setup!();
         let smoothed_targets =
             CrossEntropyLoss::compute_smoothed_targets(logits.dims(), targets, 0.05);
-        let targets_logits = Tensor::<TestBackend, 2>::from_data(Data::from([
+        let targets_logits = Tensor::<TestBackend, 2>::from_data_devauto(Data::from([
             [0.01, 0.01, 0.96, 0.01, 0.01],
             [0.96, 0.01, 0.01, 0.01, 0.01],
             [0.01, 0.01, 0.01, 0.01, 0.96],
@@ -376,7 +376,7 @@ mod tests {
             .with_smoothing(Some(0.05))
             .init()
             .forward(logits.clone(), targets);
-        let targets_logits = Tensor::<TestBackend, 2>::from_data(Data::from([
+        let targets_logits = Tensor::<TestBackend, 2>::from_data_devauto(Data::from([
             [0.01, 0.01, 0.96, 0.01, 0.01],
             [0.96, 0.01, 0.01, 0.01, 0.01],
             [0.01, 0.01, 0.01, 0.01, 0.96],
diff --git a/burn-core/src/nn/loss/mse.rs b/burn-core/src/nn/loss/mse.rs
index 4ab95cd7d..7c76ae1cc 100644
--- a/burn-core/src/nn/loss/mse.rs
+++ b/burn-core/src/nn/loss/mse.rs
@@ -60,9 +60,11 @@ mod tests {
 
     #[test]
     fn test_mse_loss() {
-        let logits = Tensor::<TestBackend, 2>::from_data(Data::from([[1.0, 2.0], [3.0, 4.0]]));
+        let logits =
+            Tensor::<TestBackend, 2>::from_data_devauto(Data::from([[1.0, 2.0], [3.0, 4.0]]));
 
-        let targets = Tensor::<TestBackend, 2>::from_data(Data::from([[2.0, 1.0], [3.0, 2.0]]));
+        let targets =
+            Tensor::<TestBackend, 2>::from_data_devauto(Data::from([[2.0, 1.0], [3.0, 2.0]]));
 
         let mse = MSELoss::new();
         let loss_no_reduction = mse.forward_no_reduction(logits.clone(), targets.clone());
diff --git a/burn-core/src/nn/norm/batch.rs b/burn-core/src/nn/norm/batch.rs
index c002459f6..fa0e55ed9 100644
--- a/burn-core/src/nn/norm/batch.rs
+++ b/burn-core/src/nn/norm/batch.rs
@@ -33,13 +33,19 @@ pub struct BatchNorm<B: Backend, const D: usize> {
 }
 
 impl BatchNormConfig {
-    /// Initialize a new [batch norm](BatchNorm) module.
-    pub fn init<B: Backend, const D: usize>(&self) -> BatchNorm<B, D> {
-        let gamma = Tensor::ones([self.num_features]);
-        let beta = Tensor::zeros([self.num_features]);
+    /// Initialize a new [batch norm](BatchNorm) module on an automatically selected device.
+    pub fn init_devauto<B: Backend, const D: usize>(&self) -> BatchNorm<B, D> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
 
-        let running_mean = Tensor::zeros([self.num_features]);
-        let running_var = Tensor::ones([self.num_features]);
+    /// Initialize a new [batch norm](BatchNorm) module.
+    pub fn init<B: Backend, const D: usize>(&self, device: &B::Device) -> BatchNorm<B, D> {
+        let gamma = Tensor::ones([self.num_features], device);
+        let beta = Tensor::zeros([self.num_features], device);
+
+        let running_mean = Tensor::zeros([self.num_features], device);
+        let running_var = Tensor::ones([self.num_features], device);
 
         BatchNorm {
             gamma: Param::from(gamma),
@@ -184,10 +190,16 @@ mod tests_1d {
     use burn_tensor::Data;
 
     #[test]
-    fn batch_norm_forward_train() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 1>();
+    fn default_device_initialization() {
+        let _module = BatchNormConfig::new(3).init_devauto::<TestAutodiffBackend, 1>();
+    }
 
-        let output = module.forward(input_tensor());
+    #[test]
+    fn batch_norm_forward_train() {
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 1>(&device);
+
+        let output = module.forward(input_tensor(&device));
 
         output.to_data().assert_approx_eq(
             &Data::from([
@@ -208,11 +220,12 @@ mod tests_1d {
 
     #[test]
     fn batch_norm_forward_inference() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 1>();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 1>(&device);
 
-        module.forward(input_tensor());
+        module.forward(input_tensor(&device));
         let module = module.valid();
-        let output = module.forward(input_tensor());
+        let output = module.forward(input_tensor(&device));
 
         output.to_data().assert_approx_eq(
             &Data::from([
@@ -223,11 +236,14 @@ mod tests_1d {
         );
     }
 
-    fn input_tensor<B: Backend>() -> Tensor<B, 3> {
-        Tensor::<B, 3>::from_floats([
-            [[0.9601, 0.7277], [0.6272, 0.9034], [0.9378, 0.7230]],
-            [[0.6356, 0.1362], [0.0249, 0.9509], [0.6600, 0.5945]],
-        ])
+    fn input_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 3> {
+        Tensor::<B, 3>::from_floats(
+            [
+                [[0.9601, 0.7277], [0.6272, 0.9034], [0.9378, 0.7230]],
+                [[0.6356, 0.1362], [0.0249, 0.9509], [0.6600, 0.5945]],
+            ],
+            device,
+        )
     }
 }
 
@@ -240,9 +256,10 @@ mod tests_2d {
 
     #[test]
     fn batch_norm_forward_train() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>(&device);
 
-        let output = module.forward(input_tensor());
+        let output = module.forward(input_tensor(&device));
 
         output.to_data().assert_approx_eq(
             &Data::from([
@@ -263,11 +280,12 @@ mod tests_2d {
 
     #[test]
     fn batch_norm_forward_inference() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>(&device);
 
-        module.forward(input_tensor());
+        module.forward(input_tensor(&device));
         let module = module.valid();
-        let output = module.forward(input_tensor());
+        let output = module.forward(input_tensor(&device));
 
         output.to_data().assert_approx_eq(
             &Data::from([
@@ -288,9 +306,10 @@ mod tests_2d {
 
     #[test]
     fn batch_norm_running_mean() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>(&device);
 
-        let _output = module.forward(input_tensor());
+        let _output = module.forward(input_tensor(&device));
 
         let running_mean = module.running_mean.value_sync();
 
@@ -302,9 +321,10 @@ mod tests_2d {
 
     #[test]
     fn batch_norm_running_var() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>(&device);
 
-        let _output = module.forward(input_tensor());
+        let _output = module.forward(input_tensor(&device));
 
         let running_var = module.running_var.value_sync();
 
@@ -316,9 +336,10 @@ mod tests_2d {
 
     #[test]
     fn batch_norm_running_mean_inner_module() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>(&device);
 
-        let _output = module.forward(input_tensor());
+        let _output = module.forward(input_tensor(&device));
 
         let module_valid = module.valid();
         let running_mean = module_valid.running_mean.value();
@@ -331,8 +352,9 @@ mod tests_2d {
 
     #[test]
     fn batch_norm_grads() {
-        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>();
-        let input = input_tensor().require_grad();
+        let device = Default::default();
+        let module = BatchNormConfig::new(3).init::<TestAutodiffBackend, 2>(&device);
+        let input = input_tensor(&device).require_grad();
 
         let output = module.forward(input.clone());
 
@@ -371,18 +393,21 @@ mod tests_2d {
         );
     }
 
-    fn input_tensor<B: Backend>() -> Tensor<B, 4> {
-        Tensor::<B, 4>::from_floats([
+    fn input_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 4> {
+        Tensor::<B, 4>::from_floats(
             [
-                [[0.9601, 0.7277], [0.1270, 0.5441]],
-                [[0.6272, 0.9034], [0.4066, 0.7179]],
-                [[0.9378, 0.7230], [0.3544, 0.9591]],
+                [
+                    [[0.9601, 0.7277], [0.1270, 0.5441]],
+                    [[0.6272, 0.9034], [0.4066, 0.7179]],
+                    [[0.9378, 0.7230], [0.3544, 0.9591]],
+                ],
+                [
+                    [[0.6356, 0.1362], [0.1333, 0.7287]],
+                    [[0.0249, 0.9509], [0.3791, 0.2481]],
+                    [[0.6600, 0.5945], [0.5424, 0.4767]],
+                ],
             ],
-            [
-                [[0.6356, 0.1362], [0.1333, 0.7287]],
-                [[0.0249, 0.9509], [0.3791, 0.2481]],
-                [[0.6600, 0.5945], [0.5424, 0.4767]],
-            ],
-        ])
+            device,
+        )
     }
 }
diff --git a/burn-core/src/nn/norm/group.rs b/burn-core/src/nn/norm/group.rs
index 249782d34..7c768bbbe 100644
--- a/burn-core/src/nn/norm/group.rs
+++ b/burn-core/src/nn/norm/group.rs
@@ -46,8 +46,8 @@ impl GroupNormConfig {
         );
 
         let (gamma, beta) = if self.affine {
-            let gamma = Tensor::ones([self.num_channels]).into();
-            let beta = Tensor::zeros([self.num_channels]).into();
+            let gamma = Tensor::ones_devauto([self.num_channels]).into();
+            let beta = Tensor::zeros_devauto([self.num_channels]).into();
 
             (Some(gamma), Some(beta))
         } else {
@@ -142,7 +142,7 @@ mod tests {
         assert!(module.gamma.is_none());
         assert!(module.beta.is_none());
 
-        let input = Tensor::from_data(Data::from([
+        let input = Tensor::from_data_devauto(Data::from([
             [
                 [-0.3034, 0.2726, -0.9659],
                 [-1.1845, -1.3236, 0.0172],
@@ -208,7 +208,7 @@ mod tests {
             .to_data()
             .assert_approx_eq(&Data::zeros([6]), 3);
 
-        let input = Tensor::from_data(Data::from([
+        let input = Tensor::from_data_devauto(Data::from([
             [
                 [0.3345, 0.4429, 0.6639],
                 [0.5041, 0.4175, 0.8437],
diff --git a/burn-core/src/nn/norm/layer.rs b/burn-core/src/nn/norm/layer.rs
index 54bed1a7f..29e5be268 100644
--- a/burn-core/src/nn/norm/layer.rs
+++ b/burn-core/src/nn/norm/layer.rs
@@ -28,9 +28,15 @@ pub struct LayerNorm<B: Backend> {
 
 impl LayerNormConfig {
     /// Initialize a new [layer norm](LayerNorm) module.
-    pub fn init<B: Backend>(&self) -> LayerNorm<B> {
-        let gamma = Tensor::ones([self.d_model]);
-        let beta = Tensor::zeros([self.d_model]);
+    pub fn init_devauto<B: Backend>(&self) -> LayerNorm<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
+    /// Initialize a new [layer norm](LayerNorm) module.
+    pub fn init<B: Backend>(&self, device: &B::Device) -> LayerNorm<B> {
+        let gamma = Tensor::ones([self.d_model], device);
+        let beta = Tensor::zeros([self.d_model], device);
 
         LayerNorm {
             gamma: Param::from(gamma),
@@ -78,12 +84,21 @@ mod tests {
     #[cfg(not(feature = "std"))]
     use crate::TestBackend;
 
+    #[test]
+    fn layer_default_initialization() {
+        let _module = LayerNormConfig::new(10).init_devauto::<TestBackend>();
+    }
+
     #[test]
     fn layer_norm_forward() {
-        let module = LayerNormConfig::new(10).init::<TestBackend>();
-        let input = Tensor::from_data(Data::from([[
-            -0.6897, -2.7106, 2.2222, -1.0330, -0.8933, 1.1765, 0.0601, 1.5252, -0.3630, 0.6728,
-        ]]));
+        let device = Default::default();
+        let module = LayerNormConfig::new(10).init::<TestBackend>(&device);
+        let input = Tensor::from_data(
+            Data::from([[
+                -0.6897, -2.7106, 2.2222, -1.0330, -0.8933, 1.1765, 0.0601, 1.5252, -0.3630, 0.6728,
+            ]]),
+            &device,
+        );
 
         let output = module.forward(input);
 
@@ -98,13 +113,18 @@ mod tests {
     #[cfg(feature = "std")]
     #[test]
     fn layer_norm_backward() {
-        let module = LayerNormConfig::new(2).init::<TestAutodiffBackend>();
-        let tensor_1 =
-            Tensor::<TestAutodiffBackend, 2>::from_data(Data::from([[0.0, 1.0], [3.0, 4.0]]))
-                .require_grad();
-        let tensor_2 =
-            Tensor::<TestAutodiffBackend, 2>::from_data(Data::from([[6.0, 7.0], [9.0, 10.0]]))
-                .require_grad();
+        let device = Default::default();
+        let module = LayerNormConfig::new(2).init::<TestAutodiffBackend>(&device);
+        let tensor_1 = Tensor::<TestAutodiffBackend, 2>::from_data(
+            Data::from([[0.0, 1.0], [3.0, 4.0]]),
+            &device,
+        )
+        .require_grad();
+        let tensor_2 = Tensor::<TestAutodiffBackend, 2>::from_data(
+            Data::from([[6.0, 7.0], [9.0, 10.0]]),
+            &device,
+        )
+        .require_grad();
 
         let x = tensor_1.clone().matmul(tensor_2.clone());
 
diff --git a/burn-core/src/nn/pos_encoding.rs b/burn-core/src/nn/pos_encoding.rs
index e4a935ac9..2fe263fc0 100644
--- a/burn-core/src/nn/pos_encoding.rs
+++ b/burn-core/src/nn/pos_encoding.rs
@@ -145,7 +145,7 @@ pub fn generate_sinusoids<B: Backend>(
         [length, d_model].into(),
     );
 
-    Tensor::<B, 2>::from_data(data.convert())
+    Tensor::<B, 2>::from_data_devauto(data.convert())
 }
 
 #[cfg(test)]
@@ -165,13 +165,13 @@ mod tests {
 
         // Use a tensor of zeros as input for easy verification of the output
         // The output should be the sinusoids broadcasted to the input shape
-        let tensor = Tensor::zeros([batch_size, length, d_model]);
+        let tensor = Tensor::zeros_devauto([batch_size, length, d_model]);
 
         let output = pe.forward(tensor);
 
         assert_eq!(output.shape().dims, [batch_size, length, d_model]);
 
-        let expected = Tensor::<TestBackend, 3>::from_floats([
+        let expected = Tensor::<TestBackend, 3>::from_floats_devauto([
             [
                 [0.00000, 1.00000, 0.00000, 1.00000, 0.00000, 1.00000],
                 [0.84147, 0.54030, 0.04640, 0.99892, 0.00215, 1.00000],
@@ -192,7 +192,7 @@ mod tests {
         let sinusoids = generate_sinusoids::<TestBackend>(12, 6, 10_000);
 
         // The values are taken from the pytorch reference implementation
-        let expected = Tensor::<TestBackend, 2>::from_floats([
+        let expected = Tensor::<TestBackend, 2>::from_floats_devauto([
             [0.00000, 1.00000, 0.00000, 1.00000, 0.00000, 1.00000],
             [0.84147, 0.54030, 0.04640, 0.99892, 0.00215, 1.00000],
             [0.90930, -0.41615, 0.09270, 0.99569, 0.00431, 0.99999],
@@ -214,7 +214,7 @@ mod tests {
     fn d_model_input_should_match() {
         let d_model = 8;
         let pe = PositionalEncodingConfig::new(d_model).init::<TestBackend>();
-        let input = Tensor::zeros([1, 5, 10]);
+        let input = Tensor::zeros_devauto([1, 5, 10]);
         let _output = pe.forward(input);
     }
 
@@ -223,7 +223,7 @@ mod tests {
     fn input_length_should_be_less_than_max_len() {
         let d_model = 8;
         let pe = PositionalEncodingConfig::new(d_model).init::<TestBackend>();
-        let input = Tensor::zeros([1, 6_000, d_model]);
+        let input = Tensor::zeros_devauto([1, 6_000, d_model]);
         let _output = pe.forward(input);
     }
 }
diff --git a/burn-core/src/nn/rnn/gate_controller.rs b/burn-core/src/nn/rnn/gate_controller.rs
index c063301ac..b5cc373bf 100644
--- a/burn-core/src/nn/rnn/gate_controller.rs
+++ b/burn-core/src/nn/rnn/gate_controller.rs
@@ -23,7 +23,13 @@ pub struct GateController<B: Backend> {
 
 impl<B: Backend> GateController<B> {
     /// Initialize a new [gate_controller](GateController) module.
-    pub fn new(d_input: usize, d_output: usize, bias: bool, initializer: Initializer) -> Self {
+    pub fn new(
+        d_input: usize,
+        d_output: usize,
+        bias: bool,
+        initializer: Initializer,
+        device: &B::Device,
+    ) -> Self {
         Self {
             input_transform: LinearConfig {
                 d_input,
@@ -31,14 +37,14 @@ impl<B: Backend> GateController<B> {
                 bias,
                 initializer: initializer.clone(),
             }
-            .init(),
+            .init(device),
             hidden_transform: LinearConfig {
                 d_input: d_output,
                 d_output,
                 bias,
                 initializer,
             }
-            .init(),
+            .init(device),
         }
     }
 
diff --git a/burn-core/src/nn/rnn/gru.rs b/burn-core/src/nn/rnn/gru.rs
index bd2c4649f..8a8c4d3a9 100644
--- a/burn-core/src/nn/rnn/gru.rs
+++ b/burn-core/src/nn/rnn/gru.rs
@@ -35,8 +35,14 @@ pub struct Gru<B: Backend> {
 }
 
 impl GruConfig {
+    /// Initialize a new [gru](Gru) module on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> Gru<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [gru](Gru) module.
-    pub fn init<B: Backend>(&self) -> Gru<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Gru<B> {
         let d_output = self.d_hidden;
 
         let update_gate = gate_controller::GateController::new(
@@ -44,18 +50,21 @@ impl GruConfig {
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
         let reset_gate = gate_controller::GateController::new(
             self.d_input,
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
         let new_gate = gate_controller::GateController::new(
             self.d_input,
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
 
         Gru {
@@ -110,7 +119,10 @@ impl<B: Backend> Gru<B> {
 
         let mut hidden_state = match state {
             Some(state) => state,
-            None => Tensor::zeros([batch_size, seq_length, self.d_hidden]),
+            None => Tensor::zeros(
+                [batch_size, seq_length, self.d_hidden],
+                &batched_input.device(),
+            ),
         };
 
         for (t, (input_t, hidden_t)) in batched_input
@@ -209,7 +221,8 @@ mod tests {
     fn tests_forward_single_input_single_feature() {
         TestBackend::seed(0);
         let config = GruConfig::new(1, 1, false);
-        let mut gru = config.init::<TestBackend>();
+        let device = Default::default();
+        let mut gru = config.init::<TestBackend>(&device);
 
         fn create_gate_controller(
             weights: f32,
@@ -218,10 +231,11 @@ mod tests {
             d_output: usize,
             bias: bool,
             initializer: Initializer,
+            device: &<TestBackend as Backend>::Device,
         ) -> GateController<TestBackend> {
             let record = LinearRecord {
-                weight: Param::from(Tensor::from_data(Data::from([[weights]]))),
-                bias: Some(Param::from(Tensor::from_data(Data::from([biases])))),
+                weight: Param::from(Tensor::from_data(Data::from([[weights]]), device)),
+                bias: Some(Param::from(Tensor::from_data(Data::from([biases]), device))),
             };
             gate_controller::GateController::create_with_weights(
                 d_input,
@@ -240,6 +254,7 @@ mod tests {
             1,
             false,
             Initializer::XavierNormal { gain: 1.0 },
+            &device,
         );
         gru.reset_gate = create_gate_controller(
             0.6,
@@ -248,6 +263,7 @@ mod tests {
             1,
             false,
             Initializer::XavierNormal { gain: 1.0 },
+            &device,
         );
         gru.new_gate = create_gate_controller(
             0.7,
@@ -256,24 +272,32 @@ mod tests {
             1,
             false,
             Initializer::XavierNormal { gain: 1.0 },
+            &device,
         );
 
-        let input = Tensor::<TestBackend, 3>::from_data(Data::from([[[0.1]]]));
+        let input = Tensor::<TestBackend, 3>::from_data(Data::from([[[0.1]]]), &device);
 
         let state = gru.forward(input, None);
 
-        let output = state.select(0, Tensor::arange(0..1)).squeeze(0);
+        let output = state.select(0, Tensor::arange(0..1, &device)).squeeze(0);
 
         output.to_data().assert_approx_eq(&Data::from([[0.034]]), 3);
     }
 
     #[test]
     fn test_batched_forward_pass() {
-        let gru = GruConfig::new(64, 1024, true).init::<TestBackend>();
-        let batched_input = Tensor::<TestBackend, 3>::random([8, 10, 64], Distribution::Default);
+        let device = Default::default();
+        let gru = GruConfig::new(64, 1024, true).init::<TestBackend>(&device);
+        let batched_input =
+            Tensor::<TestBackend, 3>::random([8, 10, 64], Distribution::Default, &device);
 
         let hidden_state = gru.forward(batched_input, None);
 
         assert_eq!(hidden_state.shape().dims, [8, 10, 1024]);
     }
+
+    #[test]
+    fn test_initialization_on_default_device() {
+        let _module = GruConfig::new(64, 1024, true).init_devauto::<TestBackend>();
+    }
 }
diff --git a/burn-core/src/nn/rnn/lstm.rs b/burn-core/src/nn/rnn/lstm.rs
index b49db3564..2635c02f0 100644
--- a/burn-core/src/nn/rnn/lstm.rs
+++ b/burn-core/src/nn/rnn/lstm.rs
@@ -36,8 +36,14 @@ pub struct Lstm<B: Backend> {
 }
 
 impl LstmConfig {
+    /// Initialize a new [lstm](Lstm) module on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> Lstm<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
     /// Initialize a new [lstm](Lstm) module.
-    pub fn init<B: Backend>(&self) -> Lstm<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Lstm<B> {
         let d_output = self.d_hidden;
 
         let input_gate = gate_controller::GateController::new(
@@ -45,24 +51,28 @@ impl LstmConfig {
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
         let forget_gate = gate_controller::GateController::new(
             self.d_input,
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
         let output_gate = gate_controller::GateController::new(
             self.d_input,
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
         let cell_gate = gate_controller::GateController::new(
             self.d_input,
             d_output,
             self.bias,
             self.initializer.clone(),
+            device,
         );
 
         Lstm {
@@ -123,14 +133,16 @@ impl<B: Backend> Lstm<B> {
         state: Option<(Tensor<B, 2>, Tensor<B, 2>)>,
     ) -> (Tensor<B, 3>, Tensor<B, 3>) {
         let [batch_size, seq_length, _] = batched_input.shape().dims;
-        let mut batched_cell_state = Tensor::zeros([batch_size, seq_length, self.d_hidden]);
-        let mut batched_hidden_state = Tensor::zeros([batch_size, seq_length, self.d_hidden]);
+        let device = &batched_input.device();
+        let mut batched_cell_state = Tensor::zeros([batch_size, seq_length, self.d_hidden], device);
+        let mut batched_hidden_state =
+            Tensor::zeros([batch_size, seq_length, self.d_hidden], device);
 
         let (mut cell_state, mut hidden_state) = match state {
             Some((cell_state, hidden_state)) => (cell_state, hidden_state),
             None => (
-                Tensor::zeros([batch_size, self.d_hidden]),
-                Tensor::zeros([batch_size, self.d_hidden]),
+                Tensor::zeros([batch_size, self.d_hidden], device),
+                Tensor::zeros([batch_size, self.d_hidden], device),
             ),
         };
 
@@ -226,7 +238,7 @@ mod tests {
 
         let config = LstmConfig::new(5, 5, false)
             .with_initializer(Initializer::Uniform { min: 0.0, max: 1.0 });
-        let lstm = config.init::<TestBackend>();
+        let lstm = config.init_devauto::<TestBackend>();
 
         let gate_to_data =
             |gate: GateController<TestBackend>| gate.input_transform.weight.val().to_data();
@@ -250,7 +262,8 @@ mod tests {
     fn test_forward_single_input_single_feature() {
         TestBackend::seed(0);
         let config = LstmConfig::new(1, 1, false);
-        let mut lstm = config.init::<TestBackend>();
+        let device = Default::default();
+        let mut lstm = config.init::<TestBackend>(&device);
 
         fn create_gate_controller(
             weights: f32,
@@ -259,10 +272,11 @@ mod tests {
             d_output: usize,
             bias: bool,
             initializer: Initializer,
+            device: &<TestBackend as Backend>::Device,
         ) -> GateController<TestBackend> {
             let record = LinearRecord {
-                weight: Param::from(Tensor::from_data(Data::from([[weights]]))),
-                bias: Some(Param::from(Tensor::from_data(Data::from([biases])))),
+                weight: Param::from(Tensor::from_data(Data::from([[weights]]), device)),
+                bias: Some(Param::from(Tensor::from_data(Data::from([biases]), device))),
             };
             gate_controller::GateController::create_with_weights(
                 d_input,
@@ -281,6 +295,7 @@ mod tests {
             1,
             false,
             Initializer::XavierUniform { gain: 1.0 },
+            &device,
         );
         lstm.forget_gate = create_gate_controller(
             0.7,
@@ -289,6 +304,7 @@ mod tests {
             1,
             false,
             Initializer::XavierUniform { gain: 1.0 },
+            &device,
         );
         lstm.cell_gate = create_gate_controller(
             0.9,
@@ -297,6 +313,7 @@ mod tests {
             1,
             false,
             Initializer::XavierUniform { gain: 1.0 },
+            &device,
         );
         lstm.output_gate = create_gate_controller(
             1.1,
@@ -305,15 +322,18 @@ mod tests {
             1,
             false,
             Initializer::XavierUniform { gain: 1.0 },
+            &device,
         );
 
         // single timestep with single feature
-        let input = Tensor::<TestBackend, 3>::from_data(Data::from([[[0.1]]]));
+        let input = Tensor::<TestBackend, 3>::from_data(Data::from([[[0.1]]]), &device);
 
         let (cell_state_batch, hidden_state_batch) = lstm.forward(input, None);
-        let cell_state = cell_state_batch.select(0, Tensor::arange(0..1)).squeeze(0);
+        let cell_state = cell_state_batch
+            .select(0, Tensor::arange(0..1, &device))
+            .squeeze(0);
         let hidden_state = hidden_state_batch
-            .select(0, Tensor::arange(0..1))
+            .select(0, Tensor::arange(0..1, &device))
             .squeeze(0);
         cell_state
             .to_data()
@@ -325,8 +345,10 @@ mod tests {
 
     #[test]
     fn test_batched_forward_pass() {
-        let lstm = LstmConfig::new(64, 1024, true).init::<TestBackend>();
-        let batched_input = Tensor::<TestBackend, 3>::random([8, 10, 64], Distribution::Default);
+        let device = Default::default();
+        let lstm = LstmConfig::new(64, 1024, true).init(&device);
+        let batched_input =
+            Tensor::<TestBackend, 3>::random([8, 10, 64], Distribution::Default, &device);
 
         let (cell_state, hidden_state) = lstm.forward(batched_input, None);
 
diff --git a/burn-core/src/nn/transformer/decoder.rs b/burn-core/src/nn/transformer/decoder.rs
index 5033a8669..f69a2a96e 100644
--- a/burn-core/src/nn/transformer/decoder.rs
+++ b/burn-core/src/nn/transformer/decoder.rs
@@ -61,9 +61,15 @@ pub struct TransformerDecoder<B: Backend> {
 
 impl TransformerDecoderConfig {
     /// Initialize a new [Transformer Decoder](TransformerDecoder) module.
-    pub fn init<B: Backend>(&self) -> TransformerDecoder<B> {
+    pub fn init_devauto<B: Backend>(&self) -> TransformerDecoder<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
+    /// Initialize a new [Transformer Decoder](TransformerDecoder) module.
+    pub fn init<B: Backend>(&self, device: &B::Device) -> TransformerDecoder<B> {
         let layers = (0..self.n_layers)
-            .map(|_| TransformerDecoderLayer::new(self))
+            .map(|_| TransformerDecoderLayer::new(self, device))
             .collect::<Vec<_>>();
 
         TransformerDecoder { layers }
@@ -190,25 +196,25 @@ impl<B: Backend> TransformerDecoderAutoregressiveCache<B> {
 }
 
 impl<B: Backend> TransformerDecoderLayer<B> {
-    fn new(config: &TransformerDecoderConfig) -> Self {
+    fn new(config: &TransformerDecoderConfig, device: &B::Device) -> Self {
         let self_attn = MultiHeadAttentionConfig::new(config.d_model, config.n_heads)
             .with_initializer(config.initializer.clone())
             .with_dropout(config.dropout)
             .with_quiet_softmax(config.quiet_softmax)
-            .init();
+            .init(device);
 
         let cross_attn = MultiHeadAttentionConfig::new(config.d_model, config.n_heads)
             .with_initializer(config.initializer.clone())
             .with_dropout(config.dropout)
             .with_quiet_softmax(config.quiet_softmax)
-            .init();
-        let norm_1 = LayerNormConfig::new(config.d_model).init();
-        let norm_2 = LayerNormConfig::new(config.d_model).init();
-        let norm_3 = LayerNormConfig::new(config.d_model).init();
+            .init(device);
+        let norm_1 = LayerNormConfig::new(config.d_model).init(device);
+        let norm_2 = LayerNormConfig::new(config.d_model).init(device);
+        let norm_3 = LayerNormConfig::new(config.d_model).init(device);
         let dropout = DropoutConfig::new(config.dropout).init();
         let pwff = PositionWiseFeedForwardConfig::new(config.d_model, config.d_ff)
             .with_dropout(config.dropout)
-            .init();
+            .init(device);
 
         Self {
             cross_attn,
@@ -397,6 +403,15 @@ mod tests {
     use crate::{nn::attention::generate_autoregressive_mask, TestBackend};
     use burn_tensor::Distribution;
 
+    #[test]
+    fn test_initialization_on_default_device() {
+        let [d_model, d_ff, n_heads, num_layers] = [12, 24, 2, 3];
+        TestBackend::seed(0);
+        let _module = TransformerDecoderConfig::new(d_model, d_ff, n_heads, num_layers)
+            .with_norm_first(false)
+            .init_devauto::<TestBackend>();
+    }
+
     #[test]
     fn test_autoregressive_norm_last() {
         let [d_model, d_ff, n_heads, num_layers] = [12, 24, 2, 3];
@@ -419,16 +434,19 @@ mod tests {
     }
 
     fn test_autoregressive(config: TransformerDecoderConfig) {
+        let device = Default::default();
         let [batch_size, seq_length, d_model] = [3, 4, config.d_model];
-        let transformer = config.init();
+        let transformer = config.init(&device);
 
         let memory = Tensor::<TestBackend, 3>::random(
             [batch_size, seq_length, d_model],
             Distribution::Default,
+            &device,
         );
         let target = Tensor::<TestBackend, 3>::random(
             [batch_size, seq_length, d_model],
             Distribution::Default,
+            &device,
         );
         let mask_attn = generate_autoregressive_mask(batch_size, seq_length, &target.device());
         let input = TransformerDecoderInput::new(target.clone(), memory.clone())
diff --git a/burn-core/src/nn/transformer/encoder.rs b/burn-core/src/nn/transformer/encoder.rs
index 7e7b4fa7e..0e7747fdd 100644
--- a/burn-core/src/nn/transformer/encoder.rs
+++ b/burn-core/src/nn/transformer/encoder.rs
@@ -91,9 +91,15 @@ impl<B: Backend> TransformerEncoderInput<B> {
 }
 impl TransformerEncoderConfig {
     /// Initialize a new [transformer encoder](TransformerEncoder) module.
-    pub fn init<B: Backend>(&self) -> TransformerEncoder<B> {
+    pub fn init_devauto<B: Backend>(&self) -> TransformerEncoder<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
+
+    /// Initialize a new [transformer encoder](TransformerEncoder) module.
+    pub fn init<B: Backend>(&self, device: &B::Device) -> TransformerEncoder<B> {
         let layers = (0..self.n_layers)
-            .map(|_| TransformerEncoderLayer::new(self))
+            .map(|_| TransformerEncoderLayer::new(self, device))
             .collect::<Vec<_>>();
 
         TransformerEncoder { layers }
@@ -202,19 +208,19 @@ impl<B: Backend> TransformerEncoderLayer<B> {
             norm_first: config.norm_first,
         }
     }
-    fn new(config: &TransformerEncoderConfig) -> Self {
+    fn new(config: &TransformerEncoderConfig, device: &B::Device) -> Self {
         let mha = MultiHeadAttentionConfig::new(config.d_model, config.n_heads)
             .with_initializer(config.initializer.clone())
             .with_dropout(config.dropout)
             .with_quiet_softmax(config.quiet_softmax)
-            .init();
-        let norm_1 = LayerNormConfig::new(config.d_model).init();
-        let norm_2 = LayerNormConfig::new(config.d_model).init();
+            .init(device);
+        let norm_1 = LayerNormConfig::new(config.d_model).init(device);
+        let norm_2 = LayerNormConfig::new(config.d_model).init(device);
         let dropout = DropoutConfig::new(config.dropout).init();
         let pwff = PositionWiseFeedForwardConfig::new(config.d_model, config.d_ff)
             .with_initializer(config.initializer.clone())
             .with_dropout(config.dropout)
-            .init();
+            .init(device);
 
         Self {
             mha,
@@ -345,6 +351,13 @@ mod tests {
     use crate::{nn::attention::generate_autoregressive_mask, TestBackend};
     use burn_tensor::Distribution;
 
+    #[test]
+    fn test_initialization_on_default_device() {
+        let [d_model, d_ff, n_heads, num_layers] = [12, 24, 2, 3];
+        let _module = TransformerEncoderConfig::new(d_model, d_ff, n_heads, num_layers)
+            .init_devauto::<TestBackend>();
+    }
+
     #[test]
     fn test_autoregressive_norm_last() {
         let [d_model, d_ff, n_heads, num_layers] = [12, 24, 2, 3];
@@ -364,11 +377,13 @@ mod tests {
 
     fn test_autoregressive(config: TransformerEncoderConfig) {
         let [batch_size, seq_length, d_model] = [3, 4, config.d_model];
-        let transformer = config.init();
+        let device = Default::default();
+        let transformer = config.init(&device);
 
         let tensor = Tensor::<TestBackend, 3>::random(
             [batch_size, seq_length, d_model],
             Distribution::Default,
+            &device,
         );
         let mask_attn = generate_autoregressive_mask(batch_size, seq_length, &tensor.device());
         let input = TransformerEncoderInput::new(tensor.clone()).mask_attn(mask_attn);
diff --git a/burn-core/src/nn/transformer/pwff.rs b/burn-core/src/nn/transformer/pwff.rs
index 1307ba8b8..e878c9be2 100644
--- a/burn-core/src/nn/transformer/pwff.rs
+++ b/burn-core/src/nn/transformer/pwff.rs
@@ -40,15 +40,21 @@ pub struct PositionWiseFeedForward<B: Backend> {
 }
 
 impl PositionWiseFeedForwardConfig {
+    /// Initialize a new [position-wise feed-forward](PositionWiseFeedForward) module
+    /// on an automatically selected device.
+    pub fn init_devauto<B: Backend>(&self) -> PositionWiseFeedForward<B> {
+        let device = B::Device::default();
+        self.init(&device)
+    }
     /// Initialize a new [position-wise feed-forward](PositionWiseFeedForward) module.
-    pub fn init<B: Backend>(&self) -> PositionWiseFeedForward<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> PositionWiseFeedForward<B> {
         PositionWiseFeedForward {
             linear_inner: LinearConfig::new(self.d_model, self.d_ff)
                 .with_initializer(self.initializer.clone())
-                .init(),
+                .init(device),
             linear_outer: LinearConfig::new(self.d_ff, self.d_model)
                 .with_initializer(self.initializer.clone())
-                .init(),
+                .init(device),
             dropout: DropoutConfig::new(self.dropout).init(),
             gelu: GELU::new(),
         }
diff --git a/burn-core/src/optim/adagrad.rs b/burn-core/src/optim/adagrad.rs
index fb3ce7ff8..f9e4d9afe 100644
--- a/burn-core/src/optim/adagrad.rs
+++ b/burn-core/src/optim/adagrad.rs
@@ -162,8 +162,9 @@ mod tests {
 
     #[test]
     fn test_adagrad_optimizer_save_load_state() {
-        let linear = nn::LinearConfig::new(6, 6).init();
-        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default);
+        let device = Default::default();
+        let linear = nn::LinearConfig::new(6, 6).init(&device);
+        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default, &device);
         let mut optimizer = create_adagrad();
         let grads = linear.forward(x).backward();
         let grads = GradientsParams::from_grads(grads, &linear);
@@ -198,12 +199,12 @@ mod tests {
             ]),
             Data::from([-0.3905, 0.0884, -0.0970, 0.1176, 0.1366, 0.0130]),
         );
-        let x_1 = Tensor::from_floats([
+        let x_1 = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ])
         .require_grad();
-        let x_2 = Tensor::from_floats([
+        let x_2 = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -257,8 +258,8 @@ mod tests {
         bias: Data<f32, 1>,
     ) -> nn::Linear<TestAutodiffBackend> {
         let record = nn::LinearRecord {
-            weight: Param::from(Tensor::from_data(weight)),
-            bias: Some(Param::from(Tensor::from_data(bias))),
+            weight: Param::from(Tensor::from_data_devauto(weight)),
+            bias: Some(Param::from(Tensor::from_data_devauto(bias))),
         };
 
         nn::LinearConfig::new(6, 6).init_with(record)
diff --git a/burn-core/src/optim/adam.rs b/burn-core/src/optim/adam.rs
index 92b34b69c..120658d46 100644
--- a/burn-core/src/optim/adam.rs
+++ b/burn-core/src/optim/adam.rs
@@ -195,8 +195,9 @@ mod tests {
 
     #[test]
     fn test_adam_optimizer_save_load_state() {
-        let linear = nn::LinearConfig::new(6, 6).init();
-        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default);
+        let device = Default::default();
+        let linear = nn::LinearConfig::new(6, 6).init(&device);
+        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default, &device);
         let mut optimizer = create_adam();
         let grads = linear.forward(x).backward();
         let grads = GradientsParams::from_grads(grads, &linear);
@@ -231,12 +232,12 @@ mod tests {
             ]),
             Data::from([-0.3905, 0.0884, -0.0970, 0.1176, 0.1366, 0.0130]),
         );
-        let x_1 = Tensor::from_floats([
+        let x_1 = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ])
         .require_grad();
-        let x_2 = Tensor::from_floats([
+        let x_2 = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -301,7 +302,7 @@ mod tests {
             Data::from([-0.3905, 0.0884, -0.0970, 0.1176, 0.1366, 0.0130]),
         );
 
-        let x = Tensor::from_floats([
+        let x = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -331,8 +332,8 @@ mod tests {
         bias: Data<f32, 1>,
     ) -> nn::Linear<TestAutodiffBackend> {
         let record = nn::LinearRecord {
-            weight: Param::from(Tensor::from_data(weight)),
-            bias: Some(Param::from(Tensor::from_data(bias))),
+            weight: Param::from(Tensor::from_data_devauto(weight)),
+            bias: Some(Param::from(Tensor::from_data_devauto(bias))),
         };
 
         nn::LinearConfig::new(6, 6).init_with(record)
diff --git a/burn-core/src/optim/adamw.rs b/burn-core/src/optim/adamw.rs
index befbeb88c..0a02ab165 100644
--- a/burn-core/src/optim/adamw.rs
+++ b/burn-core/src/optim/adamw.rs
@@ -208,8 +208,9 @@ mod tests {
 
     #[test]
     fn test_adamw_optimizer_save_load_state() {
-        let linear = nn::LinearConfig::new(6, 6).init();
-        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default);
+        let device = Default::default();
+        let linear = nn::LinearConfig::new(6, 6).init(&device);
+        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default, &device);
         let mut optimizer = create_adamw();
         let grads = linear.forward(x).backward();
         let grads = GradientsParams::from_grads(grads, &linear);
@@ -243,12 +244,12 @@ mod tests {
             ]),
             Data::from([-0.3905, 0.0884, -0.0970, 0.1176, 0.1366, 0.0130]),
         );
-        let x_1 = Tensor::from_floats([
+        let x_1 = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ])
         .require_grad();
-        let x_2 = Tensor::from_floats([
+        let x_2 = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -313,7 +314,7 @@ mod tests {
             Data::from([-0.3905, 0.0884, -0.0970, 0.1176, 0.1366, 0.0130]),
         );
 
-        let x = Tensor::from_floats([
+        let x = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -343,8 +344,8 @@ mod tests {
         bias: Data<f32, 1>,
     ) -> nn::Linear<TestAutodiffBackend> {
         let record = nn::LinearRecord {
-            weight: Param::from(Tensor::from_data(weight)),
-            bias: Some(Param::from(Tensor::from_data(bias))),
+            weight: Param::from(Tensor::from_data_devauto(weight)),
+            bias: Some(Param::from(Tensor::from_data_devauto(bias))),
         };
 
         nn::LinearConfig::new(6, 6).init_with(record)
diff --git a/burn-core/src/optim/grad_accum.rs b/burn-core/src/optim/grad_accum.rs
index e6d059e2e..92a4cf779 100644
--- a/burn-core/src/optim/grad_accum.rs
+++ b/burn-core/src/optim/grad_accum.rs
@@ -81,13 +81,14 @@ mod tests {
         nn::{Linear, LinearConfig},
         TestAutodiffBackend,
     };
-    use burn_tensor::Distribution;
+    use burn_tensor::{backend::Backend, Distribution};
 
     #[test]
     fn test_accumulate_gradients_one_step() {
+        let device = Default::default();
         let mut accumulator = GradientsAccumulator::new();
-        let layer = layer();
-        let loss = layer.forward(random_tensor());
+        let layer = layer::<TestAutodiffBackend>(&device);
+        let loss = layer.forward(random_tensor::<TestAutodiffBackend>(&device));
         let grads = GradientsParams::from_grads(loss.backward(), &layer);
 
         accumulator.accumulate(&layer, grads);
@@ -98,10 +99,11 @@ mod tests {
 
     #[test]
     fn test_accumulate_gradients_two_steps() {
+        let device = Default::default();
         let mut accumulator = GradientsAccumulator::new();
-        let layer = layer();
-        let loss_1 = layer.forward(random_tensor());
-        let loss_2 = layer.forward(random_tensor());
+        let layer = layer::<TestAutodiffBackend>(&device);
+        let loss_1 = layer.forward(random_tensor(&device));
+        let loss_2 = layer.forward(random_tensor(&device));
         let grads_1 = GradientsParams::from_grads(loss_1.backward(), &layer);
         let grads_2 = GradientsParams::from_grads(loss_2.backward(), &layer);
 
@@ -112,11 +114,11 @@ mod tests {
         assert_eq!(grads.len(), 2)
     }
 
-    fn layer() -> Linear<TestAutodiffBackend> {
-        LinearConfig::new(20, 20).with_bias(true).init()
+    fn layer<B: Backend>(device: &B::Device) -> Linear<B> {
+        LinearConfig::new(20, 20).with_bias(true).init(device)
     }
 
-    fn random_tensor() -> Tensor<TestAutodiffBackend, 2> {
-        Tensor::<TestAutodiffBackend, 2>::random([2, 20], Distribution::Default)
+    fn random_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 2> {
+        Tensor::<B, 2>::random([2, 20], Distribution::Default, device)
     }
 }
diff --git a/burn-core/src/optim/grads.rs b/burn-core/src/optim/grads.rs
index 81c3eb265..27de9daf1 100644
--- a/burn-core/src/optim/grads.rs
+++ b/burn-core/src/optim/grads.rs
@@ -99,11 +99,12 @@ mod tests {
 
     #[test]
     fn test_convert_grads() {
-        let layer_1 = layer();
+        let device = Default::default();
+        let layer_1 = layer::<TestAutodiffBackend>(&device);
         let mut layer_2 = layer_1.clone();
-        layer_2 = layer_2.fork(&<TestAutodiffBackend as Backend>::Device::default());
-        let loss_1 = layer_1.forward(random_tensor());
-        let loss_2 = layer_2.forward(random_tensor());
+        layer_2 = layer_2.fork(&device);
+        let loss_1 = layer_1.forward(random_tensor(&device));
+        let loss_2 = layer_2.forward(random_tensor(&device));
         let grads_1 = GradientsParams::from_grads(loss_1.backward(), &layer_1);
         let grads_2 = GradientsParams::from_grads(loss_2.backward(), &layer_2);
 
@@ -115,11 +116,11 @@ mod tests {
         assert_eq!(grads_2.len(), param_ids_2.len());
     }
 
-    fn layer() -> Linear<TestAutodiffBackend> {
-        LinearConfig::new(20, 20).with_bias(true).init()
+    fn layer<B: Backend>(device: &B::Device) -> Linear<B> {
+        LinearConfig::new(20, 20).with_bias(true).init(device)
     }
 
-    fn random_tensor() -> Tensor<TestAutodiffBackend, 2> {
-        Tensor::<TestAutodiffBackend, 2>::random([2, 20], Distribution::Default)
+    fn random_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 2> {
+        Tensor::<B, 2>::random([2, 20], Distribution::Default, device)
     }
 }
diff --git a/burn-core/src/optim/rmsprop.rs b/burn-core/src/optim/rmsprop.rs
index 73f688977..a5d31ff90 100644
--- a/burn-core/src/optim/rmsprop.rs
+++ b/burn-core/src/optim/rmsprop.rs
@@ -317,7 +317,7 @@ mod tests {
     use crate::optim::{GradientsParams, Optimizer};
     use crate::record::{BinFileRecorder, FullPrecisionSettings, Recorder};
     use crate::tensor::{Data, Distribution, Tensor};
-    use crate::{nn, nn::Linear, TestAutodiffBackend, TestBackend};
+    use crate::{nn, TestAutodiffBackend, TestBackend};
     use tempfile::TempDir;
 
     const LEARNING_RATE: LearningRate = 0.01;
@@ -325,8 +325,9 @@ mod tests {
 
     #[test]
     fn test_rmsprop_optimizer_save_load_state() {
-        let linear = nn::LinearConfig::new(6, 6).init();
-        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default);
+        let device = Default::default();
+        let linear = nn::LinearConfig::new(6, 6).init(&device);
+        let x = Tensor::<TestAutodiffBackend, 2>::random([2, 6], Distribution::Default, &device);
         let mut optimizer = create_rmsprop();
         let grads = linear.forward(x).backward();
         let grads = GradientsParams::from_grads(grads, &linear);
@@ -359,12 +360,12 @@ mod tests {
             ]),
             Data::from([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]),
         );
-        let x_1 = Tensor::from_floats([
+        let x_1 = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ])
         .require_grad();
-        let x_2 = Tensor::from_floats([
+        let x_2 = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -427,12 +428,12 @@ mod tests {
             ]),
             Data::from([-0.3905, 0.0884, -0.0970, 0.1176, 0.1366, 0.0130]),
         );
-        let x_1 = Tensor::from_floats([
+        let x_1 = Tensor::from_floats_devauto([
             [0.6294, 0.0940, 0.8176, 0.8824, 0.5228, 0.4310],
             [0.7152, 0.9559, 0.7893, 0.5684, 0.5939, 0.8883],
         ])
         .require_grad();
-        let x_2 = Tensor::from_floats([
+        let x_2 = Tensor::from_floats_devauto([
             [0.8491, 0.2108, 0.8939, 0.4433, 0.5527, 0.2528],
             [0.3270, 0.0412, 0.5538, 0.9605, 0.3195, 0.9085],
         ])
@@ -496,8 +497,8 @@ mod tests {
         bias: Data<f32, 1>,
     ) -> nn::Linear<TestAutodiffBackend> {
         let record = nn::LinearRecord {
-            weight: Param::from(Tensor::from_data(weight)),
-            bias: Some(Param::from(Tensor::from_data(bias))),
+            weight: Param::from(Tensor::from_data_devauto(weight)),
+            bias: Some(Param::from(Tensor::from_data_devauto(bias))),
         };
 
         nn::LinearConfig::new(6, 6).init_with(record)
@@ -505,11 +506,11 @@ mod tests {
 
     #[allow(dead_code)]
     fn create_random_tensor() -> Tensor<TestAutodiffBackend, 2> {
-        Tensor::<TestAutodiffBackend, 2>::random(Shape::new([2, 20]), Distribution::Default)
+        Tensor::<TestAutodiffBackend, 2>::random_devauto(Shape::new([2, 20]), Distribution::Default)
     }
 
     fn create_rmsprop(
-    ) -> OptimizerAdaptor<RMSProp<TestBackend>, Linear<TestAutodiffBackend>, TestAutodiffBackend>
+    ) -> OptimizerAdaptor<RMSProp<TestBackend>, nn::Linear<TestAutodiffBackend>, TestAutodiffBackend>
     {
         RMSPropConfig {
             alpha: 0.99,
diff --git a/burn-core/src/optim/sgd.rs b/burn-core/src/optim/sgd.rs
index b2ed4a4b7..01d37b79e 100644
--- a/burn-core/src/optim/sgd.rs
+++ b/burn-core/src/optim/sgd.rs
@@ -108,9 +108,10 @@ mod tests {
 
     #[test]
     fn with_updated_params_should_have_state() {
-        let layer = layer();
+        let device = Default::default();
+        let layer = layer::<TestAutodiffBackend>(&device);
         let mut optim = sgd_with_all();
-        let loss = layer.forward(random_tensor());
+        let loss = layer.forward(random_tensor::<TestAutodiffBackend>(&device));
         let grads = loss.backward();
         let grads = GradientsParams::from_grads(grads, &layer);
         let _layer = optim.step(LEARNING_RATE, layer, grads);
@@ -135,9 +136,10 @@ mod tests {
 
     #[test]
     fn should_load_state() {
-        let layer = layer();
+        let device = Default::default();
+        let layer = layer::<TestAutodiffBackend>(&device);
         let mut optim = sgd_with_all();
-        let loss = layer.forward(random_tensor());
+        let loss = layer.forward(random_tensor(&device));
         let grads = loss.backward();
         let grads = GradientsParams::from_grads(grads, &layer);
         let _layer = optim.step(LEARNING_RATE, layer, grads);
@@ -152,12 +154,12 @@ mod tests {
         assert_eq!(record.len(), state_restored.len());
     }
 
-    fn random_tensor() -> Tensor<TestAutodiffBackend, 2> {
-        Tensor::<TestAutodiffBackend, 2>::random(Shape::new([2, 20]), Distribution::Default)
+    fn random_tensor<B: Backend>(device: &B::Device) -> Tensor<B, 2> {
+        Tensor::<B, 2>::random(Shape::new([2, 20]), Distribution::Default, device)
     }
 
-    fn layer() -> Linear<TestAutodiffBackend> {
-        LinearConfig::new(20, 20).with_bias(true).init()
+    fn layer<B: Backend>(device: &B::Device) -> Linear<B> {
+        LinearConfig::new(20, 20).with_bias(true).init(device)
     }
 
     fn sgd_with_all(
diff --git a/burn-core/src/record/file.rs b/burn-core/src/record/file.rs
index b61015b6c..de650448b 100644
--- a/burn-core/src/record/file.rs
+++ b/burn-core/src/record/file.rs
@@ -347,12 +347,13 @@ mod tests {
     }
 
     fn test_can_save_and_load<Recorder: FileRecorder>(recorder: Recorder) {
-        let model_before = create_model();
+        let device = Default::default();
+        let model_before = create_model(&device);
         recorder
             .record(model_before.clone().into_record(), file_path())
             .unwrap();
 
-        let model_after = create_model().load_record(recorder.load(file_path()).unwrap());
+        let model_after = create_model(&device).load_record(recorder.load(file_path()).unwrap());
 
         let byte_recorder = BinBytesRecorder::<FullPrecisionSettings>::default();
         let model_bytes_before = byte_recorder
@@ -370,10 +371,10 @@ mod tests {
         phantom: core::marker::PhantomData<B>,
     }
 
-    pub fn create_model() -> Model<TestBackend> {
-        let conv2d1 = Conv2dConfig::new([1, 8], [3, 3]).init();
+    pub fn create_model(device: &<TestBackend as Backend>::Device) -> Model<TestBackend> {
+        let conv2d1 = Conv2dConfig::new([1, 8], [3, 3]).init(device);
 
-        let linear1 = LinearConfig::new(32, 32).with_bias(true).init();
+        let linear1 = LinearConfig::new(32, 32).with_bias(true).init(device);
 
         Model {
             conv2d1,
diff --git a/burn-core/src/record/memory.rs b/burn-core/src/record/memory.rs
index 545ad87e6..a3247e9f6 100644
--- a/burn-core/src/record/memory.rs
+++ b/burn-core/src/record/memory.rs
@@ -72,7 +72,9 @@ impl<S: PrecisionSettings> Recorder for NamedMpkBytesRecorder<S> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{module::Module, nn, record::FullPrecisionSettings, TestBackend};
+    use crate::{
+        module::Module, nn, record::FullPrecisionSettings, tensor::backend::Backend, TestBackend,
+    };
 
     #[test]
     fn test_can_save_and_load_bin_format() {
@@ -86,8 +88,9 @@ mod tests {
     }
 
     fn test_can_save_and_load<Recorder: BytesRecorder>(recorder: Recorder) {
-        let model1 = create_model();
-        let model2 = create_model();
+        let device = Default::default();
+        let model1 = create_model::<TestBackend>(&device);
+        let model2 = create_model::<TestBackend>(&device);
         let bytes1 = recorder.record(model1.into_record(), ()).unwrap();
         let bytes2 = recorder.record(model2.clone().into_record(), ()).unwrap();
 
@@ -98,7 +101,7 @@ mod tests {
         assert_eq!(bytes1, bytes2_after);
     }
 
-    pub fn create_model() -> nn::Linear<TestBackend> {
-        nn::LinearConfig::new(32, 32).with_bias(true).init()
+    pub fn create_model<B: Backend>(device: &B::Device) -> nn::Linear<B> {
+        nn::LinearConfig::new(32, 32).with_bias(true).init(device)
     }
 }
diff --git a/burn-core/src/record/tensor.rs b/burn-core/src/record/tensor.rs
index 70badf216..217e682ab 100644
--- a/burn-core/src/record/tensor.rs
+++ b/burn-core/src/record/tensor.rs
@@ -97,7 +97,7 @@ impl<B: Backend, const D: usize> Record for Tensor<B, D> {
     }
 
     fn from_item<S: PrecisionSettings>(item: Self::Item<S>) -> Self {
-        Tensor::from_data(item.data.convert::<B::FloatElem>())
+        Tensor::from_data_devauto(item.data.convert::<B::FloatElem>())
     }
 }
 
@@ -113,7 +113,7 @@ impl<B: Backend, const D: usize> Record for Tensor<B, D, Int> {
     }
 
     fn from_item<S: PrecisionSettings>(item: Self::Item<S>) -> Self {
-        Tensor::from_data(item.data.convert())
+        Tensor::from_data_devauto(item.data.convert())
     }
 }
 
@@ -129,6 +129,6 @@ impl<B: Backend, const D: usize> Record for Tensor<B, D, Bool> {
     }
 
     fn from_item<S: PrecisionSettings>(item: Self::Item<S>) -> Self {
-        Tensor::from_data(item.data)
+        Tensor::from_data_devauto(item.data)
     }
 }
diff --git a/burn-core/tests/derive_module.rs b/burn-core/tests/derive_module.rs
index 6303077af..daa05da5f 100644
--- a/burn-core/tests/derive_module.rs
+++ b/burn-core/tests/derive_module.rs
@@ -18,8 +18,8 @@ struct ModuleTensorConstInt<B: Backend> {
 }
 
 impl<B: Backend> ModuleBasic<B> {
-    fn new() -> Self {
-        let weight_basic = Tensor::random(Shape::new([20, 20]), Distribution::Default);
+    fn new(device: &B::Device) -> Self {
+        let weight_basic = Tensor::random(Shape::new([20, 20]), Distribution::Default, device);
         Self {
             weight_basic: Param::from(weight_basic),
         }
@@ -33,11 +33,11 @@ pub struct ModuleComposed<B: Backend> {
 }
 
 impl<B: Backend> ModuleComposed<B> {
-    fn new() -> Self {
-        let weight = Tensor::random(Shape::new([20, 20]), Distribution::Default);
+    fn new(device: &B::Device) -> Self {
+        let weight = Tensor::random(Shape::new([20, 20]), Distribution::Default, device);
         Self {
             weight: Param::from(weight),
-            basic: ModuleBasic::new(),
+            basic: ModuleBasic::new(device),
         }
     }
 }
@@ -47,8 +47,9 @@ mod state {
 
     #[test]
     fn should_load_from_record_basic() {
-        let module_1 = ModuleBasic::<TestBackend>::new();
-        let mut module_2 = ModuleBasic::<TestBackend>::new();
+        let device = <TestBackend as Backend>::Device::default();
+        let module_1 = ModuleBasic::<TestBackend>::new(&device);
+        let mut module_2 = ModuleBasic::<TestBackend>::new(&device);
         let state_1 = module_1.clone().into_record();
 
         assert_ne!(
@@ -66,8 +67,9 @@ mod state {
 
     #[test]
     fn should_load_from_record_compose() {
-        let module_1 = ModuleComposed::<TestBackend>::new();
-        let mut module_2 = ModuleComposed::<TestBackend>::new();
+        let device = <TestBackend as Backend>::Device::default();
+        let module_1 = ModuleComposed::<TestBackend>::new(&device);
+        let mut module_2 = ModuleComposed::<TestBackend>::new(&device);
         assert_ne!(module_1.weight.to_data(), module_2.weight.to_data());
         assert_ne!(
             module_1.basic.weight_basic.to_data(),
@@ -90,13 +92,15 @@ mod num_params {
 
     #[test]
     fn should_calculate_num_params_basic() {
-        let module = ModuleBasic::<TestBackend>::new();
+        let device = <TestBackend as Backend>::Device::default();
+        let module = ModuleBasic::<TestBackend>::new(&device);
         assert_eq!(20 * 20, module.num_params());
     }
 
     #[test]
     fn should_output_state_composed() {
-        let module = ModuleComposed::<TestBackend>::new();
+        let device = <TestBackend as Backend>::Device::default();
+        let module = ModuleComposed::<TestBackend>::new(&device);
         assert_eq!(2 * 20 * 20, module.num_params());
     }
 }
@@ -109,7 +113,8 @@ mod require_grad {
 
     #[test]
     fn should_have_grad_by_default() {
-        let module = ModuleBasic::<TestAutodiffBackend>::new();
+        let device = <TestBackend as Backend>::Device::default();
+        let module = ModuleBasic::<TestAutodiffBackend>::new(&device);
         let mut grads = calculate_grads(&module);
 
         let grad_x = module.weight_basic.grad_remove(&mut grads);
@@ -119,7 +124,8 @@ mod require_grad {
 
     #[test]
     fn should_have_no_grad_after_no_grad() {
-        let module = ModuleBasic::<TestAutodiffBackend>::new().no_grad();
+        let device = <TestAutodiffBackend as Backend>::Device::default();
+        let module = ModuleBasic::<TestAutodiffBackend>::new(&device).no_grad();
         let mut grads = calculate_grads(&module);
 
         let grad_x = module.weight_basic.grad_remove(&mut grads);
@@ -129,7 +135,8 @@ mod require_grad {
 
     #[test]
     fn should_have_grad_when_from_record() {
-        let module = ModuleBasic::<TestAutodiffBackend>::new();
+        let device = <TestAutodiffBackend as Backend>::Device::default();
+        let module = ModuleBasic::<TestAutodiffBackend>::new(&device);
         let record = ModuleBasicRecord {
             weight_basic: module.weight_basic.clone(), // Even when param is no_grad,
         };
@@ -144,7 +151,7 @@ mod require_grad {
     fn calculate_grads(
         module: &ModuleBasic<TestAutodiffBackend>,
     ) -> <TestAutodiffBackend as AutodiffBackend>::Gradients {
-        let x = Tensor::ones([20, 20]).require_grad();
+        let x = Tensor::ones_devauto([20, 20]).require_grad();
         let y = module.weight_basic.val().matmul(x);
 
         y.backward()
diff --git a/burn-core/tests/record_resilience.rs b/burn-core/tests/record_resilience.rs
index 27798197d..392af7967 100644
--- a/burn-core/tests/record_resilience.rs
+++ b/burn-core/tests/record_resilience.rs
@@ -184,12 +184,13 @@ mod tests {
     where
         R: FileRecorder,
     {
+        let device = Default::default();
         let file_path: PathBuf = file_path(format!("deserialize_with_new_optional_field-{name}"));
         let model = Model {
             single_const: 32.0,
-            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
             array_const: [2, 2],
-            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
         };
 
         recorder
@@ -209,13 +210,14 @@ mod tests {
     where
         R: FileRecorder,
     {
+        let device = Default::default();
         let file_path: PathBuf =
             file_path(format!("deserialize_with_removed_optional_field-{name}"));
         let model = ModelNewOptionalField {
             single_const: 32.0,
-            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
             array_const: [2, 2],
-            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
             new_field: None,
         };
 
@@ -233,12 +235,13 @@ mod tests {
     where
         R: FileRecorder,
     {
+        let device = Default::default();
         let file_path: PathBuf = file_path(format!("deserialize_with_new_constant_field-{name}"));
         let model = Model {
             single_const: 32.0,
             array_const: [2, 2],
-            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
-            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
+            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
         };
 
         recorder
@@ -258,13 +261,14 @@ mod tests {
     where
         R: FileRecorder,
     {
+        let device = Default::default();
         let file_path: PathBuf =
             file_path(format!("deserialize_with_removed_constant_field-{name}"));
         let model = ModelNewConstantField {
             single_const: 32.0,
             array_const: [2, 2],
-            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
-            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
+            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
             new_field: 0,
         };
 
@@ -282,12 +286,13 @@ mod tests {
     where
         R: FileRecorder,
     {
+        let device = Default::default();
         let file_path: PathBuf = file_path(format!("deserialize_with_new_field_order-{name}"));
         let model = Model {
             array_const: [2, 2],
             single_const: 32.0,
-            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
-            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(),
+            linear1: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
+            linear2: nn::LinearConfig::new(20, 20).init::<TestBackend>(&device),
         };
 
         recorder
diff --git a/burn-import/onnx-tests/tests/onnx_tests.rs b/burn-import/onnx-tests/tests/onnx_tests.rs
index c8a0b4f4c..be0c842af 100644
--- a/burn-import/onnx-tests/tests/onnx_tests.rs
+++ b/burn-import/onnx-tests/tests/onnx_tests.rs
@@ -70,7 +70,7 @@ mod tests {
         let model: add::Model<Backend> = add::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats_devauto([[[[1., 2., 3., 4.]]]]);
         let scalar = 2f64;
         let output = model.forward(input, scalar);
         let expected = Data::from([[[[9., 10., 11., 12.]]]]);
@@ -84,7 +84,7 @@ mod tests {
         let model: add_int::Model<Backend> = add_int::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 4, Int>::from_ints([[[[1, 2, 3, 4]]]]);
+        let input = Tensor::<Backend, 4, Int>::from_ints_devauto([[[[1, 2, 3, 4]]]]);
         let scalar = 2;
         let output = model.forward(input, scalar);
         let expected = Data::from([[[[9, 11, 13, 15]]]]);
@@ -98,7 +98,7 @@ mod tests {
         let model: sub::Model<Backend> = sub::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats_devauto([[[[1., 2., 3., 4.]]]]);
         let scalar = 3.0f64;
         let output = model.forward(input, scalar);
         let expected = Data::from([[[[6., 7., 8., 9.]]]]);
@@ -112,7 +112,7 @@ mod tests {
         let model: sub_int::Model<Backend> = sub_int::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 4, Int>::from_ints([[[[1, 2, 3, 4]]]]);
+        let input = Tensor::<Backend, 4, Int>::from_ints_devauto([[[[1, 2, 3, 4]]]]);
         let scalar = 3;
         let output = model.forward(input, scalar);
         let expected = Data::from([[[[6, 6, 6, 6]]]]);
@@ -125,7 +125,7 @@ mod tests {
         let model: mul::Model<Backend> = mul::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats_devauto([[[[1., 2., 3., 4.]]]]);
         let scalar = 6.0f64;
         let output = model.forward(input, scalar);
         let expected = Data::from([[[[126., 252., 378., 504.]]]]);
@@ -136,10 +136,11 @@ mod tests {
     #[test]
     fn div_tensor_by_scalar_and_tensor_by_tensor() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: div::Model<Backend> = div::Model::new();
+        let device = Default::default();
+        let model: div::Model<Backend> = div::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[3., 6., 6., 9.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[3., 6., 6., 9.]]]], &device);
         let scalar1 = 9.0f64;
         let scalar2 = 3.0f64;
         let output = model.forward(input, scalar1, scalar2);
@@ -151,10 +152,11 @@ mod tests {
     #[test]
     fn concat_tensors() {
         // Initialize the model
-        let model: concat::Model<Backend> = concat::Model::new();
+        let device = Default::default();
+        let model: concat::Model<Backend> = concat::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 4>::zeros([1, 2, 3, 5]);
+        let input = Tensor::<Backend, 4>::zeros([1, 2, 3, 5], &device);
 
         let output = model.forward(input);
 
@@ -169,7 +171,7 @@ mod tests {
         let model: conv1d::Model<Backend> = conv1d::Model::default();
 
         // Run the model with pi as input for easier testing
-        let input = Tensor::<Backend, 3>::full([6, 4, 10], consts::PI);
+        let input = Tensor::<Backend, 3>::full_devauto([6, 4, 10], consts::PI);
 
         let output = model.forward(input);
 
@@ -190,7 +192,7 @@ mod tests {
         let model: conv2d::Model<Backend> = conv2d::Model::default();
 
         // Run the model with ones as input for easier testing
-        let input = Tensor::<Backend, 4>::ones([2, 4, 10, 15]);
+        let input = Tensor::<Backend, 4>::ones_devauto([2, 4, 10, 15]);
 
         let output = model.forward(input);
 
@@ -211,7 +213,7 @@ mod tests {
         let model: dropout_opset16::Model<Backend> = dropout_opset16::Model::default();
 
         // Run the model with ones as input for easier testing
-        let input = Tensor::<Backend, 4>::ones([2, 4, 10, 15]);
+        let input = Tensor::<Backend, 4>::ones_devauto([2, 4, 10, 15]);
 
         let output = model.forward(input);
 
@@ -230,7 +232,7 @@ mod tests {
         let model: dropout_opset7::Model<Backend> = dropout_opset7::Model::default();
 
         // Run the model with ones as input for easier testing
-        let input = Tensor::<Backend, 4>::ones([2, 4, 10, 15]);
+        let input = Tensor::<Backend, 4>::ones_devauto([2, 4, 10, 15]);
 
         let output = model.forward(input);
 
@@ -248,9 +250,10 @@ mod tests {
     fn erf() {
         let model: erf::Model<Backend> = erf::Model::default();
 
-        let input = Tensor::<Backend, 4>::from_data([[[[1.0, 2.0, 3.0, 4.0]]]]);
+        let input = Tensor::<Backend, 4>::from_data_devauto([[[[1.0, 2.0, 3.0, 4.0]]]]);
         let output = model.forward(input);
-        let expected = Tensor::<Backend, 4>::from_data([[[[0.8427, 0.9953, 1.0000, 1.0000]]]]);
+        let expected =
+            Tensor::<Backend, 4>::from_data_devauto([[[[0.8427, 0.9953, 1.0000, 1.0000]]]]);
 
         output.to_data().assert_approx_eq(&expected.to_data(), 4);
     }
@@ -261,8 +264,8 @@ mod tests {
         let model: gather::Model<Backend> = gather::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 2>::from_floats([[1., 2.], [3., 4.]]);
-        let index = Tensor::<Backend, 2, Int>::from_ints([[0, 0], [1, 0]]);
+        let input = Tensor::<Backend, 2>::from_floats_devauto([[1., 2.], [3., 4.]]);
+        let index = Tensor::<Backend, 2, Int>::from_ints_devauto([[0, 0], [1, 0]]);
         let output = model.forward(input, index);
         let expected = Data::from([[1., 1.], [4., 3.]]);
 
@@ -275,8 +278,8 @@ mod tests {
         let model: global_avr_pool::Model<Backend> = global_avr_pool::Model::default();
 
         // Run the model with ones as input for easier testing
-        let input_1d = Tensor::<Backend, 3>::ones([2, 4, 10]);
-        let input_2d = Tensor::<Backend, 4>::ones([3, 10, 3, 15]);
+        let input_1d = Tensor::<Backend, 3>::ones_devauto([2, 4, 10]);
+        let input_2d = Tensor::<Backend, 4>::ones_devauto([3, 10, 3, 15]);
 
         let (output_1d, output_2d) = model.forward(input_1d, input_2d);
 
@@ -298,13 +301,17 @@ mod tests {
     #[test]
     fn softmax() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: softmax::Model<Backend> = softmax::Model::new();
+        let device = Default::default();
+        let model: softmax::Model<Backend> = softmax::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 2>::from_floats([
-            [0.33669037, 0.128_809_4, 0.23446237],
-            [0.23033303, -1.122_856_4, -0.18632829],
-        ]);
+        let input = Tensor::<Backend, 2>::from_floats(
+            [
+                [0.33669037, 0.128_809_4, 0.23446237],
+                [0.23033303, -1.122_856_4, -0.18632829],
+            ],
+            &device,
+        );
         let output = model.forward(input);
         let expected = Data::from([
             [0.36830685, 0.29917702, 0.33251613],
@@ -317,13 +324,17 @@ mod tests {
     #[test]
     fn log_softmax() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: log_softmax::Model<Backend> = log_softmax::Model::new();
+        let device = Default::default();
+        let model: log_softmax::Model<Backend> = log_softmax::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 2>::from_floats([
-            [0.33669037, 0.128_809_4, 0.23446237],
-            [0.23033303, -1.122_856_4, -0.18632829],
-        ]);
+        let input = Tensor::<Backend, 2>::from_floats(
+            [
+                [0.33669037, 0.128_809_4, 0.23446237],
+                [0.23033303, -1.122_856_4, -0.18632829],
+            ],
+            &device,
+        );
         let output = model.forward(input);
         let expected = Data::from([
             [-0.998_838_9, -1.206_719_9, -1.101_067],
@@ -335,9 +346,10 @@ mod tests {
 
     #[test]
     fn sqrt() {
-        let model: sqrt::Model<Backend> = sqrt::Model::new();
+        let device = Default::default();
+        let model: sqrt::Model<Backend> = sqrt::Model::new(&device);
 
-        let input1 = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]]);
+        let input1 = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]], &device);
         let input2 = 36f64;
 
         let (output1, output2) = model.forward(input1, input2);
@@ -351,16 +363,20 @@ mod tests {
     #[test]
     fn maxpool2d() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: maxpool2d::Model<Backend> = maxpool2d::Model::new();
+        let device = Default::default();
+        let model: maxpool2d::Model<Backend> = maxpool2d::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[
-            [1.927, 1.487, 0.901, -2.106, 0.678],
-            [-1.235, -0.043, -1.605, -0.752, -0.687],
-            [-0.493, 0.241, -1.111, 0.092, -2.317],
-            [-0.217, -1.385, -0.396, 0.803, -0.622],
-            [-0.592, -0.063, -0.829, 0.331, -1.558],
-        ]]]);
+        let input = Tensor::<Backend, 4>::from_floats(
+            [[[
+                [1.927, 1.487, 0.901, -2.106, 0.678],
+                [-1.235, -0.043, -1.605, -0.752, -0.687],
+                [-0.493, 0.241, -1.111, 0.092, -2.317],
+                [-0.217, -1.385, -0.396, 0.803, -0.622],
+                [-0.592, -0.063, -0.829, 0.331, -1.558],
+            ]]],
+            &device,
+        );
         let output = model.forward(input);
         let expected = Data::from([[[
             [0.901, 1.927, 1.487, 0.901],
@@ -374,16 +390,20 @@ mod tests {
     #[test]
     fn avg_pool2d() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: avg_pool2d::Model<Backend> = avg_pool2d::Model::new();
+        let device = Default::default();
+        let model: avg_pool2d::Model<Backend> = avg_pool2d::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[
-            [-0.077, 0.360, -0.782, 0.072, 0.665],
-            [-0.287, 1.621, -1.597, -0.052, 0.611],
-            [0.760, -0.034, -0.345, 0.494, -0.078],
-            [-1.805, -0.476, 0.205, 0.338, 1.353],
-            [0.374, 0.013, 0.774, -0.109, -0.271],
-        ]]]);
+        let input = Tensor::<Backend, 4>::from_floats(
+            [[[
+                [-0.077, 0.360, -0.782, 0.072, 0.665],
+                [-0.287, 1.621, -1.597, -0.052, 0.611],
+                [0.760, -0.034, -0.345, 0.494, -0.078],
+                [-1.805, -0.476, 0.205, 0.338, 1.353],
+                [0.374, 0.013, 0.774, -0.109, -0.271],
+            ]]],
+            &device,
+        );
         let (output1, output2, output3) = model.forward(input.clone(), input.clone(), input);
         let expected1 = Data::from([[[[0.008, -0.131, -0.208, 0.425]]]]);
         let expected2 = Data::from([[[
@@ -413,10 +433,11 @@ mod tests {
     #[test]
     fn reshape() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: reshape::Model<Backend> = reshape::Model::new();
+        let device = Default::default();
+        let model: reshape::Model<Backend> = reshape::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 1>::from_floats([0., 1., 2., 3.]);
+        let input = Tensor::<Backend, 1>::from_floats([0., 1., 2., 3.], &device);
         let output = model.forward(input);
         let expected = Data::from([[0., 1., 2., 3.]]);
 
@@ -426,10 +447,11 @@ mod tests {
     #[test]
     fn flatten() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: flatten::Model<Backend> = flatten::Model::new();
+        let device = Default::default();
+        let model: flatten::Model<Backend> = flatten::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 3>::ones([1, 5, 15]);
+        let input = Tensor::<Backend, 3>::ones([1, 5, 15], &device);
         let output = model.forward(input);
 
         let expected_shape = Shape::from([1, 75]);
@@ -441,7 +463,7 @@ mod tests {
         let model: batch_norm::Model<Backend> = batch_norm::Model::default();
 
         // Run the model with ones as input for easier testing
-        let input = Tensor::<Backend, 3>::ones([1, 20, 1]);
+        let input = Tensor::<Backend, 3>::ones_devauto([1, 20, 1]);
         let output = model.forward(input);
 
         let expected_shape = Shape::from([1, 5, 2, 2]);
@@ -455,13 +477,17 @@ mod tests {
     #[test]
     fn relu() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: relu::Model<Backend> = relu::Model::new();
+        let device = Default::default();
+        let model: relu::Model<Backend> = relu::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 2>::from_floats([
-            [0.33669037, 0.128_809_4, 0.23446237],
-            [0.23033303, -1.122_856_4, -0.18632829],
-        ]);
+        let input = Tensor::<Backend, 2>::from_floats(
+            [
+                [0.33669037, 0.128_809_4, 0.23446237],
+                [0.23033303, -1.122_856_4, -0.18632829],
+            ],
+            &device,
+        );
         let output = model.forward(input);
         let expected = Data::from([
             [0.33669037, 0.128_809_4, 0.23446237],
@@ -474,13 +500,17 @@ mod tests {
     #[test]
     fn sigmoid() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: sigmoid::Model<Backend> = sigmoid::Model::new();
+        let device = Default::default();
+        let model: sigmoid::Model<Backend> = sigmoid::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 2>::from_floats([
-            [0.33669037, 0.128_809_4, 0.23446237],
-            [0.23033303, -1.122_856_4, -0.18632829],
-        ]);
+        let input = Tensor::<Backend, 2>::from_floats(
+            [
+                [0.33669037, 0.128_809_4, 0.23446237],
+                [0.23033303, -1.122_856_4, -0.18632829],
+            ],
+            &device,
+        );
         let output = model.forward(input);
         let expected = Data::from([
             [0.58338636, 0.532_157_9, 0.55834854],
@@ -493,13 +523,17 @@ mod tests {
     #[test]
     fn transpose() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: transpose::Model<Backend> = transpose::Model::new();
+        let device = Default::default();
+        let model: transpose::Model<Backend> = transpose::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 2>::from_floats([
-            [0.33669037, 0.128_809_4, 0.23446237],
-            [0.23033303, -1.122_856_4, -0.18632829],
-        ]);
+        let input = Tensor::<Backend, 2>::from_floats(
+            [
+                [0.33669037, 0.128_809_4, 0.23446237],
+                [0.23033303, -1.122_856_4, -0.18632829],
+            ],
+            &device,
+        );
         let output = model.forward(input);
         let expected = Data::from([
             [0.33669037, 0.23033303],
@@ -516,7 +550,7 @@ mod tests {
         let model: equal::Model<Backend> = equal::Model::default();
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[1., 1., 1., 1.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats_devauto([[[[1., 1., 1., 1.]]]]);
 
         let scalar = 2f64;
         let (tensor_out, scalar_out) = model.forward(input, scalar);
@@ -530,17 +564,21 @@ mod tests {
     #[test]
     fn clip_opset16() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: clip_opset16::Model<Backend> = clip_opset16::Model::new();
+        let device = Default::default();
+        let model: clip_opset16::Model<Backend> = clip_opset16::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 1>::from_floats([
-            0.88226926,
-            0.91500396,
-            0.38286376,
-            0.95930564,
-            0.390_448_2,
-            0.60089535,
-        ]);
+        let input = Tensor::<Backend, 1>::from_floats(
+            [
+                0.88226926,
+                0.91500396,
+                0.38286376,
+                0.95930564,
+                0.390_448_2,
+                0.60089535,
+            ],
+            &device,
+        );
         let (output1, output2, output3) = model.forward(input);
         let expected1 = Data::from([
             0.88226926,
@@ -561,17 +599,21 @@ mod tests {
     #[test]
     fn clip_opset7() {
         // Initialize the model without weights (because the exported file does not contain them)
-        let model: clip_opset7::Model<Backend> = clip_opset7::Model::new();
+        let device = Default::default();
+        let model: clip_opset7::Model<Backend> = clip_opset7::Model::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 1>::from_floats([
-            0.88226926,
-            0.91500396,
-            0.38286376,
-            0.95930564,
-            0.390_448_2,
-            0.60089535,
-        ]);
+        let input = Tensor::<Backend, 1>::from_floats(
+            [
+                0.88226926,
+                0.91500396,
+                0.38286376,
+                0.95930564,
+                0.390_448_2,
+                0.60089535,
+            ],
+            &device,
+        );
         let (output1, output2, output3) = model.forward(input);
         let expected1 = Data::from([
             0.88226926,
@@ -594,11 +636,11 @@ mod tests {
         // Initialize the model with weights (loaded from the exported file)
         let model: linear::Model<Backend> = linear::Model::default();
         #[allow(clippy::approx_constant)]
-        let input1 = Tensor::<Backend, 2>::full([4, 3], 3.14);
+        let input1 = Tensor::<Backend, 2>::full_devauto([4, 3], 3.14);
         #[allow(clippy::approx_constant)]
-        let input2 = Tensor::<Backend, 2>::full([2, 5], 3.14);
+        let input2 = Tensor::<Backend, 2>::full_devauto([2, 5], 3.14);
         #[allow(clippy::approx_constant)]
-        let input3 = Tensor::<Backend, 3>::full([3, 2, 7], 3.14);
+        let input3 = Tensor::<Backend, 3>::full_devauto([3, 2, 7], 3.14);
 
         let (output1, output2, output3) = model.forward(input1, input2, input3);
 
@@ -628,10 +670,11 @@ mod tests {
     #[test]
     fn tanh() {
         // Initialize the model
-        let model = tanh::Model::<Backend>::new();
+        let device = Default::default();
+        let model = tanh::Model::<Backend>::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]], &device);
         let output = model.forward(input);
         // data from pyTorch
         let expected = Data::from([[[[0.7616, 0.9640, 0.9951, 0.9993]]]]);
@@ -641,10 +684,11 @@ mod tests {
     #[test]
     fn recip() {
         // Initialize the model
-        let model = recip::Model::<Backend>::new();
+        let device = Default::default();
+        let model = recip::Model::<Backend>::new(&device);
 
         // Run the model
-        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[1., 2., 3., 4.]]]], &device);
         let output = model.forward(input);
         // data from pyTorch
         let expected = Data::from([[[[1.0000, 0.5000, 0.3333, 0.2500]]]]);
@@ -657,7 +701,7 @@ mod tests {
         let model: conv_transpose2d::Model<Backend> = conv_transpose2d::Model::default();
 
         // Run the model with ones as input for easier testing
-        let input = Tensor::<Backend, 4>::ones([2, 4, 10, 15]);
+        let input = Tensor::<Backend, 4>::ones_devauto([2, 4, 10, 15]);
 
         let output = model.forward(input);
 
@@ -675,9 +719,10 @@ mod tests {
 
     #[test]
     fn cos() {
-        let model: cos::Model<Backend> = cos::Model::new();
+        let device = Default::default();
+        let model: cos::Model<Backend> = cos::Model::new(&device);
 
-        let input = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]], &device);
 
         let output = model.forward(input);
         let expected = Data::from([[[[0.5403, -0.6536, -0.9111, 0.9912]]]]);
@@ -688,9 +733,10 @@ mod tests {
     #[test]
     #[allow(clippy::approx_constant)]
     fn exp() {
-        let model: exp::Model<Backend> = exp::Model::new();
+        let device = Default::default();
+        let model: exp::Model<Backend> = exp::Model::new(&device);
 
-        let input = Tensor::<Backend, 4>::from_floats([[[[0.0000, 0.6931]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[0.0000, 0.6931]]]], &device);
 
         let output = model.forward(input);
         let expected = Data::from([[[[1., 2.]]]]);
@@ -700,9 +746,10 @@ mod tests {
 
     #[test]
     fn gelu() {
-        let model: gelu::Model<Backend> = gelu::Model::new();
+        let device = Default::default();
+        let model: gelu::Model<Backend> = gelu::Model::new(&device);
 
-        let input = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]], &device);
 
         let output = model.forward(input);
         let expected = Data::from([[[[0.8413, 3.9999, 9.0000, 25.0000]]]]);
@@ -712,9 +759,10 @@ mod tests {
 
     #[test]
     fn log() {
-        let model: log::Model<Backend> = log::Model::new();
+        let device = Default::default();
+        let model: log::Model<Backend> = log::Model::new(&device);
 
-        let input = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]]);
+        let input = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]], &device);
 
         let output = model.forward(input);
         let expected = Data::from([[[[0.0000, 1.3863, 2.1972, 3.2189]]]]);
@@ -724,9 +772,26 @@ mod tests {
 
     #[test]
     fn neg() {
-        let model: neg::Model<Backend> = neg::Model::new();
+        let device = Default::default();
+        let model: neg::Model<Backend> = neg::Model::new(&device);
 
-        let input1 = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]]);
+        let input1 = Tensor::<Backend, 4>::from_floats([[[[1.0, 4.0, 9.0, 25.0]]]], &device);
+        let input2 = 99f64;
+
+        let (output1, output2) = model.forward(input1, input2);
+        let expected1 = Data::from([[[[-1.0, -4.0, -9.0, -25.0]]]]);
+        let expected2 = -99f64;
+
+        output1.to_data().assert_approx_eq(&expected1, 4);
+
+        assert_eq!(output2, expected2);
+    }
+
+    #[test]
+    fn test_model_creation_with_a_default_device() {
+        let model: neg::Model<Backend> = neg::Model::new_devauto();
+
+        let input1 = Tensor::<Backend, 4>::from_floats_devauto([[[[1.0, 4.0, 9.0, 25.0]]]]);
         let input2 = 99f64;
 
         let (output1, output2) = model.forward(input1, input2);
diff --git a/burn-import/onnx-tests/tests/record_type_tests.rs b/burn-import/onnx-tests/tests/record_type_tests.rs
index 98558b501..c4f5dd271 100644
--- a/burn-import/onnx-tests/tests/record_type_tests.rs
+++ b/burn-import/onnx-tests/tests/record_type_tests.rs
@@ -25,7 +25,7 @@ macro_rules! test_model {
             let model: $mod_name::Model<Backend> = $mod_name::Model::default();
 
             // Run the model with pi as input for easier testing
-            let input = Tensor::<Backend, 3>::full([6, 4, 10], consts::PI);
+            let input = Tensor::<Backend, 3>::full_devauto([6, 4, 10], consts::PI);
 
             let output = model.forward(input);
 
diff --git a/burn-import/src/burn/graph.rs b/burn-import/src/burn/graph.rs
index 30a0cb6f1..e399ffba5 100644
--- a/burn-import/src/burn/graph.rs
+++ b/burn-import/src/burn/graph.rs
@@ -448,8 +448,8 @@ impl<PS: PrecisionSettings> BurnGraph<PS> {
             .collect::<Vec<_>>();
 
         quote! {
-            #[allow(dead_code)]
-            pub fn new() -> Self {
+            #[allow(dead_code, unused_variables)]
+            pub fn new(device: &B::Device) -> Self {
                 #body
 
                 Self {
@@ -457,6 +457,11 @@ impl<PS: PrecisionSettings> BurnGraph<PS> {
                     phantom: core::marker::PhantomData,
                 }
             }
+
+            pub fn new_devauto() -> Self {
+                let device = B::Device::default();
+                Self::new(&device)
+            }
         }
     }
     fn codegen_new_record(&self) -> TokenStream {
diff --git a/burn-import/src/burn/node/batch_norm.rs b/burn-import/src/burn/node/batch_norm.rs
index 2c3bc42ee..96a9eedb0 100644
--- a/burn-import/src/burn/node/batch_norm.rs
+++ b/burn-import/src/burn/node/batch_norm.rs
@@ -81,19 +81,19 @@ macro_rules! batch_norm_serialize {
         BatchNormRecord {
             gamma: Param::new(
                 ParamId::new(),
-                Tensor::from_data($self.gamma.clone().convert()),
+                Tensor::from_data_devauto($self.gamma.clone().convert()),
             ),
             beta: Param::new(
                 ParamId::new(),
-                Tensor::from_data($self.beta.clone().convert()),
+                Tensor::from_data_devauto($self.beta.clone().convert()),
             ),
             running_mean: Param::new(
                 ParamId::new(),
-                Tensor::from_data($self.running_mean.clone().convert()),
+                Tensor::from_data_devauto($self.running_mean.clone().convert()),
             ),
             running_var: Param::new(
                 ParamId::new(),
-                Tensor::from_data($self.running_var.clone().convert()),
+                Tensor::from_data_devauto($self.running_var.clone().convert()),
             ),
             epsilon: ConstantRecord::new(),
             momentum: ConstantRecord::new(),
@@ -123,7 +123,7 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for BatchNormNode<PS> {
                 init_with(record.#name);
             },
             false => quote! {
-                init();
+                init(device);
             },
         };
 
diff --git a/burn-import/src/burn/node/constant.rs b/burn-import/src/burn/node/constant.rs
index d091529e1..b2e252c5e 100644
--- a/burn-import/src/burn/node/constant.rs
+++ b/burn-import/src/burn/node/constant.rs
@@ -137,7 +137,7 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for ConstantNode<PS> {
                     Some(quote! {
                         let #name: burn::module::Param<#ty> = burn::module::Param::new(
                             burn::module::ParamId::new(),
-                            Tensor::<B, #dim>::zeros(#shape).set_require_grad(false),
+                            Tensor::<B, #dim>::zeros(#shape, device).set_require_grad(false),
                         );
                     })
                 }
diff --git a/burn-import/src/burn/node/conv1d.rs b/burn-import/src/burn/node/conv1d.rs
index 566190ac5..9d38afe64 100644
--- a/burn-import/src/burn/node/conv1d.rs
+++ b/burn-import/src/burn/node/conv1d.rs
@@ -72,7 +72,7 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for Conv1dNode<PS> {
                 init_with(record.#name);
             },
             false => quote! {
-                init();
+                init(device);
             },
         };
 
@@ -93,12 +93,14 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for Conv1dNode<PS> {
         let record = Conv1dRecord::<SerializationBackend> {
             weight: Param::new(
                 ParamId::new(),
-                Tensor::from_data(self.data_weights.clone().convert()),
+                Tensor::from_data_devauto(self.data_weights.clone().convert()),
             ),
-            bias: self
-                .data_bias
-                .as_ref()
-                .map(|bias| Param::new(ParamId::new(), Tensor::from_data(bias.clone().convert()))),
+            bias: self.data_bias.as_ref().map(|bias| {
+                Param::new(
+                    ParamId::new(),
+                    Tensor::from_data_devauto(bias.clone().convert()),
+                )
+            }),
             stride: ConstantRecord::new(),
             kernel_size: ConstantRecord::new(),
             dilation: ConstantRecord::new(),
diff --git a/burn-import/src/burn/node/conv2d.rs b/burn-import/src/burn/node/conv2d.rs
index 305a0fc09..6d96e483c 100644
--- a/burn-import/src/burn/node/conv2d.rs
+++ b/burn-import/src/burn/node/conv2d.rs
@@ -71,7 +71,7 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for Conv2dNode<PS> {
                 init_with(record.#name);
             },
             false => quote! {
-                init();
+                init(device);
             },
         };
 
@@ -92,12 +92,14 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for Conv2dNode<PS> {
         let record = Conv2dRecord::<SerializationBackend> {
             weight: Param::new(
                 ParamId::new(),
-                Tensor::from_data(self.data_weights.clone().convert()),
+                Tensor::from_data_devauto(self.data_weights.clone().convert()),
             ),
-            bias: self
-                .data_bias
-                .as_ref()
-                .map(|bias| Param::new(ParamId::new(), Tensor::from_data(bias.clone().convert()))),
+            bias: self.data_bias.as_ref().map(|bias| {
+                Param::new(
+                    ParamId::new(),
+                    Tensor::from_data_devauto(bias.clone().convert()),
+                )
+            }),
             stride: [ConstantRecord::new(); 2],
             kernel_size: [ConstantRecord::new(); 2],
             dilation: [ConstantRecord::new(); 2],
diff --git a/burn-import/src/burn/node/conv_transpose_2d.rs b/burn-import/src/burn/node/conv_transpose_2d.rs
index 1e56454c7..5a8bdafda 100644
--- a/burn-import/src/burn/node/conv_transpose_2d.rs
+++ b/burn-import/src/burn/node/conv_transpose_2d.rs
@@ -71,7 +71,7 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for ConvTranspose2dNode<PS> {
                 init_with(record.#name);
             },
             false => quote! {
-                init();
+                init(device);
             },
         };
 
@@ -92,12 +92,14 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for ConvTranspose2dNode<PS> {
         let record = ConvTranspose2dRecord::<SerializationBackend> {
             weight: Param::new(
                 ParamId::new(),
-                Tensor::from_data(self.data_weights.clone().convert()),
+                Tensor::from_data_devauto(self.data_weights.clone().convert()),
             ),
-            bias: self
-                .data_bias
-                .as_ref()
-                .map(|bias| Param::new(ParamId::new(), Tensor::from_data(bias.clone().convert()))),
+            bias: self.data_bias.as_ref().map(|bias| {
+                Param::new(
+                    ParamId::new(),
+                    Tensor::from_data_devauto(bias.clone().convert()),
+                )
+            }),
             stride: [ConstantRecord::new(); 2],
             kernel_size: [ConstantRecord::new(); 2],
             dilation: [ConstantRecord::new(); 2],
diff --git a/burn-import/src/burn/node/linear.rs b/burn-import/src/burn/node/linear.rs
index 4806841f2..074e7845d 100644
--- a/burn-import/src/burn/node/linear.rs
+++ b/burn-import/src/burn/node/linear.rs
@@ -68,7 +68,7 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for LinearNode<PS> {
                 init_with(record.#name);
             },
             false => quote! {
-                init();
+                init(device);
             },
         };
 
@@ -85,12 +85,14 @@ impl<PS: PrecisionSettings> NodeCodegen<PS> for LinearNode<PS> {
         let record = LinearRecord::<SerializationBackend> {
             weight: Param::new(
                 ParamId::new(),
-                Tensor::from_data(self.data_weights.clone().convert()),
+                Tensor::from_data_devauto(self.data_weights.clone().convert()),
             ),
-            bias: self
-                .data_bias
-                .as_ref()
-                .map(|bias| Param::new(ParamId::new(), Tensor::from_data(bias.clone().convert()))),
+            bias: self.data_bias.as_ref().map(|bias| {
+                Param::new(
+                    ParamId::new(),
+                    Tensor::from_data_devauto(bias.clone().convert()),
+                )
+            }),
         };
 
         let item = Record::into_item::<PS>(record);
diff --git a/burn-import/src/burn/node/unary.rs b/burn-import/src/burn/node/unary.rs
index 74098dc7f..01f47f179 100644
--- a/burn-import/src/burn/node/unary.rs
+++ b/burn-import/src/burn/node/unary.rs
@@ -231,7 +231,7 @@ impl UnaryNode {
                 // TODO: Implement this after tensor Int is implemented (@antimora 8/2/2023)
                 // TODO: If the input is scalar and the output type is a tensor,
                 // we should generate another code block. (@antimora 8/4/2023)
-                // Tensor::from_data(Data::from([#input]).convert()).unsqueeze();
+                // Tensor::from_data_devauto(Data::from([#input]).convert()).unsqueeze();
                 todo!()
             }
 
diff --git a/burn-no-std-tests/src/conv.rs b/burn-no-std-tests/src/conv.rs
index 6f1794940..60db5b412 100644
--- a/burn-no-std-tests/src/conv.rs
+++ b/burn-no-std-tests/src/conv.rs
@@ -22,10 +22,10 @@ pub struct ConvBlockConfig {
 }
 
 impl<B: Backend> ConvBlock<B> {
-    pub fn new(config: &ConvBlockConfig) -> Self {
+    pub fn new(config: &ConvBlockConfig, device: &B::Device) -> Self {
         let conv = nn::conv::Conv2dConfig::new(config.channels, config.kernel_size)
             .with_padding(nn::PaddingConfig2d::Same)
-            .init();
+            .init(device);
         let pool = nn::pool::MaxPool2dConfig::new(config.kernel_size)
             .with_padding(nn::PaddingConfig2d::Same)
             .init();
diff --git a/burn-no-std-tests/src/mlp.rs b/burn-no-std-tests/src/mlp.rs
index ec8f18971..619f67676 100644
--- a/burn-no-std-tests/src/mlp.rs
+++ b/burn-no-std-tests/src/mlp.rs
@@ -33,11 +33,11 @@ pub struct Mlp<B: Backend> {
 
 impl<B: Backend> Mlp<B> {
     /// Create the module from the given configuration.
-    pub fn new(config: &MlpConfig) -> Self {
+    pub fn new(config: &MlpConfig, device: &B::Device) -> Self {
         let mut linears = Vec::with_capacity(config.num_layers);
 
         for _ in 0..config.num_layers {
-            linears.push(nn::LinearConfig::new(config.d_model, config.d_model).init());
+            linears.push(nn::LinearConfig::new(config.d_model, config.d_model).init(device));
         }
 
         Self {
diff --git a/burn-no-std-tests/src/model.rs b/burn-no-std-tests/src/model.rs
index 7028bdb6b..d4025abd9 100644
--- a/burn-no-std-tests/src/model.rs
+++ b/burn-no-std-tests/src/model.rs
@@ -36,11 +36,11 @@ pub struct Model<B: Backend> {
 }
 
 impl<B: Backend> Model<B> {
-    pub fn new(config: &MnistConfig) -> Self {
-        let mlp = Mlp::new(&config.mlp);
-        let input = nn::LinearConfig::new(config.input_size, config.mlp.d_model).init();
-        let output = nn::LinearConfig::new(config.mlp.d_model, config.output_size).init();
-        let conv = ConvBlock::new(&ConvBlockConfig::new([1, 1]));
+    pub fn new(config: &MnistConfig, device: &B::Device) -> Self {
+        let mlp = Mlp::new(&config.mlp, device);
+        let input = nn::LinearConfig::new(config.input_size, config.mlp.d_model).init(device);
+        let output = nn::LinearConfig::new(config.mlp.d_model, config.output_size).init(device);
+        let conv = ConvBlock::new(&ConvBlockConfig::new([1, 1]), device);
 
         Self {
             mlp,
diff --git a/burn-no-std-tests/tests/integration_test.rs b/burn-no-std-tests/tests/integration_test.rs
index 6f6558cea..e9161dd95 100644
--- a/burn-no-std-tests/tests/integration_test.rs
+++ b/burn-no-std-tests/tests/integration_test.rs
@@ -3,7 +3,7 @@
 use burn_no_std_tests::mlp::*;
 use burn_no_std_tests::model::*;
 
-use burn::tensor::{backend::Backend, Distribution::Default, Tensor};
+use burn::tensor::{backend::Backend, Distribution, Tensor};
 use burn_ndarray::NdArray;
 
 #[test]
@@ -11,16 +11,17 @@ fn test_mnist_model_with_random_input() {
     type Backend = NdArray<f32>;
 
     // Model configurations
+    let device = Default::default();
     let mlp_config = MlpConfig::new();
     let mnist_config = MnistConfig::new(mlp_config);
-    let mnist_model: Model<Backend> = Model::new(&mnist_config);
+    let mnist_model: Model<Backend> = Model::new(&mnist_config, &device);
 
     // Pass a fixed seed for random, otherwise a build generated random seed is used
     Backend::seed(mnist_config.seed);
 
     // Some random input
     let input_shape = [1, 28, 28];
-    let input = Tensor::<Backend, 3>::random(input_shape, Default);
+    let input = Tensor::<Backend, 3>::random(input_shape, Distribution::Default, &device);
 
     // Run through the model
     let output = mnist_model.forward(input);
diff --git a/burn-tch/src/tensor.rs b/burn-tch/src/tensor.rs
index 598d246fe..499eeecbb 100644
--- a/burn-tch/src/tensor.rs
+++ b/burn-tch/src/tensor.rs
@@ -282,7 +282,7 @@ mod tests {
 
     #[test]
     fn should_not_update_inplace_after_reshape() {
-        let tensor_1 = Tensor::<LibTorch<f32>, 1>::from_floats([4.0, 4.0]);
+        let tensor_1 = Tensor::<LibTorch<f32>, 1>::from_floats_devauto([4.0, 4.0]);
         let tensor_2 = tensor_1.clone();
 
         let tensor_3 = tensor_2.reshape([1, 2]).add_scalar(2.0);
@@ -292,7 +292,7 @@ mod tests {
 
     #[test]
     fn should_not_update_inplace_after_slice() {
-        let tensor_1 = Tensor::<LibTorch<f32>, 1>::from_floats([4.0, 4.0]);
+        let tensor_1 = Tensor::<LibTorch<f32>, 1>::from_floats_devauto([4.0, 4.0]);
         let tensor_2 = tensor_1.clone();
 
         let tensor_3 = tensor_2.slice([0..2]).add_scalar(2.0);
diff --git a/burn-tensor/src/tensor/api/base.rs b/burn-tensor/src/tensor/api/base.rs
index 69c2305a1..8b8cb1947 100644
--- a/burn-tensor/src/tensor/api/base.rs
+++ b/burn-tensor/src/tensor/api/base.rs
@@ -43,12 +43,12 @@ where
     }
 
     /// Create an empty tensor of the given shape.
-    pub fn empty<S: Into<Shape<D>>>(shape: S) -> Self {
-        Self::empty_device(shape, &B::Device::default())
+    pub fn empty_devauto<S: Into<Shape<D>>>(shape: S) -> Self {
+        Self::empty(shape, &B::Device::default())
     }
 
     /// Create an empty tensor of the given shape.
-    pub fn empty_device<S: Into<Shape<D>>>(shape: S, device: &B::Device) -> Self {
+    pub fn empty<S: Into<Shape<D>>>(shape: S, device: &B::Device) -> Self {
         Self::new(K::empty(shape.into(), device))
     }
 
@@ -89,7 +89,7 @@ where
     /// use burn_tensor::Tensor;
     ///
     /// fn example<B: Backend>() {
-    ///    let tensor = Tensor::<B, 3>::ones([2, 3, 4]);
+    ///    let tensor = Tensor::<B, 3>::ones_devauto([2, 3, 4]);
     ///    // Given a 3D tensor with dimensions (2, 3, 4), reshape it to (2, 12)
     ///    let reshaped_tensor: Tensor::<B, 2> = tensor.reshape([2, -1]);
     ///    // The resulting tensor will have dimensions (2, 12).
@@ -156,7 +156,7 @@ where
     /// use burn_tensor::{Tensor, Shape};
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 4]));
+    ///     let tensor = Tensor::<B, 3>::ones_devauto(Shape::new([2, 3, 4]));
     ///
     ///     // Given a 3D tensor with dimensions (2, 3, 4), flatten the dimensions between indices 1 and 2:
     ///     let flattened_tensor: Tensor::<B, 2> = tensor.flatten(1, 2);
@@ -207,7 +207,7 @@ where
     /// use burn_tensor::{Tensor, Shape};
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 3>::ones(Shape::new([2, 1, 4]));
+    ///     let tensor = Tensor::<B, 3>::ones_devauto(Shape::new([2, 1, 4]));
     ///
     ///     // Given a 3D tensor with dimensions (2, 1, 4), squeeze the dimension 1
     ///     let squeezed_tensor: Tensor::<B, 2> = tensor.squeeze(1);
@@ -239,7 +239,7 @@ where
     /// use burn_tensor::{Tensor, Shape};
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 2>::ones(Shape::new([3, 3]));
+    ///     let tensor = Tensor::<B, 2>::ones_devauto(Shape::new([3, 3]));
     ///     let tensor = tensor.unsqueeze::<4>();
     ///     println!("{:?}", tensor.shape());
     ///     // Shape { dims: [1, 1, 3, 3] }
@@ -267,7 +267,7 @@ where
     /// use burn_tensor::{Tensor, Shape};
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 2>::ones(Shape::new([3, 3]));
+    ///     let tensor = Tensor::<B, 2>::ones_devauto(Shape::new([3, 3]));
     ///     let tensor: Tensor<B, 3> = tensor.unsqueeze_dim(1);
     ///     println!("{:?}", tensor.shape());
     ///     // Shape { dims: [3, 1, 3] }
@@ -306,21 +306,21 @@ where
     ///
     /// fn example<B: Backend>() {
     ///     // Create a tensor with a single dimension of ints between 0 and 11
-    ///     let tensor = Tensor::<B, 1, burn_tensor::Int>::arange(0..12);
+    ///     let tensor = Tensor::<B, 1, burn_tensor::Int>::arange_devauto(0..12);
     ///     // Select elements 0, 1, 2, 3 from the first dimension
     ///     let tensor_slices = tensor.clone().slice([0..4]);
     ///     println!("\nexpecting [0,1,2,3] : {:?}", tensor);
     ///     println!("expecting [4] : {:?}", tensor.dims());
     ///
     ///     // Create a Tensor with 3 dimensions
-    ///     let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
+    ///     let tensor = Tensor::<B, 3>::ones_devauto(Shape::new([2, 3, 3]));
     ///     // This slice will select the element 0 on the first dimension,
     ///     // elements 0,1,2 of the second dimension and element 1 of third dimension
     ///     let tensor_slices = tensor.slice([0..1, 0..3, 1..2]);
     ///     println!("expecting [1, 3, 1] : {:?}", tensor_slices.dims());
     ///
     ///     // Create a tensor of ints from 0 to 11 and reshape it into three dimensions
-    ///     let tensor = Tensor::<B, 1, burn_tensor::Int>::arange(0..12);
+    ///     let tensor = Tensor::<B, 1, burn_tensor::Int>::arange_devauto(0..12);
     ///     let tensor = tensor.reshape([1, 3, 4]);
     ///     println!("\nexpecting [[[0,1,2,3],[4,5,6,7],[8,9,10,11]]] : {:?}", tensor);
     ///     println!("expecting [1, 3, 4] : {:?}", tensor.dims());
@@ -356,8 +356,8 @@ where
     /// use burn_tensor::Tensor;
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 3>::ones([2, 3, 3]);
-    ///     let values = Tensor::<B, 3>::zeros([1, 1, 1]);
+    ///     let tensor = Tensor::<B, 3>::ones_devauto([2, 3, 3]);
+    ///     let values = Tensor::<B, 3>::zeros_devauto([1, 1, 1]);
     ///     let tensor_sliced = tensor.slice_assign([0..1, 0..1, 0..1], values);
     ///     println!("{:?}", tensor_sliced.dims()); // [2, 3, 3]
     /// }
@@ -410,15 +410,15 @@ where
     }
 
     /// Create a tensor from the given data.
-    pub fn from_data<T>(data: T) -> Self
+    pub fn from_data_devauto<T>(data: T) -> Self
     where
         T: Into<Data<K::Elem, D>>,
     {
-        Self::from_data_device(data, &B::Device::default())
+        Self::from_data(data, &B::Device::default())
     }
 
     /// Create a tensor from the given data on the given device.
-    pub fn from_data_device<T>(data: T, device: &B::Device) -> Self
+    pub fn from_data<T>(data: T, device: &B::Device) -> Self
     where
         T: Into<Data<K::Elem, D>>,
     {
@@ -798,7 +798,7 @@ where
 /// use burn_tensor::{Tensor, T};
 ///
 /// fn example<B: Backend>() {
-///     let tensor = Tensor::<B, 2>::from_floats([[1.0, 2.0], [3.0, 4.0]]);
+///     let tensor = Tensor::<B, 2>::from_floats_devauto([[1.0, 2.0], [3.0, 4.0]]);
 ///     let transposed = tensor^T;
 /// }
 /// ```
diff --git a/burn-tensor/src/tensor/api/bool.rs b/burn-tensor/src/tensor/api/bool.rs
index e7d7e9746..969c9ee02 100644
--- a/burn-tensor/src/tensor/api/bool.rs
+++ b/burn-tensor/src/tensor/api/bool.rs
@@ -5,12 +5,12 @@ where
     B: Backend,
 {
     /// Create a boolean tensor from data.
-    pub fn from_bool(data: Data<bool, D>) -> Self {
+    pub fn from_bool_devauto(data: Data<bool, D>) -> Self {
         Self::new(B::bool_from_data(data, &B::Device::default()))
     }
 
     /// Create a boolean tensor from data on the given device.
-    pub fn from_bool_device(data: Data<bool, D>, device: &B::Device) -> Self {
+    pub fn from_bool(data: Data<bool, D>, device: &B::Device) -> Self {
         Self::new(B::bool_from_data(data, device))
     }
 
diff --git a/burn-tensor/src/tensor/api/float.rs b/burn-tensor/src/tensor/api/float.rs
index 1b13e6994..613d3ea03 100644
--- a/burn-tensor/src/tensor/api/float.rs
+++ b/burn-tensor/src/tensor/api/float.rs
@@ -24,7 +24,7 @@ where
     /// want to mutate a tensor by using owned operations. A plausible usage would be to
     /// update the weights of a mutable model reference.
     pub fn inplace<F: FnOnce(Self) -> Self>(&mut self, func: F) {
-        let mut tensor_owned = Tensor::empty([0; D]);
+        let mut tensor_owned = Tensor::empty([0; D], &self.device());
         core::mem::swap(&mut tensor_owned, self);
 
         let mut tensor_new = func(tensor_owned);
@@ -100,12 +100,30 @@ where
     /// use burn_tensor::Tensor;
     ///
     /// fn example<B: Backend>() {
-    ///     let _ = Tensor::<B, 1>::from_floats([1.0, 2.0]);
-    ///     let _ = Tensor::<B, 2>::from_floats([[1.0, 2.0], [3.0, 4.0]]);
+    ///     let _ = Tensor::<B, 1>::from_floats_devauto([1.0, 2.0]);
+    ///     let _ = Tensor::<B, 2>::from_floats_devauto([[1.0, 2.0], [3.0, 4.0]]);
     /// }
     /// ```
-    pub fn from_floats<A: Into<Data<f32, D>>>(floats: A) -> Self {
-        Self::from_data(floats.into().convert())
+    pub fn from_floats_devauto<A: Into<Data<f32, D>>>(floats: A) -> Self {
+        Self::from_data_devauto(floats.into().convert())
+    }
+
+    /// Create a tensor from floats (f32) on a given device.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use burn_tensor::backend::Backend;
+    /// use burn_tensor::Tensor;
+    ///
+    /// fn example<B: Backend>() {
+    ///     let device = B::Device::default();
+    ///     let _ = Tensor::<B, 1>::from_floats([1.0, 2.0], &device);
+    ///     let _ = Tensor::<B, 2>::from_floats([[1.0, 2.0], [3.0, 4.0]], &device);
+    /// }
+    /// ```
+    pub fn from_floats<A: Into<Data<f32, D>>>(floats: A, device: &B::Device) -> Self {
+        Self::from_data(floats.into().convert(), device)
     }
 
     /// Returns a new tensor with the same shape and device as the current tensor and the data
@@ -118,7 +136,7 @@ where
     /// use burn_tensor::Tensor;
     ///
     /// fn example<B: Backend>() {
-    ///     let float_tensor = Tensor::<B, 1>::from_floats([1.0, 2.0]);
+    ///     let float_tensor = Tensor::<B, 1>::from_floats_devauto([1.0, 2.0]);
     ///     let int_tensor = float_tensor.int();
     /// }
     /// ```
@@ -161,11 +179,11 @@ where
         dims[D - 1] = num_classes;
         let shape = Shape::new(dims);
         let ranges: Vec<_> = shape.dims.iter().map(|dim| 0..*dim).collect();
-        let tensor = Tensor::zeros(shape);
+        let tensor = Tensor::zeros_devauto(shape);
         let mut ranges: [core::ops::Range<usize>; D] = ranges.try_into().unwrap();
         ranges[D - 1] = index..index + 1;
 
-        tensor.slice_assign(ranges, Tensor::ones(Shape::new([1; D])))
+        tensor.slice_assign(ranges, Tensor::ones_devauto(Shape::new([1; D])))
     }
 
     /// Applies the matrix multiplication operation.
@@ -206,14 +224,14 @@ where
 
     /// Create a random tensor of the given shape where each element is sampled from the given
     /// distribution.
-    pub fn random<S: Into<Shape<D>>>(shape: S, distribution: Distribution) -> Self {
+    pub fn random_devauto<S: Into<Shape<D>>>(shape: S, distribution: Distribution) -> Self {
         let tensor = B::random(shape.into(), distribution, &B::Device::default());
         Self::new(tensor)
     }
 
     /// Create a random tensor of the given shape on the given device where each element is
     /// sampled from the given distribution.
-    pub fn random_device<S: Into<Shape<D>>>(
+    pub fn random<S: Into<Shape<D>>>(
         shape: S,
         distribution: Distribution,
         device: &B::Device,
diff --git a/burn-tensor/src/tensor/api/int.rs b/burn-tensor/src/tensor/api/int.rs
index 395db8c28..cac476ddd 100644
--- a/burn-tensor/src/tensor/api/int.rs
+++ b/burn-tensor/src/tensor/api/int.rs
@@ -10,7 +10,7 @@ where
     /// # Arguments
     ///
     /// * `range` - The range of values to generate.
-    pub fn arange(range: Range<usize>) -> Self {
+    pub fn arange_devauto(range: Range<usize>) -> Self {
         Tensor::new(B::arange(range, &B::Device::default()))
     }
 
@@ -20,7 +20,7 @@ where
     ///
     /// * `range` - The range of values to generate.
     /// * `step` - The step between each value.
-    pub fn arange_step(range: Range<usize>, step: usize) -> Self {
+    pub fn arange_step_devauto(range: Range<usize>, step: usize) -> Self {
         Tensor::new(B::arange_step(range, step, &B::Device::default()))
     }
 
@@ -30,7 +30,7 @@ where
     ///
     /// * `range` - The range of values to generate.
     /// * `device` - The device to create the tensor on.
-    pub fn arange_device(range: Range<usize>, device: &B::Device) -> Self {
+    pub fn arange(range: Range<usize>, device: &B::Device) -> Self {
         Tensor::new(B::arange(range, device))
     }
 
@@ -40,7 +40,7 @@ where
     ///
     /// * `range` - The range of values to generate.
     /// * `step` - The step between each value.
-    pub fn arange_step_device(range: Range<usize>, step: usize, device: &B::Device) -> Self {
+    pub fn arange_step(range: Range<usize>, step: usize, device: &B::Device) -> Self {
         Tensor::new(B::arange_step(range, step, device))
     }
 }
@@ -58,12 +58,30 @@ where
     /// use burn_tensor::{Tensor, Int};
     ///
     /// fn example<B: Backend>() {
-    ///     let _x: Tensor<B, 1, Int> = Tensor::from_ints([1, 2]);
-    ///     let _y: Tensor<B, 2, Int> = Tensor::from_ints([[1, 2], [3, 4]]);
+    ///     let _x: Tensor<B, 1, Int> = Tensor::from_ints_devauto([1, 2]);
+    ///     let _y: Tensor<B, 2, Int> = Tensor::from_ints_devauto([[1, 2], [3, 4]]);
     /// }
     /// ```
-    pub fn from_ints<A: Into<Data<i32, D>>>(ints: A) -> Self {
-        Self::from_data(ints.into().convert())
+    pub fn from_ints_devauto<A: Into<Data<i32, D>>>(ints: A) -> Self {
+        Self::from_data_devauto(ints.into().convert())
+    }
+
+    /// Create a tensor from integers (i32), placing it on a given device.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use burn_tensor::backend::Backend;
+    /// use burn_tensor::{Tensor, Int};
+    ///
+    /// fn example<B: Backend>() {
+    ///     let device = B::Device::default();
+    ///     let _x: Tensor<B, 1, Int> = Tensor::from_ints([1, 2], &device);
+    ///     let _y: Tensor<B, 2, Int> = Tensor::from_ints([[1, 2], [3, 4]], &device);
+    /// }
+    /// ```
+    pub fn from_ints<A: Into<Data<i32, D>>>(ints: A, device: &B::Device) -> Self {
+        Self::from_data(ints.into().convert(), device)
     }
 
     /// Returns a new tensor with the same shape and device as the current tensor and the data
@@ -76,7 +94,7 @@ where
     /// use burn_tensor::{Int, Tensor};
     ///
     /// fn example<B: Backend>() {
-    ///     let int_tensor = Tensor::<B, 1, Int>::arange(0..5);
+    ///     let int_tensor = Tensor::<B, 1, Int>::arange_devauto(0..5);
     ///     let float_tensor = int_tensor.float();
     /// }
     /// ```
diff --git a/burn-tensor/src/tensor/api/numeric.rs b/burn-tensor/src/tensor/api/numeric.rs
index 185cf6dd8..6f0629778 100644
--- a/burn-tensor/src/tensor/api/numeric.rs
+++ b/burn-tensor/src/tensor/api/numeric.rs
@@ -106,32 +106,32 @@ where
     }
 
     /// Create a tensor of the given shape where each element is zero.
-    pub fn zeros<S: Into<Shape<D>>>(shape: S) -> Self {
-        Self::zeros_device(shape, &B::Device::default())
+    pub fn zeros_devauto<S: Into<Shape<D>>>(shape: S) -> Self {
+        Self::zeros(shape, &B::Device::default())
     }
 
     /// Create a tensor of the given shape where each element is zero.
-    pub fn zeros_device<S: Into<Shape<D>>>(shape: S, device: &B::Device) -> Self {
+    pub fn zeros<S: Into<Shape<D>>>(shape: S, device: &B::Device) -> Self {
         Self::new(K::zeros(shape.into(), device))
     }
 
     /// Create a tensor of the given shape where each element is one.
-    pub fn ones<S: Into<Shape<D>>>(shape: S) -> Self {
-        Self::ones_device(shape, &B::Device::default())
+    pub fn ones_devauto<S: Into<Shape<D>>>(shape: S) -> Self {
+        Self::ones(shape, &B::Device::default())
     }
 
     /// Create a tensor of the given shape where each element is one.
-    pub fn ones_device<S: Into<Shape<D>>>(shape: S, device: &B::Device) -> Self {
+    pub fn ones<S: Into<Shape<D>>>(shape: S, device: &B::Device) -> Self {
         Self::new(K::ones(shape.into(), device))
     }
 
     /// Create a tensor of the given shape where each element is equal to the provided value.
-    pub fn full<S: Into<Shape<D>>, E: ElementConversion>(shape: S, fill_value: E) -> Self {
-        Self::full_device(shape, fill_value, &B::Device::default())
+    pub fn full_devauto<S: Into<Shape<D>>, E: ElementConversion>(shape: S, fill_value: E) -> Self {
+        Self::full(shape, fill_value, &B::Device::default())
     }
 
     /// Create a tensor of the given shape where each element is equal to the provided value.
-    pub fn full_device<S: Into<Shape<D>>, E: ElementConversion>(
+    pub fn full<S: Into<Shape<D>>, E: ElementConversion>(
         shape: S,
         fill_value: E,
         device: &B::Device,
@@ -335,7 +335,7 @@ where
     /// use burn_tensor::{Tensor, Shape};
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
+    ///     let tensor = Tensor::<B, 3>::ones_devauto(Shape::new([2, 3, 3]));
     ///     let tensor = tensor.argmax(1);
     ///     println!("{:?}", tensor.shape());
     ///     // Shape { dims: [2, 1, 3] }
@@ -380,7 +380,7 @@ where
     /// use burn_tensor::{Tensor, Shape};
     ///
     /// fn example<B: Backend>() {
-    ///     let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
+    ///     let tensor = Tensor::<B, 3>::ones_devauto(Shape::new([2, 3, 3]));
     ///     let tensor = tensor.argmin(1);
     ///     println!("{:?}", tensor.shape());
     ///     // Shape { dims: [2, 1, 3] }
@@ -483,8 +483,8 @@ where
         let height = shape.dims[D - 2];
         let width = shape.dims[D - 1];
 
-        let row_indices: Tensor<B, 1, Int> = Tensor::arange_device(0..height, &self.device());
-        let col_indices: Tensor<B, 1, Int> = Tensor::arange_device(0..width, &self.device());
+        let row_indices: Tensor<B, 1, Int> = Tensor::arange(0..height, &self.device());
+        let col_indices: Tensor<B, 1, Int> = Tensor::arange(0..width, &self.device());
 
         let mut row_shape = [1; D];
         row_shape[D - 2] = height;
@@ -508,7 +508,7 @@ where
     /// use burn_tensor::{Int, Tensor};
     ///
     /// fn example<B: Backend>() {
-    ///    let tensor = Tensor::<B, 2, Int>::from_ints([
+    ///    let tensor = Tensor::<B, 2, Int>::from_ints_devauto([
     ///      [1, 2, 3],
     ///      [4, 5, 6],
     ///      [7, 8, 9]
@@ -535,7 +535,7 @@ where
     /// use burn_tensor::{Int, Tensor};
     ///
     /// fn example<B: Backend>() {
-    ///    let tensor = Tensor::<B, 2, Int>::from_ints([
+    ///    let tensor = Tensor::<B, 2, Int>::from_ints_devauto([
     ///      [1, 2, 3],
     ///      [4, 5, 6],
     ///      [7, 8, 9]
@@ -566,10 +566,10 @@ where
     /// # Arguments
     ///
     /// * `size` - The size of the square matrix.
-    pub fn diagonal(size: usize) -> Self {
-        let indices = Tensor::<B, 1, Int>::arange(0..size).unsqueeze();
-        let ones = K::ones([1, size].into(), &B::Device::default());
-        let zeros = K::zeros([size, size].into(), &B::Device::default());
+    pub fn diagonal(size: usize, device: &B::Device) -> Self {
+        let indices = Tensor::<B, 1, Int>::arange(0..size, device).unsqueeze();
+        let ones = K::ones([1, size].into(), device);
+        let zeros = K::zeros([size, size].into(), device);
         Self::new(K::scatter(0, zeros, indices, ones))
     }
 }
diff --git a/burn-tensor/src/tensor/named/base.rs b/burn-tensor/src/tensor/named/base.rs
index 08ea2bd99..c3c3c84bb 100644
--- a/burn-tensor/src/tensor/named/base.rs
+++ b/burn-tensor/src/tensor/named/base.rs
@@ -49,8 +49,18 @@ where
 
     /// Create a random named tensor of the given shape where each element is sampled from
     /// the given distribution.
-    pub fn random<S: Into<Shape<D>>>(shape: S, distribution: Distribution) -> Self {
-        Self::from_tensor(Tensor::random(shape, distribution))
+    pub fn random<S: Into<Shape<D>>>(
+        shape: S,
+        distribution: Distribution,
+        device: &B::Device,
+    ) -> Self {
+        Self::from_tensor(Tensor::random(shape, distribution, device))
+    }
+
+    /// Create a random named tensor of the given shape where each element is sampled from
+    /// the given distribution. Tensor will be placed on the default device of the backend.
+    pub fn random_devauto<S: Into<Shape<D>>>(shape: S, distribution: Distribution) -> Self {
+        Self::from_tensor(Tensor::random_devauto(shape, distribution))
     }
 
     /// Returns the shape of the current tensor.
diff --git a/burn-tensor/src/tests/activation/gelu.rs b/burn-tensor/src/tests/activation/gelu.rs
index a6dc2a617..8ec0af1ad 100644
--- a/burn-tensor/src/tests/activation/gelu.rs
+++ b/burn-tensor/src/tests/activation/gelu.rs
@@ -8,7 +8,9 @@ mod tests {
         let data = Data::from([[
             0.5447, 0.9809, 0.4114, 0.1398, 0.8045, 0.4103, 0.2388, 0.5262, 0.6677, 0.6737,
         ]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data).clone().clone();
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data)
+            .clone()
+            .clone();
 
         let data_actual = activation::gelu(tensor).to_data();
 
diff --git a/burn-tensor/src/tests/activation/relu.rs b/burn-tensor/src/tests/activation/relu.rs
index b9e5ff662..44f95180c 100644
--- a/burn-tensor/src/tests/activation/relu.rs
+++ b/burn-tensor/src/tests/activation/relu.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_relu_d2() {
         let data = Data::from([[0.0, -1.0, 2.0], [3.0, -4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = activation::relu(tensor).to_data();
 
diff --git a/burn-tensor/src/tests/activation/sigmoid.rs b/burn-tensor/src/tests/activation/sigmoid.rs
index 17d55ba7c..62dca35a8 100644
--- a/burn-tensor/src/tests/activation/sigmoid.rs
+++ b/burn-tensor/src/tests/activation/sigmoid.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_sigmoid() {
         let data = Data::from([[1.0, 7.0], [13.0, -3.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = activation::sigmoid(tensor).to_data();
 
@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn test_sigmoid_overflow() {
         let data = Data::from([f32::MAX, f32::MIN]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data);
 
         let data_actual = activation::sigmoid(tensor).to_data();
 
diff --git a/burn-tensor/src/tests/activation/silu.rs b/burn-tensor/src/tests/activation/silu.rs
index f207bc614..4bdd67297 100644
--- a/burn-tensor/src/tests/activation/silu.rs
+++ b/burn-tensor/src/tests/activation/silu.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_silu() {
         let data = Data::from([[1.0, 2.0], [3.0, 4.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = activation::silu(tensor).to_data();
 
diff --git a/burn-tensor/src/tests/activation/softmax.rs b/burn-tensor/src/tests/activation/softmax.rs
index 7e04168bf..99a0d13d9 100644
--- a/burn-tensor/src/tests/activation/softmax.rs
+++ b/burn-tensor/src/tests/activation/softmax.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_softmax_d2() {
         let data = Data::from([[1.0, 7.0], [13.0, -3.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = activation::softmax(tensor, 1).to_data();
 
diff --git a/burn-tensor/src/tests/activation/tanh_activation.rs b/burn-tensor/src/tests/activation/tanh_activation.rs
index 1aaa9e3d0..b5736b751 100644
--- a/burn-tensor/src/tests/activation/tanh_activation.rs
+++ b/burn-tensor/src/tests/activation/tanh_activation.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_tanh() {
         let data = Data::from([[1., 2.], [3., 4.]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = activation::tanh(tensor).to_data();
 
diff --git a/burn-tensor/src/tests/clone_invariance.rs b/burn-tensor/src/tests/clone_invariance.rs
index c8b54890a..358672371 100644
--- a/burn-tensor/src/tests/clone_invariance.rs
+++ b/burn-tensor/src/tests/clone_invariance.rs
@@ -39,13 +39,13 @@ mod tests {
                     type Args = Data<f32, 2>;
 
                     fn args(&self) -> Self::Args {
-                        TestTensor::random([32, 32], Distribution::Default)
+                        TestTensor::random_devauto([32, 32], Distribution::Default)
                             .into_data()
                             .convert()
                     }
 
                     fn run(&self, args: &Self::Args, inplace: bool) -> Data<f32, 2> {
-                        let lhs = TestTensor::from_data(args.clone().convert());
+                        let lhs = TestTensor::from_data_devauto(args.clone().convert());
 
                         if inplace {
                             $ops(lhs).into_data().convert()
@@ -72,19 +72,19 @@ mod tests {
 
                     fn args(&self) -> Self::Args {
                         (
-                            TestTensor::random([32, 32], Distribution::Default)
+                            TestTensor::random_devauto([32, 32], Distribution::Default)
                                 .into_data()
                                 .convert(),
                             // Avoid div by zero.
-                            TestTensor::random([32, 32], Distribution::Uniform(1., 3.))
+                            TestTensor::random_devauto([32, 32], Distribution::Uniform(1., 3.))
                                 .into_data()
                                 .convert(),
                         )
                     }
 
                     fn run(&self, (lhs_arg, rhs_arg): &Self::Args, inplace: bool) -> Data<f32, 2> {
-                        let lhs = TestTensor::from_data(lhs_arg.clone().convert());
-                        let rhs = TestTensor::from_data(rhs_arg.clone().convert());
+                        let lhs = TestTensor::from_data_devauto(lhs_arg.clone().convert());
+                        let rhs = TestTensor::from_data_devauto(rhs_arg.clone().convert());
 
                         if inplace {
                             $ops(lhs, rhs).into_data().convert()
@@ -113,13 +113,13 @@ mod tests {
                     type Args = Data<i32, 2>;
 
                     fn args(&self) -> Self::Args {
-                        TestTensor::random([32, 32], Distribution::Uniform(0.0, 50.0))
+                        TestTensor::random_devauto([32, 32], Distribution::Uniform(0.0, 50.0))
                             .into_data()
                             .convert()
                     }
 
                     fn run(&self, args: &Self::Args, inplace: bool) -> Data<f32, 2> {
-                        let lhs = TestTensorInt::from_data(args.clone().convert());
+                        let lhs = TestTensorInt::from_data_devauto(args.clone().convert());
 
                         if inplace {
                             $ops(lhs).into_data().convert()
@@ -146,19 +146,19 @@ mod tests {
 
                     fn args(&self) -> Self::Args {
                         (
-                            TestTensor::random([32, 32], Distribution::Uniform(0., 50.))
+                            TestTensor::random_devauto([32, 32], Distribution::Uniform(0., 50.))
                                 .into_data()
                                 .convert(),
                             // Avoid div by zero.
-                            TestTensor::random([32, 32], Distribution::Uniform(1., 51.))
+                            TestTensor::random_devauto([32, 32], Distribution::Uniform(1., 51.))
                                 .into_data()
                                 .convert(),
                         )
                     }
 
                     fn run(&self, (lhs_arg, rhs_arg): &Self::Args, inplace: bool) -> Data<f32, 2> {
-                        let lhs = TestTensorInt::from_data(lhs_arg.clone().convert());
-                        let rhs = TestTensorInt::from_data(rhs_arg.clone().convert());
+                        let lhs = TestTensorInt::from_data_devauto(lhs_arg.clone().convert());
+                        let rhs = TestTensorInt::from_data_devauto(rhs_arg.clone().convert());
 
                         if inplace {
                             $ops(lhs, rhs).into_data().convert()
@@ -345,17 +345,17 @@ mod tests {
             }
         );
         clone_invariance_test!(
-            unary: Gather,
+            unary: Gatter,
             ops_float: |tensor: TestTensor<2>| {
                 let shape = tensor.shape();
-                let indices = TestTensorInt::ones(shape);
+                let indices = TestTensorInt::ones_devauto(shape);
                 tensor.gather(0, indices)
             }
         );
         clone_invariance_test!(
             unary: Select,
             ops_float: |tensor: TestTensor<2>| {
-                let indices = TestTensorInt::from_ints([1, 2, 0, 5]);
+                let indices = TestTensorInt::from_ints_devauto([1, 2, 0, 5]);
                 tensor.select(0, indices)
             }
         );
@@ -463,7 +463,7 @@ mod tests {
             binary: Scatter,
             ops_float: |tensor: TestTensor<2>, values: TestTensor<2>| {
                 let shape = tensor.shape();
-                let indices = TestTensorInt::ones(shape);
+                let indices = TestTensorInt::ones_devauto(shape);
                 tensor.scatter(0, indices, values)
             }
         );
@@ -483,7 +483,7 @@ mod tests {
         clone_invariance_test!(
             binary: SelectAssign,
             ops_float: |tensor: TestTensor<2>, values: TestTensor<2>| {
-                let indices = TestTensorInt::from_ints([1, 2, 0, 5]);
+                let indices = TestTensorInt::from_ints_devauto([1, 2, 0, 5]);
                 let values = values.select(0, indices.clone());
                 tensor.select_assign(0, indices, values)
             }
@@ -625,17 +625,17 @@ mod tests {
             }
         );
         clone_invariance_test!(
-            unary: Gather,
+            unary: Gatter,
             ops_int: |tensor: TestTensorInt<2>| {
                 let shape = tensor.shape();
-                let indices = TestTensorInt::ones(shape);
+                let indices = TestTensorInt::ones_devauto(shape);
                 tensor.gather(0, indices)
             }
         );
         clone_invariance_test!(
             unary: Select,
             ops_int: |tensor: TestTensorInt<2>| {
-                let indices = TestTensorInt::from_ints([1, 2, 0, 5]);
+                let indices = TestTensorInt::from_ints_devauto([1, 2, 0, 5]);
                 tensor.select(0, indices)
             }
         );
@@ -697,7 +697,7 @@ mod tests {
             binary: Scatter,
             ops_int: |tensor: TestTensorInt<2>, values: TestTensorInt<2>| {
                 let shape = tensor.shape();
-                let indices = TestTensorInt::ones(shape);
+                let indices = TestTensorInt::ones_devauto(shape);
                 tensor.scatter(0, indices, values)
             }
         );
@@ -717,7 +717,7 @@ mod tests {
         clone_invariance_test!(
             binary: SelectAssign,
             ops_int: |tensor: TestTensorInt<2>, values: TestTensorInt<2>| {
-                let indices = TestTensorInt::from_ints([1, 2, 0, 5]);
+                let indices = TestTensorInt::from_ints_devauto([1, 2, 0, 5]);
                 let values = values.select(0, indices.clone());
                 tensor.select_assign(0, indices, values)
             }
diff --git a/burn-tensor/src/tests/module/adaptive_avgpool1d.rs b/burn-tensor/src/tests/module/adaptive_avgpool1d.rs
index f655ed849..86f2cf035 100644
--- a/burn-tensor/src/tests/module/adaptive_avgpool1d.rs
+++ b/burn-tensor/src/tests/module/adaptive_avgpool1d.rs
@@ -13,7 +13,7 @@ mod tests {
             length_out: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.5, 2.5, 4.5, 6.5],
             [8.5, 10.5, 12.5, 14.5],
         ]]));
@@ -28,7 +28,7 @@ mod tests {
             length_out: 3,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [1.0, 3.0, 5.0],
             [8.0, 10.0, 12.0],
         ]]));
@@ -43,7 +43,7 @@ mod tests {
             length_out: 8,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0],
             [4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0],
         ]]));
@@ -59,8 +59,8 @@ mod tests {
     impl AdaptiveAvgPool1dTestCase {
         fn assert_output(self, y: TestTensor<3>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.length]);
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/adaptive_avgpool2d.rs b/burn-tensor/src/tests/module/adaptive_avgpool2d.rs
index 271194838..055be83f8 100644
--- a/burn-tensor/src/tests/module/adaptive_avgpool2d.rs
+++ b/burn-tensor/src/tests/module/adaptive_avgpool2d.rs
@@ -15,7 +15,7 @@ mod tests {
             width_out: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [3.5000, 4.5000, 6.5000, 7.5000],
                 [15.5000, 16.5000, 18.5000, 19.5000],
@@ -42,7 +42,7 @@ mod tests {
             width_out: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [[5.0000, 8.0000], [15.5000, 18.5000], [26.0000, 29.0000]],
             [[40.0000, 43.0000], [50.5000, 53.5000], [61.0000, 64.0000]],
         ]]));
@@ -59,7 +59,7 @@ mod tests {
             width_out: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [0.0000, 0.5000, 1.5000, 2.0000],
                 [1.5000, 2.0000, 3.0000, 3.5000],
@@ -89,8 +89,8 @@ mod tests {
     impl AdaptiveAvgPool2dTestCase {
         fn assert_output(self, y: TestTensor<4>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.height, self.width]);
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/avgpool1d.rs b/burn-tensor/src/tests/module/avgpool1d.rs
index ce1a95fd5..d6dc5a9bd 100644
--- a/burn-tensor/src/tests/module/avgpool1d.rs
+++ b/burn-tensor/src/tests/module/avgpool1d.rs
@@ -16,7 +16,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[[1., 2., 3., 4.]]]));
+        test.assert_output(TestTensor::from_floats_devauto([[[1., 2., 3., 4.]]]));
     }
 
     #[test]
@@ -31,7 +31,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.3333, 2.0000, 4.0000],
             [4.3333, 8.0000, 10.0000],
         ]]));
@@ -49,7 +49,7 @@ mod tests {
             count_include_pad: false,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0.5000, 2.0000, 4.0000],
             [6.5000, 8.0000, 10.0000],
         ]]));
@@ -68,8 +68,8 @@ mod tests {
     impl AvgPool1dTestCase {
         fn assert_output(self, y: TestTensor<3>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.length]);
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/avgpool2d.rs b/burn-tensor/src/tests/module/avgpool2d.rs
index 020701432..0f674eea5 100644
--- a/burn-tensor/src/tests/module/avgpool2d.rs
+++ b/burn-tensor/src/tests/module/avgpool2d.rs
@@ -20,7 +20,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [7., 8., 9., 10.],
             [13., 14., 15., 16.],
             [19., 20., 21., 22.],
@@ -44,7 +44,7 @@ mod tests {
             count_include_pad: true,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [1.1667, 3.0000, 4.3333, 2.5000],
             [3.2500, 7.5000, 9.5000, 5.2500],
             [6.2500, 13.5000, 15.5000, 8.2500],
@@ -68,7 +68,7 @@ mod tests {
             count_include_pad: false,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [3.5000, 4.5000, 6.5000, 7.5000],
             [6.5000, 7.5000, 9.5000, 10.5000],
             [12.5000, 13.5000, 15.5000, 16.5000],
@@ -93,8 +93,8 @@ mod tests {
     impl AvgPool2dTestCase {
         fn assert_output(self, y: TestTensor<4>) {
             let shape_x = Shape::new([self.batch_size, self.channels, self.height, self.width]);
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/conv1d.rs b/burn-tensor/src/tests/module/conv1d.rs
index 662ba8a4b..435444173 100644
--- a/burn-tensor/src/tests/module/conv1d.rs
+++ b/burn-tensor/src/tests/module/conv1d.rs
@@ -19,7 +19,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([
+        test.assert_output(TestTensor::from_floats_devauto([
             [[43., 67., 82., 49.], [104., 176., 227., 158.]],
             [[139., 187., 202., 113.], [392., 584., 635., 414.]],
         ]));
@@ -39,7 +39,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([
+        test.assert_output(TestTensor::from_floats_devauto([
             [[62., 38.], [159., 111.]],
             [[158., 102.], [447., 367.]],
         ]));
@@ -59,7 +59,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([
+        test.assert_output(TestTensor::from_floats_devauto([
             [[2., 5., 8., 3.], [42., 63., 75., 47.]],
             [[26., 29., 32., 11.], [114., 159., 171., 103.]],
         ]));
@@ -79,7 +79,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([
+        test.assert_output(TestTensor::from_floats_devauto([
             [[171., 294.], [415., 781.], [659., 1268.], [903., 1755.]],
             [[495., 726.], [1387., 2185.], [2279., 3644.], [3171., 5103.]],
         ]));
@@ -105,19 +105,19 @@ mod tests {
                 self.channels_in / self.groups,
                 self.kernel_size,
             ]);
-            let weight = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_weight.num_elements())
+            let weight = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weight.num_elements())
                     .reshape(shape_weight)
                     .into_data()
                     .convert(),
             );
-            let bias = TestTensor::from_data(
-                TestTensorInt::arange(0..self.channels_out)
+            let bias = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels_out)
                     .into_data()
                     .convert(),
             );
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/conv2d.rs b/burn-tensor/src/tests/module/conv2d.rs
index ba7292ea3..ed0564694 100644
--- a/burn-tensor/src/tests/module/conv2d.rs
+++ b/burn-tensor/src/tests/module/conv2d.rs
@@ -24,7 +24,7 @@ mod tests {
             width: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [1196., 1796., 1916., 1264.],
                 [1881., 2793., 2946., 1923.],
@@ -59,7 +59,7 @@ mod tests {
             width: 5,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [[312., 348., 384.], [492., 528., 564.], [672., 708., 744.]],
             [
                 [3724., 3841., 3958.],
@@ -88,7 +88,7 @@ mod tests {
             width: 5,
         };
 
-        test.assert_output(TestTensor::from_floats([
+        test.assert_output(TestTensor::from_floats_devauto([
             [
                 [[1845., 3789., 1926.], [3210., 6465., 3228.]],
                 [[4276., 9082., 4789.], [8071., 16834., 8737.]],
@@ -130,19 +130,19 @@ mod tests {
                 self.kernel_size_1,
                 self.kernel_size_2,
             ]);
-            let weight = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_weight.num_elements())
+            let weight = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weight.num_elements())
                     .reshape(shape_weight)
                     .into_data()
                     .convert(),
             );
-            let bias = TestTensor::from_data(
-                TestTensorInt::arange(0..self.channels_out)
+            let bias = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels_out)
                     .into_data()
                     .convert(),
             );
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/conv_transpose1d.rs b/burn-tensor/src/tests/module/conv_transpose1d.rs
index 349e1f1cf..073b343dd 100644
--- a/burn-tensor/src/tests/module/conv_transpose1d.rs
+++ b/burn-tensor/src/tests/module/conv_transpose1d.rs
@@ -20,7 +20,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [270., 453., 516., 387.],
             [352., 589., 679., 505.],
         ]]));
@@ -41,7 +41,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [28., 62., 36., 78., 44., 94., 52., 62.],
             [41., 93., 55., 121., 69., 149., 83., 93.],
         ]]));
@@ -62,7 +62,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [30., 64., 78., 76., 94., 52.],
             [49., 101., 127., 113., 143., 77.],
         ]]));
@@ -83,7 +83,7 @@ mod tests {
             length: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [0., 1., 4., 7.],
             [32., 59., 71., 59.],
         ]]));
@@ -110,19 +110,19 @@ mod tests {
                 self.channels_out / self.groups,
                 self.kernel_size,
             ]);
-            let weights = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_weights.num_elements())
+            let weights = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weights.num_elements())
                     .reshape(shape_weights)
                     .into_data()
                     .convert(),
             );
-            let bias = TestTensor::from_data(
-                TestTensorInt::arange(0..self.channels_out)
+            let bias = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels_out)
                     .into_data()
                     .convert(),
             );
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/conv_transpose2d.rs b/burn-tensor/src/tests/module/conv_transpose2d.rs
index d8b3a3e05..44ebbf2a2 100644
--- a/burn-tensor/src/tests/module/conv_transpose2d.rs
+++ b/burn-tensor/src/tests/module/conv_transpose2d.rs
@@ -26,7 +26,10 @@ mod tests {
             width: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[[[5.0, 11.0], [23.0, 29.0]]]]));
+        test.assert_output(TestTensor::from_floats_devauto([[[
+            [5.0, 11.0],
+            [23.0, 29.0],
+        ]]]));
     }
     #[test]
     fn test_conv_transpose2d_simple_2() {
@@ -49,7 +52,7 @@ mod tests {
             width: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [9855., 15207., 15738., 10797.],
                 [16290., 25119., 25956., 17793.],
@@ -92,7 +95,7 @@ mod tests {
             width: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[[
+        test.assert_output(TestTensor::from_floats_devauto([[[
             [0.0, 0.0, 0.0, 1.0],
             [0.0, 0.0, 2.0, 3.0],
             [0.0, 2.0, 0.0, 3.0],
@@ -121,7 +124,7 @@ mod tests {
             width: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [126., 116., 136., 124., 146.],
                 [108., 88., 114., 92., 120.],
@@ -160,7 +163,7 @@ mod tests {
             width: 4,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [352., 728., 378., 780., 404., 832., 430., 452.],
                 [784., 1616., 836., 1720., 888., 1824., 940., 992.],
@@ -205,7 +208,7 @@ mod tests {
             width: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [[5., 11.], [23., 29.]],
             [[236., 258.], [302., 324.]],
         ]]));
@@ -232,7 +235,7 @@ mod tests {
             width: 2,
         };
 
-        test.assert_output(TestTensor::from_floats([[
+        test.assert_output(TestTensor::from_floats_devauto([[
             [
                 [0.0000e+00, 0.0000e+00, 1.0000e+00, 2.0000e+00],
                 [0.0000e+00, 5.0000e+00, 1.1000e+01, 1.1000e+01],
@@ -300,19 +303,19 @@ mod tests {
                 self.kernel_size_1,
                 self.kernel_size_2,
             ]);
-            let weights = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_weights.num_elements())
+            let weights = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_weights.num_elements())
                     .reshape(shape_weights)
                     .into_data()
                     .convert(),
             );
-            let bias = TestTensor::from_data(
-                TestTensorInt::arange(0..self.channels_out)
+            let bias = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..self.channels_out)
                     .into_data()
                     .convert(),
             );
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/module/forward.rs b/burn-tensor/src/tests/module/forward.rs
index 7ff629140..9783c3ffe 100644
--- a/burn-tensor/src/tests/module/forward.rs
+++ b/burn-tensor/src/tests/module/forward.rs
@@ -7,8 +7,8 @@ mod tests {
     fn test_embedding_forward() {
         let weights = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let indices = Data::from([[0, 1], [1, 1]]);
-        let weights = Tensor::<TestBackend, 2>::from_data(weights);
-        let indices = Tensor::<TestBackend, 2, Int>::from_data(indices);
+        let weights = Tensor::<TestBackend, 2>::from_data_devauto(weights);
+        let indices = Tensor::<TestBackend, 2, Int>::from_data_devauto(indices);
 
         let output = embedding(weights, indices);
         let expected = Data::from([
diff --git a/burn-tensor/src/tests/module/maxpool1d.rs b/burn-tensor/src/tests/module/maxpool1d.rs
index 97c26129d..75d5ba3a8 100644
--- a/burn-tensor/src/tests/module/maxpool1d.rs
+++ b/burn-tensor/src/tests/module/maxpool1d.rs
@@ -13,11 +13,11 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x = TestTensor::from_floats([[
+        let x = TestTensor::from_floats_devauto([[
             [0.9861, 0.5474, 0.4477, 0.0732, 0.3548, 0.8221],
             [0.8148, 0.5474, 0.9490, 0.7890, 0.5537, 0.5689],
         ]]);
-        let y = TestTensor::from_floats([[
+        let y = TestTensor::from_floats_devauto([[
             [0.9861, 0.5474, 0.4477, 0.8221],
             [0.949, 0.949, 0.949, 0.789],
         ]]);
@@ -34,8 +34,8 @@ mod tests {
         let stride = 2;
         let dilation = 1;
 
-        let x = TestTensor::from_floats([[[0.6309, 0.6112, 0.6998, 0.4708]]]);
-        let y = TestTensor::from_floats([[[0.6309, 0.6998]]]);
+        let x = TestTensor::from_floats_devauto([[[0.6309, 0.6112, 0.6998, 0.4708]]]);
+        let y = TestTensor::from_floats_devauto([[[0.6309, 0.6998]]]);
 
         let output = max_pool1d(x, kernel_size, stride, padding, dilation);
 
@@ -49,8 +49,8 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x = TestTensor::from_floats([[[-0.6309, -0.6112, -0.6998, -0.4708]]]);
-        let y = TestTensor::from_floats([[[-0.6112, -0.6112, -0.4708, -0.4708]]]);
+        let x = TestTensor::from_floats_devauto([[[-0.6309, -0.6112, -0.6998, -0.4708]]]);
+        let y = TestTensor::from_floats_devauto([[[-0.6112, -0.6112, -0.4708, -0.4708]]]);
 
         let output = max_pool1d(x, kernel_size, stride, padding, dilation);
 
@@ -64,11 +64,11 @@ mod tests {
         let stride = 1;
         let dilation = 2;
 
-        let x = TestTensor::from_floats([[
+        let x = TestTensor::from_floats_devauto([[
             [0.9861, 0.5474, 0.4477, 0.0732, 0.3548, 0.8221],
             [0.8148, 0.5474, 0.9490, 0.7890, 0.5537, 0.5689],
         ]]);
-        let y = TestTensor::from_floats([[
+        let y = TestTensor::from_floats_devauto([[
             [0.5474, 0.9861, 0.5474, 0.4477, 0.8221, 0.3548],
             [0.5474, 0.9490, 0.7890, 0.9490, 0.7890, 0.5537],
         ]]);
@@ -85,9 +85,9 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x = TestTensor::from_floats([[[0.2479, 0.6386, 0.3166, 0.5742]]]);
+        let x = TestTensor::from_floats_devauto([[[0.2479, 0.6386, 0.3166, 0.5742]]]);
         let indices = Data::<IntElem, 3>::from([[[1, 1, 3]]]);
-        let y = TestTensor::from_floats([[[0.6386, 0.6386, 0.5742]]]);
+        let y = TestTensor::from_floats_devauto([[[0.6386, 0.6386, 0.5742]]]);
 
         let (output, output_indices) =
             max_pool1d_with_indices(x, kernel_size, stride, padding, dilation);
@@ -103,9 +103,10 @@ mod tests {
         let stride = 1;
         let dilation = 1;
 
-        let x = TestTensor::from_floats([[[0.5388, 0.0676, 0.7122, 0.8316, 0.0653]]]);
+        let x = TestTensor::from_floats_devauto([[[0.5388, 0.0676, 0.7122, 0.8316, 0.0653]]]);
         let indices = Data::<IntElem, 3>::from([[[0, 2, 3, 3, 3, 3]]]);
-        let y = TestTensor::from_floats([[[0.5388, 0.7122, 0.8316, 0.8316, 0.8316, 0.8316]]]);
+        let y =
+            TestTensor::from_floats_devauto([[[0.5388, 0.7122, 0.8316, 0.8316, 0.8316, 0.8316]]]);
 
         let (output, output_indices) =
             max_pool1d_with_indices(x, kernel_size, stride, padding, dilation);
diff --git a/burn-tensor/src/tests/module/maxpool2d.rs b/burn-tensor/src/tests/module/maxpool2d.rs
index 47a843fa9..c8bdd7479 100644
--- a/burn-tensor/src/tests/module/maxpool2d.rs
+++ b/burn-tensor/src/tests/module/maxpool2d.rs
@@ -19,7 +19,7 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestTensor::from_floats([
+        let x = TestTensor::from_floats_devauto([
             [
                 [
                     [0.9861, 0.5474, 0.4477, 0.0732, 0.3548, 0.8221],
@@ -57,7 +57,7 @@ mod tests {
                 ],
             ],
         ]);
-        let y = TestTensor::from_floats([
+        let y = TestTensor::from_floats_devauto([
             [
                 [
                     [0.9861, 0.9861, 0.9490, 0.9490, 0.8221, 0.8221],
@@ -120,7 +120,7 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestTensor::from_floats([[[
+        let x = TestTensor::from_floats_devauto([[[
             [0.6309, 0.6112, 0.6998],
             [0.4708, 0.9161, 0.5402],
             [0.4577, 0.7397, 0.9870],
@@ -128,7 +128,7 @@ mod tests {
             [0.6277, 0.5139, 0.4525],
             [0.9333, 0.9846, 0.5006],
         ]]]);
-        let y = TestTensor::from_floats([[[
+        let y = TestTensor::from_floats_devauto([[[
             [0.6309, 0.6998],
             [0.6309, 0.9870],
             [0.6380, 0.9870],
@@ -161,7 +161,7 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestTensor::from_floats([[[
+        let x = TestTensor::from_floats_devauto([[[
             [0.6309, 0.6112, 0.6998],
             [0.4708, 0.9161, 0.5402],
             [0.4577, 0.7397, 0.9870],
@@ -170,7 +170,7 @@ mod tests {
             [0.9333, 0.9846, 0.5006],
         ]]])
         .neg();
-        let y = TestTensor::from_floats([[[
+        let y = TestTensor::from_floats_devauto([[[
             [-0.4708, -0.4708, -0.5402],
             [-0.4577, -0.4577, -0.5402],
             [-0.4352, -0.4352, -0.4352],
@@ -203,7 +203,7 @@ mod tests {
         let dilation_1 = 2;
         let dilation_2 = 2;
 
-        let x = TestTensor::from_floats([[[
+        let x = TestTensor::from_floats_devauto([[[
             [0.9861, 0.9861, 0.9490, 0.9490, 0.8221, 0.8221],
             [0.9861, 0.9861, 0.9490, 0.9490, 0.8221, 0.8221],
             [0.9540, 0.9540, 0.9540, 0.9490, 0.7890, 0.7111],
@@ -211,7 +211,7 @@ mod tests {
             [0.9540, 0.9540, 0.9540, 0.9432, 0.8855, 0.8855],
             [0.5063, 0.9432, 0.9432, 0.9432, 0.8855, 0.8855],
         ]]]);
-        let y = TestTensor::from_floats([[[
+        let y = TestTensor::from_floats_devauto([[[
             [0.9861, 0.9861, 0.9540, 0.9490],
             [0.9861, 0.9861, 0.9540, 0.9490],
             [0.9540, 0.9540, 0.9540, 0.9490],
@@ -241,7 +241,7 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestTensor::from_floats([[[
+        let x = TestTensor::from_floats_devauto([[[
             [0.2479, 0.6386, 0.3166, 0.5742],
             [0.7065, 0.1940, 0.6305, 0.8959],
             [0.5416, 0.8602, 0.8129, 0.1662],
@@ -254,7 +254,7 @@ mod tests {
             [8, 9, 9, 14, 11],
             [12, 12, 14, 14, 15],
         ]]]);
-        let y = TestTensor::from_floats([[[
+        let y = TestTensor::from_floats_devauto([[[
             [0.2479, 0.6386, 0.6386, 0.5742, 0.5742],
             [0.7065, 0.7065, 0.6386, 0.8959, 0.8959],
             [0.7065, 0.8602, 0.8602, 0.8959, 0.8959],
@@ -287,7 +287,7 @@ mod tests {
         let dilation_1 = 1;
         let dilation_2 = 1;
 
-        let x = TestTensor::from_floats([[[
+        let x = TestTensor::from_floats_devauto([[[
             [0.5388, 0.0676, 0.7122, 0.8316, 0.0653],
             [0.9154, 0.1536, 0.9089, 0.8016, 0.7518],
             [0.2073, 0.0501, 0.8811, 0.5604, 0.5075],
@@ -302,7 +302,7 @@ mod tests {
             [15, 16, 24],
             [15, 16, 24],
         ]]]);
-        let y = TestTensor::from_floats([[[
+        let y = TestTensor::from_floats_devauto([[[
             [0.9154, 0.9089, 0.8316],
             [0.9154, 0.9089, 0.8316],
             [0.9154, 0.9963, 0.8316],
diff --git a/burn-tensor/src/tests/module/unfold4d.rs b/burn-tensor/src/tests/module/unfold4d.rs
index afb1df24b..49da24e9a 100644
--- a/burn-tensor/src/tests/module/unfold4d.rs
+++ b/burn-tensor/src/tests/module/unfold4d.rs
@@ -34,7 +34,7 @@ mod tests {
             width: 4,
         };
 
-        test.assert_output(TestTensor::from_data([[
+        test.assert_output(TestTensor::from_data_devauto([[
             [0., 1., 2., 4., 5., 6., 8., 9., 10.],
             [1., 2., 3., 5., 6., 7., 9., 10., 11.],
             [4., 5., 6., 8., 9., 10., 12., 13., 14.],
@@ -59,7 +59,7 @@ mod tests {
             width: 4,
         };
 
-        test.assert_output(TestTensor::from_data([[
+        test.assert_output(TestTensor::from_data_devauto([[
             [0., 0.],
             [1., 5.],
             [3., 7.],
@@ -89,8 +89,8 @@ mod tests {
     impl Unfold4dTestCase {
         fn assert_shape(self, expected_shape: [usize; 3]) {
             let shape_x = Shape::new([self.batch_size, self.channels_in, self.height, self.width]);
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
@@ -111,8 +111,8 @@ mod tests {
 
         fn assert_output(self, expected: TestTensor<3>) {
             let shape_x = Shape::new([self.batch_size, self.channels_in, self.height, self.width]);
-            let x = TestTensor::from_data(
-                TestTensorInt::arange(0..shape_x.num_elements())
+            let x = TestTensor::from_data_devauto(
+                TestTensorInt::arange_devauto(0..shape_x.num_elements())
                     .reshape(shape_x)
                     .into_data()
                     .convert(),
diff --git a/burn-tensor/src/tests/ops/abs.rs b/burn-tensor/src/tests/ops/abs.rs
index f87b87a6f..4892a26c6 100644
--- a/burn-tensor/src/tests/ops/abs.rs
+++ b/burn-tensor/src/tests/ops/abs.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_abs_ops_float() {
         let data = Data::from([[0.0, -1.0, 2.0], [3.0, 4.0, -5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.abs().into_data();
 
@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn should_support_abs_ops_int() {
         let data = Data::from([[0, -1, 2], [3, 4, -5]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let data_actual = tensor.abs().into_data();
 
diff --git a/burn-tensor/src/tests/ops/add.rs b/burn-tensor/src/tests/ops/add.rs
index c69981dff..11731972b 100644
--- a/burn-tensor/src/tests/ops/add.rs
+++ b/burn-tensor/src/tests/ops/add.rs
@@ -8,8 +8,8 @@ mod tests {
     fn test_add_d2() {
         let data_1 = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let data_2 = Data::from([[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 + tensor_2).into_data();
 
@@ -21,8 +21,8 @@ mod tests {
     fn test_add_broadcast() {
         let data_1 = Data::from([[0.0, 1.0, 2.0]]);
         let data_2 = Data::from([[3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 + tensor_2).into_data();
 
@@ -37,8 +37,8 @@ mod tests {
 
         // We need to execute an operation after `from data` to trigger inplace in some backends.
         // Which is the operation that might be problematic in this case.
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1) * 1;
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2) * 1;
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1) * 1;
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2) * 1;
 
         let data_actual = (tensor_1 + tensor_2.transpose()).into_data();
 
@@ -53,8 +53,8 @@ mod tests {
 
         // We need to execute an operation after `from data` to trigger inplace in some backends.
         // Which is the operation that might be problematic in this case.
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1) * 1;
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2) * 1;
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1) * 1;
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2) * 1;
 
         let data_actual = (tensor_1.transpose() + tensor_2).into_data();
 
@@ -69,8 +69,8 @@ mod tests {
 
         // We need to execute an operation after `from data` to trigger inplace in some backends.
         // Which is the operation that might be problematic in this case.
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1) * 1;
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2) * 1;
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1) * 1;
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2) * 1;
 
         let data_actual = (tensor_1.transpose() + tensor_2).into_data();
 
@@ -82,7 +82,7 @@ mod tests {
     fn should_support_add_scalar_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let scalar = 2.0;
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let output = tensor + scalar;
 
@@ -95,8 +95,8 @@ mod tests {
     fn test_add_d2_int() {
         let data_1 = Data::from([[0, 1, 2], [3, 4, 5]]);
         let data_2 = Data::from([[6, 7, 8], [9, 10, 11]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 + tensor_2).into_data();
 
@@ -108,8 +108,8 @@ mod tests {
     fn test_add_broadcast_int() {
         let data_1 = Data::from([[0, 1, 2]]);
         let data_2 = Data::from([[3, 4, 5], [6, 7, 8]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 + tensor_2).into_data();
 
@@ -121,7 +121,7 @@ mod tests {
     fn should_support_add_scalar_ops_int() {
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
         let scalar = 2;
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let output = tensor + scalar;
 
diff --git a/burn-tensor/src/tests/ops/aggregation.rs b/burn-tensor/src/tests/ops/aggregation.rs
index 45b94a89b..fc66733fa 100644
--- a/burn-tensor/src/tests/ops/aggregation.rs
+++ b/burn-tensor/src/tests/ops/aggregation.rs
@@ -5,7 +5,7 @@ mod tests {
 
     #[test]
     fn test_should_mean() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let data_actual = tensor.mean().to_data();
 
@@ -14,7 +14,7 @@ mod tests {
 
     #[test]
     fn test_should_mean_int() {
-        let tensor = TestTensorInt::from_data([[2, 2, 2], [3, 4, 5]]);
+        let tensor = TestTensorInt::from_data_devauto([[2, 2, 2], [3, 4, 5]]);
 
         let data_actual = tensor.mean().to_data();
 
@@ -23,7 +23,7 @@ mod tests {
 
     #[test]
     fn test_should_sum() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let data_actual = tensor.sum().to_data();
 
@@ -32,7 +32,7 @@ mod tests {
 
     #[test]
     fn test_should_sum_int() {
-        let tensor = TestTensorInt::from_data([[0, 1, 2], [3, 4, 5]]);
+        let tensor = TestTensorInt::from_data_devauto([[0, 1, 2], [3, 4, 5]]);
 
         let data_actual = tensor.sum().to_data();
 
@@ -41,7 +41,7 @@ mod tests {
 
     #[test]
     fn test_should_mean_last_dim() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let data_actual = tensor.mean_dim(1).to_data();
 
@@ -50,7 +50,7 @@ mod tests {
 
     #[test]
     fn test_should_sum_last_dim() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let data_actual = tensor.sum_dim(1).to_data();
 
@@ -59,7 +59,7 @@ mod tests {
 
     #[test]
     fn test_should_mean_last_dim_int() {
-        let tensor = TestTensorInt::from_data([[0, 1, 2], [3, 4, 5]]);
+        let tensor = TestTensorInt::from_data_devauto([[0, 1, 2], [3, 4, 5]]);
 
         let data_actual = tensor.mean_dim(1).to_data();
 
@@ -68,7 +68,7 @@ mod tests {
 
     #[test]
     fn test_should_sum_last_dim_int() {
-        let tensor = TestTensorInt::from_data([[0, 1, 2], [3, 4, 5]]);
+        let tensor = TestTensorInt::from_data_devauto([[0, 1, 2], [3, 4, 5]]);
 
         let data_actual = tensor.sum_dim(1).to_data();
 
@@ -77,7 +77,7 @@ mod tests {
 
     #[test]
     fn test_should_sum_first_dim() {
-        let tensor = TestTensor::from_data([[3.0, 1.0, 2.0], [4.0, 2.0, 3.0]]);
+        let tensor = TestTensor::from_data_devauto([[3.0, 1.0, 2.0], [4.0, 2.0, 3.0]]);
 
         let data_actual = tensor.sum_dim(0).to_data();
 
@@ -86,7 +86,7 @@ mod tests {
 
     #[test]
     fn test_should_mean_first_dim() {
-        let tensor = TestTensor::from_data([[3.0, 1.0, 2.0], [4.0, 2.0, 3.0]]);
+        let tensor = TestTensor::from_data_devauto([[3.0, 1.0, 2.0], [4.0, 2.0, 3.0]]);
 
         let data_actual = tensor.mean_dim(0).to_data();
 
@@ -95,7 +95,7 @@ mod tests {
 
     #[test]
     fn test_should_sum_mid_dim_3d_non_contiguous_1() {
-        let tensor = TestTensor::from_data([
+        let tensor = TestTensor::from_data_devauto([
             [[2.0, 4.0, 1.0], [7.0, -5.0, 3.0]],
             [[3.0, 1.0, 2.0], [4.0, 2.0, 3.0]],
         ]);
@@ -110,7 +110,7 @@ mod tests {
 
     #[test]
     fn test_should_sum_mid_dim_3d_non_contiguous_2() {
-        let tensor = TestTensor::from_data([
+        let tensor = TestTensor::from_data_devauto([
             [[2.0, 4.0, 1.0], [7.0, -5.0, 3.0]],
             [[3.0, 1.0, 2.0], [4.0, 2.0, 3.0]],
         ]);
diff --git a/burn-tensor/src/tests/ops/arange.rs b/burn-tensor/src/tests/ops/arange.rs
index 5abe68aff..112d92063 100644
--- a/burn-tensor/src/tests/ops/arange.rs
+++ b/burn-tensor/src/tests/ops/arange.rs
@@ -5,16 +5,15 @@ mod tests {
     use burn_tensor::{Data, Int, Tensor};
 
     #[test]
-    fn test_arange() {
-        let tensor = Tensor::<TestBackend, 1, Int>::arange(2..5);
+    fn test_arange_devauto() {
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_devauto(2..5);
         assert_eq!(tensor.into_data(), Data::from([2, 3, 4]));
     }
 
     #[test]
-    fn test_arange_device() {
+    fn test_arange() {
         let device = <TestBackend as Backend>::Device::default();
-
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_device(2..5, &device);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange(2..5, &device);
         assert_eq!(tensor.clone().into_data(), Data::from([2, 3, 4]));
         assert_eq!(tensor.device(), device);
     }
diff --git a/burn-tensor/src/tests/ops/arange_step.rs b/burn-tensor/src/tests/ops/arange_step.rs
index 127f234ec..77d2e714d 100644
--- a/burn-tensor/src/tests/ops/arange_step.rs
+++ b/burn-tensor/src/tests/ops/arange_step.rs
@@ -5,34 +5,34 @@ mod tests {
     use burn_tensor::{Data, Int, Tensor};
 
     #[test]
-    fn test_arange_step() {
+    fn test_arange_step_devauto() {
         // Test correct sequence of numbers when the range is 0..9 and the step is 1
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..9, 1);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_step_devauto(0..9, 1);
         assert_eq!(tensor.into_data(), Data::from([0, 1, 2, 3, 4, 5, 6, 7, 8]));
 
         // Test correct sequence of numbers when the range is 0..3 and the step is 2
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..3, 2);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_step_devauto(0..3, 2);
         assert_eq!(tensor.into_data(), Data::from([0, 2]));
 
         // Test correct sequence of numbers when the range is 0..2 and the step is 5
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..2, 5);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_step_devauto(0..2, 5);
         assert_eq!(tensor.into_data(), Data::from([0]));
     }
 
     #[test]
-    fn test_arange_step_device() {
+    fn test_arange_step() {
         let device = <TestBackend as Backend>::Device::default();
 
         // Test correct sequence of numbers when the range is 0..9 and the step is 1
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_step_device(0..9, 1, &device);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..9, 1, &device);
         assert_eq!(tensor.into_data(), Data::from([0, 1, 2, 3, 4, 5, 6, 7, 8]));
 
         // Test correct sequence of numbers when the range is 0..3 and the step is 2
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_step_device(0..3, 2, &device);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..3, 2, &device);
         assert_eq!(tensor.into_data(), Data::from([0, 2]));
 
         // Test correct sequence of numbers when the range is 0..2 and the step is 5
-        let tensor = Tensor::<TestBackend, 1, Int>::arange_step_device(0..2, 5, &device);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..2, 5, &device);
         assert_eq!(tensor.clone().into_data(), Data::from([0]));
         assert_eq!(tensor.device(), device);
     }
@@ -40,7 +40,8 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_panic_when_step_is_zero() {
+        let device = <TestBackend as Backend>::Device::default();
         // Test that arange_step panics when the step is 0
-        let _tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..3, 0);
+        let _tensor = Tensor::<TestBackend, 1, Int>::arange_step(0..3, 0, &device);
     }
 }
diff --git a/burn-tensor/src/tests/ops/arg.rs b/burn-tensor/src/tests/ops/arg.rs
index fd6f282b7..329bae342 100644
--- a/burn-tensor/src/tests/ops/arg.rs
+++ b/burn-tensor/src/tests/ops/arg.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_argmax_2d_dim0() {
         let data = Data::from([[10.0, 11.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.argmax(0);
 
@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn test_argmin_2d_dim0() {
         let data = Data::from([[10.0, 11.0, 2.0], [30.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.argmin(0);
 
@@ -28,7 +28,7 @@ mod tests {
     #[test]
     fn test_argmax_2d_dim0_int() {
         let data = Data::from([[10, 11, 2], [3, 4, 5]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let data_actual = tensor.argmax(0);
 
@@ -39,7 +39,7 @@ mod tests {
     #[test]
     fn test_argmin_2d_dim0_int() {
         let data = Data::from([[10, 11, 2], [30, 4, 5]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let data_actual = tensor.argmin(0);
 
@@ -50,7 +50,7 @@ mod tests {
     #[test]
     fn test_argmax_2d_dim1() {
         let data = Data::from([[10.0, 11.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.argmax(1);
 
@@ -61,7 +61,7 @@ mod tests {
     #[test]
     fn test_argmin_2d_dim1() {
         let data = Data::from([[10.0, 11.0, 2.0], [30.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.argmin(1);
 
diff --git a/burn-tensor/src/tests/ops/cast.rs b/burn-tensor/src/tests/ops/cast.rs
index e6ac40ae7..32d1cc03f 100644
--- a/burn-tensor/src/tests/ops/cast.rs
+++ b/burn-tensor/src/tests/ops/cast.rs
@@ -5,7 +5,8 @@ mod tests {
 
     #[test]
     fn cast_float_to_int() {
-        let tensor = Tensor::<TestBackend, 2>::from_data([[1.0, 2.0, 3.0], [4.4, 5.5, 6.6]]);
+        let tensor =
+            Tensor::<TestBackend, 2>::from_data_devauto([[1.0, 2.0, 3.0], [4.4, 5.5, 6.6]]);
 
         let actual = tensor.int().into_data();
         let expected = Data::from([[1, 2, 3], [4, 5, 6]]);
@@ -14,7 +15,7 @@ mod tests {
 
     #[test]
     fn cast_int_to_float_tensor() {
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data([[1, 2, 3], [4, 5, 6]]);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto([[1, 2, 3], [4, 5, 6]]);
 
         let actual = tensor.float().into_data();
         let expected = Data::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
@@ -23,8 +24,10 @@ mod tests {
 
     #[test]
     fn cast_bool_to_int_tensor() {
-        let tensor =
-            Tensor::<TestBackend, 2, Bool>::from_data([[true, false, true], [false, false, true]]);
+        let tensor = Tensor::<TestBackend, 2, Bool>::from_data_devauto([
+            [true, false, true],
+            [false, false, true],
+        ]);
 
         let actual = tensor.int().into_data();
         let expected = Data::from([[1, 0, 1], [0, 0, 1]]);
@@ -33,8 +36,10 @@ mod tests {
 
     #[test]
     fn cast_bool_to_float_tensor() {
-        let tensor =
-            Tensor::<TestBackend, 2, Bool>::from_data([[true, false, true], [false, false, true]]);
+        let tensor = Tensor::<TestBackend, 2, Bool>::from_data_devauto([
+            [true, false, true],
+            [false, false, true],
+        ]);
 
         let actual = tensor.float().into_data();
         let expected = Data::from([[1., 0., 1.], [0., 0., 1.]]);
diff --git a/burn-tensor/src/tests/ops/cat.rs b/burn-tensor/src/tests/ops/cat.rs
index f01311b2d..bc46c1f45 100644
--- a/burn-tensor/src/tests/ops/cat.rs
+++ b/burn-tensor/src/tests/ops/cat.rs
@@ -5,8 +5,8 @@ mod tests {
     use burn_tensor::{Bool, Data, Int, Tensor};
     #[test]
     fn should_support_cat_ops_2d_dim0() {
-        let tensor_1 = TestTensor::from_data([[1.0, 2.0, 3.0]]);
-        let tensor_2 = TestTensor::from_data([[4.0, 5.0, 6.0]]);
+        let tensor_1 = TestTensor::from_data_devauto([[1.0, 2.0, 3.0]]);
+        let tensor_2 = TestTensor::from_data_devauto([[4.0, 5.0, 6.0]]);
 
         let data_actual = TestTensor::cat(vec![tensor_1, tensor_2], 0).into_data();
 
@@ -16,8 +16,8 @@ mod tests {
 
     #[test]
     fn should_support_cat_ops_int() {
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data([[1, 2, 3]]);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data([[4, 5, 6]]);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto([[1, 2, 3]]);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto([[4, 5, 6]]);
 
         let data_actual = Tensor::cat(vec![tensor_1, tensor_2], 0).into_data();
 
@@ -27,8 +27,8 @@ mod tests {
 
     #[test]
     fn should_support_cat_ops_bool() {
-        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data([[false, true, true]]);
-        let tensor_2 = Tensor::<TestBackend, 2, Bool>::from_data([[true, true, false]]);
+        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data_devauto([[false, true, true]]);
+        let tensor_2 = Tensor::<TestBackend, 2, Bool>::from_data_devauto([[true, true, false]]);
 
         let data_actual = Tensor::cat(vec![tensor_1, tensor_2], 0).into_data();
 
@@ -38,8 +38,8 @@ mod tests {
 
     #[test]
     fn should_support_cat_ops_2d_dim1() {
-        let tensor_1 = TestTensor::from_data([[1.0, 2.0, 3.0]]);
-        let tensor_2 = TestTensor::from_data([[4.0, 5.0, 6.0]]);
+        let tensor_1 = TestTensor::from_data_devauto([[1.0, 2.0, 3.0]]);
+        let tensor_2 = TestTensor::from_data_devauto([[4.0, 5.0, 6.0]]);
 
         let data_actual = TestTensor::cat(vec![tensor_1, tensor_2], 1).into_data();
 
@@ -49,8 +49,8 @@ mod tests {
 
     #[test]
     fn should_support_cat_ops_3d() {
-        let tensor_1 = TestTensor::from_data([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
-        let tensor_2 = TestTensor::from_data([[[4.0, 5.0, 6.0]]]);
+        let tensor_1 = TestTensor::from_data_devauto([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
+        let tensor_2 = TestTensor::from_data_devauto([[[4.0, 5.0, 6.0]]]);
 
         let data_actual = TestTensor::cat(vec![tensor_1, tensor_2], 0).into_data();
 
@@ -61,8 +61,8 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_panic_when_dimensions_are_not_the_same() {
-        let tensor_1 = TestTensor::from_data([[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]]);
-        let tensor_2 = TestTensor::from_data([[4.0, 5.0]]);
+        let tensor_1 = TestTensor::from_data_devauto([[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]]);
+        let tensor_2 = TestTensor::from_data_devauto([[4.0, 5.0]]);
 
         TestTensor::cat(vec![tensor_1, tensor_2], 0).into_data();
     }
@@ -77,8 +77,8 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_panic_when_cat_exceeds_dimension() {
-        let tensor_1 = TestTensor::from_data([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
-        let tensor_2 = TestTensor::from_data([[[4.0, 5.0, 6.0]]]);
+        let tensor_1 = TestTensor::from_data_devauto([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
+        let tensor_2 = TestTensor::from_data_devauto([[[4.0, 5.0, 6.0]]]);
 
         TestTensor::cat(vec![tensor_1, tensor_2], 3).into_data();
     }
diff --git a/burn-tensor/src/tests/ops/chunk.rs b/burn-tensor/src/tests/ops/chunk.rs
index 53b439549..2eac991d9 100644
--- a/burn-tensor/src/tests/ops/chunk.rs
+++ b/burn-tensor/src/tests/ops/chunk.rs
@@ -5,7 +5,7 @@ mod tests {
     use burn_tensor::{Data, Int, Shape, Tensor};
 
     fn test_chunk_evenly_divisible() {
-        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange(0..12).chunk(6, 0);
+        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange_devauto(0..12).chunk(6, 0);
         assert_eq!(tensors.len(), 6);
 
         let expected = vec![
@@ -24,7 +24,7 @@ mod tests {
 
     #[test]
     fn test_chunk_not_evenly_divisible() {
-        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange(0..11).chunk(6, 0);
+        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange_devauto(0..11).chunk(6, 0);
         assert_eq!(tensors.len(), 6);
 
         let expected = vec![
@@ -43,7 +43,7 @@ mod tests {
 
     #[test]
     fn test_chunk_not_evenly_divisible_remains_several() {
-        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange(0..100).chunk(8, 0);
+        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange_devauto(0..100).chunk(8, 0);
         assert_eq!(tensors.len(), 8);
 
         let expected = [13, 13, 13, 13, 13, 13, 13, 9];
@@ -55,7 +55,7 @@ mod tests {
 
     #[test]
     fn test_chunk_not_divisible() {
-        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange(0..6).chunk(7, 0);
+        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange_devauto(0..6).chunk(7, 0);
         assert_eq!(tensors.len(), 6);
 
         let expected = vec![
@@ -75,7 +75,7 @@ mod tests {
     #[test]
     fn test_chunk_multi_dimension() {
         let tensors: Vec<Tensor<TestBackend, 2, Int>> =
-            Tensor::from_data(Data::from([[0, 1, 2, 3]])).chunk(2, 1);
+            Tensor::from_data_devauto(Data::from([[0, 1, 2, 3]])).chunk(2, 1);
         assert_eq!(tensors.len(), 2);
 
         let expected = vec![Data::from([[0, 1]]), Data::from([[2, 3]])];
@@ -88,6 +88,6 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_invalid_dim() {
-        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange(0..12).chunk(6, 1);
+        let tensors: Vec<Tensor<TestBackend, 1, Int>> = Tensor::arange_devauto(0..12).chunk(6, 1);
     }
 }
diff --git a/burn-tensor/src/tests/ops/clamp.rs b/burn-tensor/src/tests/ops/clamp.rs
index 2acda4c0d..54bccdbe1 100644
--- a/burn-tensor/src/tests/ops/clamp.rs
+++ b/burn-tensor/src/tests/ops/clamp.rs
@@ -7,7 +7,7 @@ mod tests {
     fn clamp_min() {
         // test float tensor
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.clamp_min(2.0).into_data();
 
@@ -16,7 +16,7 @@ mod tests {
 
         // test int tensor
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
         let data_actual = tensor.clamp_min(2).into_data();
         let data_expected = Data::from([[2, 2, 2], [3, 4, 5]]);
         assert_eq!(data_expected, data_actual);
@@ -26,7 +26,7 @@ mod tests {
     fn clamp_max() {
         // test float tensor
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.clamp_max(2.0).into_data();
 
@@ -35,7 +35,7 @@ mod tests {
 
         // test int tensor
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
         let data_actual = tensor.clamp_max(4).into_data();
         let data_expected = Data::from([[0, 1, 2], [3, 4, 4]]);
         assert_eq!(data_expected, data_actual);
@@ -45,14 +45,14 @@ mod tests {
     fn clamp_min_max() {
         // test float tensor
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
         let data_actual = tensor.clamp(1.0, 4.0).into_data();
         let data_expected = Data::from([[1.0, 1.0, 2.0], [3.0, 4.0, 4.0]]);
         assert_eq!(data_expected, data_actual);
 
         // test int tensor
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
         let data_actual = tensor.clamp(1, 4).into_data();
         let data_expected = Data::from([[1, 1, 2], [3, 4, 4]]);
         assert_eq!(data_expected, data_actual);
diff --git a/burn-tensor/src/tests/ops/cos.rs b/burn-tensor/src/tests/ops/cos.rs
index c099b1e4e..e244ad251 100644
--- a/burn-tensor/src/tests/ops/cos.rs
+++ b/burn-tensor/src/tests/ops/cos.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_cos_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.cos().into_data();
 
diff --git a/burn-tensor/src/tests/ops/create_like.rs b/burn-tensor/src/tests/ops/create_like.rs
index ea54aeabc..e7f7bca41 100644
--- a/burn-tensor/src/tests/ops/create_like.rs
+++ b/burn-tensor/src/tests/ops/create_like.rs
@@ -5,7 +5,7 @@ mod tests {
 
     #[test]
     fn should_support_zeros_like() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
@@ -20,7 +20,7 @@ mod tests {
 
     #[test]
     fn should_support_ones_like() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
@@ -35,7 +35,7 @@ mod tests {
 
     #[test]
     fn should_support_randoms_like() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
diff --git a/burn-tensor/src/tests/ops/div.rs b/burn-tensor/src/tests/ops/div.rs
index fb3e91f07..4a8436147 100644
--- a/burn-tensor/src/tests/ops/div.rs
+++ b/burn-tensor/src/tests/ops/div.rs
@@ -7,8 +7,8 @@ mod tests {
     fn should_support_div_ops() {
         let data_1 = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let data_2 = Data::from([[1.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let output = tensor_1 / tensor_2;
 
@@ -21,8 +21,8 @@ mod tests {
     fn test_div_broadcast() {
         let data_1 = Data::from([[0.0, 1.0, 2.0]]);
         let data_2 = Data::from([[1.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 / tensor_2).into_data();
 
@@ -34,7 +34,7 @@ mod tests {
     fn should_support_div_scalar_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let scalar = 2.0;
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let output = tensor / scalar;
 
@@ -47,8 +47,8 @@ mod tests {
     fn should_support_div_ops_int() {
         let data_1 = Data::from([[0, 1, 2], [3, 4, 5]]);
         let data_2 = Data::from([[1, 1, 2], [1, 1, 2]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let output = tensor_1 / tensor_2;
 
@@ -61,8 +61,8 @@ mod tests {
     fn test_div_broadcast_int() {
         let data_1 = Data::from([[0, 1, 2]]);
         let data_2 = Data::from([[1, 1, 2], [3, 4, 5]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 / tensor_2).into_data();
 
@@ -74,7 +74,7 @@ mod tests {
     fn should_support_div_scalar_ops_int() {
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
         let scalar = 2;
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let output = tensor / scalar;
 
diff --git a/burn-tensor/src/tests/ops/erf.rs b/burn-tensor/src/tests/ops/erf.rs
index 14afb899d..001f64086 100644
--- a/burn-tensor/src/tests/ops/erf.rs
+++ b/burn-tensor/src/tests/ops/erf.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_erf_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.erf().into_data();
 
@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn should_support_erf_ops_with_negative_number() {
         let data = Data::from([[-0.056, -0.043, -0.089], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.erf().into_data();
 
diff --git a/burn-tensor/src/tests/ops/exp.rs b/burn-tensor/src/tests/ops/exp.rs
index 278b7b6a4..992381f51 100644
--- a/burn-tensor/src/tests/ops/exp.rs
+++ b/burn-tensor/src/tests/ops/exp.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_exp_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.exp().into_data();
 
diff --git a/burn-tensor/src/tests/ops/flatten.rs b/burn-tensor/src/tests/ops/flatten.rs
index 7876bfac3..af4a71592 100644
--- a/burn-tensor/src/tests/ops/flatten.rs
+++ b/burn-tensor/src/tests/ops/flatten.rs
@@ -6,7 +6,7 @@ mod tests {
     /// Test if the function can successfully flatten a 4D tensor to a 1D tensor.
     #[test]
     fn should_flatten_to_1d() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let flattened_tensor: Tensor<TestBackend, 1> = tensor.flatten(0, 3);
         let expected_shape = Shape::new([120]);
         assert_eq!(flattened_tensor.shape(), expected_shape);
@@ -15,7 +15,7 @@ mod tests {
     /// Test if the function can successfully flatten the middle dimensions of a 4D tensor.
     #[test]
     fn should_flatten_middle() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let flattened_tensor: Tensor<TestBackend, 3> = tensor.flatten(1, 2);
         let expected_shape = Shape::new([2, 12, 5]);
         assert_eq!(flattened_tensor.shape(), expected_shape);
@@ -24,7 +24,7 @@ mod tests {
     /// Test if the function can successfully flatten the first dimensions of a 4D tensor.
     #[test]
     fn should_flatten_begin() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let flattened_tensor: Tensor<TestBackend, 2> = tensor.flatten(0, 2);
         let expected_shape = Shape::new([24, 5]);
         assert_eq!(flattened_tensor.shape(), expected_shape);
@@ -33,7 +33,7 @@ mod tests {
     /// Test if the function can successfully flatten the last dimensions of a 4D tensor.
     #[test]
     fn should_flatten_end() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let flattened_tensor: Tensor<TestBackend, 2> = tensor.flatten(1, 3);
         let expected_shape = Shape::new([2, 60]);
         assert_eq!(flattened_tensor.shape(), expected_shape);
@@ -43,14 +43,14 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_flatten_panic() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let flattened_tensor: Tensor<TestBackend, 2> = tensor.flatten(2, 0);
     }
 
     #[test]
     #[should_panic]
     fn not_enough_destination_dimension() {
-        let tensor = Tensor::<TestBackend, 3>::ones(Shape::new([1, 5, 15]));
+        let tensor = Tensor::<TestBackend, 3>::ones_devauto(Shape::new([1, 5, 15]));
         let flattened_tensor: Tensor<TestBackend, 1> = tensor.flatten(1, 2);
         let expected_shape = Shape::new([75]);
         assert_eq!(flattened_tensor.shape(), expected_shape);
diff --git a/burn-tensor/src/tests/ops/full.rs b/burn-tensor/src/tests/ops/full.rs
index c1de8e859..655a18c9f 100644
--- a/burn-tensor/src/tests/ops/full.rs
+++ b/burn-tensor/src/tests/ops/full.rs
@@ -13,12 +13,12 @@ mod tests {
     #[test]
     fn test_tensor_full() {
         // Test full with f32
-        let tensor = Tensor::<TestBackend, 2>::full([2, 3], 2.1);
+        let tensor = Tensor::<TestBackend, 2>::full_devauto([2, 3], 2.1);
         let data_expected = Data::from([[2.1, 2.1, 2.1], [2.1, 2.1, 2.1]]);
         assert_eq!(data_expected, tensor.into_data());
 
         // Test full with Int
-        let int_tensor = Tensor::<TestBackend, 2, Int>::full([2, 2], 2);
+        let int_tensor = Tensor::<TestBackend, 2, Int>::full_devauto([2, 2], 2);
         let data_expected = Data::from([[2, 2], [2, 2]]);
         assert_eq!(data_expected, int_tensor.into_data());
     }
diff --git a/burn-tensor/src/tests/ops/gather_scatter.rs b/burn-tensor/src/tests/ops/gather_scatter.rs
index 7b9abc782..cc1c47dc9 100644
--- a/burn-tensor/src/tests/ops/gather_scatter.rs
+++ b/burn-tensor/src/tests/ops/gather_scatter.rs
@@ -5,8 +5,8 @@ mod tests {
 
     #[test]
     fn should_gather_1d_dim0() {
-        let tensor = TestTensor::from_floats([0.0, 1.0, 2.0]);
-        let indices = TestTensorInt::from_ints([1, 1, 0, 1, 2]);
+        let tensor = TestTensor::from_floats_devauto([0.0, 1.0, 2.0]);
+        let indices = TestTensorInt::from_ints_devauto([1, 1, 0, 1, 2]);
 
         let output = tensor.gather(0, indices);
 
@@ -15,8 +15,8 @@ mod tests {
 
     #[test]
     fn should_gather_1d_dim0_int() {
-        let tensor = TestTensorInt::from_ints([5, 6, 7]);
-        let indices = TestTensorInt::from_ints([1, 1, 0, 1, 2]);
+        let tensor = TestTensorInt::from_ints_devauto([5, 6, 7]);
+        let indices = TestTensorInt::from_ints_devauto([1, 1, 0, 1, 2]);
 
         let output = tensor.gather(0, indices);
 
@@ -25,8 +25,8 @@ mod tests {
 
     #[test]
     fn should_gather_2d_dim0() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_ints([[0, 1, 0], [1, 0, 1]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_ints_devauto([[0, 1, 0], [1, 0, 1]]);
 
         let output = tensor.gather(0, indices);
 
@@ -38,8 +38,8 @@ mod tests {
 
     #[test]
     fn should_gather_2d_dim1() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_ints([[2, 1, 0, 0], [2, 0, 1, 2]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_ints_devauto([[2, 1, 0, 0], [2, 0, 1, 2]]);
 
         let output = tensor.gather(1, indices);
 
@@ -51,11 +51,12 @@ mod tests {
 
     #[test]
     fn should_gather_3d_dim1() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
-        let indices = TestTensorInt::from_ints([[[1, 0, 0], [0, 1, 0]], [[0, 0, 1], [0, 1, 1]]]);
+        let indices =
+            TestTensorInt::from_ints_devauto([[[1, 0, 0], [0, 1, 0]], [[0, 0, 1], [0, 1, 1]]]);
 
         let output = tensor.gather(1, indices);
 
@@ -70,8 +71,8 @@ mod tests {
 
     #[test]
     fn should_gather_2d_only_1dim() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_ints([[1, 2]]).reshape([2, 1]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_ints_devauto([[1, 2]]).reshape([2, 1]);
 
         let output = tensor.gather(1, indices);
 
@@ -80,9 +81,9 @@ mod tests {
 
     #[test]
     fn should_scatter_1d() {
-        let tensor = TestTensor::from_floats([0.0, 0.0, 0.0]);
-        let values = TestTensor::from_floats([5.0, 4.0, 3.0]);
-        let indices = TestTensorInt::from_ints([1, 0, 2]);
+        let tensor = TestTensor::from_floats_devauto([0.0, 0.0, 0.0]);
+        let values = TestTensor::from_floats_devauto([5.0, 4.0, 3.0]);
+        let indices = TestTensorInt::from_ints_devauto([1, 0, 2]);
 
         let output = tensor.scatter(0, indices, values);
 
@@ -91,9 +92,9 @@ mod tests {
 
     #[test]
     fn should_scatter_1d_int() {
-        let tensor = TestTensorInt::from_ints([0, 0, 0]);
-        let values = TestTensorInt::from_ints([5, 4, 3]);
-        let indices = TestTensorInt::from_ints([1, 0, 2]);
+        let tensor = TestTensorInt::from_ints_devauto([0, 0, 0]);
+        let values = TestTensorInt::from_ints_devauto([5, 4, 3]);
+        let indices = TestTensorInt::from_ints_devauto([1, 0, 2]);
 
         let output = tensor.scatter(0, indices, values);
 
@@ -102,9 +103,9 @@ mod tests {
 
     #[test]
     fn should_scatter_2d_dim0() {
-        let tensor = TestTensor::from_floats([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]);
-        let values = TestTensor::from_floats([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
-        let indices = TestTensorInt::from_ints([[1, 0, 1], [1, 1, 0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]);
+        let values = TestTensor::from_floats_devauto([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
+        let indices = TestTensorInt::from_ints_devauto([[1, 0, 1], [1, 1, 0]]);
 
         let output = tensor.scatter(0, indices, values);
 
@@ -116,9 +117,9 @@ mod tests {
 
     #[test]
     fn should_scatter_2d_dim1() {
-        let tensor = TestTensor::from_floats([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]);
-        let values = TestTensor::from_floats([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
-        let indices = TestTensorInt::from_ints([[1, 0, 2], [1, 2, 0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]);
+        let values = TestTensor::from_floats_devauto([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
+        let indices = TestTensorInt::from_ints_devauto([[1, 0, 2], [1, 2, 0]]);
 
         let output = tensor.scatter(1, indices, values);
 
@@ -130,15 +131,16 @@ mod tests {
 
     #[test]
     fn should_scatter_3d_dim1() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
-        let values = TestTensor::from_floats([
+        let values = TestTensor::from_floats_devauto([
             [[12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
             [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
         ]);
-        let indices = TestTensorInt::from_ints([[[1, 0, 0], [0, 1, 0]], [[0, 0, 1], [0, 1, 1]]]);
+        let indices =
+            TestTensorInt::from_ints_devauto([[[1, 0, 0], [0, 1, 0]], [[0, 0, 1], [0, 1, 1]]]);
 
         let output = tensor.scatter(1, indices, values);
 
@@ -153,9 +155,9 @@ mod tests {
 
     #[test]
     fn should_scatter_2d_dim1_diff_shape() {
-        let tensor = TestTensor::from_floats([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]);
-        let values = TestTensor::from_floats([[1.0], [4.0]]);
-        let indices = TestTensorInt::from_ints([[1], [2]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]);
+        let values = TestTensor::from_floats_devauto([[1.0], [4.0]]);
+        let indices = TestTensorInt::from_ints_devauto([[1], [2]]);
 
         let output = tensor.scatter(1, indices, values);
 
@@ -168,9 +170,9 @@ mod tests {
     #[test]
     #[should_panic]
     fn scatter_should_panic_on_mismatch_of_shapes() {
-        let tensor = TestTensor::from_floats([0.0, 0.0, 0.0]);
-        let values = TestTensor::from_floats([5.0, 4.0]);
-        let indices = TestTensorInt::from_ints([1, 0, 2]);
+        let tensor = TestTensor::from_floats_devauto([0.0, 0.0, 0.0]);
+        let values = TestTensor::from_floats_devauto([5.0, 4.0]);
+        let indices = TestTensorInt::from_ints_devauto([1, 0, 2]);
 
         tensor.scatter(0, indices, values);
     }
diff --git a/burn-tensor/src/tests/ops/init.rs b/burn-tensor/src/tests/ops/init.rs
index 7a89527cd..25058cf38 100644
--- a/burn-tensor/src/tests/ops/init.rs
+++ b/burn-tensor/src/tests/ops/init.rs
@@ -6,21 +6,21 @@ mod tests {
     #[test]
     fn should_support_float_empty() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2>::empty(shape);
+        let tensor = Tensor::<TestBackend, 2>::empty_devauto(shape);
         assert_eq!(tensor.shape(), shape.into())
     }
 
     #[test]
     fn should_support_int_empty() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2, Int>::empty(shape);
+        let tensor = Tensor::<TestBackend, 2, Int>::empty_devauto(shape);
         assert_eq!(tensor.shape(), shape.into())
     }
 
     #[test]
     fn should_support_float_zeros() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2>::zeros(shape);
+        let tensor = Tensor::<TestBackend, 2>::zeros_devauto(shape);
         assert_eq!(tensor.shape(), shape.into());
         assert_eq!(tensor.to_data(), Data::from([[0., 0.], [0., 0.]]))
     }
@@ -28,7 +28,7 @@ mod tests {
     #[test]
     fn should_support_int_zeros() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2, Int>::zeros(shape);
+        let tensor = Tensor::<TestBackend, 2, Int>::zeros_devauto(shape);
         assert_eq!(tensor.shape(), shape.into());
         assert_eq!(tensor.to_data(), Data::from([[0, 0], [0, 0]]))
     }
@@ -36,7 +36,7 @@ mod tests {
     #[test]
     fn should_support_float_ones() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2>::ones(shape);
+        let tensor = Tensor::<TestBackend, 2>::ones_devauto(shape);
         assert_eq!(tensor.shape(), shape.into());
         assert_eq!(tensor.to_data(), Data::from([[1., 1.], [1., 1.]]))
     }
@@ -44,7 +44,7 @@ mod tests {
     #[test]
     fn should_support_int_ones() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2, Int>::ones(shape);
+        let tensor = Tensor::<TestBackend, 2, Int>::ones_devauto(shape);
         assert_eq!(tensor.shape(), shape.into());
         assert_eq!(tensor.to_data(), Data::from([[1, 1], [1, 1]]))
     }
@@ -52,7 +52,7 @@ mod tests {
     #[test]
     fn should_support_bool_empty() {
         let shape = [2, 2];
-        let tensor = Tensor::<TestBackend, 2, Bool>::empty(shape);
+        let tensor = Tensor::<TestBackend, 2, Bool>::empty_devauto(shape);
         assert_eq!(tensor.shape(), shape.into())
     }
 }
diff --git a/burn-tensor/src/tests/ops/iter_dim.rs b/burn-tensor/src/tests/ops/iter_dim.rs
index 48024bd9d..b8cad41be 100644
--- a/burn-tensor/src/tests/ops/iter_dim.rs
+++ b/burn-tensor/src/tests/ops/iter_dim.rs
@@ -6,9 +6,9 @@ mod test {
     #[test]
     fn test_1d_iter_last_item() {
         let data = [1, 2, 3, 4];
-        let tensor = Tensor::<TestBackend, 1, Int>::from_ints(data);
+        let tensor = Tensor::<TestBackend, 1, Int>::from_ints_devauto(data);
         assert_eq!(
-            Tensor::<TestBackend, 1, Int>::from_ints([4]).into_data(),
+            Tensor::<TestBackend, 1, Int>::from_ints_devauto([4]).into_data(),
             tensor.iter_dim(0).last().unwrap().into_data()
         )
     }
@@ -16,7 +16,7 @@ mod test {
     #[test]
     #[should_panic]
     fn test_too_high_dimension() {
-        Tensor::<TestBackend, 1>::zeros([10]).iter_dim(1);
+        Tensor::<TestBackend, 1>::zeros_devauto([10]).iter_dim(1);
     }
 
     #[test]
@@ -26,7 +26,7 @@ mod test {
             [4., 5., 6., 1., 2.],
             [7., 8., 9., 1., 2.],
         ];
-        let tensor = Tensor::<TestBackend, 2>::from_floats(data);
+        let tensor = Tensor::<TestBackend, 2>::from_floats_devauto(data);
         let lhs = tensor.clone().slice([1..2, 0..5]);
         let rhs = tensor.transpose().iter_dim(1).nth(1).unwrap();
         assert_eq!(lhs.into_data().value, rhs.into_data().value);
@@ -38,7 +38,7 @@ mod test {
             [4., 5., 6., 1., 2.],
             [7., 8., 9., 1., 2.],
         ]; 5];
-        let tensor = Tensor::<TestBackend, 3>::from_floats(data);
+        let tensor = Tensor::<TestBackend, 3>::from_floats_devauto(data);
         let lhs = tensor.iter_dim(2).nth(1).unwrap();
         let rhs = Data::from([2., 5., 8.]);
         assert_eq!(lhs.into_data().value, rhs.value);
@@ -46,7 +46,8 @@ mod test {
 
     #[test]
     fn test_iter_dim_double_end() {
-        let input = Tensor::<TestBackend, 1, Int>::arange(0..(4 * 6 * 3)).reshape([4, 6, 3]);
+        let input =
+            Tensor::<TestBackend, 1, Int>::arange_devauto(0..(4 * 6 * 3)).reshape([4, 6, 3]);
         let mut iter = input.iter_dim(1);
 
         let ele0 = Data::from([[[0, 1, 2]], [[18, 19, 20]], [[36, 37, 38]], [[54, 55, 56]]]);
@@ -83,7 +84,8 @@ mod test {
 
     #[test]
     fn test_iter_dim_single_element() {
-        let input = Tensor::<TestBackend, 1, Int>::arange(0..(4 * 1 * 3)).reshape([4, 1, 3]);
+        let input =
+            Tensor::<TestBackend, 1, Int>::arange_devauto(0..(4 * 1 * 3)).reshape([4, 1, 3]);
 
         let mut iter = input.clone().iter_dim(1);
         assert_eq!(iter.next().unwrap().into_data(), input.clone().into_data());
diff --git a/burn-tensor/src/tests/ops/log.rs b/burn-tensor/src/tests/ops/log.rs
index f71387317..2ff382d5c 100644
--- a/burn-tensor/src/tests/ops/log.rs
+++ b/burn-tensor/src/tests/ops/log.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_log_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.log().into_data();
 
diff --git a/burn-tensor/src/tests/ops/log1p.rs b/burn-tensor/src/tests/ops/log1p.rs
index 346e01b2e..f7bf1d42d 100644
--- a/burn-tensor/src/tests/ops/log1p.rs
+++ b/burn-tensor/src/tests/ops/log1p.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_exp_log1p() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.log1p().into_data();
 
diff --git a/burn-tensor/src/tests/ops/map_comparison.rs b/burn-tensor/src/tests/ops/map_comparison.rs
index 76eee5dc0..a0a2ed4e9 100644
--- a/burn-tensor/src/tests/ops/map_comparison.rs
+++ b/burn-tensor/src/tests/ops/map_comparison.rs
@@ -115,8 +115,8 @@ mod tests {
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
         let data_2 = Data::<f32, 2>::from([[1.0, 1.0, 1.0], [4.0, 3.0, 5.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_2);
 
         let data_actual_cloned = tensor_1.clone().equal(tensor_2.clone());
         let data_actual_inplace = tensor_1.equal(tensor_2);
@@ -132,7 +132,7 @@ mod tests {
         E: Element,
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 2.0, 5.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
 
         let data_actual_cloned = tensor_1.clone().equal_elem(2);
         let data_actual_inplace = tensor_1.equal_elem(2);
@@ -148,7 +148,7 @@ mod tests {
         E: Element,
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
 
         let data_actual_cloned = tensor_1.clone().greater_elem(4);
         let data_actual_inplace = tensor_1.greater_elem(4);
@@ -164,7 +164,7 @@ mod tests {
         E: Element,
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
 
         let data_actual_cloned = tensor_1.clone().greater_equal_elem(4.0);
         let data_actual_inplace = tensor_1.greater_equal_elem(4.0);
@@ -181,8 +181,8 @@ mod tests {
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
         let data_2 = Data::<f32, 2>::from([[1.0, 1.0, 1.0], [4.0, 3.0, 50.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_2);
 
         let data_actual_cloned = tensor_1.clone().greater(tensor_2.clone());
         let data_actual_inplace = tensor_1.greater(tensor_2);
@@ -199,8 +199,8 @@ mod tests {
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
         let data_2 = Data::<f32, 2>::from([[1.0, 1.0, 1.0], [4.0, 3.0, 50.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_2);
 
         let data_actual_cloned = tensor_1.clone().greater_equal(tensor_2.clone());
         let data_actual_inplace = tensor_1.greater_equal(tensor_2);
@@ -216,7 +216,7 @@ mod tests {
         E: Element,
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
 
         let data_actual_cloned = tensor_1.clone().lower_elem(4.0);
         let data_actual_inplace = tensor_1.lower_elem(4.0);
@@ -232,7 +232,7 @@ mod tests {
         E: Element,
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
 
         let data_actual_cloned = tensor_1.clone().lower_equal_elem(4.0);
         let data_actual_inplace = tensor_1.lower_equal_elem(4.0);
@@ -249,8 +249,8 @@ mod tests {
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
         let data_2 = Data::<f32, 2>::from([[1.0, 1.0, 1.0], [4.0, 3.0, 50.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_2);
 
         let data_actual_cloned = tensor_1.clone().lower(tensor_2.clone());
         let data_actual_inplace = tensor_1.lower(tensor_2);
@@ -267,8 +267,8 @@ mod tests {
     {
         let data_1 = Data::<f32, 2>::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]).convert();
         let data_2 = Data::<f32, 2>::from([[1.0, 1.0, 1.0], [4.0, 3.0, 50.0]]).convert();
-        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, K>::from_data_devauto(data_2);
 
         let data_actual_cloned = tensor_1.clone().lower_equal(tensor_2.clone());
         let data_actual_inplace = tensor_1.lower_equal(tensor_2);
@@ -282,8 +282,8 @@ mod tests {
     fn should_support_bool_equal() {
         let data_1 = Data::from([[false, true, true], [true, false, true]]);
         let data_2 = Data::from([[false, false, true], [false, true, true]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Bool>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Bool>::from_data_devauto(data_2);
 
         let data_actual_cloned = tensor_1.clone().equal(tensor_2.clone());
         let data_actual_inplace = tensor_1.equal(tensor_2);
@@ -296,7 +296,7 @@ mod tests {
     #[test]
     fn should_support_bool_not() {
         let data_1 = Data::from([[false, true, true], [true, true, false]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data(data_1);
+        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data_devauto(data_1);
 
         let data_actual_cloned = tensor_1.clone().bool_not();
         let data_actual_inplace = tensor_1.bool_not();
diff --git a/burn-tensor/src/tests/ops/mask.rs b/burn-tensor/src/tests/ops/mask.rs
index 735c31127..8d0da394b 100644
--- a/burn-tensor/src/tests/ops/mask.rs
+++ b/burn-tensor/src/tests/ops/mask.rs
@@ -5,10 +5,13 @@ mod tests {
 
     #[test]
     fn should_support_mask_where_ops() {
-        let tensor = TestTensor::from_data([[1.0, 7.0], [2.0, 3.0]]);
-        let mask =
-            Tensor::<TestBackend, 2, Bool>::from_bool(Data::from([[true, false], [false, true]]));
-        let value = Tensor::<TestBackend, 2>::from_data(Data::from([[1.8, 2.8], [3.8, 4.8]]));
+        let tensor = TestTensor::from_data_devauto([[1.0, 7.0], [2.0, 3.0]]);
+        let mask = Tensor::<TestBackend, 2, Bool>::from_bool_devauto(Data::from([
+            [true, false],
+            [false, true],
+        ]));
+        let value =
+            Tensor::<TestBackend, 2>::from_data_devauto(Data::from([[1.8, 2.8], [3.8, 4.8]]));
 
         let data_actual = tensor.mask_where(mask, value).into_data();
 
@@ -18,9 +21,11 @@ mod tests {
 
     #[test]
     fn should_support_mask_fill_ops() {
-        let tensor = TestTensor::from_data([[1.0, 7.0], [2.0, 3.0]]);
-        let mask =
-            Tensor::<TestBackend, 2, Bool>::from_bool(Data::from([[true, false], [false, true]]));
+        let tensor = TestTensor::from_data_devauto([[1.0, 7.0], [2.0, 3.0]]);
+        let mask = Tensor::<TestBackend, 2, Bool>::from_bool_devauto(Data::from([
+            [true, false],
+            [false, true],
+        ]));
 
         let data_actual = tensor.mask_fill(mask, 2.0).to_data();
 
@@ -30,10 +35,13 @@ mod tests {
 
     #[test]
     fn should_support_int_mask_where_ops() {
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data([[1, 7], [2, 3]]);
-        let mask =
-            Tensor::<TestBackend, 2, Bool>::from_bool(Data::from([[true, false], [false, true]]));
-        let value = Tensor::<TestBackend, 2, Int>::from_data(Data::from([[8, 9], [10, 11]]));
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto([[1, 7], [2, 3]]);
+        let mask = Tensor::<TestBackend, 2, Bool>::from_bool_devauto(Data::from([
+            [true, false],
+            [false, true],
+        ]));
+        let value =
+            Tensor::<TestBackend, 2, Int>::from_data_devauto(Data::from([[8, 9], [10, 11]]));
 
         let data_actual = tensor.mask_where(mask, value).into_data();
 
@@ -43,9 +51,11 @@ mod tests {
 
     #[test]
     fn should_support_int_mask_fill_ops() {
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data([[1, 7], [2, 3]]);
-        let mask =
-            Tensor::<TestBackend, 2, Bool>::from_bool(Data::from([[true, false], [false, true]]));
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto([[1, 7], [2, 3]]);
+        let mask = Tensor::<TestBackend, 2, Bool>::from_bool_devauto(Data::from([
+            [true, false],
+            [false, true],
+        ]));
 
         let data_actual = tensor.mask_fill(mask, 9).to_data();
 
diff --git a/burn-tensor/src/tests/ops/matmul.rs b/burn-tensor/src/tests/ops/matmul.rs
index 6edf59067..40ee751ca 100644
--- a/burn-tensor/src/tests/ops/matmul.rs
+++ b/burn-tensor/src/tests/ops/matmul.rs
@@ -5,8 +5,8 @@ mod tests {
 
     #[test]
     fn test_matmul_d2() {
-        let tensor_1 = TestTensor::from_floats([[1.0, 7.0], [2.0, 3.0], [1.0, 5.0]]);
-        let tensor_2 = TestTensor::from_floats([[4.0, 7.0, 5.0], [2.0, 3.0, 5.0]]);
+        let tensor_1 = TestTensor::from_floats_devauto([[1.0, 7.0], [2.0, 3.0], [1.0, 5.0]]);
+        let tensor_2 = TestTensor::from_floats_devauto([[4.0, 7.0, 5.0], [2.0, 3.0, 5.0]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
@@ -18,8 +18,8 @@ mod tests {
 
     #[test]
     fn test_matmul_d3() {
-        let tensor_1 = TestTensor::from_floats([[[1.0, 7.0], [2.0, 3.0]]]);
-        let tensor_2 = TestTensor::from_floats([[[4.0, 7.0], [2.0, 3.0]]]);
+        let tensor_1 = TestTensor::from_floats_devauto([[[1.0, 7.0], [2.0, 3.0]]]);
+        let tensor_2 = TestTensor::from_floats_devauto([[[4.0, 7.0], [2.0, 3.0]]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
@@ -31,9 +31,9 @@ mod tests {
 
     #[test]
     fn test_matmul_broadcast_1() {
-        let tensor_1 = TestTensor::from_floats([[[1.0, 7.0], [2.0, 3.0]]]);
+        let tensor_1 = TestTensor::from_floats_devauto([[[1.0, 7.0], [2.0, 3.0]]]);
         let tensor_2 =
-            TestTensor::from_floats([[[4.0, 7.0], [2.0, 3.0]], [[2.0, 5.0], [6.0, 3.0]]]);
+            TestTensor::from_floats_devauto([[[4.0, 7.0], [2.0, 3.0]], [[2.0, 5.0], [6.0, 3.0]]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
@@ -45,8 +45,8 @@ mod tests {
 
     #[test]
     fn test_matmul_simple_1() {
-        let tensor_1 = TestTensor::from_floats([[5.0, 14.0], [14.0, 50.0]]);
-        let tensor_2 = TestTensor::from_floats([[3.0, 4.0, 5.0], [0.0, 1.0, 2.0]]);
+        let tensor_1 = TestTensor::from_floats_devauto([[5.0, 14.0], [14.0, 50.0]]);
+        let tensor_2 = TestTensor::from_floats_devauto([[3.0, 4.0, 5.0], [0.0, 1.0, 2.0]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
@@ -58,8 +58,8 @@ mod tests {
 
     #[test]
     fn test_matmul_simple_2() {
-        let tensor_1 = TestTensor::from_floats([[1.0, 2.0, 3.0, 4.0]]);
-        let tensor_2 = TestTensor::from_floats([[3.0], [4.0], [5.0], [6.0]]);
+        let tensor_1 = TestTensor::from_floats_devauto([[1.0, 2.0, 3.0, 4.0]]);
+        let tensor_2 = TestTensor::from_floats_devauto([[3.0], [4.0], [5.0], [6.0]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
@@ -68,10 +68,14 @@ mod tests {
 
     #[test]
     fn test_matmul_simple_3() {
-        let tensor_1 =
-            TestTensor::from_floats([[3., 3., 3.], [4., 4., 4.], [5., 5., 5.], [6., 6., 6.]]);
+        let tensor_1 = TestTensor::from_floats_devauto([
+            [3., 3., 3.],
+            [4., 4., 4.],
+            [5., 5., 5.],
+            [6., 6., 6.],
+        ]);
         let tensor_2 =
-            TestTensor::from_floats([[1., 2., 3., 4.], [1., 2., 3., 4.], [1., 2., 3., 4.]]);
+            TestTensor::from_floats_devauto([[1., 2., 3., 4.], [1., 2., 3., 4.], [1., 2., 3., 4.]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
@@ -89,9 +93,9 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_panic_when_inner_dimensions_are_not_equal() {
-        let tensor_1 = TestTensor::from_floats([[3., 3.], [4., 4.], [5., 5.], [6., 6.]]);
+        let tensor_1 = TestTensor::from_floats_devauto([[3., 3.], [4., 4.], [5., 5.], [6., 6.]]);
         let tensor_2 =
-            TestTensor::from_floats([[1., 2., 3., 4.], [1., 2., 3., 4.], [1., 2., 3., 4.]]);
+            TestTensor::from_floats_devauto([[1., 2., 3., 4.], [1., 2., 3., 4.], [1., 2., 3., 4.]]);
 
         let tensor_3 = tensor_1.matmul(tensor_2);
 
diff --git a/burn-tensor/src/tests/ops/maxmin.rs b/burn-tensor/src/tests/ops/maxmin.rs
index 09b660112..cff4294af 100644
--- a/burn-tensor/src/tests/ops/maxmin.rs
+++ b/burn-tensor/src/tests/ops/maxmin.rs
@@ -5,7 +5,7 @@ mod tests {
 
     #[test]
     fn test_max_dim_2d() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let output_actual = tensor.max_dim(1);
 
@@ -15,7 +15,7 @@ mod tests {
 
     #[test]
     fn test_max_dim_with_indices_2d_with_dim_0th() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let (output_actual, index_actual) = tensor.max_dim_with_indices(0);
 
@@ -28,7 +28,7 @@ mod tests {
 
     #[test]
     fn test_max_dim_with_indices_2d() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let (output_actual, index_actual) = tensor.max_dim_with_indices(1);
 
@@ -41,7 +41,7 @@ mod tests {
 
     #[test]
     fn test_min_dim_2d() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let output_actual = tensor.min_dim(1);
 
@@ -51,7 +51,7 @@ mod tests {
 
     #[test]
     fn test_min_dim_with_indices_2d() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let (output_actual, index_actual) = tensor.min_dim_with_indices(1);
 
@@ -64,7 +64,7 @@ mod tests {
 
     #[test]
     fn test_sum_dim_2d() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let output_actual = tensor.clone().sum_dim(1);
 
@@ -79,7 +79,7 @@ mod tests {
 
     #[test]
     fn test_mean_dim_2d() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let output_actual = tensor.clone().mean_dim(1);
 
@@ -94,7 +94,7 @@ mod tests {
 
     #[test]
     fn test_min_dim_2d_with_0th_dim() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let output_actual = tensor.min_dim(0);
 
         let output_expected = Data::from([[0., 1., 2.]]);
@@ -103,7 +103,7 @@ mod tests {
 
     #[test]
     fn test_max_dim_2d_with_0th_dim() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let output_actual = tensor.max_dim(0);
 
@@ -113,7 +113,7 @@ mod tests {
 
     #[test]
     fn test_min_dim_with_indices_2d_with_0th_dim() {
-        let tensor = TestTensor::from_floats([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let tensor = TestTensor::from_floats_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
 
         let (output_actual, index_actual) = tensor.min_dim_with_indices(0);
 
diff --git a/burn-tensor/src/tests/ops/mul.rs b/burn-tensor/src/tests/ops/mul.rs
index eb7b8bb9d..bd393ab49 100644
--- a/burn-tensor/src/tests/ops/mul.rs
+++ b/burn-tensor/src/tests/ops/mul.rs
@@ -7,8 +7,8 @@ mod tests {
     fn should_support_mul_ops() {
         let data_1 = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let data_2 = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let output = tensor_1 * tensor_2;
 
@@ -21,8 +21,8 @@ mod tests {
     fn test_mul_broadcast() {
         let data_1 = Data::from([[0.0, 1.0, 2.0]]);
         let data_2 = Data::from([[3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 * tensor_2).into_data();
 
@@ -32,8 +32,10 @@ mod tests {
 
     #[test]
     fn test_mul_broadcast_2_dims() {
-        let tensor_1: Tensor<TestBackend, 2> = Tensor::from_data([0.0, 1.0, 2.0]).reshape([3, 1]);
-        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data([3.0, 4.0, 5.0]).reshape([1, 3]);
+        let tensor_1: Tensor<TestBackend, 2> =
+            Tensor::from_data_devauto([0.0, 1.0, 2.0]).reshape([3, 1]);
+        let tensor_2: Tensor<TestBackend, 2> =
+            Tensor::from_data_devauto([3.0, 4.0, 5.0]).reshape([1, 3]);
 
         let data_actual = (tensor_1 * tensor_2).into_data();
 
@@ -45,7 +47,7 @@ mod tests {
     fn should_support_mul_scalar_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let scalar = 2.0;
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let output = tensor * scalar;
 
@@ -58,8 +60,8 @@ mod tests {
     fn should_support_mul_ops_int() {
         let data_1 = Data::from([[0, 1, 2], [3, 4, 5]]);
         let data_2 = Data::from([[0, 1, 2], [3, 4, 5]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let output = tensor_1 * tensor_2;
 
@@ -72,8 +74,8 @@ mod tests {
     fn test_mul_broadcast_int() {
         let data_1 = Data::from([[0, 1, 2]]);
         let data_2 = Data::from([[3, 4, 5], [6, 7, 8]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 * tensor_2).into_data();
 
@@ -85,7 +87,7 @@ mod tests {
     fn should_support_mul_scalar_ops_int() {
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
         let scalar = 2;
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let output = tensor * scalar;
 
diff --git a/burn-tensor/src/tests/ops/narrow.rs b/burn-tensor/src/tests/ops/narrow.rs
index ab2dfab00..958f1bf2b 100644
--- a/burn-tensor/src/tests/ops/narrow.rs
+++ b/burn-tensor/src/tests/ops/narrow.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_narrow() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
+            Tensor::from_data_devauto(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
 
         let output = tensor.clone().narrow(0, 0, 2);
         assert_eq!(output.shape(), Shape::from([2, 3]));
@@ -25,7 +25,7 @@ mod tests {
     #[should_panic]
     fn test_narrow_invalid_dim() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
+            Tensor::from_data_devauto(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
 
         let output = tensor.narrow(2, 0, 2);
     }
@@ -34,7 +34,7 @@ mod tests {
     #[should_panic]
     fn test_narrow_invalid_start() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
+            Tensor::from_data_devauto(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
 
         let output = tensor.narrow(0, 3, 2);
     }
@@ -43,7 +43,7 @@ mod tests {
     #[should_panic]
     fn test_narrow_invalid_zero_length() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
+            Tensor::from_data_devauto(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
 
         let output = tensor.narrow(0, 1, 0);
     }
@@ -52,7 +52,7 @@ mod tests {
     #[should_panic]
     fn test_narrow_invalid_length() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
+            Tensor::from_data_devauto(Data::from([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]));
 
         let output = tensor.narrow(0, 0, 4);
     }
diff --git a/burn-tensor/src/tests/ops/neg.rs b/burn-tensor/src/tests/ops/neg.rs
index bcea87b40..c72c9049f 100644
--- a/burn-tensor/src/tests/ops/neg.rs
+++ b/burn-tensor/src/tests/ops/neg.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_neg_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.neg().into_data();
 
diff --git a/burn-tensor/src/tests/ops/powf.rs b/burn-tensor/src/tests/ops/powf.rs
index 59f9abca5..d42f825a2 100644
--- a/burn-tensor/src/tests/ops/powf.rs
+++ b/burn-tensor/src/tests/ops/powf.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_powf_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.powf(0.71).into_data();
 
@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn should_support_neg_power() {
         let data = Data::from([[1.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.powf(-0.33).into_data();
 
@@ -28,7 +28,7 @@ mod tests {
     #[test]
     fn should_support_neg_values_with_even_power() {
         let data = Data::from([[0.0, -1.0, -2.0], [-3.0, -4.0, -5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.powf(4.0).into_data();
 
@@ -39,7 +39,7 @@ mod tests {
     #[test]
     fn should_support_neg_values_with_odd_power() {
         let data = Data::from([[0.0, -1.0, -2.0], [-3.0, -4.0, -5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.powf(3.0).into_data();
 
diff --git a/burn-tensor/src/tests/ops/random.rs b/burn-tensor/src/tests/ops/random.rs
index 5aeccfa7a..c36e355bd 100644
--- a/burn-tensor/src/tests/ops/random.rs
+++ b/burn-tensor/src/tests/ops/random.rs
@@ -5,7 +5,7 @@ mod tests {
 
     #[test]
     fn rand_default() {
-        let tensor = Tensor::<TestBackend, 1>::random([20], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 1>::random_devauto([20], Distribution::Default);
 
         // check that the tensor is within the range of [0..1) (1 is exclusive)
         tensor.into_data().assert_within_range(0.0..1.0);
@@ -13,14 +13,14 @@ mod tests {
 
     #[test]
     fn rand_uniform() {
-        let tensor = Tensor::<TestBackend, 1>::random([20], Distribution::Uniform(4., 5.));
+        let tensor = Tensor::<TestBackend, 1>::random_devauto([20], Distribution::Uniform(4., 5.));
 
         tensor.into_data().assert_within_range(4.0..5.0);
     }
 
     #[test]
     fn rand_bernoulli() {
-        let tensor = Tensor::<TestBackend, 1>::random([20], Distribution::Bernoulli(1.));
+        let tensor = Tensor::<TestBackend, 1>::random_devauto([20], Distribution::Bernoulli(1.));
 
         assert_eq!(tensor.into_data(), [1.; 20].into());
     }
diff --git a/burn-tensor/src/tests/ops/recip.rs b/burn-tensor/src/tests/ops/recip.rs
index 70395fd60..8ac931bc7 100644
--- a/burn-tensor/src/tests/ops/recip.rs
+++ b/burn-tensor/src/tests/ops/recip.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_recip_ops() {
         let data = Data::from([[0.5, 1.0, 2.0], [3.0, -4.0, -5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.recip().into_data();
 
diff --git a/burn-tensor/src/tests/ops/repeat.rs b/burn-tensor/src/tests/ops/repeat.rs
index b24e6f529..3f7c982b0 100644
--- a/burn-tensor/src/tests/ops/repeat.rs
+++ b/burn-tensor/src/tests/ops/repeat.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_repeat_ops() {
         let data = Data::from([[0.0, 1.0, 2.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.repeat(0, 4).into_data();
 
@@ -22,7 +22,7 @@ mod tests {
     #[test]
     fn should_support_bool_repeat_ops() {
         let data = Data::from([[true, false, false]]);
-        let tensor = Tensor::<TestBackend, 2, Bool>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Bool>::from_data_devauto(data);
 
         let data_actual = tensor.repeat(0, 4).into_data();
 
@@ -38,7 +38,7 @@ mod tests {
     #[test]
     fn should_support_int_repeat_ops() {
         let data = Data::from([[0, 1, 2]]);
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let data_actual = tensor.repeat(0, 4).into_data();
 
diff --git a/burn-tensor/src/tests/ops/reshape.rs b/burn-tensor/src/tests/ops/reshape.rs
index 9c02dd513..f8ec69f33 100644
--- a/burn-tensor/src/tests/ops/reshape.rs
+++ b/burn-tensor/src/tests/ops/reshape.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_reshape_1d() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data);
 
         let data_actual = tensor.clone().reshape([1, 3]).into_data();
         let data_expected = Data::from([[0.0, 1.0, 2.0]]);
@@ -16,7 +16,7 @@ mod tests {
     #[test]
     fn should_support_reshape_int() {
         let data = Data::from([0, 1, 2]);
-        let tensor = Tensor::<TestBackend, 1, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1, Int>::from_data_devauto(data);
 
         let data_actual = tensor.clone().reshape([1, 3]).into_data();
         let data_expected = Data::from([[0, 1, 2]]);
@@ -26,7 +26,7 @@ mod tests {
     #[test]
     fn should_support_reshape_bool() {
         let data = Data::from([false, true, false]);
-        let tensor = Tensor::<TestBackend, 1, Bool>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1, Bool>::from_data_devauto(data);
 
         let data_actual = tensor.clone().reshape([1, 3]).into_data();
         let data_expected = Data::from([[false, true, false]]);
@@ -36,7 +36,7 @@ mod tests {
     #[test]
     fn should_support_reshape_2d() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.clone().reshape([6]).into_data();
         let data_expected = Data::from([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]);
@@ -51,7 +51,7 @@ mod tests {
             [6.0, 7.0, 8.0],
             [9.0, 10.0, 11.0],
         ]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         // Infer the dimension via -1
         let reshaped = tensor.clone().reshape([2, -1]);
@@ -74,7 +74,7 @@ mod tests {
     #[should_panic]
     fn multiple_neg_ones() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data);
         let data_actual = tensor.reshape([-1, -1]).into_data();
     }
 
@@ -82,7 +82,7 @@ mod tests {
     #[should_panic]
     fn neg_value() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data);
         let data_actual = tensor.reshape([-2, -1]).into_data();
     }
 }
diff --git a/burn-tensor/src/tests/ops/select.rs b/burn-tensor/src/tests/ops/select.rs
index d62fdaeae..584251284 100644
--- a/burn-tensor/src/tests/ops/select.rs
+++ b/burn-tensor/src/tests/ops/select.rs
@@ -5,8 +5,8 @@ mod tests {
 
     #[test]
     fn should_select_1d() {
-        let tensor = TestTensor::from_data([0.0, 1.0, 2.0]);
-        let indices = TestTensorInt::from_data([1, 1, 0, 1, 2]);
+        let tensor = TestTensor::from_data_devauto([0.0, 1.0, 2.0]);
+        let indices = TestTensorInt::from_data_devauto([1, 1, 0, 1, 2]);
 
         let output = tensor.select(0, indices);
 
@@ -15,8 +15,8 @@ mod tests {
 
     #[test]
     fn should_select_1d_int() {
-        let tensor = TestTensorInt::from_data([5, 6, 7]);
-        let indices = TestTensorInt::from_data([1, 1, 0, 1, 2]);
+        let tensor = TestTensorInt::from_data_devauto([5, 6, 7]);
+        let indices = TestTensorInt::from_data_devauto([1, 1, 0, 1, 2]);
 
         let output = tensor.select(0, indices);
 
@@ -25,8 +25,8 @@ mod tests {
 
     #[test]
     fn should_select_2d_dim0_same_num_dim() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_data(([1, 0]));
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_data_devauto(([1, 0]));
 
         let output = tensor.select(0, indices);
 
@@ -38,8 +38,8 @@ mod tests {
 
     #[test]
     fn should_select_2d_dim0_more_num_dim() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_data([1, 0, 1, 1]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_data_devauto([1, 0, 1, 1]);
 
         let output = tensor.select(0, indices);
 
@@ -56,8 +56,8 @@ mod tests {
 
     #[test]
     fn should_select_2d_dim1() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_data([1, 1, 0, 1, 2]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_data_devauto([1, 1, 0, 1, 2]);
 
         let output = tensor.select(1, indices);
 
@@ -69,9 +69,9 @@ mod tests {
 
     #[test]
     fn should_select_assign_1d() {
-        let tensor = TestTensor::from_data([0.0, 1.0, 2.0]);
-        let values = TestTensor::from_data([5.0, 4.0, 3.0, 2.0, 1.0]);
-        let indices = TestTensorInt::from_data(Data::from([1, 1, 0, 1, 2]));
+        let tensor = TestTensor::from_data_devauto([0.0, 1.0, 2.0]);
+        let values = TestTensor::from_data_devauto([5.0, 4.0, 3.0, 2.0, 1.0]);
+        let indices = TestTensorInt::from_data_devauto(Data::from([1, 1, 0, 1, 2]));
 
         let output = tensor.select_assign(0, indices, values);
 
@@ -80,9 +80,9 @@ mod tests {
 
     #[test]
     fn should_select_assign_1d_int() {
-        let tensor = TestTensorInt::from_data([7, 8, 9]);
-        let values = TestTensorInt::from_data([5, 4, 3, 2, 1]);
-        let indices = TestTensorInt::from_data(Data::from([1, 1, 0, 1, 2]));
+        let tensor = TestTensorInt::from_data_devauto([7, 8, 9]);
+        let values = TestTensorInt::from_data_devauto([5, 4, 3, 2, 1]);
+        let indices = TestTensorInt::from_data_devauto(Data::from([1, 1, 0, 1, 2]));
 
         let output = tensor.select_assign(0, indices, values);
 
@@ -91,9 +91,9 @@ mod tests {
 
     #[test]
     fn should_select_assign_2d_dim0() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let values = TestTensor::from_data([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
-        let indices = TestTensorInt::from_data(Data::from([1, 0]));
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let values = TestTensor::from_data_devauto([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
+        let indices = TestTensorInt::from_data_devauto(Data::from([1, 0]));
 
         let output = tensor.select_assign(0, indices, values);
 
@@ -105,9 +105,9 @@ mod tests {
 
     #[test]
     fn should_select_assign_2d_dim1() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let values = TestTensor::from_data([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
-        let indices = TestTensorInt::from_data(Data::from([1, 0, 2]));
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let values = TestTensor::from_data_devauto([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
+        let indices = TestTensorInt::from_data_devauto(Data::from([1, 0, 2]));
 
         let output = tensor.select_assign(1, indices, values);
 
@@ -120,8 +120,8 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_select_panic_invalid_dimension() {
-        let tensor = TestTensor::from_data([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let indices = TestTensorInt::from_data([1, 1, 0, 1, 2]);
+        let tensor = TestTensor::from_data_devauto([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
+        let indices = TestTensorInt::from_data_devauto([1, 1, 0, 1, 2]);
 
         tensor.select(10, indices);
     }
diff --git a/burn-tensor/src/tests/ops/sin.rs b/burn-tensor/src/tests/ops/sin.rs
index c7f968594..aded31e5a 100644
--- a/burn-tensor/src/tests/ops/sin.rs
+++ b/burn-tensor/src/tests/ops/sin.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_sin_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.sin().into_data();
 
diff --git a/burn-tensor/src/tests/ops/slice.rs b/burn-tensor/src/tests/ops/slice.rs
index 3448dba72..1b8687104 100644
--- a/burn-tensor/src/tests/ops/slice.rs
+++ b/burn-tensor/src/tests/ops/slice.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_full_sliceing_1d() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data.clone());
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data.clone());
 
         let data_actual = tensor.slice([0..3]).into_data();
 
@@ -16,7 +16,7 @@ mod tests {
     #[test]
     fn should_support_partial_sliceing_1d() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data);
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data);
 
         let data_actual = tensor.slice([1..3]).into_data();
 
@@ -27,7 +27,7 @@ mod tests {
     #[test]
     fn should_support_full_sliceing_2d() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data.clone());
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data.clone());
 
         let data_actual_1 = tensor.clone().slice([0..2]).into_data();
         let data_actual_2 = tensor.slice([0..2, 0..3]).into_data();
@@ -39,7 +39,7 @@ mod tests {
     #[test]
     fn should_support_partial_sliceing_2d() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.slice([0..2, 0..2]).into_data();
 
@@ -49,7 +49,7 @@ mod tests {
 
     #[test]
     fn should_support_partial_sliceing_3d() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
@@ -62,7 +62,7 @@ mod tests {
 
     #[test]
     fn should_support_partial_sliceing_3d_non_contiguous() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
@@ -78,8 +78,8 @@ mod tests {
         let data = Data::from([0.0, 1.0, 2.0]);
         let data_assigned = Data::from([10.0, 5.0]);
 
-        let tensor = Tensor::<TestBackend, 1>::from_data(data);
-        let tensor_assigned = Tensor::<TestBackend, 1>::from_data(data_assigned);
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data);
+        let tensor_assigned = Tensor::<TestBackend, 1>::from_data_devauto(data_assigned);
 
         let data_actual = tensor.slice_assign([0..2], tensor_assigned).into_data();
 
@@ -92,8 +92,8 @@ mod tests {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let data_assigned = Data::from([[10.0, 5.0]]);
 
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
-        let tensor_assigned = Tensor::<TestBackend, 2>::from_data(data_assigned);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
+        let tensor_assigned = Tensor::<TestBackend, 2>::from_data_devauto(data_assigned);
 
         let data_actual = tensor
             .slice_assign([1..2, 0..2], tensor_assigned)
@@ -105,7 +105,7 @@ mod tests {
 
     #[test]
     fn slice_should_not_corrupt_potentially_inplace_operations() {
-        let tensor = Tensor::<TestBackend, 1, Int>::from_data([1, 2, 3, 4, 5]);
+        let tensor = Tensor::<TestBackend, 1, Int>::from_data_devauto([1, 2, 3, 4, 5]);
         let tensor = tensor.clone().slice([0..3]) + tensor.clone().slice([2..5]);
 
         assert_eq!(tensor.into_data(), Data::from([4, 6, 8]));
@@ -113,8 +113,8 @@ mod tests {
 
     #[test]
     fn slice_assign_should_not_corrupt_potentially_inplace_operations() {
-        let tensor = Tensor::<TestBackend, 1, Int>::from_data([1, 2, 3, 4, 5]);
-        let values = Tensor::<TestBackend, 1, Int>::from_data([10, 20, 30]);
+        let tensor = Tensor::<TestBackend, 1, Int>::from_data_devauto([1, 2, 3, 4, 5]);
+        let values = Tensor::<TestBackend, 1, Int>::from_data_devauto([10, 20, 30]);
         let tensor_1 = tensor.clone().slice_assign([0..3], values);
         let tensor_2 = tensor + 2;
 
@@ -126,7 +126,7 @@ mod tests {
     #[should_panic]
     fn should_panic_when_slice_exceeds_dimension() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data.clone());
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data.clone());
 
         let data_actual = tensor.slice([0..4]).into_data();
 
@@ -137,7 +137,7 @@ mod tests {
     #[should_panic]
     fn should_panic_when_slice_with_too_many_dimensions() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data.clone());
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data.clone());
 
         let data_actual = tensor.slice([0..1, 0..1]).into_data();
 
@@ -148,7 +148,7 @@ mod tests {
     #[should_panic]
     fn should_panic_when_slice_is_desc() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data.clone());
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data.clone());
 
         #[allow(clippy::reversed_empty_ranges)]
         let data_actual = tensor.slice([2..1]).into_data();
@@ -160,7 +160,7 @@ mod tests {
     #[should_panic]
     fn should_panic_when_slice_is_equal() {
         let data = Data::from([0.0, 1.0, 2.0]);
-        let tensor = Tensor::<TestBackend, 1>::from_data(data.clone());
+        let tensor = Tensor::<TestBackend, 1>::from_data_devauto(data.clone());
 
         let data_actual = tensor.slice([1..1]).into_data();
 
diff --git a/burn-tensor/src/tests/ops/sqrt.rs b/burn-tensor/src/tests/ops/sqrt.rs
index 3044b1d9b..8f3badb47 100644
--- a/burn-tensor/src/tests/ops/sqrt.rs
+++ b/burn-tensor/src/tests/ops/sqrt.rs
@@ -7,7 +7,7 @@ mod tests {
     #[test]
     fn should_support_sqrt_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.sqrt().into_data();
 
diff --git a/burn-tensor/src/tests/ops/squeeze.rs b/burn-tensor/src/tests/ops/squeeze.rs
index c2f23245c..db8348424 100644
--- a/burn-tensor/src/tests/ops/squeeze.rs
+++ b/burn-tensor/src/tests/ops/squeeze.rs
@@ -6,7 +6,7 @@ mod tests {
     /// Test if the function can successfully squeeze the size 1 dimension of a 3D tensor.
     #[test]
     fn should_squeeze() {
-        let tensor = Tensor::<TestBackend, 3>::ones(Shape::new([2, 1, 4]));
+        let tensor = Tensor::<TestBackend, 3>::ones_devauto(Shape::new([2, 1, 4]));
         let squeezed_tensor: Tensor<TestBackend, 2> = tensor.squeeze(1);
         let expected_shape = Shape::new([2, 4]);
         assert_eq!(squeezed_tensor.shape(), expected_shape);
@@ -14,7 +14,7 @@ mod tests {
     /// Test if the function can successfully squeeze the first size 1 dimension of a 4D tensor.
     #[test]
     fn should_squeeze_first() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([1, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([1, 3, 4, 5]));
         let squeezed_tensor: Tensor<TestBackend, 3> = tensor.squeeze(0);
         let expected_shape = Shape::new([3, 4, 5]);
         assert_eq!(squeezed_tensor.shape(), expected_shape);
@@ -22,7 +22,7 @@ mod tests {
     /// Test if the function can successfully squeeze the last size 1 dimension of a 4D tensor.
     #[test]
     fn should_squeeze_last() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 1]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 1]));
         let squeezed_tensor: Tensor<TestBackend, 3> = tensor.squeeze(3);
         let expected_shape = Shape::new([2, 3, 4]);
         assert_eq!(squeezed_tensor.shape(), expected_shape);
@@ -31,14 +31,14 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_squeeze_panic() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let squeezed_tensor: Tensor<TestBackend, 3> = tensor.squeeze(2);
     }
 
     /// Test if the function can successfully unsqueeze the size 1 dimension at the specified position of a 3D tensor.
     #[test]
     fn should_unsqueeze_dim() {
-        let tensor = Tensor::<TestBackend, 3>::ones(Shape::new([2, 4, 1]));
+        let tensor = Tensor::<TestBackend, 3>::ones_devauto(Shape::new([2, 4, 1]));
         let unsqueezed_tensor: Tensor<TestBackend, 4> = tensor.unsqueeze_dim(1);
         let expected_shape = Shape::new([2, 1, 4, 1]);
         assert_eq!(unsqueezed_tensor.shape(), expected_shape);
@@ -47,7 +47,7 @@ mod tests {
     /// Test if the function can successfully unsqueeze the first size 1 dimension of a 4D tensor.
     #[test]
     fn should_unsqueeze_dim_first() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let unsqueezed_tensor: Tensor<TestBackend, 5> = tensor.unsqueeze_dim(0);
         let expected_shape = Shape::new([1, 2, 3, 4, 5]);
         assert_eq!(unsqueezed_tensor.shape(), expected_shape);
@@ -56,7 +56,7 @@ mod tests {
     /// Test if the function can successfully unsqueeze the last size 1 dimension of a 4D tensor.
     #[test]
     fn should_unsqueeze_dim_last() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([5, 4, 3, 2]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([5, 4, 3, 2]));
         let unsqueezed_tensor: Tensor<TestBackend, 5> = tensor.unsqueeze_dim(4);
         let expected_shape = Shape::new([5, 4, 3, 2, 1]);
         assert_eq!(unsqueezed_tensor.shape(), expected_shape);
@@ -66,7 +66,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn should_unsqueeze_dim_panic() {
-        let tensor = Tensor::<TestBackend, 4>::ones(Shape::new([2, 3, 4, 5]));
+        let tensor = Tensor::<TestBackend, 4>::ones_devauto(Shape::new([2, 3, 4, 5]));
         let unsqueezed_tensor: Tensor<TestBackend, 5> = tensor.unsqueeze_dim(5);
     }
 }
diff --git a/burn-tensor/src/tests/ops/stack.rs b/burn-tensor/src/tests/ops/stack.rs
index 302d0d34d..8db462c45 100644
--- a/burn-tensor/src/tests/ops/stack.rs
+++ b/burn-tensor/src/tests/ops/stack.rs
@@ -6,8 +6,8 @@ mod tests {
 
     #[test]
     fn should_support_stack_ops_2d_dim0() {
-        let tensor_1: Tensor<TestBackend, 2> = Tensor::from_data([[1.0, 2.0, 3.0]]);
-        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data([[4.0, 5.0, 6.0]]);
+        let tensor_1: Tensor<TestBackend, 2> = Tensor::from_data_devauto([[1.0, 2.0, 3.0]]);
+        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data_devauto([[4.0, 5.0, 6.0]]);
 
         let output = Tensor::stack(vec![tensor_1, tensor_2], 0);
 
@@ -17,8 +17,8 @@ mod tests {
 
     #[test]
     fn should_support_stack_ops_int() {
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data([[1, 2, 3]]);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data([[4, 5, 6]]);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto([[1, 2, 3]]);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto([[4, 5, 6]]);
 
         let output = Tensor::stack(vec![tensor_1, tensor_2], 0);
 
@@ -28,8 +28,8 @@ mod tests {
 
     #[test]
     fn should_support_stack_ops_bool() {
-        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data([[false, true, true]]);
-        let tensor_2 = Tensor::<TestBackend, 2, Bool>::from_data([[true, true, false]]);
+        let tensor_1 = Tensor::<TestBackend, 2, Bool>::from_data_devauto([[false, true, true]]);
+        let tensor_2 = Tensor::<TestBackend, 2, Bool>::from_data_devauto([[true, true, false]]);
 
         let output = Tensor::stack(vec![tensor_1, tensor_2], 0);
 
@@ -39,8 +39,8 @@ mod tests {
 
     #[test]
     fn should_support_stack_ops_2d_dim1() {
-        let tensor_1: Tensor<TestBackend, 2> = Tensor::from_data([[1.0, 2.0, 3.0]]);
-        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data([[4.0, 5.0, 6.0]]);
+        let tensor_1: Tensor<TestBackend, 2> = Tensor::from_data_devauto([[1.0, 2.0, 3.0]]);
+        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data_devauto([[4.0, 5.0, 6.0]]);
 
         let output = Tensor::stack(vec![tensor_1, tensor_2], 1);
 
@@ -51,9 +51,9 @@ mod tests {
     #[test]
     fn should_support_stack_ops_3d() {
         let tensor_1: Tensor<TestBackend, 3> =
-            TestTensor::from_data([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
+            TestTensor::from_data_devauto([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
         let tensor_2: Tensor<TestBackend, 3> =
-            TestTensor::from_data([[[4.0, 5.0, 6.0]], [[4.1, 5.1, 6.1]]]);
+            TestTensor::from_data_devauto([[[4.0, 5.0, 6.0]], [[4.1, 5.1, 6.1]]]);
 
         let output = Tensor::stack(vec![tensor_1, tensor_2], 0);
 
@@ -68,8 +68,8 @@ mod tests {
     #[should_panic]
     fn should_panic_when_dimensions_are_not_the_same() {
         let tensor_1: Tensor<TestBackend, 2> =
-            Tensor::from_data([[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]]);
-        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data([[4.0, 5.0]]);
+            Tensor::from_data_devauto([[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]]);
+        let tensor_2: Tensor<TestBackend, 2> = Tensor::from_data_devauto([[4.0, 5.0]]);
 
         let output: Tensor<TestBackend, 3> = Tensor::stack(vec![tensor_1, tensor_2], 0);
     }
@@ -85,8 +85,8 @@ mod tests {
     #[should_panic]
     fn should_panic_when_stack_exceeds_dimension() {
         let tensor_1: Tensor<TestBackend, 3> =
-            Tensor::from_data([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
-        let tensor_2: Tensor<TestBackend, 3> = Tensor::from_data([[[4.0, 5.0, 6.0]]]);
+            Tensor::from_data_devauto([[[1.0, 2.0, 3.0]], [[1.1, 2.1, 3.1]]]);
+        let tensor_2: Tensor<TestBackend, 3> = Tensor::from_data_devauto([[[4.0, 5.0, 6.0]]]);
 
         let output: Tensor<TestBackend, 4> = TestTensor::stack(vec![tensor_1, tensor_2], 3);
     }
@@ -100,8 +100,8 @@ mod tests {
             [19, 0, 20, 0, 21, 0, 22, 0, 23, 0, 24, 0],
         ]);
 
-        let tensor = Tensor::<TestBackend, 1, Int>::arange(1..25).reshape([4, 6]);
-        let zeros: Tensor<TestBackend, 2, Int> = Tensor::zeros([4, 6]);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_devauto(1..25).reshape([4, 6]);
+        let zeros: Tensor<TestBackend, 2, Int> = Tensor::zeros_devauto([4, 6]);
         let intersperse =
             Tensor::stack::<3>([tensor.clone(), zeros.clone()].to_vec(), 2).reshape([4, 12]);
 
diff --git a/burn-tensor/src/tests/ops/sub.rs b/burn-tensor/src/tests/ops/sub.rs
index 3293379ab..a17e51001 100644
--- a/burn-tensor/src/tests/ops/sub.rs
+++ b/burn-tensor/src/tests/ops/sub.rs
@@ -8,8 +8,8 @@ mod tests {
         let data_1 = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let data_2 = Data::from([[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]]);
         let data_expected = Data::from([[-6.0, -6.0, -6.0], [-6.0, -6.0, -6.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 - tensor_2).into_data();
 
@@ -20,8 +20,8 @@ mod tests {
     fn test_sub_broadcast() {
         let data_1 = Data::from([[0.0, 1.0, 2.0]]);
         let data_2 = Data::from([[3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]);
-        let tensor_1 = Tensor::<TestBackend, 2>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 - tensor_2).into_data();
 
@@ -33,7 +33,7 @@ mod tests {
     fn should_support_sub_scalar_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
         let scalar = 2.0;
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let output = tensor - scalar;
 
@@ -47,8 +47,8 @@ mod tests {
         let data_1 = Data::from([[0, 1, 2], [3, 4, 5]]);
         let data_2 = Data::from([[6, 7, 8], [9, 10, 11]]);
         let data_expected = Data::from([[-6, -6, -6], [-6, -6, -6]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 - tensor_2).into_data();
 
@@ -59,8 +59,8 @@ mod tests {
     fn test_sub_broadcast_int() {
         let data_1 = Data::from([[0, 1, 2]]);
         let data_2 = Data::from([[3, 4, 5], [6, 7, 8]]);
-        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data(data_1);
-        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data(data_2);
+        let tensor_1 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_1);
+        let tensor_2 = Tensor::<TestBackend, 2, Int>::from_data_devauto(data_2);
 
         let data_actual = (tensor_1 - tensor_2).into_data();
 
@@ -72,7 +72,7 @@ mod tests {
     fn should_support_sub_scalar_ops_int() {
         let data = Data::from([[0, 1, 2], [3, 4, 5]]);
         let scalar = 2;
-        let tensor = Tensor::<TestBackend, 2, Int>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2, Int>::from_data_devauto(data);
 
         let output = tensor - scalar;
 
diff --git a/burn-tensor/src/tests/ops/tanh.rs b/burn-tensor/src/tests/ops/tanh.rs
index b65b1be7a..7e7bafb96 100644
--- a/burn-tensor/src/tests/ops/tanh.rs
+++ b/burn-tensor/src/tests/ops/tanh.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn should_support_tanh_ops() {
         let data = Data::from([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.tanh().into_data();
 
diff --git a/burn-tensor/src/tests/ops/transpose.rs b/burn-tensor/src/tests/ops/transpose.rs
index 83ae67b04..84fd2128e 100644
--- a/burn-tensor/src/tests/ops/transpose.rs
+++ b/burn-tensor/src/tests/ops/transpose.rs
@@ -5,7 +5,7 @@ mod tests {
 
     #[test]
     fn should_support_transpose_ops() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
@@ -21,7 +21,7 @@ mod tests {
 
     #[test]
     fn should_support_swap_dims() {
-        let tensor = TestTensor::from_floats([
+        let tensor = TestTensor::from_floats_devauto([
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
         ]);
@@ -38,7 +38,7 @@ mod tests {
 
     #[test]
     fn should_support_transpose_ops_int() {
-        let tensor = Tensor::<TestBackend, 3, Int>::from_data([
+        let tensor = Tensor::<TestBackend, 3, Int>::from_data_devauto([
             [[0, 1, 2], [3, 4, 5]],
             [[6, 7, 8], [9, 10, 11]],
         ]);
@@ -51,7 +51,7 @@ mod tests {
 
     #[test]
     fn should_support_swap_dims_int() {
-        let tensor = Tensor::<TestBackend, 3, Int>::from_data([
+        let tensor = Tensor::<TestBackend, 3, Int>::from_data_devauto([
             [[0, 1, 2], [3, 4, 5]],
             [[6, 7, 8], [9, 10, 11]],
         ]);
@@ -64,7 +64,7 @@ mod tests {
 
     #[test]
     fn should_support_transpose_bool() {
-        let tensor = Tensor::<TestBackend, 3, Bool>::from_data([
+        let tensor = Tensor::<TestBackend, 3, Bool>::from_data_devauto([
             [[false, true, false], [false, false, false]],
             [[false, false, true], [false, false, true]],
         ]);
@@ -80,7 +80,7 @@ mod tests {
 
     #[test]
     fn should_support_swap_dims_bool() {
-        let tensor = Tensor::<TestBackend, 3, Bool>::from_data([
+        let tensor = Tensor::<TestBackend, 3, Bool>::from_data_devauto([
             [[false, true, false], [false, false, false]],
             [[false, false, true], [false, false, true]],
         ]);
diff --git a/burn-tensor/src/tests/ops/tri.rs b/burn-tensor/src/tests/ops/tri.rs
index 3780ec92b..41fca7c6f 100644
--- a/burn-tensor/src/tests/ops/tri.rs
+++ b/burn-tensor/src/tests/ops/tri.rs
@@ -6,7 +6,7 @@ mod tests {
     #[test]
     fn test_triu() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]));
+            Tensor::from_data_devauto(Data::from([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]));
         let output = tensor.triu(0);
         assert_eq!(
             output.to_data(),
@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn test_triu_positive_diagonal() {
         let tensor: Tensor<TestBackend, 2, Int> =
-            Tensor::from_data(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
+            Tensor::from_data_devauto(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
 
         let output = tensor.triu(1);
         assert_eq!(
@@ -29,7 +29,7 @@ mod tests {
     #[test]
     fn test_triu_negative_diagonal() {
         let tensor: Tensor<TestBackend, 2, Int> =
-            Tensor::from_data(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
+            Tensor::from_data_devauto(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
 
         let output = tensor.triu(-1);
         assert_eq!(
@@ -40,7 +40,7 @@ mod tests {
 
     #[test]
     fn test_triu_batch_tensors() {
-        let tensor: Tensor<TestBackend, 4, Int> = Tensor::from_data(Data::from([
+        let tensor: Tensor<TestBackend, 4, Int> = Tensor::from_data_devauto(Data::from([
             [[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]],
             [[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]],
         ]));
@@ -57,14 +57,14 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_triu_too_few_dims() {
-        let tensor: Tensor<TestBackend, 1, Int> = Tensor::from_data(Data::from([1, 2, 3]));
+        let tensor: Tensor<TestBackend, 1, Int> = Tensor::from_data_devauto(Data::from([1, 2, 3]));
         let output = tensor.triu(0);
     }
 
     #[test]
     fn test_tril() {
         let tensor: Tensor<TestBackend, 2> =
-            Tensor::from_data(Data::from([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]));
+            Tensor::from_data_devauto(Data::from([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]));
         let output = tensor.tril(0);
         assert_eq!(
             output.to_data(),
@@ -75,7 +75,7 @@ mod tests {
     #[test]
     fn test_tril_positive_diagonal() {
         let tensor: Tensor<TestBackend, 2, Int> =
-            Tensor::from_data(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
+            Tensor::from_data_devauto(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
 
         let output = tensor.tril(1);
         assert_eq!(
@@ -87,7 +87,7 @@ mod tests {
     #[test]
     fn test_tril_negative_diagonal() {
         let tensor: Tensor<TestBackend, 2, Int> =
-            Tensor::from_data(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
+            Tensor::from_data_devauto(Data::from([[1, 1, 1], [1, 1, 1], [1, 1, 1]]));
 
         let output = tensor.tril(-1);
         assert_eq!(
@@ -98,7 +98,7 @@ mod tests {
 
     #[test]
     fn test_tril_batch_tensors() {
-        let tensor: Tensor<TestBackend, 4, Int> = Tensor::from_data(Data::from([
+        let tensor: Tensor<TestBackend, 4, Int> = Tensor::from_data_devauto(Data::from([
             [[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]],
             [[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]],
         ]));
@@ -115,7 +115,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_tril_too_few_dims() {
-        let tensor: Tensor<TestBackend, 1, Int> = Tensor::from_data(Data::from([1, 2, 3]));
+        let tensor: Tensor<TestBackend, 1, Int> = Tensor::from_data_devauto(Data::from([1, 2, 3]));
         let output = tensor.tril(0);
     }
 }
diff --git a/burn-tensor/src/tests/stats/cov.rs b/burn-tensor/src/tests/stats/cov.rs
index f6fe8a91c..efa40cc63 100644
--- a/burn-tensor/src/tests/stats/cov.rs
+++ b/burn-tensor/src/tests/stats/cov.rs
@@ -10,7 +10,7 @@ mod tests {
     #[test]
     fn test_cov_1() {
         let data = Data::from([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.cov(1, 1).into_data();
 
@@ -21,7 +21,7 @@ mod tests {
     #[test]
     fn test_cov_4() {
         let data = Data::from([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.cov(1, 0).into_data();
 
@@ -32,7 +32,7 @@ mod tests {
     #[test]
     fn test_cov_2() {
         let data = Data::from([[0.5, 1.8], [0.2, -2.0], [3.0, -4.0], [5.0, 0.0]]);
-        let tensor = Tensor::<TestBackend, 2>::from_data(data);
+        let tensor = Tensor::<TestBackend, 2>::from_data_devauto(data);
 
         let data_actual = tensor.cov(1, 1).into_data();
 
@@ -53,9 +53,9 @@ mod tests {
             [[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]],
             [[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]],
         ]);
-        let tensor = Tensor::<TestBackend, 3>::from_data(data);
+        let tensor = Tensor::<TestBackend, 3>::from_data_devauto(data);
         let data_actual = tensor.cov(0, 1).into_data();
-        let data_expected = Tensor::<TestBackend, 3>::zeros([4, 4, 4]).to_data();
+        let data_expected = Tensor::<TestBackend, 3>::zeros_devauto([4, 4, 4]).to_data();
         data_expected.assert_approx_eq(&data_actual, 3);
     }
 }
diff --git a/burn-tensor/src/tests/stats/diagonal.rs b/burn-tensor/src/tests/stats/diagonal.rs
index f7fda216a..f60bce494 100644
--- a/burn-tensor/src/tests/stats/diagonal.rs
+++ b/burn-tensor/src/tests/stats/diagonal.rs
@@ -10,9 +10,10 @@ mod tests {
 
     #[test]
     fn test_diagonal() {
+        let device = <TestBackend as Backend>::Device::default();
         let data = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]];
-        let lhs = Tensor::<TestBackend, 2>::from_floats(data);
-        let rhs = Tensor::<TestBackend, 2>::diagonal(3);
+        let lhs = Tensor::<TestBackend, 2>::from_floats(data, &device);
+        let rhs = Tensor::<TestBackend, 2>::diagonal(3, &device);
         lhs.to_data().assert_approx_eq(&rhs.to_data(), 3);
     }
 }
diff --git a/burn-tensor/src/tests/stats/display.rs b/burn-tensor/src/tests/stats/display.rs
index bb4238038..2711971a8 100644
--- a/burn-tensor/src/tests/stats/display.rs
+++ b/burn-tensor/src/tests/stats/display.rs
@@ -11,7 +11,7 @@ mod tests {
     fn test_display_2d_int_tensor() {
         let int_data = Data::from([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
         let tensor_int: burn_tensor::Tensor<TestBackend, 2, burn_tensor::Int> =
-            Tensor::from_data(int_data);
+            Tensor::from_data_devauto(int_data);
 
         let output = format!("{}", tensor_int);
         let expected = format!(
@@ -37,7 +37,7 @@ mod tests {
     fn test_display_2d_float_tensor() {
         let float_data = Data::from([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [7.7, 8.8, 9.9]]);
         let tensor_float: burn_tensor::Tensor<TestBackend, 2, burn_tensor::Float> =
-            Tensor::from_data(float_data);
+            Tensor::from_data_devauto(float_data);
 
         let output = format!("{}", tensor_float);
         let expected = format!(
@@ -67,7 +67,7 @@ mod tests {
             [false, true, true],
         ]);
         let tensor_bool: burn_tensor::Tensor<TestBackend, 2, burn_tensor::Bool> =
-            Tensor::from_data(bool_data);
+            Tensor::from_data_devauto(bool_data);
 
         let output = format!("{}", tensor_bool);
         let expected = format!(
@@ -94,7 +94,8 @@ mod tests {
             [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
             [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]],
         ]);
-        let tensor: burn_tensor::Tensor<TestBackend, 3, burn_tensor::Int> = Tensor::from_data(data);
+        let tensor: burn_tensor::Tensor<TestBackend, 3, burn_tensor::Int> =
+            Tensor::from_data_devauto(data);
 
         let output = format!("{}", tensor);
         let expected = format!(
@@ -126,7 +127,8 @@ mod tests {
             [[[13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24]]],
         ]);
 
-        let tensor: burn_tensor::Tensor<TestBackend, 4, burn_tensor::Int> = Tensor::from_data(data);
+        let tensor: burn_tensor::Tensor<TestBackend, 4, burn_tensor::Int> =
+            Tensor::from_data_devauto(data);
 
         let output = format!("{}", tensor);
         let expected = format!(
@@ -156,7 +158,7 @@ mod tests {
     #[test]
     fn test_display_tensor_summarize_1() {
         let tensor: burn_tensor::Tensor<TestBackend, 4, burn_tensor::Float> =
-            Tensor::zeros(Shape::new([2, 2, 2, 1000]));
+            Tensor::zeros_devauto(Shape::new([2, 2, 2, 1000]));
 
         let output = format!("{}", tensor);
         let expected = format!(
@@ -185,7 +187,7 @@ mod tests {
     #[test]
     fn test_display_tensor_summarize_2() {
         let tensor: burn_tensor::Tensor<TestBackend, 4, burn_tensor::Float> =
-            Tensor::zeros(Shape::new([2, 2, 20, 100]));
+            Tensor::zeros_devauto(Shape::new([2, 2, 20, 100]));
 
         let output = format!("{}", tensor);
         let expected = format!(
@@ -234,7 +236,7 @@ mod tests {
     #[test]
     fn test_display_tensor_summarize_3() {
         let tensor: burn_tensor::Tensor<TestBackend, 4, burn_tensor::Float> =
-            Tensor::zeros(Shape::new([2, 2, 200, 6]));
+            Tensor::zeros_devauto(Shape::new([2, 2, 200, 6]));
 
         let output = format!("{}", tensor);
         let expected = format!(
diff --git a/burn-tensor/src/tests/stats/var.rs b/burn-tensor/src/tests/stats/var.rs
index ac6ccf2f1..3d78c8785 100644
--- a/burn-tensor/src/tests/stats/var.rs
+++ b/burn-tensor/src/tests/stats/var.rs
@@ -9,7 +9,7 @@ mod tests {
 
     #[test]
     fn test_var() {
-        let tensor = TestTensor::from_data([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
 
         let data_actual = tensor.var(1).into_data();
 
@@ -19,7 +19,7 @@ mod tests {
 
     #[test]
     fn test_var_mean() {
-        let tensor = TestTensor::from_data([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
 
         let (var, mean) = tensor.var_mean(1);
 
@@ -32,7 +32,7 @@ mod tests {
 
     #[test]
     fn test_var_bias() {
-        let tensor = TestTensor::from_data([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
 
         let data_actual = tensor.var_bias(1).into_data();
 
@@ -42,7 +42,7 @@ mod tests {
 
     #[test]
     fn test_var_mean_bias() {
-        let tensor = TestTensor::from_data([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
+        let tensor = TestTensor::from_data_devauto([[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]]);
 
         let (var, mean) = tensor.var_mean_bias(1);
 
diff --git a/burn-train/src/metric/acc.rs b/burn-train/src/metric/acc.rs
index a1a0f3ff2..59e7d5989 100644
--- a/burn-train/src/metric/acc.rs
+++ b/burn-train/src/metric/acc.rs
@@ -94,13 +94,13 @@ mod tests {
     fn test_accuracy_without_padding() {
         let mut metric = AccuracyMetric::<TestBackend>::new();
         let input = AccuracyInput::new(
-            Tensor::from_data([
+            Tensor::from_data_devauto([
                 [0.0, 0.2, 0.8], // 2
                 [1.0, 2.0, 0.5], // 1
                 [0.4, 0.1, 0.2], // 0
                 [0.6, 0.7, 0.2], // 1
             ]),
-            Tensor::from_data([2, 2, 1, 1]),
+            Tensor::from_data_devauto([2, 2, 1, 1]),
         );
 
         let _entry = metric.update(&input, &MetricMetadata::fake());
@@ -111,7 +111,7 @@ mod tests {
     fn test_accuracy_with_padding() {
         let mut metric = AccuracyMetric::<TestBackend>::new().with_pad_token(3);
         let input = AccuracyInput::new(
-            Tensor::from_data([
+            Tensor::from_data_devauto([
                 [0.0, 0.2, 0.8, 0.0], // 2
                 [1.0, 2.0, 0.5, 0.0], // 1
                 [0.4, 0.1, 0.2, 0.0], // 0
@@ -120,7 +120,7 @@ mod tests {
                 [0.0, 0.1, 0.2, 0.0], // Error on padding should not count
                 [0.6, 0.0, 0.2, 0.0], // Error on padding should not count
             ]),
-            Tensor::from_data([2, 2, 1, 1, 3, 3, 3]),
+            Tensor::from_data_devauto([2, 2, 1, 1, 3, 3, 3]),
         );
 
         let _entry = metric.update(&input, &MetricMetadata::fake());
diff --git a/burn-train/src/metric/processor/mod.rs b/burn-train/src/metric/processor/mod.rs
index f88989409..18516c2a2 100644
--- a/burn-train/src/metric/processor/mod.rs
+++ b/burn-train/src/metric/processor/mod.rs
@@ -20,7 +20,7 @@ pub(crate) mod test_utils {
 
     impl<B: Backend> Adaptor<LossInput<B>> for f64 {
         fn adapt(&self) -> LossInput<B> {
-            LossInput::new(Tensor::from_data([self.elem()]))
+            LossInput::new(Tensor::from_data_devauto([self.elem()]))
         }
     }
 
diff --git a/burn-wgpu/benches/fused_elemwise.rs b/burn-wgpu/benches/fused_elemwise.rs
index ff8443bd2..9cb01f282 100644
--- a/burn-wgpu/benches/fused_elemwise.rs
+++ b/burn-wgpu/benches/fused_elemwise.rs
@@ -43,8 +43,8 @@ impl<B: Backend> Benchmark for ElemWiseBenchmark<B> {
 
     fn prepare(&self) -> Self::Args {
         B::seed(10);
-        let lhs = Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device);
-        let rhs = Tensor::random_device(self.shape.clone(), Distribution::Default, &self.device);
+        let lhs = Tensor::random(self.shape.clone(), Distribution::Default, &self.device);
+        let rhs = Tensor::random(self.shape.clone(), Distribution::Default, &self.device);
 
         (lhs, rhs)
     }
diff --git a/burn-wgpu/benches/matmul.rs b/burn-wgpu/benches/matmul.rs
index 586faf0e9..ed06a91fe 100644
--- a/burn-wgpu/benches/matmul.rs
+++ b/burn-wgpu/benches/matmul.rs
@@ -57,10 +57,8 @@ where
     }
 
     fn prepare(&self) -> Self::Args {
-        let lhs =
-            WTensor::random_device(self.shape_lhs.clone(), Distribution::Default, &self.device);
-        let rhs =
-            WTensor::random_device(self.shape_rhs.clone(), Distribution::Default, &self.device);
+        let lhs = WTensor::random(self.shape_lhs.clone(), Distribution::Default, &self.device);
+        let rhs = WTensor::random(self.shape_rhs.clone(), Distribution::Default, &self.device);
 
         (lhs, rhs)
     }
diff --git a/burn-wgpu/benches/reduction.rs b/burn-wgpu/benches/reduction.rs
index 494044590..4ca3303ee 100644
--- a/burn-wgpu/benches/reduction.rs
+++ b/burn-wgpu/benches/reduction.rs
@@ -51,7 +51,7 @@ where
     }
 
     fn prepare(&self) -> Self::Args {
-        WTensor::random_device(self.shape.clone(), Distribution::Default, &self.device)
+        WTensor::random(self.shape.clone(), Distribution::Default, &self.device)
     }
 
     fn sync(&self) {
diff --git a/burn-wgpu/src/fusion/elemwise/optimization.rs b/burn-wgpu/src/fusion/elemwise/optimization.rs
index 09fc888b8..02feb25ce 100644
--- a/burn-wgpu/src/fusion/elemwise/optimization.rs
+++ b/burn-wgpu/src/fusion/elemwise/optimization.rs
@@ -122,10 +122,12 @@ mod tests {
         type Backend = Wgpu;
         type FusedBackend = Fusion<Wgpu>;
 
-        let data_1 = Tensor::<FusedBackend, 2>::random([1, 32], burn_tensor::Distribution::Default)
-            .into_data();
+        let data_1 =
+            Tensor::<FusedBackend, 2>::random_devauto([1, 32], burn_tensor::Distribution::Default)
+                .into_data();
         let data_2 =
-            Tensor::<Backend, 2>::random([32, 32], burn_tensor::Distribution::Default).into_data();
+            Tensor::<Backend, 2>::random_devauto([32, 32], burn_tensor::Distribution::Default)
+                .into_data();
 
         let result_ref = execute::<Backend>(
             data_1.clone(),
@@ -146,10 +148,12 @@ mod tests {
         type Backend = Wgpu;
         type FusedBackend = Fusion<Wgpu>;
 
-        let data_1 = Tensor::<FusedBackend, 2>::random([1, 32], burn_tensor::Distribution::Default)
-            .into_data();
+        let data_1 =
+            Tensor::<FusedBackend, 2>::random_devauto([1, 32], burn_tensor::Distribution::Default)
+                .into_data();
         let data_2 =
-            Tensor::<Backend, 2>::random([32, 32], burn_tensor::Distribution::Default).into_data();
+            Tensor::<Backend, 2>::random_devauto([32, 32], burn_tensor::Distribution::Default)
+                .into_data();
 
         let result_ref = execute::<Backend>(
             data_1.clone(),
@@ -174,8 +178,8 @@ mod tests {
     #[test]
     fn test_end_condition_scalar_ops() {
         type Backend = Fusion<Wgpu>;
-        let tensor1 = Tensor::<Backend, 2>::ones([32, 32]);
-        let tensor2 = Tensor::<Backend, 2>::ones([32, 42]);
+        let tensor1 = Tensor::<Backend, 2>::ones_devauto([32, 32]);
+        let tensor2 = Tensor::<Backend, 2>::ones_devauto([32, 42]);
         let output = tensor1.exp().log();
 
         // This will add a scalar to the context, even if the actual operation can't be fused with
@@ -205,8 +209,8 @@ mod tests {
         data_2: Data<f32, 2>,
         variant: ImplementationDetails,
     ) -> Data<f32, 2> {
-        let tensor_1 = Tensor::<B, 2>::from_data(data_1.convert());
-        let tensor_2 = Tensor::<B, 2>::from_data(data_2.convert());
+        let tensor_1 = Tensor::<B, 2>::from_data_devauto(data_1.convert());
+        let tensor_2 = Tensor::<B, 2>::from_data_devauto(data_2.convert());
         let tensor_3 = tensor_1.clone() + tensor_2;
         let tensor_4 = tensor_3.clone() - tensor_1;
         let mut tensor_5 = tensor_4.clone() + 5.0;
diff --git a/burn-wgpu/src/kernel/cast.rs b/burn-wgpu/src/kernel/cast.rs
index d840c5268..3822601b5 100644
--- a/burn-wgpu/src/kernel/cast.rs
+++ b/burn-wgpu/src/kernel/cast.rs
@@ -70,7 +70,7 @@ mod tests {
         const START: usize = 0;
         const END: usize = 100;
 
-        let tensor = Tensor::<TestBackend, 1, Int>::arange(START..END);
+        let tensor = Tensor::<TestBackend, 1, Int>::arange_devauto(START..END);
         let tensor_float = cast::<i32, f32, 1>(tensor.clone().into_primitive());
 
         let data_int = tensor.into_data();
diff --git a/burn-wgpu/src/kernel/cat.rs b/burn-wgpu/src/kernel/cat.rs
index 427154115..3c4441af9 100644
--- a/burn-wgpu/src/kernel/cat.rs
+++ b/burn-wgpu/src/kernel/cat.rs
@@ -77,11 +77,11 @@ mod tests {
     fn test_same_as_reference(shape: [usize; 2], num_tensors: usize, dim: usize) {
         TestBackend::seed(0);
         let tensors = (0..num_tensors)
-            .map(|_| Tensor::<TestBackend, 2>::random(shape, Distribution::Default))
+            .map(|_| Tensor::<TestBackend, 2>::random_devauto(shape, Distribution::Default))
             .collect::<Vec<_>>();
         let tensors_ref = tensors
             .iter()
-            .map(|tensor| Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data()))
+            .map(|tensor| Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data()))
             .collect::<Vec<_>>();
 
         let tensor = Tensor::<TestBackend, 2>::cat(tensors, dim);
diff --git a/burn-wgpu/src/kernel/clamp.rs b/burn-wgpu/src/kernel/clamp.rs
index 85ff88f4f..438a5d1d4 100644
--- a/burn-wgpu/src/kernel/clamp.rs
+++ b/burn-wgpu/src/kernel/clamp.rs
@@ -31,8 +31,8 @@ mod tests {
 
     #[test]
     fn clamp_should_match_reference() {
-        let input = Tensor::<TestBackend, 4>::random([1, 5, 32, 32], Distribution::Default);
-        let input_ref = Tensor::<ReferenceBackend, 4>::from_data(input.to_data());
+        let input = Tensor::<TestBackend, 4>::random_devauto([1, 5, 32, 32], Distribution::Default);
+        let input_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(input.to_data());
 
         let output = input.clamp(0.3, 0.7);
 
diff --git a/burn-wgpu/src/kernel/conv/conv2d.rs b/burn-wgpu/src/kernel/conv/conv2d.rs
index 39b0ecf45..6ec7bd366 100644
--- a/burn-wgpu/src/kernel/conv/conv2d.rs
+++ b/burn-wgpu/src/kernel/conv/conv2d.rs
@@ -90,12 +90,13 @@ mod tests {
 
     #[test]
     fn conv2d_should_work_with_multiple_invocations() {
-        let input = Tensor::<TestBackend, 4>::random([6, 16, 32, 32], Distribution::Default);
-        let weight = Tensor::<TestBackend, 4>::random([12, 8, 3, 3], Distribution::Default);
-        let bias = Tensor::<TestBackend, 1>::random([12], Distribution::Default);
-        let input_ref = Tensor::<ReferenceBackend, 4>::from_data(input.to_data());
-        let weight_ref = Tensor::<ReferenceBackend, 4>::from_data(weight.to_data());
-        let bias_ref = Tensor::<ReferenceBackend, 1>::from_data(bias.to_data());
+        let input =
+            Tensor::<TestBackend, 4>::random_devauto([6, 16, 32, 32], Distribution::Default);
+        let weight = Tensor::<TestBackend, 4>::random_devauto([12, 8, 3, 3], Distribution::Default);
+        let bias = Tensor::<TestBackend, 1>::random_devauto([12], Distribution::Default);
+        let input_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(input.to_data());
+        let weight_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(weight.to_data());
+        let bias_ref = Tensor::<ReferenceBackend, 1>::from_data_devauto(bias.to_data());
         let options = burn_tensor::ops::ConvOptions::new([2, 3], [2, 3], [2, 3], 2);
 
         let output = module::conv2d(input, weight, Some(bias), options.clone());
diff --git a/burn-wgpu/src/kernel/conv/conv_transpose2d.rs b/burn-wgpu/src/kernel/conv/conv_transpose2d.rs
index d59a2cb6f..774af408f 100644
--- a/burn-wgpu/src/kernel/conv/conv_transpose2d.rs
+++ b/burn-wgpu/src/kernel/conv/conv_transpose2d.rs
@@ -92,11 +92,11 @@ mod tests {
         let options =
             burn_tensor::ops::ConvTransposeOptions::new([1, 1], [1, 1], [0, 0], [1, 1], 1);
 
-        let input = Tensor::<TestBackend, 4>::random(
+        let input = Tensor::<TestBackend, 4>::random_devauto(
             [batch_size, in_channels, height, width],
             Distribution::Default,
         );
-        let weight = Tensor::<TestBackend, 4>::random(
+        let weight = Tensor::<TestBackend, 4>::random_devauto(
             [
                 in_channels,
                 out_channels / options.groups,
@@ -105,10 +105,10 @@ mod tests {
             ],
             Distribution::Default,
         );
-        let bias = Tensor::<TestBackend, 1>::random([out_channels], Distribution::Default);
-        let input_ref = Tensor::<ReferenceBackend, 4>::from_data(input.to_data());
-        let weight_ref = Tensor::<ReferenceBackend, 4>::from_data(weight.to_data());
-        let bias_ref = Tensor::<ReferenceBackend, 1>::from_data(bias.to_data());
+        let bias = Tensor::<TestBackend, 1>::random_devauto([out_channels], Distribution::Default);
+        let input_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(input.to_data());
+        let weight_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(weight.to_data());
+        let bias_ref = Tensor::<ReferenceBackend, 1>::from_data_devauto(bias.to_data());
 
         let output = module::conv_transpose2d(input, weight, Some(bias), options.clone());
         let output_ref = module::conv_transpose2d(input_ref, weight_ref, Some(bias_ref), options);
diff --git a/burn-wgpu/src/kernel/index/gather.rs b/burn-wgpu/src/kernel/index/gather.rs
index 826df4422..be3bc04c5 100644
--- a/burn-wgpu/src/kernel/index/gather.rs
+++ b/burn-wgpu/src/kernel/index/gather.rs
@@ -60,9 +60,9 @@ mod tests {
         TestBackend::seed(0);
         let max = shape[dim];
         let shape = Shape::new(shape);
-        let tensor = Tensor::<TestBackend, D>::random(shape.clone(), Distribution::Default);
-        let indices = Tensor::<TestBackend, 1, Int>::from_data(
-            Tensor::<TestBackend, 1>::random(
+        let tensor = Tensor::<TestBackend, D>::random_devauto(shape.clone(), Distribution::Default);
+        let indices = Tensor::<TestBackend, 1, Int>::from_data_devauto(
+            Tensor::<TestBackend, 1>::random_devauto(
                 [shape.num_elements()],
                 Distribution::Uniform(0., max as f64),
             )
@@ -70,9 +70,9 @@ mod tests {
             .convert(),
         )
         .reshape(shape);
-        let tensor_ref = Tensor::<ReferenceBackend, D>::from_data(tensor.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, D>::from_data_devauto(tensor.to_data());
         let indices_ref =
-            Tensor::<ReferenceBackend, D, Int>::from_data(indices.to_data().convert());
+            Tensor::<ReferenceBackend, D, Int>::from_data_devauto(indices.to_data().convert());
 
         let actual = Tensor::<TestBackend, D>::from_primitive(gather(
             dim,
diff --git a/burn-wgpu/src/kernel/index/repeat.rs b/burn-wgpu/src/kernel/index/repeat.rs
index 16d241862..df7fbc4c1 100644
--- a/burn-wgpu/src/kernel/index/repeat.rs
+++ b/burn-wgpu/src/kernel/index/repeat.rs
@@ -55,10 +55,10 @@ mod tests {
 
     #[test]
     fn repeat_dim_0_few_times() {
-        let tensor = Tensor::<TestBackend, 3>::random([1, 6, 6], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([1, 6, 6], Distribution::Default);
         let dim = 0;
         let times = 4;
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
 
         let actual = repeat(tensor.into_primitive(), dim, times);
         let expected = tensor_ref.repeat(dim, times);
@@ -71,10 +71,10 @@ mod tests {
 
     #[test]
     fn repeat_dim_1_few_times() {
-        let tensor = Tensor::<TestBackend, 3>::random([6, 1, 6], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([6, 1, 6], Distribution::Default);
         let dim = 1;
         let times = 4;
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
 
         let actual = repeat(tensor.into_primitive(), dim, times);
         let expected = tensor_ref.repeat(dim, times);
@@ -87,10 +87,10 @@ mod tests {
 
     #[test]
     fn repeat_dim_2_few_times() {
-        let tensor = Tensor::<TestBackend, 3>::random([6, 6, 1], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([6, 6, 1], Distribution::Default);
         let dim = 2;
         let times = 4;
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
 
         let actual = repeat(tensor.into_primitive(), dim, times);
         let expected = tensor_ref.repeat(dim, times);
@@ -103,10 +103,10 @@ mod tests {
 
     #[test]
     fn repeat_dim_2_many_times() {
-        let tensor = Tensor::<TestBackend, 3>::random([10, 10, 1], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([10, 10, 1], Distribution::Default);
         let dim = 2;
         let times = 200;
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
 
         let actual = repeat(tensor.into_primitive(), dim, times);
         let expected = tensor_ref.repeat(dim, times);
diff --git a/burn-wgpu/src/kernel/index/scatter.rs b/burn-wgpu/src/kernel/index/scatter.rs
index 8789fd683..90b4e0d42 100644
--- a/burn-wgpu/src/kernel/index/scatter.rs
+++ b/burn-wgpu/src/kernel/index/scatter.rs
@@ -106,10 +106,10 @@ mod tests {
         shape2: [usize; D],
     ) {
         TestBackend::seed(0);
-        let tensor = Tensor::<TestBackend, D>::random(shape1, Distribution::Default);
-        let value = Tensor::<TestBackend, D>::random(shape2, Distribution::Default);
-        let indices = Tensor::<TestBackend, 1, Int>::from_data(
-            Tensor::<TestBackend, 1>::random(
+        let tensor = Tensor::<TestBackend, D>::random_devauto(shape1, Distribution::Default);
+        let value = Tensor::<TestBackend, D>::random_devauto(shape2, Distribution::Default);
+        let indices = Tensor::<TestBackend, 1, Int>::from_data_devauto(
+            Tensor::<TestBackend, 1>::random_devauto(
                 [shape2.iter().product()],
                 Distribution::Uniform(0., shape2[dim] as f64),
             )
@@ -117,10 +117,10 @@ mod tests {
             .convert(),
         )
         .reshape(shape2);
-        let tensor_ref = Tensor::<ReferenceBackend, D>::from_data(tensor.to_data());
-        let value_ref = Tensor::<ReferenceBackend, D>::from_data(value.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, D>::from_data_devauto(tensor.to_data());
+        let value_ref = Tensor::<ReferenceBackend, D>::from_data_devauto(value.to_data());
         let indices_ref =
-            Tensor::<ReferenceBackend, D, Int>::from_data(indices.to_data().convert());
+            Tensor::<ReferenceBackend, D, Int>::from_data_devauto(indices.to_data().convert());
 
         let actual = Tensor::<TestBackend, D>::from_primitive(scatter(
             dim,
diff --git a/burn-wgpu/src/kernel/index/select.rs b/burn-wgpu/src/kernel/index/select.rs
index 09ccd4dba..50707f97d 100644
--- a/burn-wgpu/src/kernel/index/select.rs
+++ b/burn-wgpu/src/kernel/index/select.rs
@@ -105,11 +105,11 @@ mod tests {
 
     #[test]
     fn select_should_work_with_multiple_workgroups() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 256], Distribution::Default);
-        let indices = Tensor::<TestBackend, 1, Int>::arange(0..100);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 256], Distribution::Default);
+        let indices = Tensor::<TestBackend, 1, Int>::arange_devauto(0..100);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
         let indices_ref =
-            Tensor::<ReferenceBackend, 1, Int>::from_data(indices.to_data().convert());
+            Tensor::<ReferenceBackend, 1, Int>::from_data_devauto(indices.to_data().convert());
 
         let actual = select(tensor.into_primitive(), 1, indices.into_primitive());
         let expected = tensor_ref.select(1, indices_ref);
@@ -147,20 +147,20 @@ mod tests {
 
     fn select_assign_same_as_ref<const D: usize>(dim: usize, shape: [usize; D]) {
         TestBackend::seed(0);
-        let tensor = Tensor::<TestBackend, D>::random(shape, Distribution::Default);
-        let value = Tensor::<TestBackend, D>::random(shape, Distribution::Default);
-        let indices = Tensor::<TestBackend, 1, Int>::from_data(
-            Tensor::<TestBackend, 1>::random(
+        let tensor = Tensor::<TestBackend, D>::random_devauto(shape, Distribution::Default);
+        let value = Tensor::<TestBackend, D>::random_devauto(shape, Distribution::Default);
+        let indices = Tensor::<TestBackend, 1, Int>::from_data_devauto(
+            Tensor::<TestBackend, 1>::random_devauto(
                 [shape[dim]],
                 Distribution::Uniform(0., shape[dim] as f64),
             )
             .into_data()
             .convert(),
         );
-        let tensor_ref = Tensor::<ReferenceBackend, D>::from_data(tensor.to_data());
-        let value_ref = Tensor::<ReferenceBackend, D>::from_data(value.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, D>::from_data_devauto(tensor.to_data());
+        let value_ref = Tensor::<ReferenceBackend, D>::from_data_devauto(value.to_data());
         let indices_ref =
-            Tensor::<ReferenceBackend, 1, Int>::from_data(indices.to_data().convert());
+            Tensor::<ReferenceBackend, 1, Int>::from_data_devauto(indices.to_data().convert());
 
         let actual = Tensor::<TestBackend, D>::from_primitive(select_assign(
             tensor.into_primitive(),
diff --git a/burn-wgpu/src/kernel/index/slice.rs b/burn-wgpu/src/kernel/index/slice.rs
index e431168b6..0ba5048c3 100644
--- a/burn-wgpu/src/kernel/index/slice.rs
+++ b/burn-wgpu/src/kernel/index/slice.rs
@@ -96,9 +96,9 @@ mod tests {
 
     #[test]
     fn slice_should_work_with_multiple_workgroups() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 256], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 256], Distribution::Default);
         let indices = [3..5, 45..256];
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
 
         let actual = slice(tensor.into_primitive(), indices.clone());
         let expected = tensor_ref.slice(indices);
@@ -111,11 +111,11 @@ mod tests {
 
     #[test]
     fn slice_assign_should_work_with_multiple_workgroups() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 256], Distribution::Default);
-        let value = Tensor::<TestBackend, 2>::random([2, 211], Distribution::Default);
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 256], Distribution::Default);
+        let value = Tensor::<TestBackend, 2>::random_devauto([2, 211], Distribution::Default);
         let indices = [3..5, 45..256];
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
-        let value_ref = Tensor::<ReferenceBackend, 2>::from_data(value.to_data());
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
+        let value_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(value.to_data());
 
         let actual = slice_assign(
             tensor.into_primitive(),
diff --git a/burn-wgpu/src/kernel/mask/mask_fill.rs b/burn-wgpu/src/kernel/mask/mask_fill.rs
index aed9c3359..dc21f509e 100644
--- a/burn-wgpu/src/kernel/mask/mask_fill.rs
+++ b/burn-wgpu/src/kernel/mask/mask_fill.rs
@@ -111,11 +111,12 @@ mod tests {
         Tensor<ReferenceBackend, 3>,
         Tensor<ReferenceBackend, 3, Bool>,
     ) {
-        let tensor = Tensor::<TestBackend, 3>::random([2, 6, 256], Distribution::Default);
-        let mask = Tensor::<TestBackend, 3>::random([2, 6, 256], Distribution::Uniform(0., 1.))
-            .lower_equal_elem(0.5);
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
-        let mask_ref = Tensor::<ReferenceBackend, 3, Bool>::from_data(mask.to_data());
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([2, 6, 256], Distribution::Default);
+        let mask =
+            Tensor::<TestBackend, 3>::random_devauto([2, 6, 256], Distribution::Uniform(0., 1.))
+                .lower_equal_elem(0.5);
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
+        let mask_ref = Tensor::<ReferenceBackend, 3, Bool>::from_data_devauto(mask.to_data());
 
         (tensor, mask, tensor_ref, mask_ref)
     }
diff --git a/burn-wgpu/src/kernel/mask/mask_where.rs b/burn-wgpu/src/kernel/mask/mask_where.rs
index 9972554ab..4d06e0365 100644
--- a/burn-wgpu/src/kernel/mask/mask_where.rs
+++ b/burn-wgpu/src/kernel/mask/mask_where.rs
@@ -136,13 +136,14 @@ mod tests {
         Tensor<ReferenceBackend, 3, Bool>,
     ) {
         TestBackend::seed(0);
-        let tensor = Tensor::<TestBackend, 3>::random([2, 6, 256], Distribution::Default);
-        let value = Tensor::<TestBackend, 3>::random([2, 6, 256], Distribution::Default);
-        let mask = Tensor::<TestBackend, 3>::random([2, 6, 256], Distribution::Uniform(0., 1.))
-            .lower_equal_elem(0.5);
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
-        let value_ref = Tensor::<ReferenceBackend, 3>::from_data(value.to_data());
-        let mask_ref = Tensor::<ReferenceBackend, 3, Bool>::from_data(mask.to_data());
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([2, 6, 256], Distribution::Default);
+        let value = Tensor::<TestBackend, 3>::random_devauto([2, 6, 256], Distribution::Default);
+        let mask =
+            Tensor::<TestBackend, 3>::random_devauto([2, 6, 256], Distribution::Uniform(0., 1.))
+                .lower_equal_elem(0.5);
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
+        let value_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(value.to_data());
+        let mask_ref = Tensor::<ReferenceBackend, 3, Bool>::from_data_devauto(mask.to_data());
         assert_eq!(mask.to_data(), mask_ref.to_data());
 
         (tensor, value, mask, tensor_ref, value_ref, mask_ref)
diff --git a/burn-wgpu/src/kernel/matmul/tiling2d/padding.rs b/burn-wgpu/src/kernel/matmul/tiling2d/padding.rs
index 290d34078..a3678f0e5 100644
--- a/burn-wgpu/src/kernel/matmul/tiling2d/padding.rs
+++ b/burn-wgpu/src/kernel/matmul/tiling2d/padding.rs
@@ -108,7 +108,7 @@ mod tests {
         let row_divisor = 5;
         let col = 12;
         let col_divisor = 3;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
         let expected_shape = [row, col].into();
 
         let padded = pad_round(tensor.into_primitive(), row_divisor, col_divisor).into_tensor();
@@ -122,7 +122,7 @@ mod tests {
         let row_divisor = 5;
         let col = 12;
         let col_divisor = 3;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
 
         let padded = pad_round(tensor.clone().into_primitive(), row_divisor, col_divisor);
 
@@ -136,7 +136,7 @@ mod tests {
         let row_divisor = 6;
         let col = 12;
         let col_divisor = 5;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
         let expected_shape = [12, 15].into();
 
         let padded = pad_round(tensor.into_primitive(), row_divisor, col_divisor).into_tensor();
@@ -150,7 +150,7 @@ mod tests {
         let row_divisor = 6;
         let col = 12;
         let col_divisor = 5;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
 
         let padded =
             pad_round(tensor.clone().into_primitive(), row_divisor, col_divisor).into_tensor();
@@ -170,7 +170,7 @@ mod tests {
         let row_divisor = 6;
         let col = 12;
         let col_divisor = 5;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
 
         let padded = pad_round(tensor.into_primitive(), row_divisor, col_divisor).into_tensor();
         let padded = TestTensor::from_primitive(padded).to_data();
@@ -195,7 +195,8 @@ mod tests {
         let row_divisor = 4;
         let col = 12;
         let col_divisor = 5;
-        let tensor = TestTensor::random([2, 3, row, col], burn_tensor::Distribution::Default);
+        let tensor =
+            TestTensor::random_devauto([2, 3, row, col], burn_tensor::Distribution::Default);
         let expected_shape = [2, 3, 12, 15].into();
 
         let padded = pad_round(tensor.into_primitive(), row_divisor, col_divisor).into_tensor();
@@ -209,7 +210,7 @@ mod tests {
         let row_divisor = 32;
         let col = 4;
         let col_divisor = 3;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
         let expected_shape = [row_divisor, 2 * col_divisor].into();
 
         let padded = pad_round(tensor.into_primitive(), row_divisor, col_divisor).into_tensor();
@@ -223,7 +224,7 @@ mod tests {
         let row_divisor = 32;
         let col = 4;
         let col_divisor = 64;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
         let expected_shape = [32, 64].into();
 
         let padded = pad_round(tensor.into_primitive(), row_divisor, col_divisor).into_tensor();
@@ -235,12 +236,12 @@ mod tests {
     fn crop_same_shape_should_be_unchanged_shape() {
         let row = 10;
         let col = 12;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
         let expected_shape = [row, col].into();
 
         let unpadded = crop(
             tensor.clone().into_primitive(),
-            TestTensor::empty([row, col]).into_primitive(),
+            TestTensor::empty_devauto([row, col]).into_primitive(),
         );
 
         assert!(unpadded.shape == expected_shape);
@@ -250,11 +251,11 @@ mod tests {
     fn crop_same_shape_should_have_unchanged_values() {
         let row = 10;
         let col = 12;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
 
         let unpadded = crop(
             tensor.clone().into_primitive(),
-            TestTensor::empty([row, col]).into_primitive(),
+            TestTensor::empty_devauto([row, col]).into_primitive(),
         );
 
         let unpadded = TestTensor::from_primitive(unpadded).to_data();
@@ -272,12 +273,12 @@ mod tests {
         let keep_rows = 8;
         let col = 12;
         let keep_cols = 10;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
         let expected_shape = [keep_rows, keep_cols].into();
 
         let unpadded = crop(
             tensor.clone().into_primitive(),
-            TestTensor::empty([keep_rows, keep_cols]).into_primitive(),
+            TestTensor::empty_devauto([keep_rows, keep_cols]).into_primitive(),
         );
 
         assert!(unpadded.shape == expected_shape);
@@ -289,11 +290,11 @@ mod tests {
         let keep_rows = 3;
         let col = 4;
         let keep_cols = 3;
-        let tensor = TestTensor::random([row, col], burn_tensor::Distribution::Default);
+        let tensor = TestTensor::random_devauto([row, col], burn_tensor::Distribution::Default);
 
         let unpadded = crop(
             tensor.clone().into_primitive(),
-            TestTensor::empty([keep_rows, keep_cols]).into_primitive(),
+            TestTensor::empty_devauto([keep_rows, keep_cols]).into_primitive(),
         );
 
         let unpadded = TestTensor::from_primitive(unpadded).to_data();
diff --git a/burn-wgpu/src/kernel/matmul/utils.rs b/burn-wgpu/src/kernel/matmul/utils.rs
index 8a791ba35..d2ce19fe9 100644
--- a/burn-wgpu/src/kernel/matmul/utils.rs
+++ b/burn-wgpu/src/kernel/matmul/utils.rs
@@ -40,11 +40,17 @@ pub(crate) mod tests {
         F: Fn(WgpuTensor<f32, D>, WgpuTensor<f32, D>, WgpuTensor<f32, D>) -> WgpuTensor<f32, D>,
         S: Into<Shape<D>>,
     {
-        let x = ReferenceTensor::random(shape_lhs, burn_tensor::Distribution::Uniform(-1.0, 1.0));
-        let y = ReferenceTensor::random(shape_rhs, burn_tensor::Distribution::Uniform(-1.0, 1.0));
+        let x = ReferenceTensor::random_devauto(
+            shape_lhs,
+            burn_tensor::Distribution::Uniform(-1.0, 1.0),
+        );
+        let y = ReferenceTensor::random_devauto(
+            shape_rhs,
+            burn_tensor::Distribution::Uniform(-1.0, 1.0),
+        );
 
-        let x_wgpu = TestTensor::from_data(x.to_data()).into_primitive();
-        let y_wgpu = TestTensor::from_data(y.to_data()).into_primitive();
+        let x_wgpu = TestTensor::from_data_devauto(x.to_data()).into_primitive();
+        let y_wgpu = TestTensor::from_data_devauto(y.to_data()).into_primitive();
 
         let z_reference = x.matmul(y);
 
@@ -65,11 +71,17 @@ pub(crate) mod tests {
         F: Fn(WgpuTensor<f32, D>, WgpuTensor<f32, D>, WgpuTensor<f32, D>) -> WgpuTensor<f32, D>,
         S: Into<Shape<D>>,
     {
-        let x = ReferenceTensor::random(shape_lhs, burn_tensor::Distribution::Uniform(-1.0, 1.0));
-        let y = ReferenceTensor::random(shape_rhs, burn_tensor::Distribution::Uniform(-1.0, 1.0));
+        let x = ReferenceTensor::random_devauto(
+            shape_lhs,
+            burn_tensor::Distribution::Uniform(-1.0, 1.0),
+        );
+        let y = ReferenceTensor::random_devauto(
+            shape_rhs,
+            burn_tensor::Distribution::Uniform(-1.0, 1.0),
+        );
 
-        let x_wgpu = TestTensor::from_data(x.to_data()).swap_dims(swap_lhs[0], swap_lhs[1]);
-        let y_wgpu = TestTensor::from_data(y.to_data()).swap_dims(swap_rhs[0], swap_rhs[1]);
+        let x_wgpu = TestTensor::from_data_devauto(x.to_data()).swap_dims(swap_lhs[0], swap_lhs[1]);
+        let y_wgpu = TestTensor::from_data_devauto(y.to_data()).swap_dims(swap_rhs[0], swap_rhs[1]);
 
         let z_reference = x
             .swap_dims(swap_lhs[0], swap_lhs[1])
diff --git a/burn-wgpu/src/kernel/pool/avg_pool2d.rs b/burn-wgpu/src/kernel/pool/avg_pool2d.rs
index 05a5d840d..63f5e6fcd 100644
--- a/burn-wgpu/src/kernel/pool/avg_pool2d.rs
+++ b/burn-wgpu/src/kernel/pool/avg_pool2d.rs
@@ -107,8 +107,9 @@ mod tests {
 
     #[test]
     fn avg_pool2d_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 4>::random([32, 32, 32, 32], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data(tensor.to_data());
+        let tensor =
+            Tensor::<TestBackend, 4>::random_devauto([32, 32, 32, 32], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(tensor.to_data());
         let kernel_size = [3, 4];
         let stride = [1, 2];
         let padding = [1, 2];
@@ -127,8 +128,9 @@ mod tests {
     fn avg_pool2d_backward_should_work_with_multiple_invocations() {
         TestBackend::seed(0);
         ReferenceBackend::seed(0);
-        let tensor = Tensor::<TestBackend, 4>::random([32, 32, 32, 32], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data(tensor.to_data());
+        let tensor =
+            Tensor::<TestBackend, 4>::random_devauto([32, 32, 32, 32], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(tensor.to_data());
         let kernel_size = [3, 3];
         let stride = [1, 1];
         let padding = [1, 1];
@@ -142,8 +144,10 @@ mod tests {
             count_include_pad,
         )
         .shape();
-        let grad_output = Tensor::<TestBackend, 4>::random(shape_out, Distribution::Default);
-        let grad_output_ref = Tensor::<ReferenceBackend, 4>::from_data(grad_output.to_data());
+        let grad_output =
+            Tensor::<TestBackend, 4>::random_devauto(shape_out, Distribution::Default);
+        let grad_output_ref =
+            Tensor::<ReferenceBackend, 4>::from_data_devauto(grad_output.to_data());
 
         let grad: Tensor<TestBackend, 4> =
             Tensor::from_primitive(TestBackend::avg_pool2d_backward(
diff --git a/burn-wgpu/src/kernel/pool/max_pool2d.rs b/burn-wgpu/src/kernel/pool/max_pool2d.rs
index 77ce5d998..91d482cde 100644
--- a/burn-wgpu/src/kernel/pool/max_pool2d.rs
+++ b/burn-wgpu/src/kernel/pool/max_pool2d.rs
@@ -108,8 +108,9 @@ mod tests {
 
     #[test]
     pub fn max_pool2d_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 4>::random([32, 32, 32, 32], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data(tensor.to_data());
+        let tensor =
+            Tensor::<TestBackend, 4>::random_devauto([32, 32, 32, 32], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(tensor.to_data());
         let kernel_size = [3, 3];
         let stride = [2, 2];
         let padding = [1, 1];
@@ -125,8 +126,9 @@ mod tests {
 
     #[test]
     pub fn max_pool2d_with_indices_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 4>::random([32, 32, 32, 32], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data(tensor.to_data());
+        let tensor =
+            Tensor::<TestBackend, 4>::random_devauto([32, 32, 32, 32], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(tensor.to_data());
         let kernel_size = [3, 3];
         let stride = [2, 2];
         let padding = [1, 1];
@@ -145,10 +147,13 @@ mod tests {
 
     #[test]
     pub fn max_pool2d_with_indices_backward_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 4>::random([32, 32, 32, 32], Distribution::Default);
-        let grad_output = Tensor::<TestBackend, 4>::random([32, 32, 16, 16], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data(tensor.to_data());
-        let grad_output_ref = Tensor::<ReferenceBackend, 4>::from_data(grad_output.to_data());
+        let tensor =
+            Tensor::<TestBackend, 4>::random_devauto([32, 32, 32, 32], Distribution::Default);
+        let grad_output =
+            Tensor::<TestBackend, 4>::random_devauto([32, 32, 16, 16], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 4>::from_data_devauto(tensor.to_data());
+        let grad_output_ref =
+            Tensor::<ReferenceBackend, 4>::from_data_devauto(grad_output.to_data());
         let kernel_size = [3, 3];
         let stride = [2, 2];
         let padding = [1, 1];
diff --git a/burn-wgpu/src/kernel/prng/bernoulli.rs b/burn-wgpu/src/kernel/prng/bernoulli.rs
index 69c4cbf21..62c6afcff 100644
--- a/burn-wgpu/src/kernel/prng/bernoulli.rs
+++ b/burn-wgpu/src/kernel/prng/bernoulli.rs
@@ -68,16 +68,10 @@ mod tests {
         let shape: Shape<2> = [40, 40].into();
         let device = WgpuDevice::default();
 
-        let tensor_1 = Tensor::<TestBackend, 2>::random_device(
-            shape.clone(),
-            Distribution::Bernoulli(0.5),
-            &device,
-        );
-        let tensor_2 = Tensor::<TestBackend, 2>::random_device(
-            shape.clone(),
-            Distribution::Bernoulli(0.5),
-            &device,
-        );
+        let tensor_1 =
+            Tensor::<TestBackend, 2>::random(shape.clone(), Distribution::Bernoulli(0.5), &device);
+        let tensor_2 =
+            Tensor::<TestBackend, 2>::random(shape.clone(), Distribution::Bernoulli(0.5), &device);
         let mut diff_exists = false;
         for i in 0..shape.num_elements() {
             if tensor_1.to_data().value[i] != tensor_2.to_data().value[i] {
@@ -96,11 +90,8 @@ mod tests {
         let device = WgpuDevice::default();
         let prob = 0.7;
 
-        let tensor_1 = Tensor::<TestBackend, 2>::random_device(
-            shape.clone(),
-            Distribution::Bernoulli(prob),
-            &device,
-        );
+        let tensor_1 =
+            Tensor::<TestBackend, 2>::random(shape.clone(), Distribution::Bernoulli(prob), &device);
 
         // High bound slightly over 1 so 1.0 is included in second bin
         let bin_stats = calculate_bin_stats(tensor_1.into_data().value, 2, 0., 1.1);
@@ -116,8 +107,7 @@ mod tests {
         TestBackend::seed(0);
         let shape = Shape::new([512, 512]);
         let device = WgpuDevice::default();
-        let tensor =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Bernoulli(0.5), &device);
+        let tensor = Tensor::<TestBackend, 2>::random(shape, Distribution::Bernoulli(0.5), &device);
 
         let numbers = tensor.into_data().value;
         let stats = calculate_bin_stats(numbers, 2, 0., 1.1);
diff --git a/burn-wgpu/src/kernel/prng/normal.rs b/burn-wgpu/src/kernel/prng/normal.rs
index fc80f3f1e..47bd51417 100644
--- a/burn-wgpu/src/kernel/prng/normal.rs
+++ b/burn-wgpu/src/kernel/prng/normal.rs
@@ -72,9 +72,9 @@ mod tests {
         let device = WgpuDevice::default();
 
         let tensor_1 =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Normal(0., 1.), &device);
+            Tensor::<TestBackend, 2>::random(shape, Distribution::Normal(0., 1.), &device);
         let tensor_2 =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Normal(0., 1.), &device);
+            Tensor::<TestBackend, 2>::random(shape, Distribution::Normal(0., 1.), &device);
         for i in 0..20 {
             assert!(tensor_1.to_data().value[i] != tensor_2.to_data().value[i]);
         }
@@ -88,7 +88,7 @@ mod tests {
         let device = WgpuDevice::default();
         let mean = 10.;
         let tensor =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Normal(mean, 2.), &device);
+            Tensor::<TestBackend, 2>::random(shape, Distribution::Normal(mean, 2.), &device);
         let empirical_mean = tensor.mean().into_data();
         empirical_mean.assert_approx_eq(&Data::from([mean as f32]), 1);
     }
@@ -101,11 +101,8 @@ mod tests {
         let device = WgpuDevice::default();
         let mu = 0.;
         let s = 1.;
-        let tensor = Tensor::<TestBackend, 2>::random_device(
-            shape.clone(),
-            Distribution::Normal(mu, s),
-            &device,
-        );
+        let tensor =
+            Tensor::<TestBackend, 2>::random(shape.clone(), Distribution::Normal(mu, s), &device);
         let stats = calculate_bin_stats(
             tensor.into_data().value,
             6,
diff --git a/burn-wgpu/src/kernel/prng/uniform.rs b/burn-wgpu/src/kernel/prng/uniform.rs
index ec9f8e00a..b30727ad9 100644
--- a/burn-wgpu/src/kernel/prng/uniform.rs
+++ b/burn-wgpu/src/kernel/prng/uniform.rs
@@ -93,10 +93,8 @@ mod tests {
         let shape = [4, 5];
         let device = WgpuDevice::default();
 
-        let tensor_1 =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Default, &device);
-        let tensor_2 =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Default, &device);
+        let tensor_1 = Tensor::<TestBackend, 2>::random(shape, Distribution::Default, &device);
+        let tensor_2 = Tensor::<TestBackend, 2>::random(shape, Distribution::Default, &device);
         for i in 0..20 {
             assert!(tensor_1.to_data().value[i] != tensor_2.to_data().value[i]);
         }
@@ -109,7 +107,7 @@ mod tests {
         let shape = [24, 24];
         let device = WgpuDevice::default();
 
-        let tensor = Tensor::<TestBackend, 2>::random_device(shape, Distribution::Default, &device);
+        let tensor = Tensor::<TestBackend, 2>::random(shape, Distribution::Default, &device);
         tensor.to_data().assert_within_range(0..1);
     }
 
@@ -121,7 +119,7 @@ mod tests {
         let device = WgpuDevice::default();
 
         let tensor =
-            Tensor::<TestBackend, 2>::random_device(shape, Distribution::Uniform(5., 17.), &device);
+            Tensor::<TestBackend, 2>::random(shape, Distribution::Uniform(5., 17.), &device);
         tensor.to_data().assert_within_range(5..17);
     }
 
@@ -132,11 +130,8 @@ mod tests {
         let shape = [64, 64];
         let device = WgpuDevice::default();
 
-        let tensor = Tensor::<TestBackend, 2>::random_device(
-            shape,
-            Distribution::Uniform(-5., 10.),
-            &device,
-        );
+        let tensor =
+            Tensor::<TestBackend, 2>::random(shape, Distribution::Uniform(-5., 10.), &device);
         let numbers = tensor.into_data().value;
         let stats = calculate_bin_stats(numbers, 3, -5., 10.);
         assert!(stats[0].count >= 1);
@@ -150,7 +145,7 @@ mod tests {
         TestBackend::seed(0);
         let shape = Shape::new([512, 512]);
         let device = WgpuDevice::default();
-        let tensor = Tensor::<TestBackend, 2>::random_device(shape, Distribution::Default, &device);
+        let tensor = Tensor::<TestBackend, 2>::random(shape, Distribution::Default, &device);
 
         let numbers = tensor.into_data().value;
         let stats = calculate_bin_stats(numbers, 2, 0., 1.);
diff --git a/burn-wgpu/src/kernel/reduce/reduction.rs b/burn-wgpu/src/kernel/reduce/reduction.rs
index 432f67882..9d64437ad 100644
--- a/burn-wgpu/src/kernel/reduce/reduction.rs
+++ b/burn-wgpu/src/kernel/reduce/reduction.rs
@@ -182,8 +182,8 @@ mod tests {
 
     #[test]
     fn reduction_sum_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 256], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 256], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
 
         let val = Tensor::<TestBackend, 1>::from_primitive(sum(tensor.into_primitive()));
         let val_ref = tensor_ref.sum();
@@ -193,8 +193,8 @@ mod tests {
 
     #[test]
     fn reduction_sum_dim_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 1024], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 1024], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
         let reduce_dim = 1;
         let output = init_reduce_output(&tensor.clone().into_primitive(), reduce_dim);
 
@@ -210,8 +210,8 @@ mod tests {
 
     #[test]
     fn reduction_args_dim_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 1024], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 1024], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
 
         let val = Tensor::<TestBackend, 2, Int>::from_primitive(argmax(tensor.into_primitive(), 1));
         let val_ref = tensor_ref.argmax(1);
diff --git a/burn-wgpu/src/kernel/reduce/reduction_shared_memory.rs b/burn-wgpu/src/kernel/reduce/reduction_shared_memory.rs
index 4d4fb43e3..bf44075a0 100644
--- a/burn-wgpu/src/kernel/reduce/reduction_shared_memory.rs
+++ b/burn-wgpu/src/kernel/reduce/reduction_shared_memory.rs
@@ -119,8 +119,8 @@ mod tests {
 
     #[test]
     fn reduction_sum_dim_shared_memory_small() {
-        let tensor = Tensor::<TestBackend, 1>::random([700], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 1>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 1>::random_devauto([700], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 1>::from_data_devauto(tensor.to_data());
         let reduce_dim = 0;
         let output = init_reduce_output(&tensor.clone().into_primitive(), reduce_dim);
 
@@ -136,8 +136,8 @@ mod tests {
 
     #[test]
     fn reduction_sum_dim_shared_memory_medium() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 1024], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 1024], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
         let reduce_dim = 1;
         let output = init_reduce_output(&tensor.clone().into_primitive(), reduce_dim);
 
@@ -153,8 +153,8 @@ mod tests {
 
     #[test]
     fn reduction_sum_dim_shared_memory_large() {
-        let tensor = Tensor::<TestBackend, 3>::random([4, 1024, 50], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 3>::random_devauto([4, 1024, 50], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 3>::from_data_devauto(tensor.to_data());
         let reduce_dim = 2;
         let output = init_reduce_output(&tensor.clone().into_primitive(), reduce_dim);
 
diff --git a/burn-wgpu/src/kernel/unary.rs b/burn-wgpu/src/kernel/unary.rs
index 06d5b912b..bd0a63b89 100644
--- a/burn-wgpu/src/kernel/unary.rs
+++ b/burn-wgpu/src/kernel/unary.rs
@@ -213,8 +213,8 @@ mod tests {
 
     #[test]
     fn unary_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 256], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 256], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
 
         let actual =
             unary::<Ops<f32>, OpsInplace<f32>, f32, 2>(tensor.into_primitive(), None, true);
@@ -228,8 +228,8 @@ mod tests {
 
     #[test]
     fn unary_inplace_should_work_with_multiple_invocations() {
-        let tensor = Tensor::<TestBackend, 2>::random([6, 256], Distribution::Default);
-        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data(tensor.to_data());
+        let tensor = Tensor::<TestBackend, 2>::random_devauto([6, 256], Distribution::Default);
+        let tensor_ref = Tensor::<ReferenceBackend, 2>::from_data_devauto(tensor.to_data());
 
         let actual =
             unary::<Ops<f32>, OpsInplace<f32>, f32, 2>(tensor.into_primitive(), None, true);
@@ -244,7 +244,7 @@ mod tests {
     #[test]
     fn tanh_should_not_have_numerical_bugs_on_macos() {
         fn tanh_one_value(input: f32) -> f32 {
-            let tensor = Tensor::<TestBackend, 1>::ones([1]) * input;
+            let tensor = Tensor::<TestBackend, 1>::ones_devauto([1]) * input;
             let output = tensor.tanh().into_primitive();
             Tensor::<TestBackend, 1>::from_primitive(output)
                 .into_data()
diff --git a/examples/custom-renderer/src/lib.rs b/examples/custom-renderer/src/lib.rs
index f1e066aff..522a785df 100644
--- a/examples/custom-renderer/src/lib.rs
+++ b/examples/custom-renderer/src/lib.rs
@@ -48,7 +48,7 @@ pub fn run<B: AutodiffBackend>(device: B::Device) {
     B::seed(config.seed);
 
     // Create the model and optimizer.
-    let model = config.model.init();
+    let model = config.model.init(&device);
     let optim = config.optimizer.init();
 
     // Create the batcher.
diff --git a/examples/custom-training-loop/src/lib.rs b/examples/custom-training-loop/src/lib.rs
index 9eb8b154c..3120f543a 100644
--- a/examples/custom-training-loop/src/lib.rs
+++ b/examples/custom-training-loop/src/lib.rs
@@ -42,7 +42,7 @@ pub fn run<B: AutodiffBackend>(device: B::Device) {
     B::seed(config.seed);
 
     // Create the model and optimizer.
-    let mut model = config.model.init();
+    let mut model = config.model.init(&device);
     let mut optim = config.optimizer.init();
 
     // Create the batcher.
diff --git a/examples/custom-wgpu-kernel/examples/custom-wgpu-kernel.rs b/examples/custom-wgpu-kernel/examples/custom-wgpu-kernel.rs
index 9a2e9d96f..09cf0f539 100644
--- a/examples/custom-wgpu-kernel/examples/custom-wgpu-kernel.rs
+++ b/examples/custom-wgpu-kernel/examples/custom-wgpu-kernel.rs
@@ -4,9 +4,9 @@ use custom_wgpu_kernel::{
 };
 
 fn inference<B: Backend>() {
-    let lhs = Tensor::<B, 3>::random([1, 32, 32], Distribution::Default);
-    let rhs = Tensor::random([32, 32, 32], Distribution::Default);
-    let bias = Tensor::random([32, 32, 32], Distribution::Default);
+    let lhs = Tensor::<B, 3>::random_devauto([1, 32, 32], Distribution::Default);
+    let rhs = Tensor::random_devauto([32, 32, 32], Distribution::Default);
+    let bias = Tensor::random_devauto([32, 32, 32], Distribution::Default);
 
     let reference = matmul_add_relu_reference(lhs.clone(), rhs.clone(), bias.clone())
         .into_data()
@@ -21,9 +21,9 @@ fn inference<B: Backend>() {
 }
 
 fn autodiff<B: AutodiffBackend>() {
-    let lhs = Tensor::<B, 3>::random([1, 32, 32], Distribution::Default).require_grad();
-    let rhs = Tensor::random([32, 32, 32], Distribution::Default).require_grad();
-    let bias = Tensor::random([32, 32, 32], Distribution::Default).require_grad();
+    let lhs = Tensor::<B, 3>::random_devauto([1, 32, 32], Distribution::Default).require_grad();
+    let rhs = Tensor::random_devauto([32, 32, 32], Distribution::Default).require_grad();
+    let bias = Tensor::random_devauto([32, 32, 32], Distribution::Default).require_grad();
 
     let reference = matmul_add_relu_reference(lhs.clone(), rhs.clone(), bias.clone());
 
diff --git a/examples/guide/src/data.rs b/examples/guide/src/data.rs
index fb43b4a08..15313d661 100644
--- a/examples/guide/src/data.rs
+++ b/examples/guide/src/data.rs
@@ -24,7 +24,7 @@ impl<B: Backend> Batcher<MNISTItem, MNISTBatch<B>> for MNISTBatcher<B> {
         let images = items
             .iter()
             .map(|item| Data::<f32, 2>::from(item.image))
-            .map(|data| Tensor::<B, 2>::from_data(data.convert()))
+            .map(|data| Tensor::<B, 2>::from_data_devauto(data.convert()))
             .map(|tensor| tensor.reshape([1, 28, 28]))
             // normalize: make between [0,1] and make the mean =  0 and std = 1
             // values mean=0.1307,std=0.3081 were copied from Pytorch Mist Example
@@ -34,7 +34,7 @@ impl<B: Backend> Batcher<MNISTItem, MNISTBatch<B>> for MNISTBatcher<B> {
 
         let targets = items
             .iter()
-            .map(|item| Tensor::<B, 1, Int>::from_data([(item.label as i64).elem()]))
+            .map(|item| Tensor::<B, 1, Int>::from_data_devauto([(item.label as i64).elem()]))
             .collect();
 
         let images = Tensor::cat(images, 0).to_device(&self.device);
diff --git a/examples/guide/src/model.rs b/examples/guide/src/model.rs
index 665612b50..9db5ebd00 100644
--- a/examples/guide/src/model.rs
+++ b/examples/guide/src/model.rs
@@ -30,14 +30,14 @@ pub struct ModelConfig {
 
 impl ModelConfig {
     /// Returns the initialized model.
-    pub fn init<B: Backend>(&self) -> Model<B> {
+    pub fn init<B: Backend>(&self, device: &B::Device) -> Model<B> {
         Model {
-            conv1: Conv2dConfig::new([1, 8], [3, 3]).init(),
-            conv2: Conv2dConfig::new([8, 16], [3, 3]).init(),
+            conv1: Conv2dConfig::new([1, 8], [3, 3]).init(device),
+            conv2: Conv2dConfig::new([8, 16], [3, 3]).init(device),
             pool: AdaptiveAvgPool2dConfig::new([8, 8]).init(),
             activation: ReLU::new(),
-            linear1: LinearConfig::new(16 * 8 * 8, self.hidden_size).init(),
-            linear2: LinearConfig::new(self.hidden_size, self.num_classes).init(),
+            linear1: LinearConfig::new(16 * 8 * 8, self.hidden_size).init(device),
+            linear2: LinearConfig::new(self.hidden_size, self.num_classes).init(device),
             dropout: DropoutConfig::new(self.dropout).init(),
         }
     }
diff --git a/examples/guide/src/training.rs b/examples/guide/src/training.rs
index e1924338f..b0f25eb2c 100644
--- a/examples/guide/src/training.rs
+++ b/examples/guide/src/training.rs
@@ -93,10 +93,10 @@ pub fn train<B: AutodiffBackend>(artifact_dir: &str, config: TrainingConfig, dev
         .metric_train_numeric(LossMetric::new())
         .metric_valid_numeric(LossMetric::new())
         .with_file_checkpointer(CompactRecorder::new())
-        .devices(vec![device])
+        .devices(vec![device.clone()])
         .num_epochs(config.num_epochs)
         .build(
-            config.model.init::<B>(),
+            config.model.init::<B>(&device),
             config.optimizer.init(),
             config.learning_rate,
         );
diff --git a/examples/image-classification-web/src/model/normalizer.rs b/examples/image-classification-web/src/model/normalizer.rs
index 7e1e6019c..0892f89ce 100644
--- a/examples/image-classification-web/src/model/normalizer.rs
+++ b/examples/image-classification-web/src/model/normalizer.rs
@@ -14,8 +14,8 @@ pub struct Normalizer<B: Backend> {
 impl<B: Backend> Normalizer<B> {
     /// Creates a new normalizer.
     pub fn new() -> Self {
-        let mean = Tensor::from_floats(MEAN).reshape([1, 3, 1, 1]);
-        let std = Tensor::from_floats(STD).reshape([1, 3, 1, 1]);
+        let mean = Tensor::from_floats_devauto(MEAN).reshape([1, 3, 1, 1]);
+        let std = Tensor::from_floats_devauto(STD).reshape([1, 3, 1, 1]);
         Self { mean, std }
     }
 
diff --git a/examples/image-classification-web/src/web.rs b/examples/image-classification-web/src/web.rs
index 385afbd76..75040e953 100644
--- a/examples/image-classification-web/src/web.rs
+++ b/examples/image-classification-web/src/web.rs
@@ -138,7 +138,8 @@ impl<B: Backend> Model<B> {
     /// Normalizes input and runs inference on the image
     pub async fn forward(&self, input: &[f32]) -> Vec<f32> {
         // Reshape from the 1D array to 3d tensor [ width, height, channels]
-        let input: Tensor<B, 4> = Tensor::from_floats(input).reshape([1, CHANNELS, HEIGHT, WIDTH]);
+        let input: Tensor<B, 4> =
+            Tensor::from_floats_devauto(input).reshape([1, CHANNELS, HEIGHT, WIDTH]);
 
         // Normalize input: make between [-1,1] and make the mean=0 and std=1
         let input = self.normalizer.normalize(input);
diff --git a/examples/mnist-inference-web/src/model.rs b/examples/mnist-inference-web/src/model.rs
index 66054100a..b48c8c2dd 100644
--- a/examples/mnist-inference-web/src/model.rs
+++ b/examples/mnist-inference-web/src/model.rs
@@ -22,17 +22,17 @@ pub struct Model<B: Backend> {
 const NUM_CLASSES: usize = 10;
 
 impl<B: Backend> Model<B> {
-    pub fn new() -> Self {
-        let conv1 = ConvBlock::new([1, 8], [3, 3]); // out: [Batch,8,26,26]
-        let conv2 = ConvBlock::new([8, 16], [3, 3]); // out: [Batch,16,24x24]
-        let conv3 = ConvBlock::new([16, 24], [3, 3]); // out: [Batch,24,22x22]
+    pub fn new(device: &B::Device) -> Self {
+        let conv1 = ConvBlock::new([1, 8], [3, 3], device); // out: [Batch,8,26,26]
+        let conv2 = ConvBlock::new([8, 16], [3, 3], device); // out: [Batch,16,24x24]
+        let conv3 = ConvBlock::new([16, 24], [3, 3], device); // out: [Batch,24,22x22]
         let hidden_size = 24 * 22 * 22;
         let fc1 = nn::LinearConfig::new(hidden_size, 32)
             .with_bias(false)
-            .init();
+            .init(device);
         let fc2 = nn::LinearConfig::new(32, NUM_CLASSES)
             .with_bias(false)
-            .init();
+            .init(device);
 
         let dropout = nn::DropoutConfig::new(0.5).init();
 
@@ -74,11 +74,11 @@ pub struct ConvBlock<B: Backend> {
 }
 
 impl<B: Backend> ConvBlock<B> {
-    pub fn new(channels: [usize; 2], kernel_size: [usize; 2]) -> Self {
+    pub fn new(channels: [usize; 2], kernel_size: [usize; 2], device: &B::Device) -> Self {
         let conv = nn::conv::Conv2dConfig::new(channels, kernel_size)
             .with_padding(PaddingConfig2d::Valid)
-            .init();
-        let norm = nn::BatchNormConfig::new(channels[1]).init();
+            .init(device);
+        let norm = nn::BatchNormConfig::new(channels[1]).init(device);
 
         Self {
             conv,
diff --git a/examples/mnist-inference-web/src/state.rs b/examples/mnist-inference-web/src/state.rs
index 5fabc868e..9b58ca775 100644
--- a/examples/mnist-inference-web/src/state.rs
+++ b/examples/mnist-inference-web/src/state.rs
@@ -1,4 +1,6 @@
 use crate::model::Model;
+#[cfg(feature = "wgpu")]
+use burn::backend::wgpu::WgpuDevice;
 use burn::module::Module;
 use burn::record::BinBytesRecorder;
 use burn::record::FullPrecisionSettings;
@@ -20,7 +22,7 @@ pub async fn build_and_load_model() -> Model<Backend> {
     #[cfg(feature = "wgpu")]
     init_async::<AutoGraphicsApi>(&WgpuDevice::default()).await;
 
-    let model: Model<Backend> = Model::new();
+    let model: Model<Backend> = Model::new(&Default::default());
     let record = BinBytesRecorder::<FullPrecisionSettings>::default()
         .load(STATE_ENCODED.to_vec())
         .expect("Failed to decode state");
diff --git a/examples/mnist-inference-web/src/web.rs b/examples/mnist-inference-web/src/web.rs
index d528f0244..153e158e7 100644
--- a/examples/mnist-inference-web/src/web.rs
+++ b/examples/mnist-inference-web/src/web.rs
@@ -52,7 +52,7 @@ impl Mnist {
         let model = self.model.as_ref().unwrap();
 
         // Reshape from the 1D array to 3d tensor [batch, height, width]
-        let input: Tensor<Backend, 3> = Tensor::from_floats(input).reshape([1, 28, 28]);
+        let input: Tensor<Backend, 3> = Tensor::from_floats_devauto(input).reshape([1, 28, 28]);
 
         // Normalize input: make between [0,1] and make the mean=0 and std=1
         // values mean=0.1307,std=0.3081 were copied from Pytorch Mist Example
diff --git a/examples/mnist/src/data.rs b/examples/mnist/src/data.rs
index d424b9e03..2dd9286ce 100644
--- a/examples/mnist/src/data.rs
+++ b/examples/mnist/src/data.rs
@@ -24,7 +24,7 @@ impl<B: Backend> Batcher<MNISTItem, MNISTBatch<B>> for MNISTBatcher<B> {
         let images = items
             .iter()
             .map(|item| Data::<f32, 2>::from(item.image))
-            .map(|data| Tensor::<B, 2>::from_data(data.convert()))
+            .map(|data| Tensor::<B, 2>::from_data_devauto(data.convert()))
             .map(|tensor| tensor.reshape([1, 28, 28]))
             // normalize: make between [0,1] and make the mean =  0 and std = 1
             // values mean=0.1307,std=0.3081 were copied from Pytorch Mist Example
@@ -34,7 +34,9 @@ impl<B: Backend> Batcher<MNISTItem, MNISTBatch<B>> for MNISTBatcher<B> {
 
         let targets = items
             .iter()
-            .map(|item| Tensor::<B, 1, Int>::from_data(Data::from([(item.label as i64).elem()])))
+            .map(|item| {
+                Tensor::<B, 1, Int>::from_data_devauto(Data::from([(item.label as i64).elem()]))
+            })
             .collect();
 
         let images = Tensor::cat(images, 0).to_device(&self.device);
diff --git a/examples/mnist/src/model.rs b/examples/mnist/src/model.rs
index eca5be9b1..3ea4792d8 100644
--- a/examples/mnist/src/model.rs
+++ b/examples/mnist/src/model.rs
@@ -22,24 +22,25 @@ pub struct Model<B: Backend> {
 
 impl<B: Backend> Default for Model<B> {
     fn default() -> Self {
-        Self::new()
+        let device = B::Device::default();
+        Self::new(&device)
     }
 }
 
 const NUM_CLASSES: usize = 10;
 
 impl<B: Backend> Model<B> {
-    pub fn new() -> Self {
-        let conv1 = ConvBlock::new([1, 8], [3, 3]); // out: [Batch,8,26,26]
-        let conv2 = ConvBlock::new([8, 16], [3, 3]); // out: [Batch,16,24x24]
-        let conv3 = ConvBlock::new([16, 24], [3, 3]); // out: [Batch,24,22x22]
+    pub fn new(device: &B::Device) -> Self {
+        let conv1 = ConvBlock::new([1, 8], [3, 3], device); // out: [Batch,8,26,26]
+        let conv2 = ConvBlock::new([8, 16], [3, 3], device); // out: [Batch,16,24x24]
+        let conv3 = ConvBlock::new([16, 24], [3, 3], device); // out: [Batch,24,22x22]
         let hidden_size = 24 * 22 * 22;
         let fc1 = nn::LinearConfig::new(hidden_size, 32)
             .with_bias(false)
-            .init();
+            .init(device);
         let fc2 = nn::LinearConfig::new(32, NUM_CLASSES)
             .with_bias(false)
-            .init();
+            .init(device);
 
         let dropout = nn::DropoutConfig::new(0.5).init();
 
@@ -94,11 +95,11 @@ pub struct ConvBlock<B: Backend> {
 }
 
 impl<B: Backend> ConvBlock<B> {
-    pub fn new(channels: [usize; 2], kernel_size: [usize; 2]) -> Self {
+    pub fn new(channels: [usize; 2], kernel_size: [usize; 2], device: &B::Device) -> Self {
         let conv = nn::conv::Conv2dConfig::new(channels, kernel_size)
             .with_padding(PaddingConfig2d::Valid)
-            .init();
-        let norm = nn::BatchNormConfig::new(channels[1]).init();
+            .init(device);
+        let norm = nn::BatchNormConfig::new(channels[1]).init(device);
 
         Self {
             conv,
diff --git a/examples/mnist/src/training.rs b/examples/mnist/src/training.rs
index 2f7a5bed9..3831a227d 100644
--- a/examples/mnist/src/training.rs
+++ b/examples/mnist/src/training.rs
@@ -77,9 +77,9 @@ pub fn run<B: AutodiffBackend>(device: B::Device) {
             Split::Valid,
             StoppingCondition::NoImprovementSince { n_epochs: 1 },
         ))
-        .devices(vec![device])
+        .devices(vec![device.clone()])
         .num_epochs(config.num_epochs)
-        .build(Model::new(), config.optimizer.init(), 1e-4);
+        .build(Model::new(&device), config.optimizer.init(), 1e-4);
 
     let model_trained = learner.fit(dataloader_train, dataloader_test);
 
diff --git a/examples/named-tensor/src/lib.rs b/examples/named-tensor/src/lib.rs
index 3aa637a58..3ad01ffcf 100644
--- a/examples/named-tensor/src/lib.rs
+++ b/examples/named-tensor/src/lib.rs
@@ -10,12 +10,12 @@ pub fn run<B: Backend>() {
     let seq_length = 48;
     let d_model = 24;
 
-    let weights = NamedTensor::<B, (Batch, DModel, DModel)>::random(
+    let weights = NamedTensor::<B, (Batch, DModel, DModel)>::random_devauto(
         [1, d_model, d_model],
         Distribution::Default,
     );
 
-    let input = NamedTensor::<B, (Batch, SeqLength, DModel)>::random(
+    let input = NamedTensor::<B, (Batch, SeqLength, DModel)>::random_devauto(
         [batch_size, seq_length, d_model],
         Distribution::Default,
     );
diff --git a/examples/notebook/basic-tensor-op.ipynb b/examples/notebook/basic-tensor-op.ipynb
index 5ead14807..f2afe50df 100644
--- a/examples/notebook/basic-tensor-op.ipynb
+++ b/examples/notebook/basic-tensor-op.ipynb
@@ -97,7 +97,7 @@
     "println!(\"Empty tensor: {}\", tensor);\n",
     "\n",
     "// Create a tensor from a slice of floats\n",
-    "let tensor: Tensor<B, 2> = Tensor::from_floats([1.0, 2.0, 3.0, 4.0]).reshape([2, 2]);\n",
+    "let tensor: Tensor<B, 2> = Tensor::from_floats_devauto([1.0, 2.0, 3.0, 4.0]).reshape([2, 2]);\n",
     "println!(\"Tensor from slice: {}\", tensor);\n",
     "\n",
     "// Create a random tensor\n",
@@ -108,7 +108,7 @@
     "// Create a tensor using fill values, zeros, or ones\n",
     "let tensor: Tensor<B,2> = Tensor::full([2, 2], 7.0);\n",
     "let tensor: Tensor<B,2> = Tensor::zeros([2, 2]);\n",
-    "let tensor: Tensor<B,2> = Tensor::ones([2, 2]);\n"
+    "let tensor: Tensor<B,2> = Tensor::ones_devauto([2, 2]);\n"
    ]
   },
   {
@@ -143,7 +143,7 @@
     }
    ],
    "source": [
-    "let x1: Tensor<B,2> = Tensor::ones([2, 2]);\n",
+    "let x1: Tensor<B,2> = Tensor::ones_devauto([2, 2]);\n",
     "let x2: Tensor<B,2> = Tensor::full([2, 2], 7.0);\n",
     "\n",
     "let x3 = x1 + x2;\n",
diff --git a/examples/onnx-inference/README.md b/examples/onnx-inference/README.md
index 34d1cc217..1b39008c8 100644
--- a/examples/onnx-inference/README.md
+++ b/examples/onnx-inference/README.md
@@ -77,7 +77,7 @@ https://datasets-server.huggingface.co/assets/mnist/--/mnist/test/15/image/image
        let model: Model<Backend> = Model::new().load_state();
 
        // Create a new input tensor (all zeros for demonstration purposes)
-       let input = tensor::Tensor::<NdArray<f32>, 4>::zeros([1, 1, 28, 28]);
+       let input = tensor::Tensor::<NdArray<f32>, 4>::zeros_devauto([1, 1, 28, 28]);
 
        // Run the model
        let output = model.forward(input);
diff --git a/examples/onnx-inference/src/bin/mnist_inference.rs b/examples/onnx-inference/src/bin/mnist_inference.rs
index 82913f469..214bba116 100644
--- a/examples/onnx-inference/src/bin/mnist_inference.rs
+++ b/examples/onnx-inference/src/bin/mnist_inference.rs
@@ -37,7 +37,7 @@ fn main() {
     // Create a tensor from the image data
     let image_data = item.image.iter().copied().flatten().collect::<Vec<f32>>();
     let mut input: Tensor<Backend, 4> =
-        Tensor::from_floats(image_data.as_slice()).reshape([1, 1, 28, 28]);
+        Tensor::from_floats_devauto(image_data.as_slice()).reshape([1, 1, 28, 28]);
 
     // Normalize the input
     input = ((input / 255) - 0.1307) / 0.3081;
diff --git a/examples/text-classification/src/data/batcher.rs b/examples/text-classification/src/data/batcher.rs
index 75ef1080b..3ff226345 100644
--- a/examples/text-classification/src/data/batcher.rs
+++ b/examples/text-classification/src/data/batcher.rs
@@ -53,7 +53,9 @@ impl<B: Backend> Batcher<TextClassificationItem, TextClassificationTrainingBatch
         // Tokenize text and create label tensor for each item
         for item in items {
             tokens_list.push(self.tokenizer.encode(&item.text));
-            labels_list.push(Tensor::from_data(Data::from([(item.label as i64).elem()])));
+            labels_list.push(Tensor::from_data_devauto(Data::from([
+                (item.label as i64).elem()
+            ])));
         }
 
         // Generate padding mask for tokenized text
diff --git a/examples/text-classification/src/model.rs b/examples/text-classification/src/model.rs
index 914b14576..af36309fe 100644
--- a/examples/text-classification/src/model.rs
+++ b/examples/text-classification/src/model.rs
@@ -40,13 +40,13 @@ pub struct TextClassificationModel<B: Backend> {
 // Define functions for model initialization
 impl TextClassificationModelConfig {
     /// Initializes a model with default weights
-    pub fn init<B: Backend>(&self) -> TextClassificationModel<B> {
-        let output = LinearConfig::new(self.transformer.d_model, self.n_classes).init();
-        let transformer = self.transformer.init();
+    pub fn init<B: Backend>(&self, device: &B::Device) -> TextClassificationModel<B> {
+        let output = LinearConfig::new(self.transformer.d_model, self.n_classes).init(device);
+        let transformer = self.transformer.init(device);
         let embedding_token =
-            EmbeddingConfig::new(self.vocab_size, self.transformer.d_model).init();
+            EmbeddingConfig::new(self.vocab_size, self.transformer.d_model).init(device);
         let embedding_pos =
-            EmbeddingConfig::new(self.max_seq_length, self.transformer.d_model).init();
+            EmbeddingConfig::new(self.max_seq_length, self.transformer.d_model).init(device);
 
         TextClassificationModel {
             transformer,
@@ -96,7 +96,7 @@ impl<B: Backend> TextClassificationModel<B> {
         let mask_pad = item.mask_pad.to_device(device);
 
         // Calculate token and position embeddings, and combine them
-        let index_positions = Tensor::arange_device(0..seq_length, device)
+        let index_positions = Tensor::arange(0..seq_length, device)
             .reshape([1, seq_length])
             .repeat(0, batch_size);
         let embedding_positions = self.embedding_pos.forward(index_positions);
@@ -135,7 +135,7 @@ impl<B: Backend> TextClassificationModel<B> {
         let mask_pad = item.mask_pad.to_device(device);
 
         // Calculate token and position embeddings, and combine them
-        let index_positions = Tensor::arange_device(0..seq_length, device)
+        let index_positions = Tensor::arange(0..seq_length, device)
             .reshape([1, seq_length])
             .repeat(0, batch_size);
         let embedding_positions = self.embedding_pos.forward(index_positions);
diff --git a/examples/text-classification/src/training.rs b/examples/text-classification/src/training.rs
index 71841d96c..ea7398be8 100644
--- a/examples/text-classification/src/training.rs
+++ b/examples/text-classification/src/training.rs
@@ -68,7 +68,7 @@ pub fn train<B: AutodiffBackend, D: TextClassificationDataset + 'static>(
         tokenizer.vocab_size(),
         config.max_seq_length,
     )
-    .init();
+    .init(&devices[0]);
 
     // Initialize data loaders for training and testing data
     let dataloader_train = DataLoaderBuilder::new(batcher_train)
diff --git a/examples/text-generation/src/model.rs b/examples/text-generation/src/model.rs
index 6e2312142..b176c59ea 100644
--- a/examples/text-generation/src/model.rs
+++ b/examples/text-generation/src/model.rs
@@ -33,13 +33,13 @@ pub struct TextGenerationModel<B: Backend> {
 }
 
 impl TextGenerationModelConfig {
-    pub fn init<B: Backend>(&self) -> TextGenerationModel<B> {
-        let output = LinearConfig::new(self.transformer.d_model, self.vocab_size).init();
-        let transformer = self.transformer.init();
+    pub fn init<B: Backend>(&self, device: &B::Device) -> TextGenerationModel<B> {
+        let output = LinearConfig::new(self.transformer.d_model, self.vocab_size).init(device);
+        let transformer = self.transformer.init(device);
         let embedding_token =
-            EmbeddingConfig::new(self.vocab_size, self.transformer.d_model).init();
+            EmbeddingConfig::new(self.vocab_size, self.transformer.d_model).init(device);
         let embedding_pos =
-            EmbeddingConfig::new(self.max_seq_length, self.transformer.d_model).init();
+            EmbeddingConfig::new(self.max_seq_length, self.transformer.d_model).init(device);
 
         TextGenerationModel {
             transformer,
@@ -64,7 +64,7 @@ impl<B: Backend> TextGenerationModel<B> {
         let targets = item.targets.to_device(device);
         let mask_pad = item.mask_pad.to_device(device);
 
-        let index_positions = Tensor::arange_device(0..seq_length, device)
+        let index_positions = Tensor::arange(0..seq_length, device)
             .reshape([1, seq_length])
             .repeat(0, batch_size);
 
diff --git a/examples/text-generation/src/training.rs b/examples/text-generation/src/training.rs
index 782012b8b..d437960ad 100644
--- a/examples/text-generation/src/training.rs
+++ b/examples/text-generation/src/training.rs
@@ -48,7 +48,7 @@ pub fn train<B: AutodiffBackend, D: Dataset<TextGenerationItem> + 'static>(
         tokenizer.pad_token(),
         config.max_seq_length,
     )
-    .init::<B>();
+    .init::<B>(&device);
 
     let dataloader_train = DataLoaderBuilder::new(batcher_train)
         .batch_size(config.batch_size)