= ndims_in);\n\n for i in 0..ndims_in {\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\n }\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape_grad = grad.shape();\n let mut grad = grad;\n\n #[allow(clippy::needless_range_loop)]\n for i in 0..ndims_out {\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\n grad = B::float_sum_dim(grad, i);\n }\n }\n\n B::float_reshape(grad, shape_in)\n });\n }\n }\n\n match ExpandDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), shape.clone()),\n B::float_expand(tensor.primitive, shape),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\n }\n }"},"file_content":{"kind":"string","value":"use alloc::{boxed::Box, vec, vec::Vec};\nuse core::marker::PhantomData;\n\n#[cfg(not(feature = \"std\"))]\n#[allow(unused_imports, reason = \"required on aarch64, unused on x86_64\")]\nuse num_traits::float::Float;\n\nuse crate::{\n Autodiff,\n checkpoint::{\n base::Checkpointer, builder::CheckpointerBuilder, retro_forward::RetroForward,\n state::BackwardStates, strategy::CheckpointStrategy,\n },\n grads::Gradients,\n graph::{ComputingProperty, NodeID, NodeRef, Requirement, Step},\n ops::{Backward, Ops, OpsKind, binary, broadcast_shape, unary},\n retro_binary, retro_unary, retro_unary_scalar,\n tensor::AutodiffTensor,\n utils::duplicate,\n};\n\nuse burn_tensor::{\n Device, ElementConversion, Shape, TensorData, TensorMetadata,\n backend::Backend,\n ops::{BoolTensor, FloatElem, FloatTensor, FloatTensorOps, IntTensor},\n};\n\nuse super::maxmin::MaxMinDim;\n\n// Unsqueeze op on primitive.\nfn unsqueeze_like<B: Backend>(\n tensor: B::FloatTensorPrimitive,\n shape: Shape,\n) -> B::FloatTensorPrimitive {\n /*\n let mut dims = [1; D2];\n let num_ones = D2 - D;\n let shape = self.shape();\n\n dims[num_ones..(D + num_ones)].copy_from_slice(&shape.dims[..D]);\n\n let shape = Shape::new(dims);\n self.reshape(shape)\n */\n\n let ndims_out = shape.num_dims();\n let shape = tensor.shape();\n let ndims_in = shape.num_dims();\n\n let mut dims = vec![1; ndims_out];\n let num_ones = ndims_out - ndims_in;\n dims[num_ones..(ndims_in + num_ones)].copy_from_slice(&shape.dims[..ndims_in]);\n\n B::float_reshape(tensor, Shape::from(dims))\n}\n\nimpl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distribution: burn_tensor::Distribution,\n device: &Device<Self>,\n ) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_random(shape, distribution, device))\n }\n\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_zeros(shape, device))\n }\n\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_ones(shape, device))\n }\n\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\n B::float_into_data(tensor.primitive).await\n }\n\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\n B::float_device(&tensor.primitive)\n }\n\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct ToDevice;\n\n impl<B: Backend> Backward<B, 1> for ToDevice {\n type State = B::Device;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_to_device(grad, &ops.state)\n });\n }\n }\n\n match ToDevice\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let device_old = B::float_device(&tensor.primitive);\n prep.finish(device_old, B::float_to_device(tensor.primitive, device))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_to_device(tensor.primitive, device)),\n }\n }\n\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_empty(shape, device))\n }\n\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Add;\n\n retro_binary!(RetroAdd, B::float_add);\n\n impl<B: Backend> Backward<B, 2> for Add {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_lhs, shape_rhs) = ops.state;\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\n |grad| broadcast_shape::<B>(grad, &shape_rhs),\n );\n }\n }\n\n match Add\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroAdd::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (lhs.primitive.shape(), rhs.primitive.shape()),\n B::float_add(lhs.primitive, rhs.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_add(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct AddScalar;\n\n retro_unary_scalar!(RetroAddScalar, B::float_add_scalar);\n\n impl<B: Backend> Backward<B, 1> for AddScalar {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\n }\n }\n\n AddScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroAddScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateless(B::float_add_scalar(lhs.primitive, rhs))\n }\n\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sub;\n\n retro_binary!(RetroSub, B::float_sub);\n\n impl<B: Backend> Backward<B, 2> for Sub {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_lhs, shape_rhs) = ops.state;\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\n |grad| broadcast_shape::<B>(B::float_neg(grad), &shape_rhs),\n );\n }\n }\n\n match Sub\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroSub::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (lhs.primitive.shape(), rhs.primitive.shape()),\n B::float_sub(lhs.primitive, rhs.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_sub(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SubScalar;\n\n retro_unary_scalar!(RetroSubScalar, B::float_sub_scalar);\n\n impl<B: Backend> Backward<B, 1> for SubScalar {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\n }\n }\n\n SubScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroSubScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateless(B::float_sub_scalar(lhs.primitive, rhs))\n }\n\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Mul;\n\n retro_binary!(RetroMul, B::float_mul);\n\n impl<B: Backend> Backward<B, 2> for Mul {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let grad = B::float_mul(grad, rhs.unwrap());\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n let grad = B::float_mul(grad, lhs.unwrap());\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Mul\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroMul::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\n\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_mul(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MulScalar;\n\n retro_unary_scalar!(RetroMulScalar, B::float_mul_scalar);\n\n impl<B: Backend> Backward<B, 1> for MulScalar {\n type State = FloatElem<B>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mul_scalar(grad, ops.state)\n });\n }\n }\n\n match MulScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroMulScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_mul_scalar(lhs.primitive, rhs)),\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul_scalar(lhs.primitive, rhs)),\n }\n }\n\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Div;\n\n retro_binary!(RetroDiv, B::float_div);\n\n impl<B: Backend> Backward<B, 2> for Div {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, rhs);\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let rhs = rhs_4lhs.unwrap();\n let value = B::float_powf_scalar(rhs, -1.0);\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n let rhs = rhs_4rhs.unwrap();\n let lhs = lhs.unwrap();\n let value = B::float_div(B::float_neg(lhs), B::float_powf_scalar(rhs, 2.0));\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Div\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroDiv::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\n\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_div(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_div(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct DivScalar;\n\n retro_unary_scalar!(RetroDivScalar, B::float_div_scalar);\n\n impl<B: Backend> Backward<B, 1> for DivScalar {\n type State = FloatElem<B>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let tmp = 1.0 / ops.state.elem::<f32>();\n B::float_mul_scalar(grad, tmp.elem())\n });\n }\n }\n\n match DivScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroDivScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_div_scalar(lhs.primitive, rhs)),\n OpsKind::UnTracked(prep) => prep.finish(B::float_div_scalar(lhs.primitive, rhs)),\n }\n }\n\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Rem;\n\n retro_binary!(RetroRem, B::float_remainder);\n\n impl<B: Backend> Backward<B, 2> for Rem {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n // remainder(x, y) = x - floor(x / y) * y\n // partial(x - floor(x / y) * y, x) = 1\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n // partial(x - floor(x / y) * y, y) = - floor(x / y)\n let rhs = rhs.unwrap();\n let lhs = lhs.unwrap();\n let value = B::float_neg(B::float_floor(B::float_div(lhs, rhs)));\n let grad = B::float_mul(grad, value);\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Rem\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroRem::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\n\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_remainder(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_remainder(lhs.primitive, rhs.primitive))\n }\n }\n }\n\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct RemainderScalar;\n\n retro_unary_scalar!(RetroRemainderScalar, B::float_remainder_scalar);\n\n impl<B: Backend> Backward<B, 1> for RemainderScalar {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\n }\n }\n\n RemainderScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroRemainderScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateless(B::float_remainder_scalar(lhs.primitive, rhs))\n }\n\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Matmul;\n\n impl<B: Backend> Backward<B, 2> for Matmul {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let rhs = B::float_transpose(rhs.unwrap());\n let grad = B::float_matmul(grad, rhs);\n\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n let lhs = B::float_transpose(lhs.unwrap());\n let grad = B::float_matmul(lhs, grad);\n\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Matmul\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_matmul(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_matmul(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Neg;\n\n retro_unary!(RetroNeg, B::float_neg);\n\n impl<B: Backend> Backward<B, 1> for Neg {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| B::float_neg(grad));\n }\n }\n\n Neg.prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroNeg::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateless(B::float_neg(tensor.primitive))\n }\n\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Recip;\n\n retro_unary!(RetroRecip, B::float_recip);\n\n impl<B: Backend> Backward<B, 1> for Recip {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let tensor = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let tmp = B::float_powf_scalar(tensor, -2.0);\n let value = B::float_neg(tmp);\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Recip\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRecip::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_recip(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_recip(tensor.primitive)),\n }\n }\n\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SwapDim;\n\n #[derive(new, Debug)]\n struct RetroSwapDims<B: Backend> {\n input_id: NodeID,\n dim1: usize,\n dim2: usize,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSwapDims<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_swap_dims(input, self.dim1, self.dim2);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for SwapDim {\n type State = (usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim1, dim2) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_swap_dims(grad, dim2, dim1)\n });\n }\n }\n\n match SwapDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSwapDims::<B>::new(tensor.node.id, dim1, dim2))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim1, dim2),\n B::float_swap_dims(tensor.primitive, dim1, dim2),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_swap_dims(tensor.primitive, dim1, dim2))\n }\n }\n }\n\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct PermuteDim;\n\n #[derive(new, Debug)]\n struct RetroPermuteDims<B: Backend> {\n input_id: NodeID,\n axes: Vec<usize>,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroPermuteDims<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_permute(input, &self.axes);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for PermuteDim {\n type State = Vec<usize>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let axes = ops.state;\n\n let mut inverse = vec![0usize; axes.len()];\n axes.iter()\n .enumerate()\n .for_each(|(i, &axis)| inverse[axis] = i);\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_permute(grad, &inverse)\n });\n }\n }\n\n match PermuteDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroPermuteDims::<B>::new(tensor.node.id, axes.to_vec()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n prep.finish(axes.to_vec(), B::float_permute(tensor.primitive, axes))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_permute(tensor.primitive, axes)),\n }\n }\n\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct FlipDim;\n\n #[derive(new, Debug)]\n struct RetroFlipDims<B: Backend> {\n input_id: NodeID,\n axes: Vec<usize>,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroFlipDims<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_flip(input, &self.axes);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for FlipDim {\n type State = Vec<usize>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let axes = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_flip(grad, &axes)\n });\n }\n }\n\n match FlipDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroFlipDims::<B>::new(tensor.node.id, axes.to_vec()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n prep.finish(axes.to_vec(), B::float_flip(tensor.primitive, axes))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_flip(tensor.primitive, axes)),\n }\n }\n\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct ReshapeDim;\n\n #[derive(new, Debug)]\n struct RetroReshape<B: Backend> {\n input_id: NodeID,\n shape: Shape,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroReshape<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_reshape(input, self.shape.clone());\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for ReshapeDim {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_original, shape) = ops.state;\n let ndims_out = shape.num_dims();\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape_grad = grad.shape();\n let mut grad = grad;\n\n for i in 0..ndims_out {\n if shape.dims[i] == 1 && shape_grad.dims[i] != 1 {\n grad = B::float_sum_dim(grad, i);\n }\n }\n\n B::float_reshape(grad, shape_original)\n });\n }\n }\n\n match ReshapeDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroReshape::<B>::new(tensor.node.id, shape.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), shape.clone()),\n B::float_reshape(tensor.primitive, shape),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_reshape(tensor.primitive, shape)),\n }\n }\n\n fn float_gather(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<B>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Gather;\n\n impl<B: Backend> Backward<B, 1> for Gather {\n type State = (usize, IntTensor<B>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices, shape, device) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let zeros = B::float_zeros(shape, &device);\n B::float_scatter(dim, zeros, indices, grad)\n });\n }\n }\n\n match Gather\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n dim,\n indices.clone(),\n tensor.primitive.shape(),\n B::float_device(&tensor.primitive),\n ),\n B::float_gather(dim, tensor.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_gather(dim, tensor.primitive, indices))\n }\n }\n }\n\n fn float_scatter(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<B>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Scatter;\n\n impl<B: Backend> Backward<B, 2> for Scatter {\n type State = (usize, IntTensor<B>, Shape, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices, shape_lhs, shape_rhs, device) = ops.state;\n let [indices_4lhs, indices_4rhs] = duplicate(&ops.parents, Some(indices));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let zeros = B::float_zeros(shape_lhs, &device);\n B::float_scatter(dim, grad, indices_4lhs.unwrap(), zeros)\n },\n |grad| {\n let zeros = B::float_zeros(shape_rhs, &device);\n B::float_scatter(dim, zeros, indices_4rhs.unwrap(), grad)\n },\n );\n }\n }\n\n match Scatter\n .prepare::<C>([tensor.node, value.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n dim,\n indices.clone(),\n tensor.primitive.shape(),\n value.primitive.shape(),\n B::float_device(&value.primitive),\n ),\n B::float_scatter(dim, tensor.primitive, indices, value.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_scatter(\n dim,\n tensor.primitive,\n indices,\n value.primitive,\n )),\n }\n }\n\n fn float_select(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<B>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Select;\n\n #[derive(new, Debug)]\n struct RetroSelect<B: Backend> {\n input_id: NodeID,\n dim: usize,\n indices: IntTensor<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSelect<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_select(input, self.dim, self.indices.clone());\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Select {\n type State = (usize, IntTensor<B>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices, shape, device) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let zeros = B::float_zeros(shape, &device);\n B::float_select_assign(zeros, dim, indices, grad)\n });\n }\n }\n\n match Select\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSelect::<B>::new(tensor.node.id, dim, indices.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n dim,\n indices.clone(),\n tensor.primitive.shape(),\n B::float_device(&tensor.primitive),\n ),\n B::float_select(tensor.primitive, dim, indices),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_select(tensor.primitive, dim, indices))\n }\n }\n }\n\n fn float_select_assign(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<B>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct IndexSelectDimAssign;\n\n #[derive(new, Debug)]\n struct RetroSelectAssign<B: Backend> {\n tensor_id: NodeID,\n dim: usize,\n indices: IntTensor<B>,\n value_id: NodeID,\n }\n\n impl<B: Backend> RetroForward for RetroSelectAssign<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\n let out = B::float_select_assign(tensor, self.dim, self.indices.clone(), value);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 2> for IndexSelectDimAssign {\n type State = (usize, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices) = ops.state;\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| grad,\n |grad| B::float_select(grad, dim, indices),\n );\n }\n }\n\n match IndexSelectDimAssign\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\n .memory_bound()\n .retro_forward(RetroSelectAssign::<B>::new(\n tensor.node.id,\n dim,\n indices.clone(),\n value.node.id,\n ))\n .parents([&tensor, &value])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim, indices.clone()),\n B::float_select_assign(tensor.primitive, dim, indices, value.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_select_assign(\n tensor.primitive,\n dim,\n indices,\n value.primitive,\n )),\n }\n }\n\n fn float_slice(\n tensor: FloatTensor<Self>,\n ranges: &[core::ops::Range<usize>],\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Index;\n\n #[derive(new, Debug)]\n struct RetroSlice<B: Backend> {\n tensor_id: NodeID,\n ranges: Vec<core::ops::Range<usize>>,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSlice<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let out = B::float_slice(tensor, &self.ranges);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Index {\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (ranges, shape, device) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let zeros = B::float_zeros(shape, &device);\n B::float_slice_assign(zeros, &ranges, grad)\n });\n }\n }\n\n match Index\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSlice::<B>::new(tensor.node.id, ranges.to_vec()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n ranges.to_vec(),\n tensor.primitive.shape(),\n B::float_device(&tensor.primitive),\n ),\n B::float_slice(tensor.primitive, ranges),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice(tensor.primitive, ranges)),\n }\n }\n\n fn float_slice_assign(\n tensor: FloatTensor<Self>,\n ranges: &[core::ops::Range<usize>],\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SliceAssign;\n\n #[derive(new, Debug)]\n struct RetroSliceAssign<B: Backend> {\n tensor_id: NodeID,\n ranges: Vec<core::ops::Range<usize>>,\n value_id: NodeID,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSliceAssign<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\n let out = B::float_slice_assign(tensor, &self.ranges, value);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 2> for SliceAssign {\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (ranges, shape_rhs, device) = ops.state;\n let [ranges_4lhs, ranges_4rhs] = duplicate(&ops.parents, Some(ranges));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let zeros = B::float_zeros(shape_rhs, &device);\n B::float_slice_assign(grad, &ranges_4lhs.unwrap(), zeros)\n },\n |grad| B::float_slice(grad, &ranges_4rhs.unwrap()),\n );\n }\n }\n\n match SliceAssign\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\n .memory_bound()\n .retro_forward(RetroSliceAssign::<B>::new(\n tensor.node.id,\n ranges.to_vec(),\n value.node.id,\n ))\n .parents([&tensor, &value])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n ranges.to_vec(),\n value.primitive.shape(),\n B::float_device(&value.primitive),\n ),\n B::float_slice_assign(tensor.primitive, ranges, value.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice_assign(\n tensor.primitive,\n ranges,\n value.primitive,\n )),\n }\n }\n\n fn float_mask_where(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<Self>,\n source: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MaskWhere;\n\n impl<B: Backend> Backward<B, 2> for MaskWhere {\n type State = (BoolTensor<B>, Shape, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (mask, shape_lhs, shape_rhs, device) = ops.state;\n let [mask_4lhs, mask_4rhs] = duplicate(&ops.parents, Some(mask));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let zeros = B::float_zeros(shape_lhs.clone(), &device);\n let grad = B::float_mask_where(grad, mask_4lhs.unwrap(), zeros);\n\n broadcast_shape::<B>(grad, &shape_lhs)\n },\n |grad| {\n let zeros = B::float_zeros(shape_rhs.clone(), &device);\n let grad = B::float_mask_where(zeros, mask_4rhs.unwrap(), grad);\n\n broadcast_shape::<B>(grad, &shape_rhs)\n },\n );\n }\n }\n\n match MaskWhere\n .prepare::<C>([tensor.node, source.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n mask.clone(),\n tensor.primitive.shape(),\n source.primitive.shape(),\n B::float_device(&source.primitive),\n ),\n B::float_mask_where(tensor.primitive, mask, source.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_mask_where(\n tensor.primitive,\n mask,\n source.primitive,\n )),\n }\n }\n\n fn float_mask_fill(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<B>,\n value: FloatElem<B>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MaskFill;\n\n impl<B: Backend> Backward<B, 1> for MaskFill {\n type State = BoolTensor<B>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mask_fill(grad, ops.state, 0.elem())\n });\n }\n }\n\n match MaskFill\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n mask.clone(),\n B::float_mask_fill(tensor.primitive, mask, value),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_mask_fill(tensor.primitive, mask, value))\n }\n }\n }\n\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_equal(lhs.primitive, rhs.primitive)\n }\n\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_equal_elem(lhs.primitive, rhs)\n }\n\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_greater(lhs.primitive, rhs.primitive)\n }\n\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_greater_elem(lhs.primitive, rhs)\n }\n\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_greater_equal(lhs.primitive, rhs.primitive)\n }\n\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_greater_equal_elem(lhs.primitive, rhs)\n }\n\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_lower(lhs.primitive, rhs.primitive)\n }\n\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_lower_elem(lhs.primitive, rhs)\n }\n\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_lower_equal(lhs.primitive, rhs.primitive)\n }\n\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_lower_equal_elem(lhs.primitive, rhs)\n }\n\n fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n // When we detach a tensor, we remove it from the graph, but we still want to keep the\n // `require_grad` setting.\n let is_require_grad = Self::float_is_require_grad(&tensor);\n let tensor = AutodiffTensor::new(tensor.primitive);\n\n match is_require_grad {\n true => tensor.require_grad(),\n false => tensor,\n }\n }\n\n fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool) -> FloatTensor<Self> {\n if require_grad {\n return tensor.require_grad();\n }\n\n AutodiffTensor::new(tensor.primitive)\n }\n\n fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {\n matches!(tensor.node.requirement, Requirement::Grad)\n }\n\n fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Mean;\n\n impl<B: Backend> Backward<B, 1> for Mean {\n type State = Shape;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape = ops.state;\n let val = 1_f64 / shape.num_elements() as f64;\n let ones = B::float_ones(shape, &B::float_device(&grad));\n let val = B::float_mul_scalar(ones, val.elem());\n\n let grad = unsqueeze_like::<B>(grad, val.shape());\n B::float_mul(val, grad)\n });\n }\n }\n\n match Mean.prepare::<C>([tensor.node]).compute_bound().stateful() {\n OpsKind::Tracked(prep) => {\n prep.finish(tensor.primitive.shape(), B::float_mean(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean(tensor.primitive)),\n }\n }\n\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sum;\n\n impl<B: Backend> Backward<B, 1> for Sum {\n type State = Shape;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let val = B::float_ones(ops.state, &B::float_device(&grad));\n\n let grad = unsqueeze_like::<B>(grad, val.shape());\n B::float_mul(val, grad)\n });\n }\n }\n\n match Sum.prepare::<C>([tensor.node]).compute_bound().stateful() {\n OpsKind::Tracked(prep) => {\n prep.finish(tensor.primitive.shape(), B::float_sum(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum(tensor.primitive)),\n }\n }\n\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MeanDim;\n\n impl<B: Backend> Backward<B, 1> for MeanDim {\n type State = (Shape, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, dim) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let val = 1_f64 / shape.dims[dim] as f64;\n let ones = B::float_ones(shape, &B::float_device(&grad));\n let val = B::float_mul_scalar(ones, B::FloatElem::from_elem(val));\n\n let grad = B::float_sum_dim(grad, dim);\n B::float_mul(val, grad)\n });\n }\n }\n\n match MeanDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), dim),\n B::float_mean_dim(tensor.primitive, dim),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean_dim(tensor.primitive, dim)),\n }\n }\n\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SumDim;\n\n impl<B: Backend> Backward<B, 1> for SumDim {\n type State = (Shape, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, dim) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let ones = B::float_ones(shape, &B::float_device(&grad));\n let grad = B::float_sum_dim(grad, dim);\n\n B::float_mul(ones, grad)\n });\n }\n }\n\n match SumDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), dim),\n B::float_sum_dim(tensor.primitive, dim),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum_dim(tensor.primitive, dim)),\n }\n }\n\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\n B::float_argmax(tensor.primitive, dim)\n }\n\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\n B::float_argmin(tensor.primitive, dim)\n }\n\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Exp;\n\n retro_unary!(RetroExp, B::float_exp);\n\n impl<B: Backend> Backward<B, 1> for Exp {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n let output = B::float_exp(input);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mul(grad, output)\n });\n }\n }\n\n match Exp\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroExp::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_exp(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_exp(tensor.primitive)),\n }\n }\n\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Log;\n\n retro_unary!(RetroLog, B::float_log);\n\n impl<B: Backend> Backward<B, 1> for Log {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_powf_scalar(input, -1.0);\n B::float_mul(grad, value)\n });\n }\n }\n\n match Log\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroLog::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_log(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_log(tensor.primitive)),\n }\n }\n\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Log1P;\n\n retro_unary!(RetroLog1P, B::float_log1p);\n\n impl<B: Backend> Backward<B, 1> for Log1P {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_add_scalar(input, 1.elem());\n let value = B::float_powf_scalar(value, -1.0);\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Log1P\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroLog1P::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_log1p(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_log1p(tensor.primitive)),\n }\n }\n\n fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct PowfScalar;\n\n #[derive(new, Debug)]\n struct RetroPowfScalar<B: Backend> {\n lhs_id: NodeID,\n rhs: f32,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroPowfScalar<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let lhs = states.get_state::<B::FloatTensorPrimitive>(&self.lhs_id);\n let out = B::float_powf_scalar(lhs, self.rhs);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for PowfScalar {\n type State = (NodeID, f32);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (tensor_id, value) = ops.state;\n let tensor = checkpointer.retrieve_node_output(tensor_id);\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let tmp = B::float_powf_scalar(tensor, value - 1.0);\n let value = B::float_mul_scalar(tmp, value.elem());\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match PowfScalar\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroPowfScalar::<B>::new(tensor.node.id, value))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = (prep.checkpoint(&tensor), value);\n prep.finish(state, B::float_powf_scalar(tensor.primitive, value))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf_scalar(tensor.primitive, value)),\n }\n }\n\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sqrt;\n\n retro_unary!(RetroSqrt, B::float_sqrt);\n\n impl<B: Backend> Backward<B, 1> for Sqrt {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_div_scalar(B::float_powf_scalar(input, -0.5), 2.elem());\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Sqrt\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSqrt::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_sqrt(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_sqrt(tensor.primitive)),\n }\n }\n\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Abs;\n\n retro_unary!(RetroAbs, B::float_abs);\n\n impl<B: Backend> Backward<B, 1> for Abs {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let tensor: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(ops.state);\n let state = B::float_sign(tensor);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mul(grad, state)\n });\n }\n }\n\n match Abs\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroAbs::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_abs(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_abs(tensor.primitive)),\n }\n }\n\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Cos;\n\n retro_unary!(RetroCos, B::float_cos);\n\n impl<B: Backend> Backward<B, 1> for Cos {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_neg(B::float_sin(input));\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Cos\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroCos::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_cos(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_cos(tensor.primitive)),\n }\n }\n\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sin;\n\n retro_unary!(RetroSin, B::float_sin);\n\n impl<B: Backend> Backward<B, 1> for Sin {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let state = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_cos(state);\n B::float_mul(grad, value)\n });\n }\n }\n\n match Sin\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSin::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_sin(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_sin(tensor.primitive)),\n }\n }\n\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Tanh;\n\n retro_unary!(RetroTanh, B::float_tanh);\n\n impl<B: Backend> Backward<B, 1> for Tanh {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n let state = B::float_tanh(input);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_add_scalar(\n B::float_neg(B::float_powf_scalar(state, 2.0)),\n 1.elem(),\n );\n B::float_mul(grad, value)\n });\n }\n }\n\n match Tanh\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroTanh::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_tanh(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_tanh(tensor.primitive)),\n }\n }\n\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Round;\n retro_unary!(RetroRound, B::float_round);\n\n impl<B: Backend> Backward<B, 1> for Round {\n type State = (Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, device) = ops.state;\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\n B::float_zeros(shape, &device)\n })\n }\n }\n\n match Round\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRound::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\n B::float_round(tensor.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_round(tensor.primitive)),\n }\n }\n\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Floor;\n retro_unary!(RetroFloor, B::float_floor);\n\n impl<B: Backend> Backward<B, 1> for Floor {\n type State = (Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, device) = ops.state;\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\n B::float_zeros(shape, &device)\n })\n }\n }\n\n match Floor\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroFloor::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\n B::float_floor(tensor.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\n }\n }\n\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Ceil;\n retro_unary!(RetroCeil, B::float_ceil);\n\n impl<B: Backend> Backward<B, 1> for Ceil {\n type State = (Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, device) = ops.state;\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\n B::float_zeros(shape, &device)\n })\n }\n }\n\n match Ceil\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroCeil::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\n B::float_floor(tensor.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\n }\n }\n\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Erf;\n\n retro_unary!(RetroErf, B::float_erf);\n\n impl<B: Backend> Backward<B, 1> for Erf {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let ops = checkpointer.retrieve_node_output(ops.state);\n let exponent = B::float_neg(B::float_powf_scalar(ops, 2.0));\n let numerator = B::float_mul_scalar(B::float_exp(exponent), 2.0.elem());\n let denominator = core::f64::consts::PI.sqrt().elem();\n let value = B::float_div_scalar(numerator, denominator);\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Erf\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroErf::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_erf(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_erf(tensor.primitive)),\n }\n }\n\n fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {\n #[derive(new, Debug)]\n struct CatStep<B: Backend> {\n nodes: Vec<Option<NodeRef>>,\n // The dimension of each tensor along the dim dimension.\n // This indicates the number of dimension concatenated for each tensor.\n dim_sizes: Vec<usize>,\n output: NodeRef,\n phantom: PhantomData<B>,\n dim: usize,\n }\n\n impl<B: Backend> Step for CatStep<B> {\n fn step(self: Box<Self>, grads: &mut Gradients, _checkpointer: &mut Checkpointer) {\n let grad = grads.consume::<B>(&self.output);\n let ranges: Vec<_> = grad.shape().dims.iter().map(|v| 0..*v).collect();\n\n let mut current_index = 0;\n\n self.nodes\n .into_iter()\n .zip(self.dim_sizes)\n .filter_map(|(node, dim_size)| node.map(|node| (node, dim_size)))\n .for_each(|(node, dim_size)| {\n let mut ranges = ranges.clone();\n ranges[self.dim] = current_index..dim_size + current_index;\n current_index += dim_size;\n grads.register::<B>(node.id, B::float_slice(grad.clone(), &ranges));\n });\n }\n\n fn node(&self) -> NodeID {\n self.output.id\n }\n\n fn parents(&self) -> Vec<NodeID> {\n self.nodes\n .iter()\n .filter_map(|node| node.clone())\n .map(|node| node.id)\n .collect()\n }\n fn depth(&self) -> usize {\n self.output.order\n }\n }\n\n let mut nodes = Vec::with_capacity(tensors.len());\n let mut primitives = Vec::with_capacity(tensors.len());\n let mut dim_sizes = Vec::with_capacity(tensors.len());\n\n tensors.into_iter().for_each(|tensor| {\n dim_sizes.push(tensor.primitive.shape().dims[dim]);\n nodes.push(tensor.node);\n primitives.push(tensor.primitive);\n });\n\n let requirement = Requirement::from_nodes(&nodes);\n\n // For simplicity, this operation does not checkpoint anything\n let cat_computing_property = ComputingProperty::Ambiguous;\n let checkpointer_builder = CheckpointerBuilder::default();\n\n let output = B::float_cat(primitives, dim);\n if requirement.is_none() {\n return AutodiffTensor::from_parents(\n output,\n &nodes,\n requirement,\n cat_computing_property,\n );\n }\n\n let output =\n AutodiffTensor::from_parents(output, &nodes, requirement, cat_computing_property);\n let nodes = nodes\n .into_iter()\n .map(|node| node.clone_if_require_grad())\n .collect::<Vec<_>>();\n\n let ops = CatStep::<B>::new(nodes, dim_sizes, output.node.clone(), dim);\n output.register_step(ops, checkpointer_builder)\n }\n\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\n prep.finish((index, shape), tensor)\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_max_dim(tensor.primitive, dim)),\n }\n }\n fn float_max_dim_with_indices(\n tensor: FloatTensor<Self>,\n dim: usize,\n ) -> (FloatTensor<Self>, IntTensor<B>) {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish((index.clone(), shape), tensor);\n\n (tensor, index)\n }\n OpsKind::UnTracked(prep) => {\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish(tensor);\n\n (tensor, index)\n }\n }\n }\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\n prep.finish((index, shape), tensor)\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_min_dim(tensor.primitive, dim)),\n }\n }\n fn float_min_dim_with_indices(\n tensor: FloatTensor<Self>,\n dim: usize,\n ) -> (FloatTensor<Self>, IntTensor<B>) {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish((index.clone(), shape), tensor);\n\n (tensor, index)\n }\n OpsKind::UnTracked(prep) => {\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish(tensor);\n\n (tensor, index)\n }\n }\n }\n\n fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>::IntTensorPrimitive {\n B::float_into_int(tensor.primitive)\n }\n\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct PowF;\n\n retro_binary!(RetroPowf, B::float_powf);\n\n impl<B: Backend> Backward<B, 2> for PowF {\n type State = (NodeID, NodeID, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs_id, rhs_id, broadcast) = ops.state;\n let lhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(lhs_id);\n let rhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(rhs_id);\n\n // Both lhs and rhs are needed for both lhs and rhs gradients, but we clone them\n // the number of times required by the parents specification.\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, Some(rhs));\n let [lhs_4lhs, lhs_4rhs] = duplicate(&ops.parents, Some(lhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n //rhs*(lhs.val**(rhs-1))*grad\n let rhs1 = rhs_4lhs.unwrap();\n let rhs2 = rhs1.clone();\n let lhs = lhs_4lhs.unwrap();\n\n let tmp = B::float_powf(\n lhs,\n B::float_sub_scalar(rhs1, B::FloatElem::from_elem(1.0)),\n );\n let value = B::float_mul(tmp, rhs2);\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n //lhs**rhs * ln(lhs) * grad\n let rhs = rhs_4rhs.unwrap();\n let lhs1 = lhs_4rhs.unwrap();\n let lhs2 = lhs1.clone();\n let tmp = B::float_powf(lhs1, rhs);\n let value = B::float_mul(tmp, B::float_log(lhs2));\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match PowF\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroPowf::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = prep.checkpoint(&lhs);\n let rhs_state = prep.checkpoint(&rhs);\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_powf(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sign;\n\n retro_unary!(RetroSign, B::float_sign);\n\n impl<B: Backend> Backward<B, 1> for Sign {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad|\n // Always return 0 because the derivative of the sign function\n // does not contribute to gradient updates in a meaningful way.\n B::float_mul_scalar(grad, 0.elem()));\n }\n }\n\n Sign.prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSign::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateless(B::float_sign(tensor.primitive))\n }\n\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n // D1: tensor, D2: shape\n #[derive(Debug)]\n struct ExpandDim;\n\n #[derive(new, Debug)]\n struct RetroExpand<B: Backend> {\n input_id: NodeID,\n shape: Shape,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroExpand<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_expand(input, self.shape.clone());\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for ExpandDim {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_in, shape_out) = ops.state;\n let ndims_in = shape_in.num_dims();\n let ndims_out = shape_out.num_dims();\n\n let mut shape_expanded = vec![1; ndims_out];\n\n debug_assert!(ndims_out >= ndims_in);\n\n for i in 0..ndims_in {\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\n }\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape_grad = grad.shape();\n let mut grad = grad;\n\n #[allow(clippy::needless_range_loop)]\n for i in 0..ndims_out {\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\n grad = B::float_sum_dim(grad, i);\n }\n }\n\n B::float_reshape(grad, shape_in)\n });\n }\n }\n\n match ExpandDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), shape.clone()),\n B::float_expand(tensor.primitive, shape),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\n }\n }\n\n fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> FloatTensor<Self> {\n match super::sort::SortDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, indices) =\n B::float_sort_with_indices(tensor.primitive, dim, descending);\n prep.finish((indices, shape), tensor)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_sort(tensor.primitive, dim, descending))\n }\n }\n }\n\n fn float_sort_with_indices(\n tensor: FloatTensor<Self>,\n dim: usize,\n descending: bool,\n ) -> (FloatTensor<Self>, IntTensor<B>) {\n match super::sort::SortDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, indices) =\n B::float_sort_with_indices(tensor.primitive, dim, descending);\n let tensor = prep.finish((indices.clone(), shape), tensor);\n\n (tensor, indices)\n }\n OpsKind::UnTracked(prep) => {\n let (tensor, indices) =\n B::float_sort_with_indices(tensor.primitive, dim, descending);\n let tensor = prep.finish(tensor);\n\n (tensor, indices)\n }\n }\n }\n\n fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> IntTensor<B> {\n B::float_argsort(tensor.primitive, dim, descending)\n }\n\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Repeat;\n\n #[derive(new, Debug)]\n struct RetroRepeat<B: Backend> {\n tensor_id: NodeID,\n dim: usize,\n times: usize,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroRepeat<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Repeat {\n type State = (usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, times) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let mut dims = grad.shape().dims;\n let orig_dim_size = dims[dim] / times;\n if orig_dim_size > 1 {\n dims[dim] = orig_dim_size;\n let orig_dims = dims.clone();\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\n let grad = B::float_reshape(grad, Shape::from(dims));\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\n B::float_reshape(grad, Shape::from(orig_dims))\n } else {\n B::float_sum_dim(grad, dim)\n }\n });\n }\n }\n\n match Repeat\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim, times),\n B::float_repeat_dim(tensor.primitive, dim, times),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\n }\n }\n }\n\n fn float_cast(tensor: FloatTensor<Self>, dtype: burn_tensor::FloatDType) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_cast(tensor.primitive, dtype))\n }\n\n // TODO: Implement float_prod and float_sum\n // https://github.com/tracel-ai/burn/issues/1458\n}\n\n#[derive(Debug, Clone)]\nenum BinaryOpsBroadcast {\n Broadcasted(Shape, Shape),\n None,\n}\n\nimpl BinaryOpsBroadcast {\n fn new<B: Backend>(lhs: &B::FloatTensorPrimitive, rhs: &B::FloatTensorPrimitive) -> Self {\n let shape_lhs = lhs.shape();\n let shape_rhs = rhs.shape();\n let ndims = shape_lhs.num_dims();\n\n for i in 0..ndims {\n if shape_rhs.dims[i] != shape_lhs.dims[i] {\n return Self::Broadcasted(shape_lhs, shape_rhs);\n }\n }\n\n Self::None\n }\n\n fn backward_lhs<B: Backend>(&self, grad: B::FloatTensorPrimitive) -> B::FloatTensorPrimitive {\n match self {\n BinaryOpsBroadcast::Broadcasted(lhs, _rhs) => broadcast_shape::<B>(grad, lhs),\n BinaryOpsBroadcast::None => grad,\n }\n }\n\n fn backward_rhs<B: Backend>(&self, grad: B::FloatTensorPrimitive) -> B::FloatTensorPrimitive {\n match self {\n BinaryOpsBroadcast::Broadcasted(_lhs, rhs) => broadcast_shape::<B>(grad, rhs),\n BinaryOpsBroadcast::None => grad,\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_from_data(data, device))\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: burn_tensor::Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_random(shape, distribution, device))\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_zeros(shape, device))\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_ones(shape, device))\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n B::float_into_data(tensor.primitive).await\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n B::float_device(&tensor.primitive)\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ToDevice;\\n\\n impl<B: Backend> Backward<B, 1> for ToDevice {\\n type State = B::Device;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_to_device(grad, &ops.state)\\n });\\n }\\n }\\n\\n match ToDevice\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let device_old = B::float_device(&tensor.primitive);\\n prep.finish(device_old, B::float_to_device(tensor.primitive, device))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_to_device(tensor.primitive, device)),\\n }\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_empty(shape, device))\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Add;\\n\\n retro_binary!(RetroAdd, B::float_add);\\n\\n impl<B: Backend> Backward<B, 2> for Add {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(grad, &shape_rhs),\\n );\\n }\\n }\\n\\n match Add\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAdd::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_add(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_add(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct AddScalar;\\n\\n retro_unary_scalar!(RetroAddScalar, B::float_add_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for AddScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n AddScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAddScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_add_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sub;\\n\\n retro_binary!(RetroSub, B::float_sub);\\n\\n impl<B: Backend> Backward<B, 2> for Sub {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(B::float_neg(grad), &shape_rhs),\\n );\\n }\\n }\\n\\n match Sub\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSub::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_sub(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_sub(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SubScalar;\\n\\n retro_unary_scalar!(RetroSubScalar, B::float_sub_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for SubScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n SubScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSubScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_sub_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mul;\\n\\n retro_binary!(RetroMul, B::float_mul);\\n\\n impl<B: Backend> Backward<B, 2> for Mul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let grad = B::float_mul(grad, rhs.unwrap());\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let grad = B::float_mul(grad, lhs.unwrap());\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Mul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMul::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_mul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MulScalar;\\n\\n retro_unary_scalar!(RetroMulScalar, B::float_mul_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for MulScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul_scalar(grad, ops.state)\\n });\\n }\\n }\\n\\n match MulScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMulScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_mul_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Div;\\n\\n retro_binary!(RetroDiv, B::float_div);\\n\\n impl<B: Backend> Backward<B, 2> for Div {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, rhs);\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = rhs_4lhs.unwrap();\\n let value = B::float_powf_scalar(rhs, -1.0);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let rhs = rhs_4rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_div(B::float_neg(lhs), B::float_powf_scalar(rhs, 2.0));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Div\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDiv::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_div(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct DivScalar;\\n\\n retro_unary_scalar!(RetroDivScalar, B::float_div_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for DivScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = 1.0 / ops.state.elem::<f32>();\\n B::float_mul_scalar(grad, tmp.elem())\\n });\\n }\\n }\\n\\n match DivScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDivScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_div_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Rem;\\n\\n retro_binary!(RetroRem, B::float_remainder);\\n\\n impl<B: Backend> Backward<B, 2> for Rem {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n // remainder(x, y) = x - floor(x / y) * y\\n // partial(x - floor(x / y) * y, x) = 1\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n // partial(x - floor(x / y) * y, y) = - floor(x / y)\\n let rhs = rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_neg(B::float_floor(B::float_div(lhs, rhs)));\\n let grad = B::float_mul(grad, value);\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Rem\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRem::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_remainder(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_remainder(lhs.primitive, rhs.primitive))\\n }\\n }\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct RemainderScalar;\\n\\n retro_unary_scalar!(RetroRemainderScalar, B::float_remainder_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for RemainderScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n RemainderScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRemainderScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_remainder_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Matmul;\\n\\n impl<B: Backend> Backward<B, 2> for Matmul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = B::float_transpose(rhs.unwrap());\\n let grad = B::float_matmul(grad, rhs);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let lhs = B::float_transpose(lhs.unwrap());\\n let grad = B::float_matmul(lhs, grad);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Matmul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_matmul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_matmul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Neg;\\n\\n retro_unary!(RetroNeg, B::float_neg);\\n\\n impl<B: Backend> Backward<B, 1> for Neg {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| B::float_neg(grad));\\n }\\n }\\n\\n Neg.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroNeg::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_neg(tensor.primitive))\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Recip;\\n\\n retro_unary!(RetroRecip, B::float_recip);\\n\\n impl<B: Backend> Backward<B, 1> for Recip {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, -2.0);\\n let value = B::float_neg(tmp);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Recip\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRecip::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_recip(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_recip(tensor.primitive)),\\n }\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SwapDim;\\n\\n #[derive(new, Debug)]\\n struct RetroSwapDims<B: Backend> {\\n input_id: NodeID,\\n dim1: usize,\\n dim2: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSwapDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_swap_dims(input, self.dim1, self.dim2);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for SwapDim {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim1, dim2) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_swap_dims(grad, dim2, dim1)\\n });\\n }\\n }\\n\\n match SwapDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSwapDims::<B>::new(tensor.node.id, dim1, dim2))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim1, dim2),\\n B::float_swap_dims(tensor.primitive, dim1, dim2),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_swap_dims(tensor.primitive, dim1, dim2))\\n }\\n }\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PermuteDim;\\n\\n #[derive(new, Debug)]\\n struct RetroPermuteDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPermuteDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_permute(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PermuteDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n let mut inverse = vec![0usize; axes.len()];\\n axes.iter()\\n .enumerate()\\n .for_each(|(i, &axis)| inverse[axis] = i);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_permute(grad, &inverse)\\n });\\n }\\n }\\n\\n match PermuteDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPermuteDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_permute(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_permute(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct FlipDim;\\n\\n #[derive(new, Debug)]\\n struct RetroFlipDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroFlipDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_flip(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for FlipDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_flip(grad, &axes)\\n });\\n }\\n }\\n\\n match FlipDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFlipDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_flip(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_flip(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ReshapeDim;\\n\\n #[derive(new, Debug)]\\n struct RetroReshape<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroReshape<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_reshape(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ReshapeDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_original, shape) = ops.state;\\n let ndims_out = shape.num_dims();\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n for i in 0..ndims_out {\\n if shape.dims[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_original)\\n });\\n }\\n }\\n\\n match ReshapeDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroReshape::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_reshape(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_reshape(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Gather;\\n\\n impl<B: Backend> Backward<B, 1> for Gather {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_scatter(dim, zeros, indices, grad)\\n });\\n }\\n }\\n\\n match Gather\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_gather(dim, tensor.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_gather(dim, tensor.primitive, indices))\\n }\\n }\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Scatter;\\n\\n impl<B: Backend> Backward<B, 2> for Scatter {\\n type State = (usize, IntTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape_lhs, shape_rhs, device) = ops.state;\\n let [indices_4lhs, indices_4rhs] = duplicate(&ops.parents, Some(indices));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs, &device);\\n B::float_scatter(dim, grad, indices_4lhs.unwrap(), zeros)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_scatter(dim, zeros, indices_4rhs.unwrap(), grad)\\n },\\n );\\n }\\n }\\n\\n match Scatter\\n .prepare::<C>([tensor.node, value.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_scatter(dim, tensor.primitive, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_scatter(\\n dim,\\n tensor.primitive,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Select;\\n\\n #[derive(new, Debug)]\\n struct RetroSelect<B: Backend> {\\n input_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelect<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_select(input, self.dim, self.indices.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Select {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_select_assign(zeros, dim, indices, grad)\\n });\\n }\\n }\\n\\n match Select\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelect::<B>::new(tensor.node.id, dim, indices.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_select(tensor.primitive, dim, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_select(tensor.primitive, dim, indices))\\n }\\n }\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct IndexSelectDimAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSelectAssign<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n value_id: NodeID,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelectAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_select_assign(tensor, self.dim, self.indices.clone(), value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for IndexSelectDimAssign {\\n type State = (usize, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| grad,\\n |grad| B::float_select(grad, dim, indices),\\n );\\n }\\n }\\n\\n match IndexSelectDimAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelectAssign::<B>::new(\\n tensor.node.id,\\n dim,\\n indices.clone(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, indices.clone()),\\n B::float_select_assign(tensor.primitive, dim, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_select_assign(\\n tensor.primitive,\\n dim,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_slice(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Index;\\n\\n #[derive(new, Debug)]\\n struct RetroSlice<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSlice<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_slice(tensor, &self.ranges);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Index {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_slice_assign(zeros, &ranges, grad)\\n });\\n }\\n }\\n\\n match Index\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSlice::<B>::new(tensor.node.id, ranges.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_slice(tensor.primitive, ranges),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice(tensor.primitive, ranges)),\\n }\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SliceAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSliceAssign<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n value_id: NodeID,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSliceAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_slice_assign(tensor, &self.ranges, value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for SliceAssign {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape_rhs, device) = ops.state;\\n let [ranges_4lhs, ranges_4rhs] = duplicate(&ops.parents, Some(ranges));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_slice_assign(grad, &ranges_4lhs.unwrap(), zeros)\\n },\\n |grad| B::float_slice(grad, &ranges_4rhs.unwrap()),\\n );\\n }\\n }\\n\\n match SliceAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSliceAssign::<B>::new(\\n tensor.node.id,\\n ranges.to_vec(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_slice_assign(tensor.primitive, ranges, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice_assign(\\n tensor.primitive,\\n ranges,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n source: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskWhere;\\n\\n impl<B: Backend> Backward<B, 2> for MaskWhere {\\n type State = (BoolTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (mask, shape_lhs, shape_rhs, device) = ops.state;\\n let [mask_4lhs, mask_4rhs] = duplicate(&ops.parents, Some(mask));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs.clone(), &device);\\n let grad = B::float_mask_where(grad, mask_4lhs.unwrap(), zeros);\\n\\n broadcast_shape::<B>(grad, &shape_lhs)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs.clone(), &device);\\n let grad = B::float_mask_where(zeros, mask_4rhs.unwrap(), grad);\\n\\n broadcast_shape::<B>(grad, &shape_rhs)\\n },\\n );\\n }\\n }\\n\\n match MaskWhere\\n .prepare::<C>([tensor.node, source.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n mask.clone(),\\n tensor.primitive.shape(),\\n source.primitive.shape(),\\n B::float_device(&source.primitive),\\n ),\\n B::float_mask_where(tensor.primitive, mask, source.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mask_where(\\n tensor.primitive,\\n mask,\\n source.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<B>,\\n value: FloatElem<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskFill;\\n\\n impl<B: Backend> Backward<B, 1> for MaskFill {\\n type State = BoolTensor<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mask_fill(grad, ops.state, 0.elem())\\n });\\n }\\n }\\n\\n match MaskFill\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n mask.clone(),\\n B::float_mask_fill(tensor.primitive, mask, value),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_mask_fill(tensor.primitive, mask, value))\\n }\\n }\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n // When we detach a tensor, we remove it from the graph, but we still want to keep the\\n // `require_grad` setting.\\n let is_require_grad = Self::float_is_require_grad(&tensor);\\n let tensor = AutodiffTensor::new(tensor.primitive);\\n\\n match is_require_grad {\\n true => tensor.require_grad(),\\n false => tensor,\\n }\\n }\\n\\n fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool) -> FloatTensor<Self> {\\n if require_grad {\\n return tensor.require_grad();\\n }\\n\\n AutodiffTensor::new(tensor.primitive)\\n }\\n\\n fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {\\n matches!(tensor.node.requirement, Requirement::Grad)\\n }\\n\\n fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mean;\\n\\n impl<B: Backend> Backward<B, 1> for Mean {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape = ops.state;\\n let val = 1_f64 / shape.num_elements() as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, val.elem());\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Mean.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_mean(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean(tensor.primitive)),\\n }\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sum;\\n\\n impl<B: Backend> Backward<B, 1> for Sum {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = B::float_ones(ops.state, &B::float_device(&grad));\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Sum.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_sum(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum(tensor.primitive)),\\n }\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MeanDim;\\n\\n impl<B: Backend> Backward<B, 1> for MeanDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = 1_f64 / shape.dims[dim] as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, B::FloatElem::from_elem(val));\\n\\n let grad = B::float_sum_dim(grad, dim);\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match MeanDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_mean_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SumDim;\\n\\n impl<B: Backend> Backward<B, 1> for SumDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let grad = B::float_sum_dim(grad, dim);\\n\\n B::float_mul(ones, grad)\\n });\\n }\\n }\\n\\n match SumDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_sum_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmax(tensor.primitive, dim)\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmin(tensor.primitive, dim)\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Exp;\\n\\n retro_unary!(RetroExp, B::float_exp);\\n\\n impl<B: Backend> Backward<B, 1> for Exp {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let output = B::float_exp(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, output)\\n });\\n }\\n }\\n\\n match Exp\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExp::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_exp(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_exp(tensor.primitive)),\\n }\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log;\\n\\n retro_unary!(RetroLog, B::float_log);\\n\\n impl<B: Backend> Backward<B, 1> for Log {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_powf_scalar(input, -1.0);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log(tensor.primitive)),\\n }\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log1P;\\n\\n retro_unary!(RetroLog1P, B::float_log1p);\\n\\n impl<B: Backend> Backward<B, 1> for Log1P {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(input, 1.elem());\\n let value = B::float_powf_scalar(value, -1.0);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log1P\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog1P::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log1p(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log1p(tensor.primitive)),\\n }\\n }\\n\\n fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowfScalar;\\n\\n #[derive(new, Debug)]\\n struct RetroPowfScalar<B: Backend> {\\n lhs_id: NodeID,\\n rhs: f32,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPowfScalar<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let lhs = states.get_state::<B::FloatTensorPrimitive>(&self.lhs_id);\\n let out = B::float_powf_scalar(lhs, self.rhs);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PowfScalar {\\n type State = (NodeID, f32);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (tensor_id, value) = ops.state;\\n let tensor = checkpointer.retrieve_node_output(tensor_id);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, value - 1.0);\\n let value = B::float_mul_scalar(tmp, value.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match PowfScalar\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowfScalar::<B>::new(tensor.node.id, value))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = (prep.checkpoint(&tensor), value);\\n prep.finish(state, B::float_powf_scalar(tensor.primitive, value))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf_scalar(tensor.primitive, value)),\\n }\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sqrt;\\n\\n retro_unary!(RetroSqrt, B::float_sqrt);\\n\\n impl<B: Backend> Backward<B, 1> for Sqrt {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_div_scalar(B::float_powf_scalar(input, -0.5), 2.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sqrt\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSqrt::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sqrt(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sqrt(tensor.primitive)),\\n }\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Abs;\\n\\n retro_unary!(RetroAbs, B::float_abs);\\n\\n impl<B: Backend> Backward<B, 1> for Abs {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_sign(tensor);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, state)\\n });\\n }\\n }\\n\\n match Abs\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAbs::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_abs(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_abs(tensor.primitive)),\\n }\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Cos;\\n\\n retro_unary!(RetroCos, B::float_cos);\\n\\n impl<B: Backend> Backward<B, 1> for Cos {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_neg(B::float_sin(input));\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Cos\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCos::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_cos(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_cos(tensor.primitive)),\\n }\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sin;\\n\\n retro_unary!(RetroSin, B::float_sin);\\n\\n impl<B: Backend> Backward<B, 1> for Sin {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let state = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_cos(state);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sin\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSin::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sin(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sin(tensor.primitive)),\\n }\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Tanh;\\n\\n retro_unary!(RetroTanh, B::float_tanh);\\n\\n impl<B: Backend> Backward<B, 1> for Tanh {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_tanh(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(\\n B::float_neg(B::float_powf_scalar(state, 2.0)),\\n 1.elem(),\\n );\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Tanh\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroTanh::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_tanh(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_tanh(tensor.primitive)),\\n }\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Round;\\n retro_unary!(RetroRound, B::float_round);\\n\\n impl<B: Backend> Backward<B, 1> for Round {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Round\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRound::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_round(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_round(tensor.primitive)),\\n }\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Floor;\\n retro_unary!(RetroFloor, B::float_floor);\\n\\n impl<B: Backend> Backward<B, 1> for Floor {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Floor\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFloor::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Ceil;\\n retro_unary!(RetroCeil, B::float_ceil);\\n\\n impl<B: Backend> Backward<B, 1> for Ceil {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Ceil\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCeil::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Erf;\\n\\n retro_unary!(RetroErf, B::float_erf);\\n\\n impl<B: Backend> Backward<B, 1> for Erf {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ops = checkpointer.retrieve_node_output(ops.state);\\n let exponent = B::float_neg(B::float_powf_scalar(ops, 2.0));\\n let numerator = B::float_mul_scalar(B::float_exp(exponent), 2.0.elem());\\n let denominator = core::f64::consts::PI.sqrt().elem();\\n let value = B::float_div_scalar(numerator, denominator);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Erf\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroErf::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_erf(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_erf(tensor.primitive)),\\n }\\n }\\n\\n fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {\\n #[derive(new, Debug)]\\n struct CatStep<B: Backend> {\\n nodes: Vec<Option<NodeRef>>,\\n // The dimension of each tensor along the dim dimension.\\n // This indicates the number of dimension concatenated for each tensor.\\n dim_sizes: Vec<usize>,\\n output: NodeRef,\\n phantom: PhantomData<B>,\\n dim: usize,\\n }\\n\\n impl<B: Backend> Step for CatStep<B> {\\n fn step(self: Box<Self>, grads: &mut Gradients, _checkpointer: &mut Checkpointer) {\\n let grad = grads.consume::<B>(&self.output);\\n let ranges: Vec<_> = grad.shape().dims.iter().map(|v| 0..*v).collect();\\n\\n let mut current_index = 0;\\n\\n self.nodes\\n .into_iter()\\n .zip(self.dim_sizes)\\n .filter_map(|(node, dim_size)| node.map(|node| (node, dim_size)))\\n .for_each(|(node, dim_size)| {\\n let mut ranges = ranges.clone();\\n ranges[self.dim] = current_index..dim_size + current_index;\\n current_index += dim_size;\\n grads.register::<B>(node.id, B::float_slice(grad.clone(), &ranges));\\n });\\n }\\n\\n fn node(&self) -> NodeID {\\n self.output.id\\n }\\n\\n fn parents(&self) -> Vec<NodeID> {\\n self.nodes\\n .iter()\\n .filter_map(|node| node.clone())\\n .map(|node| node.id)\\n .collect()\\n }\\n fn depth(&self) -> usize {\\n self.output.order\\n }\\n }\\n\\n let mut nodes = Vec::with_capacity(tensors.len());\\n let mut primitives = Vec::with_capacity(tensors.len());\\n let mut dim_sizes = Vec::with_capacity(tensors.len());\\n\\n tensors.into_iter().for_each(|tensor| {\\n dim_sizes.push(tensor.primitive.shape().dims[dim]);\\n nodes.push(tensor.node);\\n primitives.push(tensor.primitive);\\n });\\n\\n let requirement = Requirement::from_nodes(&nodes);\\n\\n // For simplicity, this operation does not checkpoint anything\\n let cat_computing_property = ComputingProperty::Ambiguous;\\n let checkpointer_builder = CheckpointerBuilder::default();\\n\\n let output = B::float_cat(primitives, dim);\\n if requirement.is_none() {\\n return AutodiffTensor::from_parents(\\n output,\\n &nodes,\\n requirement,\\n cat_computing_property,\\n );\\n }\\n\\n let output =\\n AutodiffTensor::from_parents(output, &nodes, requirement, cat_computing_property);\\n let nodes = nodes\\n .into_iter()\\n .map(|node| node.clone_if_require_grad())\\n .collect::<Vec<_>>();\\n\\n let ops = CatStep::<B>::new(nodes, dim_sizes, output.node.clone(), dim);\\n output.register_step(ops, checkpointer_builder)\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_max_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_max_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_min_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_min_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>::IntTensorPrimitive {\\n B::float_into_int(tensor.primitive)\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowF;\\n\\n retro_binary!(RetroPowf, B::float_powf);\\n\\n impl<B: Backend> Backward<B, 2> for PowF {\\n type State = (NodeID, NodeID, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs_id, rhs_id, broadcast) = ops.state;\\n let lhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(lhs_id);\\n let rhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(rhs_id);\\n\\n // Both lhs and rhs are needed for both lhs and rhs gradients, but we clone them\\n // the number of times required by the parents specification.\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, Some(rhs));\\n let [lhs_4lhs, lhs_4rhs] = duplicate(&ops.parents, Some(lhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n //rhs*(lhs.val**(rhs-1))*grad\\n let rhs1 = rhs_4lhs.unwrap();\\n let rhs2 = rhs1.clone();\\n let lhs = lhs_4lhs.unwrap();\\n\\n let tmp = B::float_powf(\\n lhs,\\n B::float_sub_scalar(rhs1, B::FloatElem::from_elem(1.0)),\\n );\\n let value = B::float_mul(tmp, rhs2);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n //lhs**rhs * ln(lhs) * grad\\n let rhs = rhs_4rhs.unwrap();\\n let lhs1 = lhs_4rhs.unwrap();\\n let lhs2 = lhs1.clone();\\n let tmp = B::float_powf(lhs1, rhs);\\n let value = B::float_mul(tmp, B::float_log(lhs2));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match PowF\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowf::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = prep.checkpoint(&lhs);\\n let rhs_state = prep.checkpoint(&rhs);\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_powf(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sign;\\n\\n retro_unary!(RetroSign, B::float_sign);\\n\\n impl<B: Backend> Backward<B, 1> for Sign {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad|\\n // Always return 0 because the derivative of the sign function\\n // does not contribute to gradient updates in a meaningful way.\\n B::float_mul_scalar(grad, 0.elem()));\\n }\\n }\\n\\n Sign.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSign::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_sign(tensor.primitive))\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n // D1: tensor, D2: shape\\n #[derive(Debug)]\\n struct ExpandDim;\\n\\n #[derive(new, Debug)]\\n struct RetroExpand<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroExpand<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_expand(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ExpandDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_in, shape_out) = ops.state;\\n let ndims_in = shape_in.num_dims();\\n let ndims_out = shape_out.num_dims();\\n\\n let mut shape_expanded = vec![1; ndims_out];\\n\\n debug_assert!(ndims_out >= ndims_in);\\n\\n for i in 0..ndims_in {\\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\\n }\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n #[allow(clippy::needless_range_loop)]\\n for i in 0..ndims_out {\\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_in)\\n });\\n }\\n }\\n\\n match ExpandDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_expand(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> FloatTensor<Self> {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n prep.finish((indices, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_sort(tensor.primitive, dim, descending))\\n }\\n }\\n }\\n\\n fn float_sort_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n descending: bool,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish((indices.clone(), shape), tensor);\\n\\n (tensor, indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, indices)\\n }\\n }\\n }\\n\\n fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> IntTensor<B> {\\n B::float_argsort(tensor.primitive, dim, descending)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Repeat;\\n\\n #[derive(new, Debug)]\\n struct RetroRepeat<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n times: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroRepeat<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Repeat {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, times) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let mut dims = grad.shape().dims;\\n let orig_dim_size = dims[dim] / times;\\n if orig_dim_size > 1 {\\n dims[dim] = orig_dim_size;\\n let orig_dims = dims.clone();\\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\\n let grad = B::float_reshape(grad, Shape::from(dims));\\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\\n B::float_reshape(grad, Shape::from(orig_dims))\\n } else {\\n B::float_sum_dim(grad, dim)\\n }\\n });\\n }\\n }\\n\\n match Repeat\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, times),\\n B::float_repeat_dim(tensor.primitive, dim, times),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\\n }\\n }\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: burn_tensor::FloatDType) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_cast(tensor.primitive, dtype))\\n }\\n\\n // TODO: Implement float_prod and float_sum\\n // https://github.com/tracel-ai/burn/issues/1458\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"FloatTensor<Self>\"\n }\n ],\n \"end_line\": 2439,\n \"name\": \"float_expand\",\n \"signature\": \"fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self>\",\n \"start_line\": 2369\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_from_data(data, device))\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: burn_tensor::Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_random(shape, distribution, device))\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_zeros(shape, device))\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_ones(shape, device))\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n B::float_into_data(tensor.primitive).await\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n B::float_device(&tensor.primitive)\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ToDevice;\\n\\n impl<B: Backend> Backward<B, 1> for ToDevice {\\n type State = B::Device;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_to_device(grad, &ops.state)\\n });\\n }\\n }\\n\\n match ToDevice\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let device_old = B::float_device(&tensor.primitive);\\n prep.finish(device_old, B::float_to_device(tensor.primitive, device))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_to_device(tensor.primitive, device)),\\n }\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_empty(shape, device))\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Add;\\n\\n retro_binary!(RetroAdd, B::float_add);\\n\\n impl<B: Backend> Backward<B, 2> for Add {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(grad, &shape_rhs),\\n );\\n }\\n }\\n\\n match Add\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAdd::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_add(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_add(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct AddScalar;\\n\\n retro_unary_scalar!(RetroAddScalar, B::float_add_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for AddScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n AddScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAddScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_add_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sub;\\n\\n retro_binary!(RetroSub, B::float_sub);\\n\\n impl<B: Backend> Backward<B, 2> for Sub {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(B::float_neg(grad), &shape_rhs),\\n );\\n }\\n }\\n\\n match Sub\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSub::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_sub(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_sub(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SubScalar;\\n\\n retro_unary_scalar!(RetroSubScalar, B::float_sub_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for SubScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n SubScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSubScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_sub_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mul;\\n\\n retro_binary!(RetroMul, B::float_mul);\\n\\n impl<B: Backend> Backward<B, 2> for Mul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let grad = B::float_mul(grad, rhs.unwrap());\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let grad = B::float_mul(grad, lhs.unwrap());\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Mul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMul::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_mul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MulScalar;\\n\\n retro_unary_scalar!(RetroMulScalar, B::float_mul_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for MulScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul_scalar(grad, ops.state)\\n });\\n }\\n }\\n\\n match MulScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMulScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_mul_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Div;\\n\\n retro_binary!(RetroDiv, B::float_div);\\n\\n impl<B: Backend> Backward<B, 2> for Div {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, rhs);\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = rhs_4lhs.unwrap();\\n let value = B::float_powf_scalar(rhs, -1.0);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let rhs = rhs_4rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_div(B::float_neg(lhs), B::float_powf_scalar(rhs, 2.0));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Div\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDiv::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_div(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct DivScalar;\\n\\n retro_unary_scalar!(RetroDivScalar, B::float_div_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for DivScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = 1.0 / ops.state.elem::<f32>();\\n B::float_mul_scalar(grad, tmp.elem())\\n });\\n }\\n }\\n\\n match DivScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDivScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_div_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Rem;\\n\\n retro_binary!(RetroRem, B::float_remainder);\\n\\n impl<B: Backend> Backward<B, 2> for Rem {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n // remainder(x, y) = x - floor(x / y) * y\\n // partial(x - floor(x / y) * y, x) = 1\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n // partial(x - floor(x / y) * y, y) = - floor(x / y)\\n let rhs = rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_neg(B::float_floor(B::float_div(lhs, rhs)));\\n let grad = B::float_mul(grad, value);\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Rem\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRem::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_remainder(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_remainder(lhs.primitive, rhs.primitive))\\n }\\n }\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct RemainderScalar;\\n\\n retro_unary_scalar!(RetroRemainderScalar, B::float_remainder_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for RemainderScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n RemainderScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRemainderScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_remainder_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Matmul;\\n\\n impl<B: Backend> Backward<B, 2> for Matmul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = B::float_transpose(rhs.unwrap());\\n let grad = B::float_matmul(grad, rhs);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let lhs = B::float_transpose(lhs.unwrap());\\n let grad = B::float_matmul(lhs, grad);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Matmul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_matmul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_matmul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Neg;\\n\\n retro_unary!(RetroNeg, B::float_neg);\\n\\n impl<B: Backend> Backward<B, 1> for Neg {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| B::float_neg(grad));\\n }\\n }\\n\\n Neg.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroNeg::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_neg(tensor.primitive))\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Recip;\\n\\n retro_unary!(RetroRecip, B::float_recip);\\n\\n impl<B: Backend> Backward<B, 1> for Recip {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, -2.0);\\n let value = B::float_neg(tmp);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Recip\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRecip::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_recip(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_recip(tensor.primitive)),\\n }\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SwapDim;\\n\\n #[derive(new, Debug)]\\n struct RetroSwapDims<B: Backend> {\\n input_id: NodeID,\\n dim1: usize,\\n dim2: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSwapDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_swap_dims(input, self.dim1, self.dim2);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for SwapDim {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim1, dim2) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_swap_dims(grad, dim2, dim1)\\n });\\n }\\n }\\n\\n match SwapDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSwapDims::<B>::new(tensor.node.id, dim1, dim2))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim1, dim2),\\n B::float_swap_dims(tensor.primitive, dim1, dim2),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_swap_dims(tensor.primitive, dim1, dim2))\\n }\\n }\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PermuteDim;\\n\\n #[derive(new, Debug)]\\n struct RetroPermuteDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPermuteDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_permute(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PermuteDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n let mut inverse = vec![0usize; axes.len()];\\n axes.iter()\\n .enumerate()\\n .for_each(|(i, &axis)| inverse[axis] = i);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_permute(grad, &inverse)\\n });\\n }\\n }\\n\\n match PermuteDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPermuteDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_permute(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_permute(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct FlipDim;\\n\\n #[derive(new, Debug)]\\n struct RetroFlipDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroFlipDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_flip(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for FlipDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_flip(grad, &axes)\\n });\\n }\\n }\\n\\n match FlipDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFlipDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_flip(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_flip(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ReshapeDim;\\n\\n #[derive(new, Debug)]\\n struct RetroReshape<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroReshape<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_reshape(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ReshapeDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_original, shape) = ops.state;\\n let ndims_out = shape.num_dims();\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n for i in 0..ndims_out {\\n if shape.dims[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_original)\\n });\\n }\\n }\\n\\n match ReshapeDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroReshape::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_reshape(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_reshape(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Gather;\\n\\n impl<B: Backend> Backward<B, 1> for Gather {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_scatter(dim, zeros, indices, grad)\\n });\\n }\\n }\\n\\n match Gather\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_gather(dim, tensor.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_gather(dim, tensor.primitive, indices))\\n }\\n }\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Scatter;\\n\\n impl<B: Backend> Backward<B, 2> for Scatter {\\n type State = (usize, IntTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape_lhs, shape_rhs, device) = ops.state;\\n let [indices_4lhs, indices_4rhs] = duplicate(&ops.parents, Some(indices));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs, &device);\\n B::float_scatter(dim, grad, indices_4lhs.unwrap(), zeros)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_scatter(dim, zeros, indices_4rhs.unwrap(), grad)\\n },\\n );\\n }\\n }\\n\\n match Scatter\\n .prepare::<C>([tensor.node, value.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_scatter(dim, tensor.primitive, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_scatter(\\n dim,\\n tensor.primitive,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Select;\\n\\n #[derive(new, Debug)]\\n struct RetroSelect<B: Backend> {\\n input_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelect<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_select(input, self.dim, self.indices.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Select {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_select_assign(zeros, dim, indices, grad)\\n });\\n }\\n }\\n\\n match Select\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelect::<B>::new(tensor.node.id, dim, indices.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_select(tensor.primitive, dim, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_select(tensor.primitive, dim, indices))\\n }\\n }\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct IndexSelectDimAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSelectAssign<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n value_id: NodeID,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelectAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_select_assign(tensor, self.dim, self.indices.clone(), value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for IndexSelectDimAssign {\\n type State = (usize, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| grad,\\n |grad| B::float_select(grad, dim, indices),\\n );\\n }\\n }\\n\\n match IndexSelectDimAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelectAssign::<B>::new(\\n tensor.node.id,\\n dim,\\n indices.clone(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, indices.clone()),\\n B::float_select_assign(tensor.primitive, dim, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_select_assign(\\n tensor.primitive,\\n dim,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_slice(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Index;\\n\\n #[derive(new, Debug)]\\n struct RetroSlice<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSlice<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_slice(tensor, &self.ranges);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Index {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_slice_assign(zeros, &ranges, grad)\\n });\\n }\\n }\\n\\n match Index\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSlice::<B>::new(tensor.node.id, ranges.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_slice(tensor.primitive, ranges),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice(tensor.primitive, ranges)),\\n }\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SliceAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSliceAssign<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n value_id: NodeID,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSliceAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_slice_assign(tensor, &self.ranges, value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for SliceAssign {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape_rhs, device) = ops.state;\\n let [ranges_4lhs, ranges_4rhs] = duplicate(&ops.parents, Some(ranges));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_slice_assign(grad, &ranges_4lhs.unwrap(), zeros)\\n },\\n |grad| B::float_slice(grad, &ranges_4rhs.unwrap()),\\n );\\n }\\n }\\n\\n match SliceAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSliceAssign::<B>::new(\\n tensor.node.id,\\n ranges.to_vec(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_slice_assign(tensor.primitive, ranges, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice_assign(\\n tensor.primitive,\\n ranges,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n source: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskWhere;\\n\\n impl<B: Backend> Backward<B, 2> for MaskWhere {\\n type State = (BoolTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (mask, shape_lhs, shape_rhs, device) = ops.state;\\n let [mask_4lhs, mask_4rhs] = duplicate(&ops.parents, Some(mask));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs.clone(), &device);\\n let grad = B::float_mask_where(grad, mask_4lhs.unwrap(), zeros);\\n\\n broadcast_shape::<B>(grad, &shape_lhs)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs.clone(), &device);\\n let grad = B::float_mask_where(zeros, mask_4rhs.unwrap(), grad);\\n\\n broadcast_shape::<B>(grad, &shape_rhs)\\n },\\n );\\n }\\n }\\n\\n match MaskWhere\\n .prepare::<C>([tensor.node, source.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n mask.clone(),\\n tensor.primitive.shape(),\\n source.primitive.shape(),\\n B::float_device(&source.primitive),\\n ),\\n B::float_mask_where(tensor.primitive, mask, source.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mask_where(\\n tensor.primitive,\\n mask,\\n source.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<B>,\\n value: FloatElem<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskFill;\\n\\n impl<B: Backend> Backward<B, 1> for MaskFill {\\n type State = BoolTensor<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mask_fill(grad, ops.state, 0.elem())\\n });\\n }\\n }\\n\\n match MaskFill\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n mask.clone(),\\n B::float_mask_fill(tensor.primitive, mask, value),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_mask_fill(tensor.primitive, mask, value))\\n }\\n }\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n // When we detach a tensor, we remove it from the graph, but we still want to keep the\\n // `require_grad` setting.\\n let is_require_grad = Self::float_is_require_grad(&tensor);\\n let tensor = AutodiffTensor::new(tensor.primitive);\\n\\n match is_require_grad {\\n true => tensor.require_grad(),\\n false => tensor,\\n }\\n }\\n\\n fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool) -> FloatTensor<Self> {\\n if require_grad {\\n return tensor.require_grad();\\n }\\n\\n AutodiffTensor::new(tensor.primitive)\\n }\\n\\n fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {\\n matches!(tensor.node.requirement, Requirement::Grad)\\n }\\n\\n fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mean;\\n\\n impl<B: Backend> Backward<B, 1> for Mean {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape = ops.state;\\n let val = 1_f64 / shape.num_elements() as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, val.elem());\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Mean.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_mean(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean(tensor.primitive)),\\n }\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sum;\\n\\n impl<B: Backend> Backward<B, 1> for Sum {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = B::float_ones(ops.state, &B::float_device(&grad));\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Sum.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_sum(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum(tensor.primitive)),\\n }\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MeanDim;\\n\\n impl<B: Backend> Backward<B, 1> for MeanDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = 1_f64 / shape.dims[dim] as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, B::FloatElem::from_elem(val));\\n\\n let grad = B::float_sum_dim(grad, dim);\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match MeanDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_mean_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SumDim;\\n\\n impl<B: Backend> Backward<B, 1> for SumDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let grad = B::float_sum_dim(grad, dim);\\n\\n B::float_mul(ones, grad)\\n });\\n }\\n }\\n\\n match SumDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_sum_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmax(tensor.primitive, dim)\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmin(tensor.primitive, dim)\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Exp;\\n\\n retro_unary!(RetroExp, B::float_exp);\\n\\n impl<B: Backend> Backward<B, 1> for Exp {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let output = B::float_exp(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, output)\\n });\\n }\\n }\\n\\n match Exp\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExp::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_exp(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_exp(tensor.primitive)),\\n }\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log;\\n\\n retro_unary!(RetroLog, B::float_log);\\n\\n impl<B: Backend> Backward<B, 1> for Log {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_powf_scalar(input, -1.0);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log(tensor.primitive)),\\n }\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log1P;\\n\\n retro_unary!(RetroLog1P, B::float_log1p);\\n\\n impl<B: Backend> Backward<B, 1> for Log1P {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(input, 1.elem());\\n let value = B::float_powf_scalar(value, -1.0);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log1P\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog1P::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log1p(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log1p(tensor.primitive)),\\n }\\n }\\n\\n fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowfScalar;\\n\\n #[derive(new, Debug)]\\n struct RetroPowfScalar<B: Backend> {\\n lhs_id: NodeID,\\n rhs: f32,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPowfScalar<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let lhs = states.get_state::<B::FloatTensorPrimitive>(&self.lhs_id);\\n let out = B::float_powf_scalar(lhs, self.rhs);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PowfScalar {\\n type State = (NodeID, f32);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (tensor_id, value) = ops.state;\\n let tensor = checkpointer.retrieve_node_output(tensor_id);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, value - 1.0);\\n let value = B::float_mul_scalar(tmp, value.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match PowfScalar\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowfScalar::<B>::new(tensor.node.id, value))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = (prep.checkpoint(&tensor), value);\\n prep.finish(state, B::float_powf_scalar(tensor.primitive, value))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf_scalar(tensor.primitive, value)),\\n }\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sqrt;\\n\\n retro_unary!(RetroSqrt, B::float_sqrt);\\n\\n impl<B: Backend> Backward<B, 1> for Sqrt {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_div_scalar(B::float_powf_scalar(input, -0.5), 2.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sqrt\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSqrt::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sqrt(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sqrt(tensor.primitive)),\\n }\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Abs;\\n\\n retro_unary!(RetroAbs, B::float_abs);\\n\\n impl<B: Backend> Backward<B, 1> for Abs {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_sign(tensor);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, state)\\n });\\n }\\n }\\n\\n match Abs\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAbs::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_abs(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_abs(tensor.primitive)),\\n }\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Cos;\\n\\n retro_unary!(RetroCos, B::float_cos);\\n\\n impl<B: Backend> Backward<B, 1> for Cos {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_neg(B::float_sin(input));\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Cos\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCos::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_cos(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_cos(tensor.primitive)),\\n }\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sin;\\n\\n retro_unary!(RetroSin, B::float_sin);\\n\\n impl<B: Backend> Backward<B, 1> for Sin {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let state = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_cos(state);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sin\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSin::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sin(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sin(tensor.primitive)),\\n }\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Tanh;\\n\\n retro_unary!(RetroTanh, B::float_tanh);\\n\\n impl<B: Backend> Backward<B, 1> for Tanh {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_tanh(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(\\n B::float_neg(B::float_powf_scalar(state, 2.0)),\\n 1.elem(),\\n );\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Tanh\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroTanh::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_tanh(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_tanh(tensor.primitive)),\\n }\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Round;\\n retro_unary!(RetroRound, B::float_round);\\n\\n impl<B: Backend> Backward<B, 1> for Round {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Round\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRound::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_round(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_round(tensor.primitive)),\\n }\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Floor;\\n retro_unary!(RetroFloor, B::float_floor);\\n\\n impl<B: Backend> Backward<B, 1> for Floor {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Floor\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFloor::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Ceil;\\n retro_unary!(RetroCeil, B::float_ceil);\\n\\n impl<B: Backend> Backward<B, 1> for Ceil {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Ceil\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCeil::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Erf;\\n\\n retro_unary!(RetroErf, B::float_erf);\\n\\n impl<B: Backend> Backward<B, 1> for Erf {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ops = checkpointer.retrieve_node_output(ops.state);\\n let exponent = B::float_neg(B::float_powf_scalar(ops, 2.0));\\n let numerator = B::float_mul_scalar(B::float_exp(exponent), 2.0.elem());\\n let denominator = core::f64::consts::PI.sqrt().elem();\\n let value = B::float_div_scalar(numerator, denominator);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Erf\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroErf::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_erf(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_erf(tensor.primitive)),\\n }\\n }\\n\\n fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {\\n #[derive(new, Debug)]\\n struct CatStep<B: Backend> {\\n nodes: Vec<Option<NodeRef>>,\\n // The dimension of each tensor along the dim dimension.\\n // This indicates the number of dimension concatenated for each tensor.\\n dim_sizes: Vec<usize>,\\n output: NodeRef,\\n phantom: PhantomData<B>,\\n dim: usize,\\n }\\n\\n impl<B: Backend> Step for CatStep<B> {\\n fn step(self: Box<Self>, grads: &mut Gradients, _checkpointer: &mut Checkpointer) {\\n let grad = grads.consume::<B>(&self.output);\\n let ranges: Vec<_> = grad.shape().dims.iter().map(|v| 0..*v).collect();\\n\\n let mut current_index = 0;\\n\\n self.nodes\\n .into_iter()\\n .zip(self.dim_sizes)\\n .filter_map(|(node, dim_size)| node.map(|node| (node, dim_size)))\\n .for_each(|(node, dim_size)| {\\n let mut ranges = ranges.clone();\\n ranges[self.dim] = current_index..dim_size + current_index;\\n current_index += dim_size;\\n grads.register::<B>(node.id, B::float_slice(grad.clone(), &ranges));\\n });\\n }\\n\\n fn node(&self) -> NodeID {\\n self.output.id\\n }\\n\\n fn parents(&self) -> Vec<NodeID> {\\n self.nodes\\n .iter()\\n .filter_map(|node| node.clone())\\n .map(|node| node.id)\\n .collect()\\n }\\n fn depth(&self) -> usize {\\n self.output.order\\n }\\n }\\n\\n let mut nodes = Vec::with_capacity(tensors.len());\\n let mut primitives = Vec::with_capacity(tensors.len());\\n let mut dim_sizes = Vec::with_capacity(tensors.len());\\n\\n tensors.into_iter().for_each(|tensor| {\\n dim_sizes.push(tensor.primitive.shape().dims[dim]);\\n nodes.push(tensor.node);\\n primitives.push(tensor.primitive);\\n });\\n\\n let requirement = Requirement::from_nodes(&nodes);\\n\\n // For simplicity, this operation does not checkpoint anything\\n let cat_computing_property = ComputingProperty::Ambiguous;\\n let checkpointer_builder = CheckpointerBuilder::default();\\n\\n let output = B::float_cat(primitives, dim);\\n if requirement.is_none() {\\n return AutodiffTensor::from_parents(\\n output,\\n &nodes,\\n requirement,\\n cat_computing_property,\\n );\\n }\\n\\n let output =\\n AutodiffTensor::from_parents(output, &nodes, requirement, cat_computing_property);\\n let nodes = nodes\\n .into_iter()\\n .map(|node| node.clone_if_require_grad())\\n .collect::<Vec<_>>();\\n\\n let ops = CatStep::<B>::new(nodes, dim_sizes, output.node.clone(), dim);\\n output.register_step(ops, checkpointer_builder)\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_max_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_max_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_min_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_min_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>::IntTensorPrimitive {\\n B::float_into_int(tensor.primitive)\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowF;\\n\\n retro_binary!(RetroPowf, B::float_powf);\\n\\n impl<B: Backend> Backward<B, 2> for PowF {\\n type State = (NodeID, NodeID, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs_id, rhs_id, broadcast) = ops.state;\\n let lhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(lhs_id);\\n let rhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(rhs_id);\\n\\n // Both lhs and rhs are needed for both lhs and rhs gradients, but we clone them\\n // the number of times required by the parents specification.\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, Some(rhs));\\n let [lhs_4lhs, lhs_4rhs] = duplicate(&ops.parents, Some(lhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n //rhs*(lhs.val**(rhs-1))*grad\\n let rhs1 = rhs_4lhs.unwrap();\\n let rhs2 = rhs1.clone();\\n let lhs = lhs_4lhs.unwrap();\\n\\n let tmp = B::float_powf(\\n lhs,\\n B::float_sub_scalar(rhs1, B::FloatElem::from_elem(1.0)),\\n );\\n let value = B::float_mul(tmp, rhs2);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n //lhs**rhs * ln(lhs) * grad\\n let rhs = rhs_4rhs.unwrap();\\n let lhs1 = lhs_4rhs.unwrap();\\n let lhs2 = lhs1.clone();\\n let tmp = B::float_powf(lhs1, rhs);\\n let value = B::float_mul(tmp, B::float_log(lhs2));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match PowF\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowf::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = prep.checkpoint(&lhs);\\n let rhs_state = prep.checkpoint(&rhs);\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_powf(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sign;\\n\\n retro_unary!(RetroSign, B::float_sign);\\n\\n impl<B: Backend> Backward<B, 1> for Sign {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad|\\n // Always return 0 because the derivative of the sign function\\n // does not contribute to gradient updates in a meaningful way.\\n B::float_mul_scalar(grad, 0.elem()));\\n }\\n }\\n\\n Sign.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSign::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_sign(tensor.primitive))\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n // D1: tensor, D2: shape\\n #[derive(Debug)]\\n struct ExpandDim;\\n\\n #[derive(new, Debug)]\\n struct RetroExpand<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroExpand<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_expand(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ExpandDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_in, shape_out) = ops.state;\\n let ndims_in = shape_in.num_dims();\\n let ndims_out = shape_out.num_dims();\\n\\n let mut shape_expanded = vec![1; ndims_out];\\n\\n debug_assert!(ndims_out >= ndims_in);\\n\\n for i in 0..ndims_in {\\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\\n }\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n #[allow(clippy::needless_range_loop)]\\n for i in 0..ndims_out {\\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_in)\\n });\\n }\\n }\\n\\n match ExpandDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_expand(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> FloatTensor<Self> {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n prep.finish((indices, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_sort(tensor.primitive, dim, descending))\\n }\\n }\\n }\\n\\n fn float_sort_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n descending: bool,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish((indices.clone(), shape), tensor);\\n\\n (tensor, indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, indices)\\n }\\n }\\n }\\n\\n fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> IntTensor<B> {\\n B::float_argsort(tensor.primitive, dim, descending)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Repeat;\\n\\n #[derive(new, Debug)]\\n struct RetroRepeat<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n times: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroRepeat<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Repeat {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, times) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let mut dims = grad.shape().dims;\\n let orig_dim_size = dims[dim] / times;\\n if orig_dim_size > 1 {\\n dims[dim] = orig_dim_size;\\n let orig_dims = dims.clone();\\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\\n let grad = B::float_reshape(grad, Shape::from(dims));\\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\\n B::float_reshape(grad, Shape::from(orig_dims))\\n } else {\\n B::float_sum_dim(grad, dim)\\n }\\n });\\n }\\n }\\n\\n match Repeat\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, times),\\n B::float_repeat_dim(tensor.primitive, dim, times),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\\n }\\n }\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: burn_tensor::FloatDType) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_cast(tensor.primitive, dtype))\\n }\\n\\n // TODO: Implement float_prod and float_sum\\n // https://github.com/tracel-ai/burn/issues/1458\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C>\"\n}"}}},{"rowIdx":135,"cells":{"function_name":{"kind":"string","value":"float_repeat_dim"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/tensor.rs"},"focal_code":{"kind":"string","value":"fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Repeat;\n\n #[derive(new, Debug)]\n struct RetroRepeat<B: Backend> {\n tensor_id: NodeID,\n dim: usize,\n times: usize,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroRepeat<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Repeat {\n type State = (usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, times) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let mut dims = grad.shape().dims;\n let orig_dim_size = dims[dim] / times;\n if orig_dim_size > 1 {\n dims[dim] = orig_dim_size;\n let orig_dims = dims.clone();\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\n let grad = B::float_reshape(grad, Shape::from(dims));\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\n B::float_reshape(grad, Shape::from(orig_dims))\n } else {\n B::float_sum_dim(grad, dim)\n }\n });\n }\n }\n\n match Repeat\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim, times),\n B::float_repeat_dim(tensor.primitive, dim, times),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\n }\n }\n }"},"file_content":{"kind":"string","value":"use alloc::{boxed::Box, vec, vec::Vec};\nuse core::marker::PhantomData;\n\n#[cfg(not(feature = \"std\"))]\n#[allow(unused_imports, reason = \"required on aarch64, unused on x86_64\")]\nuse num_traits::float::Float;\n\nuse crate::{\n Autodiff,\n checkpoint::{\n base::Checkpointer, builder::CheckpointerBuilder, retro_forward::RetroForward,\n state::BackwardStates, strategy::CheckpointStrategy,\n },\n grads::Gradients,\n graph::{ComputingProperty, NodeID, NodeRef, Requirement, Step},\n ops::{Backward, Ops, OpsKind, binary, broadcast_shape, unary},\n retro_binary, retro_unary, retro_unary_scalar,\n tensor::AutodiffTensor,\n utils::duplicate,\n};\n\nuse burn_tensor::{\n Device, ElementConversion, Shape, TensorData, TensorMetadata,\n backend::Backend,\n ops::{BoolTensor, FloatElem, FloatTensor, FloatTensorOps, IntTensor},\n};\n\nuse super::maxmin::MaxMinDim;\n\n// Unsqueeze op on primitive.\nfn unsqueeze_like<B: Backend>(\n tensor: B::FloatTensorPrimitive,\n shape: Shape,\n) -> B::FloatTensorPrimitive {\n /*\n let mut dims = [1; D2];\n let num_ones = D2 - D;\n let shape = self.shape();\n\n dims[num_ones..(D + num_ones)].copy_from_slice(&shape.dims[..D]);\n\n let shape = Shape::new(dims);\n self.reshape(shape)\n */\n\n let ndims_out = shape.num_dims();\n let shape = tensor.shape();\n let ndims_in = shape.num_dims();\n\n let mut dims = vec![1; ndims_out];\n let num_ones = ndims_out - ndims_in;\n dims[num_ones..(ndims_in + num_ones)].copy_from_slice(&shape.dims[..ndims_in]);\n\n B::float_reshape(tensor, Shape::from(dims))\n}\n\nimpl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distribution: burn_tensor::Distribution,\n device: &Device<Self>,\n ) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_random(shape, distribution, device))\n }\n\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_zeros(shape, device))\n }\n\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_ones(shape, device))\n }\n\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\n B::float_into_data(tensor.primitive).await\n }\n\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\n B::float_device(&tensor.primitive)\n }\n\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct ToDevice;\n\n impl<B: Backend> Backward<B, 1> for ToDevice {\n type State = B::Device;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_to_device(grad, &ops.state)\n });\n }\n }\n\n match ToDevice\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let device_old = B::float_device(&tensor.primitive);\n prep.finish(device_old, B::float_to_device(tensor.primitive, device))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_to_device(tensor.primitive, device)),\n }\n }\n\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_empty(shape, device))\n }\n\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Add;\n\n retro_binary!(RetroAdd, B::float_add);\n\n impl<B: Backend> Backward<B, 2> for Add {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_lhs, shape_rhs) = ops.state;\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\n |grad| broadcast_shape::<B>(grad, &shape_rhs),\n );\n }\n }\n\n match Add\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroAdd::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (lhs.primitive.shape(), rhs.primitive.shape()),\n B::float_add(lhs.primitive, rhs.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_add(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct AddScalar;\n\n retro_unary_scalar!(RetroAddScalar, B::float_add_scalar);\n\n impl<B: Backend> Backward<B, 1> for AddScalar {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\n }\n }\n\n AddScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroAddScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateless(B::float_add_scalar(lhs.primitive, rhs))\n }\n\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sub;\n\n retro_binary!(RetroSub, B::float_sub);\n\n impl<B: Backend> Backward<B, 2> for Sub {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_lhs, shape_rhs) = ops.state;\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\n |grad| broadcast_shape::<B>(B::float_neg(grad), &shape_rhs),\n );\n }\n }\n\n match Sub\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroSub::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (lhs.primitive.shape(), rhs.primitive.shape()),\n B::float_sub(lhs.primitive, rhs.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_sub(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SubScalar;\n\n retro_unary_scalar!(RetroSubScalar, B::float_sub_scalar);\n\n impl<B: Backend> Backward<B, 1> for SubScalar {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\n }\n }\n\n SubScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroSubScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateless(B::float_sub_scalar(lhs.primitive, rhs))\n }\n\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Mul;\n\n retro_binary!(RetroMul, B::float_mul);\n\n impl<B: Backend> Backward<B, 2> for Mul {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let grad = B::float_mul(grad, rhs.unwrap());\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n let grad = B::float_mul(grad, lhs.unwrap());\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Mul\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroMul::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\n\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_mul(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MulScalar;\n\n retro_unary_scalar!(RetroMulScalar, B::float_mul_scalar);\n\n impl<B: Backend> Backward<B, 1> for MulScalar {\n type State = FloatElem<B>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mul_scalar(grad, ops.state)\n });\n }\n }\n\n match MulScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroMulScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_mul_scalar(lhs.primitive, rhs)),\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul_scalar(lhs.primitive, rhs)),\n }\n }\n\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Div;\n\n retro_binary!(RetroDiv, B::float_div);\n\n impl<B: Backend> Backward<B, 2> for Div {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, rhs);\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let rhs = rhs_4lhs.unwrap();\n let value = B::float_powf_scalar(rhs, -1.0);\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n let rhs = rhs_4rhs.unwrap();\n let lhs = lhs.unwrap();\n let value = B::float_div(B::float_neg(lhs), B::float_powf_scalar(rhs, 2.0));\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Div\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroDiv::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\n\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_div(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_div(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct DivScalar;\n\n retro_unary_scalar!(RetroDivScalar, B::float_div_scalar);\n\n impl<B: Backend> Backward<B, 1> for DivScalar {\n type State = FloatElem<B>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let tmp = 1.0 / ops.state.elem::<f32>();\n B::float_mul_scalar(grad, tmp.elem())\n });\n }\n }\n\n match DivScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroDivScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_div_scalar(lhs.primitive, rhs)),\n OpsKind::UnTracked(prep) => prep.finish(B::float_div_scalar(lhs.primitive, rhs)),\n }\n }\n\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Rem;\n\n retro_binary!(RetroRem, B::float_remainder);\n\n impl<B: Backend> Backward<B, 2> for Rem {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n // remainder(x, y) = x - floor(x / y) * y\n // partial(x - floor(x / y) * y, x) = 1\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n // partial(x - floor(x / y) * y, y) = - floor(x / y)\n let rhs = rhs.unwrap();\n let lhs = lhs.unwrap();\n let value = B::float_neg(B::float_floor(B::float_div(lhs, rhs)));\n let grad = B::float_mul(grad, value);\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Rem\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroRem::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\n\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_remainder(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_remainder(lhs.primitive, rhs.primitive))\n }\n }\n }\n\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct RemainderScalar;\n\n retro_unary_scalar!(RetroRemainderScalar, B::float_remainder_scalar);\n\n impl<B: Backend> Backward<B, 1> for RemainderScalar {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\n }\n }\n\n RemainderScalar\n .prepare::<C>([lhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroRemainderScalar::<B>::new(lhs.node.id, rhs))\n .parents([&lhs])\n .stateless(B::float_remainder_scalar(lhs.primitive, rhs))\n }\n\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Matmul;\n\n impl<B: Backend> Backward<B, 2> for Matmul {\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs, rhs, broadcast) = ops.state;\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let rhs = B::float_transpose(rhs.unwrap());\n let grad = B::float_matmul(grad, rhs);\n\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n let lhs = B::float_transpose(lhs.unwrap());\n let grad = B::float_matmul(lhs, grad);\n\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let lhs_tracked = lhs.is_tracked();\n let rhs_tracked = rhs.is_tracked();\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match Matmul\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_matmul(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_matmul(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Neg;\n\n retro_unary!(RetroNeg, B::float_neg);\n\n impl<B: Backend> Backward<B, 1> for Neg {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| B::float_neg(grad));\n }\n }\n\n Neg.prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroNeg::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateless(B::float_neg(tensor.primitive))\n }\n\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Recip;\n\n retro_unary!(RetroRecip, B::float_recip);\n\n impl<B: Backend> Backward<B, 1> for Recip {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let tensor = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let tmp = B::float_powf_scalar(tensor, -2.0);\n let value = B::float_neg(tmp);\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Recip\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRecip::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_recip(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_recip(tensor.primitive)),\n }\n }\n\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SwapDim;\n\n #[derive(new, Debug)]\n struct RetroSwapDims<B: Backend> {\n input_id: NodeID,\n dim1: usize,\n dim2: usize,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSwapDims<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_swap_dims(input, self.dim1, self.dim2);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for SwapDim {\n type State = (usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim1, dim2) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_swap_dims(grad, dim2, dim1)\n });\n }\n }\n\n match SwapDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSwapDims::<B>::new(tensor.node.id, dim1, dim2))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim1, dim2),\n B::float_swap_dims(tensor.primitive, dim1, dim2),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_swap_dims(tensor.primitive, dim1, dim2))\n }\n }\n }\n\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct PermuteDim;\n\n #[derive(new, Debug)]\n struct RetroPermuteDims<B: Backend> {\n input_id: NodeID,\n axes: Vec<usize>,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroPermuteDims<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_permute(input, &self.axes);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for PermuteDim {\n type State = Vec<usize>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let axes = ops.state;\n\n let mut inverse = vec![0usize; axes.len()];\n axes.iter()\n .enumerate()\n .for_each(|(i, &axis)| inverse[axis] = i);\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_permute(grad, &inverse)\n });\n }\n }\n\n match PermuteDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroPermuteDims::<B>::new(tensor.node.id, axes.to_vec()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n prep.finish(axes.to_vec(), B::float_permute(tensor.primitive, axes))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_permute(tensor.primitive, axes)),\n }\n }\n\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct FlipDim;\n\n #[derive(new, Debug)]\n struct RetroFlipDims<B: Backend> {\n input_id: NodeID,\n axes: Vec<usize>,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroFlipDims<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_flip(input, &self.axes);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for FlipDim {\n type State = Vec<usize>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let axes = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_flip(grad, &axes)\n });\n }\n }\n\n match FlipDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroFlipDims::<B>::new(tensor.node.id, axes.to_vec()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n prep.finish(axes.to_vec(), B::float_flip(tensor.primitive, axes))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_flip(tensor.primitive, axes)),\n }\n }\n\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct ReshapeDim;\n\n #[derive(new, Debug)]\n struct RetroReshape<B: Backend> {\n input_id: NodeID,\n shape: Shape,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroReshape<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_reshape(input, self.shape.clone());\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for ReshapeDim {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_original, shape) = ops.state;\n let ndims_out = shape.num_dims();\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape_grad = grad.shape();\n let mut grad = grad;\n\n for i in 0..ndims_out {\n if shape.dims[i] == 1 && shape_grad.dims[i] != 1 {\n grad = B::float_sum_dim(grad, i);\n }\n }\n\n B::float_reshape(grad, shape_original)\n });\n }\n }\n\n match ReshapeDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroReshape::<B>::new(tensor.node.id, shape.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), shape.clone()),\n B::float_reshape(tensor.primitive, shape),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_reshape(tensor.primitive, shape)),\n }\n }\n\n fn float_gather(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<B>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Gather;\n\n impl<B: Backend> Backward<B, 1> for Gather {\n type State = (usize, IntTensor<B>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices, shape, device) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let zeros = B::float_zeros(shape, &device);\n B::float_scatter(dim, zeros, indices, grad)\n });\n }\n }\n\n match Gather\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n dim,\n indices.clone(),\n tensor.primitive.shape(),\n B::float_device(&tensor.primitive),\n ),\n B::float_gather(dim, tensor.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_gather(dim, tensor.primitive, indices))\n }\n }\n }\n\n fn float_scatter(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<B>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Scatter;\n\n impl<B: Backend> Backward<B, 2> for Scatter {\n type State = (usize, IntTensor<B>, Shape, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices, shape_lhs, shape_rhs, device) = ops.state;\n let [indices_4lhs, indices_4rhs] = duplicate(&ops.parents, Some(indices));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let zeros = B::float_zeros(shape_lhs, &device);\n B::float_scatter(dim, grad, indices_4lhs.unwrap(), zeros)\n },\n |grad| {\n let zeros = B::float_zeros(shape_rhs, &device);\n B::float_scatter(dim, zeros, indices_4rhs.unwrap(), grad)\n },\n );\n }\n }\n\n match Scatter\n .prepare::<C>([tensor.node, value.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n dim,\n indices.clone(),\n tensor.primitive.shape(),\n value.primitive.shape(),\n B::float_device(&value.primitive),\n ),\n B::float_scatter(dim, tensor.primitive, indices, value.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_scatter(\n dim,\n tensor.primitive,\n indices,\n value.primitive,\n )),\n }\n }\n\n fn float_select(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<B>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Select;\n\n #[derive(new, Debug)]\n struct RetroSelect<B: Backend> {\n input_id: NodeID,\n dim: usize,\n indices: IntTensor<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSelect<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_select(input, self.dim, self.indices.clone());\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Select {\n type State = (usize, IntTensor<B>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices, shape, device) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let zeros = B::float_zeros(shape, &device);\n B::float_select_assign(zeros, dim, indices, grad)\n });\n }\n }\n\n match Select\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSelect::<B>::new(tensor.node.id, dim, indices.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n dim,\n indices.clone(),\n tensor.primitive.shape(),\n B::float_device(&tensor.primitive),\n ),\n B::float_select(tensor.primitive, dim, indices),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_select(tensor.primitive, dim, indices))\n }\n }\n }\n\n fn float_select_assign(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<B>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct IndexSelectDimAssign;\n\n #[derive(new, Debug)]\n struct RetroSelectAssign<B: Backend> {\n tensor_id: NodeID,\n dim: usize,\n indices: IntTensor<B>,\n value_id: NodeID,\n }\n\n impl<B: Backend> RetroForward for RetroSelectAssign<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\n let out = B::float_select_assign(tensor, self.dim, self.indices.clone(), value);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 2> for IndexSelectDimAssign {\n type State = (usize, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, indices) = ops.state;\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| grad,\n |grad| B::float_select(grad, dim, indices),\n );\n }\n }\n\n match IndexSelectDimAssign\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\n .memory_bound()\n .retro_forward(RetroSelectAssign::<B>::new(\n tensor.node.id,\n dim,\n indices.clone(),\n value.node.id,\n ))\n .parents([&tensor, &value])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim, indices.clone()),\n B::float_select_assign(tensor.primitive, dim, indices, value.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_select_assign(\n tensor.primitive,\n dim,\n indices,\n value.primitive,\n )),\n }\n }\n\n fn float_slice(\n tensor: FloatTensor<Self>,\n ranges: &[core::ops::Range<usize>],\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Index;\n\n #[derive(new, Debug)]\n struct RetroSlice<B: Backend> {\n tensor_id: NodeID,\n ranges: Vec<core::ops::Range<usize>>,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSlice<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let out = B::float_slice(tensor, &self.ranges);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Index {\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (ranges, shape, device) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let zeros = B::float_zeros(shape, &device);\n B::float_slice_assign(zeros, &ranges, grad)\n });\n }\n }\n\n match Index\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSlice::<B>::new(tensor.node.id, ranges.to_vec()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n ranges.to_vec(),\n tensor.primitive.shape(),\n B::float_device(&tensor.primitive),\n ),\n B::float_slice(tensor.primitive, ranges),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice(tensor.primitive, ranges)),\n }\n }\n\n fn float_slice_assign(\n tensor: FloatTensor<Self>,\n ranges: &[core::ops::Range<usize>],\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SliceAssign;\n\n #[derive(new, Debug)]\n struct RetroSliceAssign<B: Backend> {\n tensor_id: NodeID,\n ranges: Vec<core::ops::Range<usize>>,\n value_id: NodeID,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroSliceAssign<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\n let out = B::float_slice_assign(tensor, &self.ranges, value);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 2> for SliceAssign {\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (ranges, shape_rhs, device) = ops.state;\n let [ranges_4lhs, ranges_4rhs] = duplicate(&ops.parents, Some(ranges));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let zeros = B::float_zeros(shape_rhs, &device);\n B::float_slice_assign(grad, &ranges_4lhs.unwrap(), zeros)\n },\n |grad| B::float_slice(grad, &ranges_4rhs.unwrap()),\n );\n }\n }\n\n match SliceAssign\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\n .memory_bound()\n .retro_forward(RetroSliceAssign::<B>::new(\n tensor.node.id,\n ranges.to_vec(),\n value.node.id,\n ))\n .parents([&tensor, &value])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n ranges.to_vec(),\n value.primitive.shape(),\n B::float_device(&value.primitive),\n ),\n B::float_slice_assign(tensor.primitive, ranges, value.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice_assign(\n tensor.primitive,\n ranges,\n value.primitive,\n )),\n }\n }\n\n fn float_mask_where(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<Self>,\n source: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MaskWhere;\n\n impl<B: Backend> Backward<B, 2> for MaskWhere {\n type State = (BoolTensor<B>, Shape, Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (mask, shape_lhs, shape_rhs, device) = ops.state;\n let [mask_4lhs, mask_4rhs] = duplicate(&ops.parents, Some(mask));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n let zeros = B::float_zeros(shape_lhs.clone(), &device);\n let grad = B::float_mask_where(grad, mask_4lhs.unwrap(), zeros);\n\n broadcast_shape::<B>(grad, &shape_lhs)\n },\n |grad| {\n let zeros = B::float_zeros(shape_rhs.clone(), &device);\n let grad = B::float_mask_where(zeros, mask_4rhs.unwrap(), grad);\n\n broadcast_shape::<B>(grad, &shape_rhs)\n },\n );\n }\n }\n\n match MaskWhere\n .prepare::<C>([tensor.node, source.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (\n mask.clone(),\n tensor.primitive.shape(),\n source.primitive.shape(),\n B::float_device(&source.primitive),\n ),\n B::float_mask_where(tensor.primitive, mask, source.primitive),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_mask_where(\n tensor.primitive,\n mask,\n source.primitive,\n )),\n }\n }\n\n fn float_mask_fill(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<B>,\n value: FloatElem<B>,\n ) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MaskFill;\n\n impl<B: Backend> Backward<B, 1> for MaskFill {\n type State = BoolTensor<B>;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mask_fill(grad, ops.state, 0.elem())\n });\n }\n }\n\n match MaskFill\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n mask.clone(),\n B::float_mask_fill(tensor.primitive, mask, value),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_mask_fill(tensor.primitive, mask, value))\n }\n }\n }\n\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_equal(lhs.primitive, rhs.primitive)\n }\n\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_equal_elem(lhs.primitive, rhs)\n }\n\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_greater(lhs.primitive, rhs.primitive)\n }\n\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_greater_elem(lhs.primitive, rhs)\n }\n\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_greater_equal(lhs.primitive, rhs.primitive)\n }\n\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_greater_equal_elem(lhs.primitive, rhs)\n }\n\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_lower(lhs.primitive, rhs.primitive)\n }\n\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_lower_elem(lhs.primitive, rhs)\n }\n\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\n B::float_lower_equal(lhs.primitive, rhs.primitive)\n }\n\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\n B::float_lower_equal_elem(lhs.primitive, rhs)\n }\n\n fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n // When we detach a tensor, we remove it from the graph, but we still want to keep the\n // `require_grad` setting.\n let is_require_grad = Self::float_is_require_grad(&tensor);\n let tensor = AutodiffTensor::new(tensor.primitive);\n\n match is_require_grad {\n true => tensor.require_grad(),\n false => tensor,\n }\n }\n\n fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool) -> FloatTensor<Self> {\n if require_grad {\n return tensor.require_grad();\n }\n\n AutodiffTensor::new(tensor.primitive)\n }\n\n fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {\n matches!(tensor.node.requirement, Requirement::Grad)\n }\n\n fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Mean;\n\n impl<B: Backend> Backward<B, 1> for Mean {\n type State = Shape;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape = ops.state;\n let val = 1_f64 / shape.num_elements() as f64;\n let ones = B::float_ones(shape, &B::float_device(&grad));\n let val = B::float_mul_scalar(ones, val.elem());\n\n let grad = unsqueeze_like::<B>(grad, val.shape());\n B::float_mul(val, grad)\n });\n }\n }\n\n match Mean.prepare::<C>([tensor.node]).compute_bound().stateful() {\n OpsKind::Tracked(prep) => {\n prep.finish(tensor.primitive.shape(), B::float_mean(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean(tensor.primitive)),\n }\n }\n\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sum;\n\n impl<B: Backend> Backward<B, 1> for Sum {\n type State = Shape;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let val = B::float_ones(ops.state, &B::float_device(&grad));\n\n let grad = unsqueeze_like::<B>(grad, val.shape());\n B::float_mul(val, grad)\n });\n }\n }\n\n match Sum.prepare::<C>([tensor.node]).compute_bound().stateful() {\n OpsKind::Tracked(prep) => {\n prep.finish(tensor.primitive.shape(), B::float_sum(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum(tensor.primitive)),\n }\n }\n\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct MeanDim;\n\n impl<B: Backend> Backward<B, 1> for MeanDim {\n type State = (Shape, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, dim) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let val = 1_f64 / shape.dims[dim] as f64;\n let ones = B::float_ones(shape, &B::float_device(&grad));\n let val = B::float_mul_scalar(ones, B::FloatElem::from_elem(val));\n\n let grad = B::float_sum_dim(grad, dim);\n B::float_mul(val, grad)\n });\n }\n }\n\n match MeanDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), dim),\n B::float_mean_dim(tensor.primitive, dim),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean_dim(tensor.primitive, dim)),\n }\n }\n\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct SumDim;\n\n impl<B: Backend> Backward<B, 1> for SumDim {\n type State = (Shape, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, dim) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let ones = B::float_ones(shape, &B::float_device(&grad));\n let grad = B::float_sum_dim(grad, dim);\n\n B::float_mul(ones, grad)\n });\n }\n }\n\n match SumDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), dim),\n B::float_sum_dim(tensor.primitive, dim),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum_dim(tensor.primitive, dim)),\n }\n }\n\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\n B::float_argmax(tensor.primitive, dim)\n }\n\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\n B::float_argmin(tensor.primitive, dim)\n }\n\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Exp;\n\n retro_unary!(RetroExp, B::float_exp);\n\n impl<B: Backend> Backward<B, 1> for Exp {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n let output = B::float_exp(input);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mul(grad, output)\n });\n }\n }\n\n match Exp\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroExp::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_exp(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_exp(tensor.primitive)),\n }\n }\n\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Log;\n\n retro_unary!(RetroLog, B::float_log);\n\n impl<B: Backend> Backward<B, 1> for Log {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_powf_scalar(input, -1.0);\n B::float_mul(grad, value)\n });\n }\n }\n\n match Log\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroLog::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_log(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_log(tensor.primitive)),\n }\n }\n\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Log1P;\n\n retro_unary!(RetroLog1P, B::float_log1p);\n\n impl<B: Backend> Backward<B, 1> for Log1P {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_add_scalar(input, 1.elem());\n let value = B::float_powf_scalar(value, -1.0);\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Log1P\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroLog1P::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_log1p(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_log1p(tensor.primitive)),\n }\n }\n\n fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct PowfScalar;\n\n #[derive(new, Debug)]\n struct RetroPowfScalar<B: Backend> {\n lhs_id: NodeID,\n rhs: f32,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroPowfScalar<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let lhs = states.get_state::<B::FloatTensorPrimitive>(&self.lhs_id);\n let out = B::float_powf_scalar(lhs, self.rhs);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for PowfScalar {\n type State = (NodeID, f32);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (tensor_id, value) = ops.state;\n let tensor = checkpointer.retrieve_node_output(tensor_id);\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let tmp = B::float_powf_scalar(tensor, value - 1.0);\n let value = B::float_mul_scalar(tmp, value.elem());\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match PowfScalar\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroPowfScalar::<B>::new(tensor.node.id, value))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = (prep.checkpoint(&tensor), value);\n prep.finish(state, B::float_powf_scalar(tensor.primitive, value))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf_scalar(tensor.primitive, value)),\n }\n }\n\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sqrt;\n\n retro_unary!(RetroSqrt, B::float_sqrt);\n\n impl<B: Backend> Backward<B, 1> for Sqrt {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_div_scalar(B::float_powf_scalar(input, -0.5), 2.elem());\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Sqrt\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSqrt::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_sqrt(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_sqrt(tensor.primitive)),\n }\n }\n\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Abs;\n\n retro_unary!(RetroAbs, B::float_abs);\n\n impl<B: Backend> Backward<B, 1> for Abs {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let tensor: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(ops.state);\n let state = B::float_sign(tensor);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::float_mul(grad, state)\n });\n }\n }\n\n match Abs\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroAbs::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_abs(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_abs(tensor.primitive)),\n }\n }\n\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Cos;\n\n retro_unary!(RetroCos, B::float_cos);\n\n impl<B: Backend> Backward<B, 1> for Cos {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_neg(B::float_sin(input));\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Cos\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroCos::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_cos(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_cos(tensor.primitive)),\n }\n }\n\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sin;\n\n retro_unary!(RetroSin, B::float_sin);\n\n impl<B: Backend> Backward<B, 1> for Sin {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let state = checkpointer.retrieve_node_output(ops.state);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_cos(state);\n B::float_mul(grad, value)\n });\n }\n }\n\n match Sin\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSin::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_sin(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_sin(tensor.primitive)),\n }\n }\n\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Tanh;\n\n retro_unary!(RetroTanh, B::float_tanh);\n\n impl<B: Backend> Backward<B, 1> for Tanh {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let input = checkpointer.retrieve_node_output(ops.state);\n let state = B::float_tanh(input);\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let value = B::float_add_scalar(\n B::float_neg(B::float_powf_scalar(state, 2.0)),\n 1.elem(),\n );\n B::float_mul(grad, value)\n });\n }\n }\n\n match Tanh\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroTanh::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_tanh(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_tanh(tensor.primitive)),\n }\n }\n\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Round;\n retro_unary!(RetroRound, B::float_round);\n\n impl<B: Backend> Backward<B, 1> for Round {\n type State = (Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, device) = ops.state;\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\n B::float_zeros(shape, &device)\n })\n }\n }\n\n match Round\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRound::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\n B::float_round(tensor.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_round(tensor.primitive)),\n }\n }\n\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Floor;\n retro_unary!(RetroFloor, B::float_floor);\n\n impl<B: Backend> Backward<B, 1> for Floor {\n type State = (Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, device) = ops.state;\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\n B::float_zeros(shape, &device)\n })\n }\n }\n\n match Floor\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroFloor::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\n B::float_floor(tensor.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\n }\n }\n\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Ceil;\n retro_unary!(RetroCeil, B::float_ceil);\n\n impl<B: Backend> Backward<B, 1> for Ceil {\n type State = (Shape, B::Device);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape, device) = ops.state;\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\n B::float_zeros(shape, &device)\n })\n }\n }\n\n match Ceil\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroCeil::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(preps) => preps.finish(\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\n B::float_floor(tensor.primitive),\n ),\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\n }\n }\n\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Erf;\n\n retro_unary!(RetroErf, B::float_erf);\n\n impl<B: Backend> Backward<B, 1> for Erf {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let ops = checkpointer.retrieve_node_output(ops.state);\n let exponent = B::float_neg(B::float_powf_scalar(ops, 2.0));\n let numerator = B::float_mul_scalar(B::float_exp(exponent), 2.0.elem());\n let denominator = core::f64::consts::PI.sqrt().elem();\n let value = B::float_div_scalar(numerator, denominator);\n\n B::float_mul(grad, value)\n });\n }\n }\n\n match Erf\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroErf::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let state = prep.checkpoint(&tensor);\n prep.finish(state, B::float_erf(tensor.primitive))\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_erf(tensor.primitive)),\n }\n }\n\n fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {\n #[derive(new, Debug)]\n struct CatStep<B: Backend> {\n nodes: Vec<Option<NodeRef>>,\n // The dimension of each tensor along the dim dimension.\n // This indicates the number of dimension concatenated for each tensor.\n dim_sizes: Vec<usize>,\n output: NodeRef,\n phantom: PhantomData<B>,\n dim: usize,\n }\n\n impl<B: Backend> Step for CatStep<B> {\n fn step(self: Box<Self>, grads: &mut Gradients, _checkpointer: &mut Checkpointer) {\n let grad = grads.consume::<B>(&self.output);\n let ranges: Vec<_> = grad.shape().dims.iter().map(|v| 0..*v).collect();\n\n let mut current_index = 0;\n\n self.nodes\n .into_iter()\n .zip(self.dim_sizes)\n .filter_map(|(node, dim_size)| node.map(|node| (node, dim_size)))\n .for_each(|(node, dim_size)| {\n let mut ranges = ranges.clone();\n ranges[self.dim] = current_index..dim_size + current_index;\n current_index += dim_size;\n grads.register::<B>(node.id, B::float_slice(grad.clone(), &ranges));\n });\n }\n\n fn node(&self) -> NodeID {\n self.output.id\n }\n\n fn parents(&self) -> Vec<NodeID> {\n self.nodes\n .iter()\n .filter_map(|node| node.clone())\n .map(|node| node.id)\n .collect()\n }\n fn depth(&self) -> usize {\n self.output.order\n }\n }\n\n let mut nodes = Vec::with_capacity(tensors.len());\n let mut primitives = Vec::with_capacity(tensors.len());\n let mut dim_sizes = Vec::with_capacity(tensors.len());\n\n tensors.into_iter().for_each(|tensor| {\n dim_sizes.push(tensor.primitive.shape().dims[dim]);\n nodes.push(tensor.node);\n primitives.push(tensor.primitive);\n });\n\n let requirement = Requirement::from_nodes(&nodes);\n\n // For simplicity, this operation does not checkpoint anything\n let cat_computing_property = ComputingProperty::Ambiguous;\n let checkpointer_builder = CheckpointerBuilder::default();\n\n let output = B::float_cat(primitives, dim);\n if requirement.is_none() {\n return AutodiffTensor::from_parents(\n output,\n &nodes,\n requirement,\n cat_computing_property,\n );\n }\n\n let output =\n AutodiffTensor::from_parents(output, &nodes, requirement, cat_computing_property);\n let nodes = nodes\n .into_iter()\n .map(|node| node.clone_if_require_grad())\n .collect::<Vec<_>>();\n\n let ops = CatStep::<B>::new(nodes, dim_sizes, output.node.clone(), dim);\n output.register_step(ops, checkpointer_builder)\n }\n\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\n prep.finish((index, shape), tensor)\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_max_dim(tensor.primitive, dim)),\n }\n }\n fn float_max_dim_with_indices(\n tensor: FloatTensor<Self>,\n dim: usize,\n ) -> (FloatTensor<Self>, IntTensor<B>) {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish((index.clone(), shape), tensor);\n\n (tensor, index)\n }\n OpsKind::UnTracked(prep) => {\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish(tensor);\n\n (tensor, index)\n }\n }\n }\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\n prep.finish((index, shape), tensor)\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_min_dim(tensor.primitive, dim)),\n }\n }\n fn float_min_dim_with_indices(\n tensor: FloatTensor<Self>,\n dim: usize,\n ) -> (FloatTensor<Self>, IntTensor<B>) {\n match MaxMinDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish((index.clone(), shape), tensor);\n\n (tensor, index)\n }\n OpsKind::UnTracked(prep) => {\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\n let tensor = prep.finish(tensor);\n\n (tensor, index)\n }\n }\n }\n\n fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>::IntTensorPrimitive {\n B::float_into_int(tensor.primitive)\n }\n\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct PowF;\n\n retro_binary!(RetroPowf, B::float_powf);\n\n impl<B: Backend> Backward<B, 2> for PowF {\n type State = (NodeID, NodeID, BinaryOpsBroadcast);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let (lhs_id, rhs_id, broadcast) = ops.state;\n let lhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(lhs_id);\n let rhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(rhs_id);\n\n // Both lhs and rhs are needed for both lhs and rhs gradients, but we clone them\n // the number of times required by the parents specification.\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, Some(rhs));\n let [lhs_4lhs, lhs_4rhs] = duplicate(&ops.parents, Some(lhs));\n\n binary::<B, _, _>(\n ops.parents,\n ops.node,\n grads,\n |grad| {\n //rhs*(lhs.val**(rhs-1))*grad\n let rhs1 = rhs_4lhs.unwrap();\n let rhs2 = rhs1.clone();\n let lhs = lhs_4lhs.unwrap();\n\n let tmp = B::float_powf(\n lhs,\n B::float_sub_scalar(rhs1, B::FloatElem::from_elem(1.0)),\n );\n let value = B::float_mul(tmp, rhs2);\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_lhs::<B>(grad)\n },\n |grad| {\n //lhs**rhs * ln(lhs) * grad\n let rhs = rhs_4rhs.unwrap();\n let lhs1 = lhs_4rhs.unwrap();\n let lhs2 = lhs1.clone();\n let tmp = B::float_powf(lhs1, rhs);\n let value = B::float_mul(tmp, B::float_log(lhs2));\n let grad = B::float_mul(grad, value);\n\n broadcast.backward_rhs::<B>(grad)\n },\n );\n }\n }\n\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\n\n match PowF\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\n .memory_bound()\n .retro_forward(RetroPowf::<B>::new(lhs.node.id, rhs.node.id))\n .parents([&lhs, &rhs])\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let lhs_state = prep.checkpoint(&lhs);\n let rhs_state = prep.checkpoint(&rhs);\n prep.finish(\n (lhs_state, rhs_state, broadcast),\n B::float_powf(lhs.primitive, rhs.primitive),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf(lhs.primitive, rhs.primitive)),\n }\n }\n\n fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Sign;\n\n retro_unary!(RetroSign, B::float_sign);\n\n impl<B: Backend> Backward<B, 1> for Sign {\n type State = ();\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n unary::<B, _>(ops.parents, ops.node, grads, |grad|\n // Always return 0 because the derivative of the sign function\n // does not contribute to gradient updates in a meaningful way.\n B::float_mul_scalar(grad, 0.elem()));\n }\n }\n\n Sign.prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroSign::<B>::new(tensor.node.id))\n .parents([&tensor])\n .stateless(B::float_sign(tensor.primitive))\n }\n\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n // D1: tensor, D2: shape\n #[derive(Debug)]\n struct ExpandDim;\n\n #[derive(new, Debug)]\n struct RetroExpand<B: Backend> {\n input_id: NodeID,\n shape: Shape,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroExpand<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\n let out = B::float_expand(input, self.shape.clone());\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for ExpandDim {\n type State = (Shape, Shape);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (shape_in, shape_out) = ops.state;\n let ndims_in = shape_in.num_dims();\n let ndims_out = shape_out.num_dims();\n\n let mut shape_expanded = vec![1; ndims_out];\n\n debug_assert!(ndims_out >= ndims_in);\n\n for i in 0..ndims_in {\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\n }\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let shape_grad = grad.shape();\n let mut grad = grad;\n\n #[allow(clippy::needless_range_loop)]\n for i in 0..ndims_out {\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\n grad = B::float_sum_dim(grad, i);\n }\n }\n\n B::float_reshape(grad, shape_in)\n });\n }\n }\n\n match ExpandDim\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (tensor.primitive.shape(), shape.clone()),\n B::float_expand(tensor.primitive, shape),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\n }\n }\n\n fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> FloatTensor<Self> {\n match super::sort::SortDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, indices) =\n B::float_sort_with_indices(tensor.primitive, dim, descending);\n prep.finish((indices, shape), tensor)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_sort(tensor.primitive, dim, descending))\n }\n }\n }\n\n fn float_sort_with_indices(\n tensor: FloatTensor<Self>,\n dim: usize,\n descending: bool,\n ) -> (FloatTensor<Self>, IntTensor<B>) {\n match super::sort::SortDim\n .prepare::<C>([tensor.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => {\n let shape = tensor.primitive.shape();\n let (tensor, indices) =\n B::float_sort_with_indices(tensor.primitive, dim, descending);\n let tensor = prep.finish((indices.clone(), shape), tensor);\n\n (tensor, indices)\n }\n OpsKind::UnTracked(prep) => {\n let (tensor, indices) =\n B::float_sort_with_indices(tensor.primitive, dim, descending);\n let tensor = prep.finish(tensor);\n\n (tensor, indices)\n }\n }\n }\n\n fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> IntTensor<B> {\n B::float_argsort(tensor.primitive, dim, descending)\n }\n\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\n #[derive(Debug)]\n struct Repeat;\n\n #[derive(new, Debug)]\n struct RetroRepeat<B: Backend> {\n tensor_id: NodeID,\n dim: usize,\n times: usize,\n _backend: PhantomData<B>,\n }\n\n impl<B: Backend> RetroForward for RetroRepeat<B> {\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\n states.save(out_node, out)\n }\n }\n\n impl<B: Backend> Backward<B, 1> for Repeat {\n type State = (usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (dim, times) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n let mut dims = grad.shape().dims;\n let orig_dim_size = dims[dim] / times;\n if orig_dim_size > 1 {\n dims[dim] = orig_dim_size;\n let orig_dims = dims.clone();\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\n let grad = B::float_reshape(grad, Shape::from(dims));\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\n B::float_reshape(grad, Shape::from(orig_dims))\n } else {\n B::float_sum_dim(grad, dim)\n }\n });\n }\n }\n\n match Repeat\n .prepare::<C>([tensor.node.clone()])\n .memory_bound()\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\n .parents([&tensor])\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (dim, times),\n B::float_repeat_dim(tensor.primitive, dim, times),\n ),\n OpsKind::UnTracked(prep) => {\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\n }\n }\n }\n\n fn float_cast(tensor: FloatTensor<Self>, dtype: burn_tensor::FloatDType) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_cast(tensor.primitive, dtype))\n }\n\n // TODO: Implement float_prod and float_sum\n // https://github.com/tracel-ai/burn/issues/1458\n}\n\n#[derive(Debug, Clone)]\nenum BinaryOpsBroadcast {\n Broadcasted(Shape, Shape),\n None,\n}\n\nimpl BinaryOpsBroadcast {\n fn new<B: Backend>(lhs: &B::FloatTensorPrimitive, rhs: &B::FloatTensorPrimitive) -> Self {\n let shape_lhs = lhs.shape();\n let shape_rhs = rhs.shape();\n let ndims = shape_lhs.num_dims();\n\n for i in 0..ndims {\n if shape_rhs.dims[i] != shape_lhs.dims[i] {\n return Self::Broadcasted(shape_lhs, shape_rhs);\n }\n }\n\n Self::None\n }\n\n fn backward_lhs<B: Backend>(&self, grad: B::FloatTensorPrimitive) -> B::FloatTensorPrimitive {\n match self {\n BinaryOpsBroadcast::Broadcasted(lhs, _rhs) => broadcast_shape::<B>(grad, lhs),\n BinaryOpsBroadcast::None => grad,\n }\n }\n\n fn backward_rhs<B: Backend>(&self, grad: B::FloatTensorPrimitive) -> B::FloatTensorPrimitive {\n match self {\n BinaryOpsBroadcast::Broadcasted(_lhs, rhs) => broadcast_shape::<B>(grad, rhs),\n BinaryOpsBroadcast::None => grad,\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_from_data(data, device))\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: burn_tensor::Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_random(shape, distribution, device))\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_zeros(shape, device))\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_ones(shape, device))\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n B::float_into_data(tensor.primitive).await\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n B::float_device(&tensor.primitive)\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ToDevice;\\n\\n impl<B: Backend> Backward<B, 1> for ToDevice {\\n type State = B::Device;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_to_device(grad, &ops.state)\\n });\\n }\\n }\\n\\n match ToDevice\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let device_old = B::float_device(&tensor.primitive);\\n prep.finish(device_old, B::float_to_device(tensor.primitive, device))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_to_device(tensor.primitive, device)),\\n }\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_empty(shape, device))\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Add;\\n\\n retro_binary!(RetroAdd, B::float_add);\\n\\n impl<B: Backend> Backward<B, 2> for Add {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(grad, &shape_rhs),\\n );\\n }\\n }\\n\\n match Add\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAdd::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_add(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_add(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct AddScalar;\\n\\n retro_unary_scalar!(RetroAddScalar, B::float_add_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for AddScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n AddScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAddScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_add_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sub;\\n\\n retro_binary!(RetroSub, B::float_sub);\\n\\n impl<B: Backend> Backward<B, 2> for Sub {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(B::float_neg(grad), &shape_rhs),\\n );\\n }\\n }\\n\\n match Sub\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSub::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_sub(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_sub(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SubScalar;\\n\\n retro_unary_scalar!(RetroSubScalar, B::float_sub_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for SubScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n SubScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSubScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_sub_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mul;\\n\\n retro_binary!(RetroMul, B::float_mul);\\n\\n impl<B: Backend> Backward<B, 2> for Mul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let grad = B::float_mul(grad, rhs.unwrap());\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let grad = B::float_mul(grad, lhs.unwrap());\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Mul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMul::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_mul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MulScalar;\\n\\n retro_unary_scalar!(RetroMulScalar, B::float_mul_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for MulScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul_scalar(grad, ops.state)\\n });\\n }\\n }\\n\\n match MulScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMulScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_mul_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Div;\\n\\n retro_binary!(RetroDiv, B::float_div);\\n\\n impl<B: Backend> Backward<B, 2> for Div {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, rhs);\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = rhs_4lhs.unwrap();\\n let value = B::float_powf_scalar(rhs, -1.0);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let rhs = rhs_4rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_div(B::float_neg(lhs), B::float_powf_scalar(rhs, 2.0));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Div\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDiv::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_div(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct DivScalar;\\n\\n retro_unary_scalar!(RetroDivScalar, B::float_div_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for DivScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = 1.0 / ops.state.elem::<f32>();\\n B::float_mul_scalar(grad, tmp.elem())\\n });\\n }\\n }\\n\\n match DivScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDivScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_div_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Rem;\\n\\n retro_binary!(RetroRem, B::float_remainder);\\n\\n impl<B: Backend> Backward<B, 2> for Rem {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n // remainder(x, y) = x - floor(x / y) * y\\n // partial(x - floor(x / y) * y, x) = 1\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n // partial(x - floor(x / y) * y, y) = - floor(x / y)\\n let rhs = rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_neg(B::float_floor(B::float_div(lhs, rhs)));\\n let grad = B::float_mul(grad, value);\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Rem\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRem::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_remainder(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_remainder(lhs.primitive, rhs.primitive))\\n }\\n }\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct RemainderScalar;\\n\\n retro_unary_scalar!(RetroRemainderScalar, B::float_remainder_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for RemainderScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n RemainderScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRemainderScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_remainder_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Matmul;\\n\\n impl<B: Backend> Backward<B, 2> for Matmul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = B::float_transpose(rhs.unwrap());\\n let grad = B::float_matmul(grad, rhs);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let lhs = B::float_transpose(lhs.unwrap());\\n let grad = B::float_matmul(lhs, grad);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Matmul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_matmul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_matmul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Neg;\\n\\n retro_unary!(RetroNeg, B::float_neg);\\n\\n impl<B: Backend> Backward<B, 1> for Neg {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| B::float_neg(grad));\\n }\\n }\\n\\n Neg.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroNeg::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_neg(tensor.primitive))\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Recip;\\n\\n retro_unary!(RetroRecip, B::float_recip);\\n\\n impl<B: Backend> Backward<B, 1> for Recip {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, -2.0);\\n let value = B::float_neg(tmp);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Recip\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRecip::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_recip(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_recip(tensor.primitive)),\\n }\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SwapDim;\\n\\n #[derive(new, Debug)]\\n struct RetroSwapDims<B: Backend> {\\n input_id: NodeID,\\n dim1: usize,\\n dim2: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSwapDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_swap_dims(input, self.dim1, self.dim2);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for SwapDim {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim1, dim2) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_swap_dims(grad, dim2, dim1)\\n });\\n }\\n }\\n\\n match SwapDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSwapDims::<B>::new(tensor.node.id, dim1, dim2))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim1, dim2),\\n B::float_swap_dims(tensor.primitive, dim1, dim2),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_swap_dims(tensor.primitive, dim1, dim2))\\n }\\n }\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PermuteDim;\\n\\n #[derive(new, Debug)]\\n struct RetroPermuteDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPermuteDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_permute(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PermuteDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n let mut inverse = vec![0usize; axes.len()];\\n axes.iter()\\n .enumerate()\\n .for_each(|(i, &axis)| inverse[axis] = i);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_permute(grad, &inverse)\\n });\\n }\\n }\\n\\n match PermuteDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPermuteDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_permute(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_permute(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct FlipDim;\\n\\n #[derive(new, Debug)]\\n struct RetroFlipDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroFlipDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_flip(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for FlipDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_flip(grad, &axes)\\n });\\n }\\n }\\n\\n match FlipDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFlipDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_flip(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_flip(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ReshapeDim;\\n\\n #[derive(new, Debug)]\\n struct RetroReshape<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroReshape<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_reshape(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ReshapeDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_original, shape) = ops.state;\\n let ndims_out = shape.num_dims();\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n for i in 0..ndims_out {\\n if shape.dims[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_original)\\n });\\n }\\n }\\n\\n match ReshapeDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroReshape::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_reshape(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_reshape(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Gather;\\n\\n impl<B: Backend> Backward<B, 1> for Gather {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_scatter(dim, zeros, indices, grad)\\n });\\n }\\n }\\n\\n match Gather\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_gather(dim, tensor.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_gather(dim, tensor.primitive, indices))\\n }\\n }\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Scatter;\\n\\n impl<B: Backend> Backward<B, 2> for Scatter {\\n type State = (usize, IntTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape_lhs, shape_rhs, device) = ops.state;\\n let [indices_4lhs, indices_4rhs] = duplicate(&ops.parents, Some(indices));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs, &device);\\n B::float_scatter(dim, grad, indices_4lhs.unwrap(), zeros)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_scatter(dim, zeros, indices_4rhs.unwrap(), grad)\\n },\\n );\\n }\\n }\\n\\n match Scatter\\n .prepare::<C>([tensor.node, value.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_scatter(dim, tensor.primitive, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_scatter(\\n dim,\\n tensor.primitive,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Select;\\n\\n #[derive(new, Debug)]\\n struct RetroSelect<B: Backend> {\\n input_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelect<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_select(input, self.dim, self.indices.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Select {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_select_assign(zeros, dim, indices, grad)\\n });\\n }\\n }\\n\\n match Select\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelect::<B>::new(tensor.node.id, dim, indices.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_select(tensor.primitive, dim, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_select(tensor.primitive, dim, indices))\\n }\\n }\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct IndexSelectDimAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSelectAssign<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n value_id: NodeID,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelectAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_select_assign(tensor, self.dim, self.indices.clone(), value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for IndexSelectDimAssign {\\n type State = (usize, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| grad,\\n |grad| B::float_select(grad, dim, indices),\\n );\\n }\\n }\\n\\n match IndexSelectDimAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelectAssign::<B>::new(\\n tensor.node.id,\\n dim,\\n indices.clone(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, indices.clone()),\\n B::float_select_assign(tensor.primitive, dim, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_select_assign(\\n tensor.primitive,\\n dim,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_slice(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Index;\\n\\n #[derive(new, Debug)]\\n struct RetroSlice<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSlice<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_slice(tensor, &self.ranges);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Index {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_slice_assign(zeros, &ranges, grad)\\n });\\n }\\n }\\n\\n match Index\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSlice::<B>::new(tensor.node.id, ranges.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_slice(tensor.primitive, ranges),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice(tensor.primitive, ranges)),\\n }\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SliceAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSliceAssign<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n value_id: NodeID,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSliceAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_slice_assign(tensor, &self.ranges, value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for SliceAssign {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape_rhs, device) = ops.state;\\n let [ranges_4lhs, ranges_4rhs] = duplicate(&ops.parents, Some(ranges));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_slice_assign(grad, &ranges_4lhs.unwrap(), zeros)\\n },\\n |grad| B::float_slice(grad, &ranges_4rhs.unwrap()),\\n );\\n }\\n }\\n\\n match SliceAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSliceAssign::<B>::new(\\n tensor.node.id,\\n ranges.to_vec(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_slice_assign(tensor.primitive, ranges, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice_assign(\\n tensor.primitive,\\n ranges,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n source: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskWhere;\\n\\n impl<B: Backend> Backward<B, 2> for MaskWhere {\\n type State = (BoolTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (mask, shape_lhs, shape_rhs, device) = ops.state;\\n let [mask_4lhs, mask_4rhs] = duplicate(&ops.parents, Some(mask));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs.clone(), &device);\\n let grad = B::float_mask_where(grad, mask_4lhs.unwrap(), zeros);\\n\\n broadcast_shape::<B>(grad, &shape_lhs)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs.clone(), &device);\\n let grad = B::float_mask_where(zeros, mask_4rhs.unwrap(), grad);\\n\\n broadcast_shape::<B>(grad, &shape_rhs)\\n },\\n );\\n }\\n }\\n\\n match MaskWhere\\n .prepare::<C>([tensor.node, source.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n mask.clone(),\\n tensor.primitive.shape(),\\n source.primitive.shape(),\\n B::float_device(&source.primitive),\\n ),\\n B::float_mask_where(tensor.primitive, mask, source.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mask_where(\\n tensor.primitive,\\n mask,\\n source.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<B>,\\n value: FloatElem<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskFill;\\n\\n impl<B: Backend> Backward<B, 1> for MaskFill {\\n type State = BoolTensor<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mask_fill(grad, ops.state, 0.elem())\\n });\\n }\\n }\\n\\n match MaskFill\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n mask.clone(),\\n B::float_mask_fill(tensor.primitive, mask, value),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_mask_fill(tensor.primitive, mask, value))\\n }\\n }\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n // When we detach a tensor, we remove it from the graph, but we still want to keep the\\n // `require_grad` setting.\\n let is_require_grad = Self::float_is_require_grad(&tensor);\\n let tensor = AutodiffTensor::new(tensor.primitive);\\n\\n match is_require_grad {\\n true => tensor.require_grad(),\\n false => tensor,\\n }\\n }\\n\\n fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool) -> FloatTensor<Self> {\\n if require_grad {\\n return tensor.require_grad();\\n }\\n\\n AutodiffTensor::new(tensor.primitive)\\n }\\n\\n fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {\\n matches!(tensor.node.requirement, Requirement::Grad)\\n }\\n\\n fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mean;\\n\\n impl<B: Backend> Backward<B, 1> for Mean {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape = ops.state;\\n let val = 1_f64 / shape.num_elements() as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, val.elem());\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Mean.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_mean(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean(tensor.primitive)),\\n }\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sum;\\n\\n impl<B: Backend> Backward<B, 1> for Sum {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = B::float_ones(ops.state, &B::float_device(&grad));\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Sum.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_sum(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum(tensor.primitive)),\\n }\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MeanDim;\\n\\n impl<B: Backend> Backward<B, 1> for MeanDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = 1_f64 / shape.dims[dim] as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, B::FloatElem::from_elem(val));\\n\\n let grad = B::float_sum_dim(grad, dim);\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match MeanDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_mean_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SumDim;\\n\\n impl<B: Backend> Backward<B, 1> for SumDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let grad = B::float_sum_dim(grad, dim);\\n\\n B::float_mul(ones, grad)\\n });\\n }\\n }\\n\\n match SumDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_sum_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmax(tensor.primitive, dim)\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmin(tensor.primitive, dim)\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Exp;\\n\\n retro_unary!(RetroExp, B::float_exp);\\n\\n impl<B: Backend> Backward<B, 1> for Exp {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let output = B::float_exp(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, output)\\n });\\n }\\n }\\n\\n match Exp\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExp::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_exp(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_exp(tensor.primitive)),\\n }\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log;\\n\\n retro_unary!(RetroLog, B::float_log);\\n\\n impl<B: Backend> Backward<B, 1> for Log {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_powf_scalar(input, -1.0);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log(tensor.primitive)),\\n }\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log1P;\\n\\n retro_unary!(RetroLog1P, B::float_log1p);\\n\\n impl<B: Backend> Backward<B, 1> for Log1P {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(input, 1.elem());\\n let value = B::float_powf_scalar(value, -1.0);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log1P\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog1P::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log1p(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log1p(tensor.primitive)),\\n }\\n }\\n\\n fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowfScalar;\\n\\n #[derive(new, Debug)]\\n struct RetroPowfScalar<B: Backend> {\\n lhs_id: NodeID,\\n rhs: f32,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPowfScalar<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let lhs = states.get_state::<B::FloatTensorPrimitive>(&self.lhs_id);\\n let out = B::float_powf_scalar(lhs, self.rhs);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PowfScalar {\\n type State = (NodeID, f32);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (tensor_id, value) = ops.state;\\n let tensor = checkpointer.retrieve_node_output(tensor_id);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, value - 1.0);\\n let value = B::float_mul_scalar(tmp, value.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match PowfScalar\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowfScalar::<B>::new(tensor.node.id, value))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = (prep.checkpoint(&tensor), value);\\n prep.finish(state, B::float_powf_scalar(tensor.primitive, value))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf_scalar(tensor.primitive, value)),\\n }\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sqrt;\\n\\n retro_unary!(RetroSqrt, B::float_sqrt);\\n\\n impl<B: Backend> Backward<B, 1> for Sqrt {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_div_scalar(B::float_powf_scalar(input, -0.5), 2.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sqrt\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSqrt::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sqrt(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sqrt(tensor.primitive)),\\n }\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Abs;\\n\\n retro_unary!(RetroAbs, B::float_abs);\\n\\n impl<B: Backend> Backward<B, 1> for Abs {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_sign(tensor);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, state)\\n });\\n }\\n }\\n\\n match Abs\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAbs::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_abs(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_abs(tensor.primitive)),\\n }\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Cos;\\n\\n retro_unary!(RetroCos, B::float_cos);\\n\\n impl<B: Backend> Backward<B, 1> for Cos {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_neg(B::float_sin(input));\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Cos\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCos::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_cos(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_cos(tensor.primitive)),\\n }\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sin;\\n\\n retro_unary!(RetroSin, B::float_sin);\\n\\n impl<B: Backend> Backward<B, 1> for Sin {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let state = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_cos(state);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sin\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSin::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sin(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sin(tensor.primitive)),\\n }\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Tanh;\\n\\n retro_unary!(RetroTanh, B::float_tanh);\\n\\n impl<B: Backend> Backward<B, 1> for Tanh {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_tanh(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(\\n B::float_neg(B::float_powf_scalar(state, 2.0)),\\n 1.elem(),\\n );\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Tanh\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroTanh::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_tanh(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_tanh(tensor.primitive)),\\n }\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Round;\\n retro_unary!(RetroRound, B::float_round);\\n\\n impl<B: Backend> Backward<B, 1> for Round {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Round\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRound::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_round(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_round(tensor.primitive)),\\n }\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Floor;\\n retro_unary!(RetroFloor, B::float_floor);\\n\\n impl<B: Backend> Backward<B, 1> for Floor {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Floor\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFloor::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Ceil;\\n retro_unary!(RetroCeil, B::float_ceil);\\n\\n impl<B: Backend> Backward<B, 1> for Ceil {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Ceil\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCeil::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Erf;\\n\\n retro_unary!(RetroErf, B::float_erf);\\n\\n impl<B: Backend> Backward<B, 1> for Erf {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ops = checkpointer.retrieve_node_output(ops.state);\\n let exponent = B::float_neg(B::float_powf_scalar(ops, 2.0));\\n let numerator = B::float_mul_scalar(B::float_exp(exponent), 2.0.elem());\\n let denominator = core::f64::consts::PI.sqrt().elem();\\n let value = B::float_div_scalar(numerator, denominator);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Erf\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroErf::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_erf(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_erf(tensor.primitive)),\\n }\\n }\\n\\n fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {\\n #[derive(new, Debug)]\\n struct CatStep<B: Backend> {\\n nodes: Vec<Option<NodeRef>>,\\n // The dimension of each tensor along the dim dimension.\\n // This indicates the number of dimension concatenated for each tensor.\\n dim_sizes: Vec<usize>,\\n output: NodeRef,\\n phantom: PhantomData<B>,\\n dim: usize,\\n }\\n\\n impl<B: Backend> Step for CatStep<B> {\\n fn step(self: Box<Self>, grads: &mut Gradients, _checkpointer: &mut Checkpointer) {\\n let grad = grads.consume::<B>(&self.output);\\n let ranges: Vec<_> = grad.shape().dims.iter().map(|v| 0..*v).collect();\\n\\n let mut current_index = 0;\\n\\n self.nodes\\n .into_iter()\\n .zip(self.dim_sizes)\\n .filter_map(|(node, dim_size)| node.map(|node| (node, dim_size)))\\n .for_each(|(node, dim_size)| {\\n let mut ranges = ranges.clone();\\n ranges[self.dim] = current_index..dim_size + current_index;\\n current_index += dim_size;\\n grads.register::<B>(node.id, B::float_slice(grad.clone(), &ranges));\\n });\\n }\\n\\n fn node(&self) -> NodeID {\\n self.output.id\\n }\\n\\n fn parents(&self) -> Vec<NodeID> {\\n self.nodes\\n .iter()\\n .filter_map(|node| node.clone())\\n .map(|node| node.id)\\n .collect()\\n }\\n fn depth(&self) -> usize {\\n self.output.order\\n }\\n }\\n\\n let mut nodes = Vec::with_capacity(tensors.len());\\n let mut primitives = Vec::with_capacity(tensors.len());\\n let mut dim_sizes = Vec::with_capacity(tensors.len());\\n\\n tensors.into_iter().for_each(|tensor| {\\n dim_sizes.push(tensor.primitive.shape().dims[dim]);\\n nodes.push(tensor.node);\\n primitives.push(tensor.primitive);\\n });\\n\\n let requirement = Requirement::from_nodes(&nodes);\\n\\n // For simplicity, this operation does not checkpoint anything\\n let cat_computing_property = ComputingProperty::Ambiguous;\\n let checkpointer_builder = CheckpointerBuilder::default();\\n\\n let output = B::float_cat(primitives, dim);\\n if requirement.is_none() {\\n return AutodiffTensor::from_parents(\\n output,\\n &nodes,\\n requirement,\\n cat_computing_property,\\n );\\n }\\n\\n let output =\\n AutodiffTensor::from_parents(output, &nodes, requirement, cat_computing_property);\\n let nodes = nodes\\n .into_iter()\\n .map(|node| node.clone_if_require_grad())\\n .collect::<Vec<_>>();\\n\\n let ops = CatStep::<B>::new(nodes, dim_sizes, output.node.clone(), dim);\\n output.register_step(ops, checkpointer_builder)\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_max_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_max_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_min_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_min_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>::IntTensorPrimitive {\\n B::float_into_int(tensor.primitive)\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowF;\\n\\n retro_binary!(RetroPowf, B::float_powf);\\n\\n impl<B: Backend> Backward<B, 2> for PowF {\\n type State = (NodeID, NodeID, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs_id, rhs_id, broadcast) = ops.state;\\n let lhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(lhs_id);\\n let rhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(rhs_id);\\n\\n // Both lhs and rhs are needed for both lhs and rhs gradients, but we clone them\\n // the number of times required by the parents specification.\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, Some(rhs));\\n let [lhs_4lhs, lhs_4rhs] = duplicate(&ops.parents, Some(lhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n //rhs*(lhs.val**(rhs-1))*grad\\n let rhs1 = rhs_4lhs.unwrap();\\n let rhs2 = rhs1.clone();\\n let lhs = lhs_4lhs.unwrap();\\n\\n let tmp = B::float_powf(\\n lhs,\\n B::float_sub_scalar(rhs1, B::FloatElem::from_elem(1.0)),\\n );\\n let value = B::float_mul(tmp, rhs2);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n //lhs**rhs * ln(lhs) * grad\\n let rhs = rhs_4rhs.unwrap();\\n let lhs1 = lhs_4rhs.unwrap();\\n let lhs2 = lhs1.clone();\\n let tmp = B::float_powf(lhs1, rhs);\\n let value = B::float_mul(tmp, B::float_log(lhs2));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match PowF\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowf::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = prep.checkpoint(&lhs);\\n let rhs_state = prep.checkpoint(&rhs);\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_powf(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sign;\\n\\n retro_unary!(RetroSign, B::float_sign);\\n\\n impl<B: Backend> Backward<B, 1> for Sign {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad|\\n // Always return 0 because the derivative of the sign function\\n // does not contribute to gradient updates in a meaningful way.\\n B::float_mul_scalar(grad, 0.elem()));\\n }\\n }\\n\\n Sign.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSign::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_sign(tensor.primitive))\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n // D1: tensor, D2: shape\\n #[derive(Debug)]\\n struct ExpandDim;\\n\\n #[derive(new, Debug)]\\n struct RetroExpand<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroExpand<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_expand(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ExpandDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_in, shape_out) = ops.state;\\n let ndims_in = shape_in.num_dims();\\n let ndims_out = shape_out.num_dims();\\n\\n let mut shape_expanded = vec![1; ndims_out];\\n\\n debug_assert!(ndims_out >= ndims_in);\\n\\n for i in 0..ndims_in {\\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\\n }\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n #[allow(clippy::needless_range_loop)]\\n for i in 0..ndims_out {\\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_in)\\n });\\n }\\n }\\n\\n match ExpandDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_expand(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> FloatTensor<Self> {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n prep.finish((indices, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_sort(tensor.primitive, dim, descending))\\n }\\n }\\n }\\n\\n fn float_sort_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n descending: bool,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish((indices.clone(), shape), tensor);\\n\\n (tensor, indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, indices)\\n }\\n }\\n }\\n\\n fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> IntTensor<B> {\\n B::float_argsort(tensor.primitive, dim, descending)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Repeat;\\n\\n #[derive(new, Debug)]\\n struct RetroRepeat<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n times: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroRepeat<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Repeat {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, times) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let mut dims = grad.shape().dims;\\n let orig_dim_size = dims[dim] / times;\\n if orig_dim_size > 1 {\\n dims[dim] = orig_dim_size;\\n let orig_dims = dims.clone();\\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\\n let grad = B::float_reshape(grad, Shape::from(dims));\\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\\n B::float_reshape(grad, Shape::from(orig_dims))\\n } else {\\n B::float_sum_dim(grad, dim)\\n }\\n });\\n }\\n }\\n\\n match Repeat\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, times),\\n B::float_repeat_dim(tensor.primitive, dim, times),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\\n }\\n }\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: burn_tensor::FloatDType) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_cast(tensor.primitive, dtype))\\n }\\n\\n // TODO: Implement float_prod and float_sum\\n // https://github.com/tracel-ai/burn/issues/1458\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"FloatTensor<Self>\"\n }\n ],\n \"end_line\": 2554,\n \"name\": \"float_repeat_dim\",\n \"signature\": \"fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self>\",\n \"start_line\": 2491\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_from_data(data, device))\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: burn_tensor::Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_random(shape, distribution, device))\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_zeros(shape, device))\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_ones(shape, device))\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n B::float_into_data(tensor.primitive).await\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n B::float_device(&tensor.primitive)\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ToDevice;\\n\\n impl<B: Backend> Backward<B, 1> for ToDevice {\\n type State = B::Device;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_to_device(grad, &ops.state)\\n });\\n }\\n }\\n\\n match ToDevice\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let device_old = B::float_device(&tensor.primitive);\\n prep.finish(device_old, B::float_to_device(tensor.primitive, device))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_to_device(tensor.primitive, device)),\\n }\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_empty(shape, device))\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Add;\\n\\n retro_binary!(RetroAdd, B::float_add);\\n\\n impl<B: Backend> Backward<B, 2> for Add {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(grad, &shape_rhs),\\n );\\n }\\n }\\n\\n match Add\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAdd::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_add(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_add(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct AddScalar;\\n\\n retro_unary_scalar!(RetroAddScalar, B::float_add_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for AddScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n AddScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAddScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_add_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sub;\\n\\n retro_binary!(RetroSub, B::float_sub);\\n\\n impl<B: Backend> Backward<B, 2> for Sub {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_lhs, shape_rhs) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| broadcast_shape::<B>(grad, &shape_lhs),\\n |grad| broadcast_shape::<B>(B::float_neg(grad), &shape_rhs),\\n );\\n }\\n }\\n\\n match Sub\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSub::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (lhs.primitive.shape(), rhs.primitive.shape()),\\n B::float_sub(lhs.primitive, rhs.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_sub(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SubScalar;\\n\\n retro_unary_scalar!(RetroSubScalar, B::float_sub_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for SubScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n SubScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSubScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_sub_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mul;\\n\\n retro_binary!(RetroMul, B::float_mul);\\n\\n impl<B: Backend> Backward<B, 2> for Mul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let grad = B::float_mul(grad, rhs.unwrap());\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let grad = B::float_mul(grad, lhs.unwrap());\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Mul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMul::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_mul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MulScalar;\\n\\n retro_unary_scalar!(RetroMulScalar, B::float_mul_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for MulScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul_scalar(grad, ops.state)\\n });\\n }\\n }\\n\\n match MulScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroMulScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_mul_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mul_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Div;\\n\\n retro_binary!(RetroDiv, B::float_div);\\n\\n impl<B: Backend> Backward<B, 2> for Div {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, rhs);\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = rhs_4lhs.unwrap();\\n let value = B::float_powf_scalar(rhs, -1.0);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let rhs = rhs_4rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_div(B::float_neg(lhs), B::float_powf_scalar(rhs, 2.0));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Div\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDiv::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_div(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct DivScalar;\\n\\n retro_unary_scalar!(RetroDivScalar, B::float_div_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for DivScalar {\\n type State = FloatElem<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = 1.0 / ops.state.elem::<f32>();\\n B::float_mul_scalar(grad, tmp.elem())\\n });\\n }\\n }\\n\\n match DivScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroDivScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(rhs, B::float_div_scalar(lhs.primitive, rhs)),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_div_scalar(lhs.primitive, rhs)),\\n }\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Rem;\\n\\n retro_binary!(RetroRem, B::float_remainder);\\n\\n impl<B: Backend> Backward<B, 2> for Rem {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n // remainder(x, y) = x - floor(x / y) * y\\n // partial(x - floor(x / y) * y, x) = 1\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n // partial(x - floor(x / y) * y, y) = - floor(x / y)\\n let rhs = rhs.unwrap();\\n let lhs = lhs.unwrap();\\n let value = B::float_neg(B::float_floor(B::float_div(lhs, rhs)));\\n let grad = B::float_mul(grad, value);\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Rem\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRem::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = (lhs_tracked || rhs_tracked).then(|| prep.checkpoint(&rhs));\\n\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_remainder(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_remainder(lhs.primitive, rhs.primitive))\\n }\\n }\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct RemainderScalar;\\n\\n retro_unary_scalar!(RetroRemainderScalar, B::float_remainder_scalar);\\n\\n impl<B: Backend> Backward<B, 1> for RemainderScalar {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| grad);\\n }\\n }\\n\\n RemainderScalar\\n .prepare::<C>([lhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRemainderScalar::<B>::new(lhs.node.id, rhs))\\n .parents([&lhs])\\n .stateless(B::float_remainder_scalar(lhs.primitive, rhs))\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Matmul;\\n\\n impl<B: Backend> Backward<B, 2> for Matmul {\\n type State = (Option<NodeID>, Option<NodeID>, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs, rhs, broadcast) = ops.state;\\n let lhs = lhs.map(|lhs| checkpointer.retrieve_node_output(lhs));\\n let rhs = rhs.map(|rhs| checkpointer.retrieve_node_output(rhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let rhs = B::float_transpose(rhs.unwrap());\\n let grad = B::float_matmul(grad, rhs);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n let lhs = B::float_transpose(lhs.unwrap());\\n let grad = B::float_matmul(lhs, grad);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let lhs_tracked = lhs.is_tracked();\\n let rhs_tracked = rhs.is_tracked();\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match Matmul\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = rhs_tracked.then(|| prep.checkpoint(&lhs));\\n let rhs_state = lhs_tracked.then(|| prep.checkpoint(&rhs));\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_matmul(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_matmul(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Neg;\\n\\n retro_unary!(RetroNeg, B::float_neg);\\n\\n impl<B: Backend> Backward<B, 1> for Neg {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| B::float_neg(grad));\\n }\\n }\\n\\n Neg.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroNeg::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_neg(tensor.primitive))\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Recip;\\n\\n retro_unary!(RetroRecip, B::float_recip);\\n\\n impl<B: Backend> Backward<B, 1> for Recip {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, -2.0);\\n let value = B::float_neg(tmp);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Recip\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRecip::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_recip(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_recip(tensor.primitive)),\\n }\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SwapDim;\\n\\n #[derive(new, Debug)]\\n struct RetroSwapDims<B: Backend> {\\n input_id: NodeID,\\n dim1: usize,\\n dim2: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSwapDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_swap_dims(input, self.dim1, self.dim2);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for SwapDim {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim1, dim2) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_swap_dims(grad, dim2, dim1)\\n });\\n }\\n }\\n\\n match SwapDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSwapDims::<B>::new(tensor.node.id, dim1, dim2))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim1, dim2),\\n B::float_swap_dims(tensor.primitive, dim1, dim2),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_swap_dims(tensor.primitive, dim1, dim2))\\n }\\n }\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PermuteDim;\\n\\n #[derive(new, Debug)]\\n struct RetroPermuteDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPermuteDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_permute(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PermuteDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n let mut inverse = vec![0usize; axes.len()];\\n axes.iter()\\n .enumerate()\\n .for_each(|(i, &axis)| inverse[axis] = i);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_permute(grad, &inverse)\\n });\\n }\\n }\\n\\n match PermuteDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPermuteDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_permute(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_permute(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct FlipDim;\\n\\n #[derive(new, Debug)]\\n struct RetroFlipDims<B: Backend> {\\n input_id: NodeID,\\n axes: Vec<usize>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroFlipDims<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_flip(input, &self.axes);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for FlipDim {\\n type State = Vec<usize>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let axes = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_flip(grad, &axes)\\n });\\n }\\n }\\n\\n match FlipDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFlipDims::<B>::new(tensor.node.id, axes.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n prep.finish(axes.to_vec(), B::float_flip(tensor.primitive, axes))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_flip(tensor.primitive, axes)),\\n }\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct ReshapeDim;\\n\\n #[derive(new, Debug)]\\n struct RetroReshape<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroReshape<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_reshape(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ReshapeDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_original, shape) = ops.state;\\n let ndims_out = shape.num_dims();\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n for i in 0..ndims_out {\\n if shape.dims[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_original)\\n });\\n }\\n }\\n\\n match ReshapeDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroReshape::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_reshape(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_reshape(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Gather;\\n\\n impl<B: Backend> Backward<B, 1> for Gather {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_scatter(dim, zeros, indices, grad)\\n });\\n }\\n }\\n\\n match Gather\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_gather(dim, tensor.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_gather(dim, tensor.primitive, indices))\\n }\\n }\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Scatter;\\n\\n impl<B: Backend> Backward<B, 2> for Scatter {\\n type State = (usize, IntTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape_lhs, shape_rhs, device) = ops.state;\\n let [indices_4lhs, indices_4rhs] = duplicate(&ops.parents, Some(indices));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs, &device);\\n B::float_scatter(dim, grad, indices_4lhs.unwrap(), zeros)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_scatter(dim, zeros, indices_4rhs.unwrap(), grad)\\n },\\n );\\n }\\n }\\n\\n match Scatter\\n .prepare::<C>([tensor.node, value.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_scatter(dim, tensor.primitive, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_scatter(\\n dim,\\n tensor.primitive,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Select;\\n\\n #[derive(new, Debug)]\\n struct RetroSelect<B: Backend> {\\n input_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelect<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_select(input, self.dim, self.indices.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Select {\\n type State = (usize, IntTensor<B>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_select_assign(zeros, dim, indices, grad)\\n });\\n }\\n }\\n\\n match Select\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelect::<B>::new(tensor.node.id, dim, indices.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n dim,\\n indices.clone(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_select(tensor.primitive, dim, indices),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_select(tensor.primitive, dim, indices))\\n }\\n }\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<B>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct IndexSelectDimAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSelectAssign<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n indices: IntTensor<B>,\\n value_id: NodeID,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSelectAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_select_assign(tensor, self.dim, self.indices.clone(), value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for IndexSelectDimAssign {\\n type State = (usize, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, indices) = ops.state;\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| grad,\\n |grad| B::float_select(grad, dim, indices),\\n );\\n }\\n }\\n\\n match IndexSelectDimAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSelectAssign::<B>::new(\\n tensor.node.id,\\n dim,\\n indices.clone(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, indices.clone()),\\n B::float_select_assign(tensor.primitive, dim, indices, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_select_assign(\\n tensor.primitive,\\n dim,\\n indices,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_slice(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Index;\\n\\n #[derive(new, Debug)]\\n struct RetroSlice<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSlice<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_slice(tensor, &self.ranges);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Index {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape, device) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let zeros = B::float_zeros(shape, &device);\\n B::float_slice_assign(zeros, &ranges, grad)\\n });\\n }\\n }\\n\\n match Index\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSlice::<B>::new(tensor.node.id, ranges.to_vec()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n tensor.primitive.shape(),\\n B::float_device(&tensor.primitive),\\n ),\\n B::float_slice(tensor.primitive, ranges),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice(tensor.primitive, ranges)),\\n }\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[core::ops::Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SliceAssign;\\n\\n #[derive(new, Debug)]\\n struct RetroSliceAssign<B: Backend> {\\n tensor_id: NodeID,\\n ranges: Vec<core::ops::Range<usize>>,\\n value_id: NodeID,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroSliceAssign<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let value = states.get_state::<B::FloatTensorPrimitive>(&self.value_id);\\n let out = B::float_slice_assign(tensor, &self.ranges, value);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for SliceAssign {\\n type State = (Vec<core::ops::Range<usize>>, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (ranges, shape_rhs, device) = ops.state;\\n let [ranges_4lhs, ranges_4rhs] = duplicate(&ops.parents, Some(ranges));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs, &device);\\n B::float_slice_assign(grad, &ranges_4lhs.unwrap(), zeros)\\n },\\n |grad| B::float_slice(grad, &ranges_4rhs.unwrap()),\\n );\\n }\\n }\\n\\n match SliceAssign\\n .prepare::<C>([tensor.node.clone(), value.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSliceAssign::<B>::new(\\n tensor.node.id,\\n ranges.to_vec(),\\n value.node.id,\\n ))\\n .parents([&tensor, &value])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n ranges.to_vec(),\\n value.primitive.shape(),\\n B::float_device(&value.primitive),\\n ),\\n B::float_slice_assign(tensor.primitive, ranges, value.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_slice_assign(\\n tensor.primitive,\\n ranges,\\n value.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n source: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskWhere;\\n\\n impl<B: Backend> Backward<B, 2> for MaskWhere {\\n type State = (BoolTensor<B>, Shape, Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (mask, shape_lhs, shape_rhs, device) = ops.state;\\n let [mask_4lhs, mask_4rhs] = duplicate(&ops.parents, Some(mask));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n let zeros = B::float_zeros(shape_lhs.clone(), &device);\\n let grad = B::float_mask_where(grad, mask_4lhs.unwrap(), zeros);\\n\\n broadcast_shape::<B>(grad, &shape_lhs)\\n },\\n |grad| {\\n let zeros = B::float_zeros(shape_rhs.clone(), &device);\\n let grad = B::float_mask_where(zeros, mask_4rhs.unwrap(), grad);\\n\\n broadcast_shape::<B>(grad, &shape_rhs)\\n },\\n );\\n }\\n }\\n\\n match MaskWhere\\n .prepare::<C>([tensor.node, source.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (\\n mask.clone(),\\n tensor.primitive.shape(),\\n source.primitive.shape(),\\n B::float_device(&source.primitive),\\n ),\\n B::float_mask_where(tensor.primitive, mask, source.primitive),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mask_where(\\n tensor.primitive,\\n mask,\\n source.primitive,\\n )),\\n }\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<B>,\\n value: FloatElem<B>,\\n ) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MaskFill;\\n\\n impl<B: Backend> Backward<B, 1> for MaskFill {\\n type State = BoolTensor<B>;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mask_fill(grad, ops.state, 0.elem())\\n });\\n }\\n }\\n\\n match MaskFill\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n mask.clone(),\\n B::float_mask_fill(tensor.primitive, mask, value),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_mask_fill(tensor.primitive, mask, value))\\n }\\n }\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_greater_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_greater_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<B> {\\n B::float_lower_equal(lhs.primitive, rhs.primitive)\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<B>) -> BoolTensor<B> {\\n B::float_lower_equal_elem(lhs.primitive, rhs)\\n }\\n\\n fn float_detach(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n // When we detach a tensor, we remove it from the graph, but we still want to keep the\\n // `require_grad` setting.\\n let is_require_grad = Self::float_is_require_grad(&tensor);\\n let tensor = AutodiffTensor::new(tensor.primitive);\\n\\n match is_require_grad {\\n true => tensor.require_grad(),\\n false => tensor,\\n }\\n }\\n\\n fn float_set_require_grad(tensor: FloatTensor<Self>, require_grad: bool) -> FloatTensor<Self> {\\n if require_grad {\\n return tensor.require_grad();\\n }\\n\\n AutodiffTensor::new(tensor.primitive)\\n }\\n\\n fn float_is_require_grad(tensor: &FloatTensor<Self>) -> bool {\\n matches!(tensor.node.requirement, Requirement::Grad)\\n }\\n\\n fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Mean;\\n\\n impl<B: Backend> Backward<B, 1> for Mean {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape = ops.state;\\n let val = 1_f64 / shape.num_elements() as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, val.elem());\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Mean.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_mean(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean(tensor.primitive)),\\n }\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sum;\\n\\n impl<B: Backend> Backward<B, 1> for Sum {\\n type State = Shape;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = B::float_ones(ops.state, &B::float_device(&grad));\\n\\n let grad = unsqueeze_like::<B>(grad, val.shape());\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match Sum.prepare::<C>([tensor.node]).compute_bound().stateful() {\\n OpsKind::Tracked(prep) => {\\n prep.finish(tensor.primitive.shape(), B::float_sum(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum(tensor.primitive)),\\n }\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct MeanDim;\\n\\n impl<B: Backend> Backward<B, 1> for MeanDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let val = 1_f64 / shape.dims[dim] as f64;\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let val = B::float_mul_scalar(ones, B::FloatElem::from_elem(val));\\n\\n let grad = B::float_sum_dim(grad, dim);\\n B::float_mul(val, grad)\\n });\\n }\\n }\\n\\n match MeanDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_mean_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_mean_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct SumDim;\\n\\n impl<B: Backend> Backward<B, 1> for SumDim {\\n type State = (Shape, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, dim) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ones = B::float_ones(shape, &B::float_device(&grad));\\n let grad = B::float_sum_dim(grad, dim);\\n\\n B::float_mul(ones, grad)\\n });\\n }\\n }\\n\\n match SumDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), dim),\\n B::float_sum_dim(tensor.primitive, dim),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sum_dim(tensor.primitive, dim)),\\n }\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmax(tensor.primitive, dim)\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<B> {\\n B::float_argmin(tensor.primitive, dim)\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Exp;\\n\\n retro_unary!(RetroExp, B::float_exp);\\n\\n impl<B: Backend> Backward<B, 1> for Exp {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let output = B::float_exp(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, output)\\n });\\n }\\n }\\n\\n match Exp\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExp::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_exp(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_exp(tensor.primitive)),\\n }\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log;\\n\\n retro_unary!(RetroLog, B::float_log);\\n\\n impl<B: Backend> Backward<B, 1> for Log {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_powf_scalar(input, -1.0);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log(tensor.primitive)),\\n }\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Log1P;\\n\\n retro_unary!(RetroLog1P, B::float_log1p);\\n\\n impl<B: Backend> Backward<B, 1> for Log1P {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(input, 1.elem());\\n let value = B::float_powf_scalar(value, -1.0);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Log1P\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroLog1P::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_log1p(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_log1p(tensor.primitive)),\\n }\\n }\\n\\n fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowfScalar;\\n\\n #[derive(new, Debug)]\\n struct RetroPowfScalar<B: Backend> {\\n lhs_id: NodeID,\\n rhs: f32,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroPowfScalar<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let lhs = states.get_state::<B::FloatTensorPrimitive>(&self.lhs_id);\\n let out = B::float_powf_scalar(lhs, self.rhs);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for PowfScalar {\\n type State = (NodeID, f32);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (tensor_id, value) = ops.state;\\n let tensor = checkpointer.retrieve_node_output(tensor_id);\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let tmp = B::float_powf_scalar(tensor, value - 1.0);\\n let value = B::float_mul_scalar(tmp, value.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match PowfScalar\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowfScalar::<B>::new(tensor.node.id, value))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = (prep.checkpoint(&tensor), value);\\n prep.finish(state, B::float_powf_scalar(tensor.primitive, value))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf_scalar(tensor.primitive, value)),\\n }\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sqrt;\\n\\n retro_unary!(RetroSqrt, B::float_sqrt);\\n\\n impl<B: Backend> Backward<B, 1> for Sqrt {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_div_scalar(B::float_powf_scalar(input, -0.5), 2.elem());\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sqrt\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSqrt::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sqrt(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sqrt(tensor.primitive)),\\n }\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Abs;\\n\\n retro_unary!(RetroAbs, B::float_abs);\\n\\n impl<B: Backend> Backward<B, 1> for Abs {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let tensor: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_sign(tensor);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::float_mul(grad, state)\\n });\\n }\\n }\\n\\n match Abs\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroAbs::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_abs(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_abs(tensor.primitive)),\\n }\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Cos;\\n\\n retro_unary!(RetroCos, B::float_cos);\\n\\n impl<B: Backend> Backward<B, 1> for Cos {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_neg(B::float_sin(input));\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Cos\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCos::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_cos(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_cos(tensor.primitive)),\\n }\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sin;\\n\\n retro_unary!(RetroSin, B::float_sin);\\n\\n impl<B: Backend> Backward<B, 1> for Sin {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let state = checkpointer.retrieve_node_output(ops.state);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_cos(state);\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Sin\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSin::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_sin(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_sin(tensor.primitive)),\\n }\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Tanh;\\n\\n retro_unary!(RetroTanh, B::float_tanh);\\n\\n impl<B: Backend> Backward<B, 1> for Tanh {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let input = checkpointer.retrieve_node_output(ops.state);\\n let state = B::float_tanh(input);\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let value = B::float_add_scalar(\\n B::float_neg(B::float_powf_scalar(state, 2.0)),\\n 1.elem(),\\n );\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Tanh\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroTanh::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_tanh(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_tanh(tensor.primitive)),\\n }\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Round;\\n retro_unary!(RetroRound, B::float_round);\\n\\n impl<B: Backend> Backward<B, 1> for Round {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Round\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRound::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_round(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_round(tensor.primitive)),\\n }\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Floor;\\n retro_unary!(RetroFloor, B::float_floor);\\n\\n impl<B: Backend> Backward<B, 1> for Floor {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Floor\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroFloor::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Ceil;\\n retro_unary!(RetroCeil, B::float_ceil);\\n\\n impl<B: Backend> Backward<B, 1> for Ceil {\\n type State = (Shape, B::Device);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape, device) = ops.state;\\n unary::<B, _>(ops.parents, ops.node, grads, |_grad| {\\n B::float_zeros(shape, &device)\\n })\\n }\\n }\\n\\n match Ceil\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroCeil::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(preps) => preps.finish(\\n (tensor.primitive.shape(), B::float_device(&tensor.primitive)),\\n B::float_floor(tensor.primitive),\\n ),\\n OpsKind::UnTracked(preps) => preps.finish(B::float_floor(tensor.primitive)),\\n }\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Erf;\\n\\n retro_unary!(RetroErf, B::float_erf);\\n\\n impl<B: Backend> Backward<B, 1> for Erf {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let ops = checkpointer.retrieve_node_output(ops.state);\\n let exponent = B::float_neg(B::float_powf_scalar(ops, 2.0));\\n let numerator = B::float_mul_scalar(B::float_exp(exponent), 2.0.elem());\\n let denominator = core::f64::consts::PI.sqrt().elem();\\n let value = B::float_div_scalar(numerator, denominator);\\n\\n B::float_mul(grad, value)\\n });\\n }\\n }\\n\\n match Erf\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroErf::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let state = prep.checkpoint(&tensor);\\n prep.finish(state, B::float_erf(tensor.primitive))\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_erf(tensor.primitive)),\\n }\\n }\\n\\n fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {\\n #[derive(new, Debug)]\\n struct CatStep<B: Backend> {\\n nodes: Vec<Option<NodeRef>>,\\n // The dimension of each tensor along the dim dimension.\\n // This indicates the number of dimension concatenated for each tensor.\\n dim_sizes: Vec<usize>,\\n output: NodeRef,\\n phantom: PhantomData<B>,\\n dim: usize,\\n }\\n\\n impl<B: Backend> Step for CatStep<B> {\\n fn step(self: Box<Self>, grads: &mut Gradients, _checkpointer: &mut Checkpointer) {\\n let grad = grads.consume::<B>(&self.output);\\n let ranges: Vec<_> = grad.shape().dims.iter().map(|v| 0..*v).collect();\\n\\n let mut current_index = 0;\\n\\n self.nodes\\n .into_iter()\\n .zip(self.dim_sizes)\\n .filter_map(|(node, dim_size)| node.map(|node| (node, dim_size)))\\n .for_each(|(node, dim_size)| {\\n let mut ranges = ranges.clone();\\n ranges[self.dim] = current_index..dim_size + current_index;\\n current_index += dim_size;\\n grads.register::<B>(node.id, B::float_slice(grad.clone(), &ranges));\\n });\\n }\\n\\n fn node(&self) -> NodeID {\\n self.output.id\\n }\\n\\n fn parents(&self) -> Vec<NodeID> {\\n self.nodes\\n .iter()\\n .filter_map(|node| node.clone())\\n .map(|node| node.id)\\n .collect()\\n }\\n fn depth(&self) -> usize {\\n self.output.order\\n }\\n }\\n\\n let mut nodes = Vec::with_capacity(tensors.len());\\n let mut primitives = Vec::with_capacity(tensors.len());\\n let mut dim_sizes = Vec::with_capacity(tensors.len());\\n\\n tensors.into_iter().for_each(|tensor| {\\n dim_sizes.push(tensor.primitive.shape().dims[dim]);\\n nodes.push(tensor.node);\\n primitives.push(tensor.primitive);\\n });\\n\\n let requirement = Requirement::from_nodes(&nodes);\\n\\n // For simplicity, this operation does not checkpoint anything\\n let cat_computing_property = ComputingProperty::Ambiguous;\\n let checkpointer_builder = CheckpointerBuilder::default();\\n\\n let output = B::float_cat(primitives, dim);\\n if requirement.is_none() {\\n return AutodiffTensor::from_parents(\\n output,\\n &nodes,\\n requirement,\\n cat_computing_property,\\n );\\n }\\n\\n let output =\\n AutodiffTensor::from_parents(output, &nodes, requirement, cat_computing_property);\\n let nodes = nodes\\n .into_iter()\\n .map(|node| node.clone_if_require_grad())\\n .collect::<Vec<_>>();\\n\\n let ops = CatStep::<B>::new(nodes, dim_sizes, output.node.clone(), dim);\\n output.register_step(ops, checkpointer_builder)\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_max_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_max_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_max_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n prep.finish((index, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_min_dim(tensor.primitive, dim)),\\n }\\n }\\n fn float_min_dim_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match MaxMinDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish((index.clone(), shape), tensor);\\n\\n (tensor, index)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, index) = B::float_min_dim_with_indices(tensor.primitive, dim);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, index)\\n }\\n }\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> <Autodiff<B> as Backend>::IntTensorPrimitive {\\n B::float_into_int(tensor.primitive)\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct PowF;\\n\\n retro_binary!(RetroPowf, B::float_powf);\\n\\n impl<B: Backend> Backward<B, 2> for PowF {\\n type State = (NodeID, NodeID, BinaryOpsBroadcast);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let (lhs_id, rhs_id, broadcast) = ops.state;\\n let lhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(lhs_id);\\n let rhs: B::FloatTensorPrimitive = checkpointer.retrieve_node_output(rhs_id);\\n\\n // Both lhs and rhs are needed for both lhs and rhs gradients, but we clone them\\n // the number of times required by the parents specification.\\n let [rhs_4lhs, rhs_4rhs] = duplicate(&ops.parents, Some(rhs));\\n let [lhs_4lhs, lhs_4rhs] = duplicate(&ops.parents, Some(lhs));\\n\\n binary::<B, _, _>(\\n ops.parents,\\n ops.node,\\n grads,\\n |grad| {\\n //rhs*(lhs.val**(rhs-1))*grad\\n let rhs1 = rhs_4lhs.unwrap();\\n let rhs2 = rhs1.clone();\\n let lhs = lhs_4lhs.unwrap();\\n\\n let tmp = B::float_powf(\\n lhs,\\n B::float_sub_scalar(rhs1, B::FloatElem::from_elem(1.0)),\\n );\\n let value = B::float_mul(tmp, rhs2);\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_lhs::<B>(grad)\\n },\\n |grad| {\\n //lhs**rhs * ln(lhs) * grad\\n let rhs = rhs_4rhs.unwrap();\\n let lhs1 = lhs_4rhs.unwrap();\\n let lhs2 = lhs1.clone();\\n let tmp = B::float_powf(lhs1, rhs);\\n let value = B::float_mul(tmp, B::float_log(lhs2));\\n let grad = B::float_mul(grad, value);\\n\\n broadcast.backward_rhs::<B>(grad)\\n },\\n );\\n }\\n }\\n\\n let broadcast = BinaryOpsBroadcast::new::<B>(&lhs.primitive, &rhs.primitive);\\n\\n match PowF\\n .prepare::<C>([lhs.node.clone(), rhs.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroPowf::<B>::new(lhs.node.id, rhs.node.id))\\n .parents([&lhs, &rhs])\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let lhs_state = prep.checkpoint(&lhs);\\n let rhs_state = prep.checkpoint(&rhs);\\n prep.finish(\\n (lhs_state, rhs_state, broadcast),\\n B::float_powf(lhs.primitive, rhs.primitive),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::float_powf(lhs.primitive, rhs.primitive)),\\n }\\n }\\n\\n fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Sign;\\n\\n retro_unary!(RetroSign, B::float_sign);\\n\\n impl<B: Backend> Backward<B, 1> for Sign {\\n type State = ();\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n unary::<B, _>(ops.parents, ops.node, grads, |grad|\\n // Always return 0 because the derivative of the sign function\\n // does not contribute to gradient updates in a meaningful way.\\n B::float_mul_scalar(grad, 0.elem()));\\n }\\n }\\n\\n Sign.prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroSign::<B>::new(tensor.node.id))\\n .parents([&tensor])\\n .stateless(B::float_sign(tensor.primitive))\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n // D1: tensor, D2: shape\\n #[derive(Debug)]\\n struct ExpandDim;\\n\\n #[derive(new, Debug)]\\n struct RetroExpand<B: Backend> {\\n input_id: NodeID,\\n shape: Shape,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroExpand<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let input = states.get_state::<B::FloatTensorPrimitive>(&self.input_id);\\n let out = B::float_expand(input, self.shape.clone());\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for ExpandDim {\\n type State = (Shape, Shape);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (shape_in, shape_out) = ops.state;\\n let ndims_in = shape_in.num_dims();\\n let ndims_out = shape_out.num_dims();\\n\\n let mut shape_expanded = vec![1; ndims_out];\\n\\n debug_assert!(ndims_out >= ndims_in);\\n\\n for i in 0..ndims_in {\\n shape_expanded[i + (ndims_out - ndims_in)] = shape_in.dims[i];\\n }\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let shape_grad = grad.shape();\\n let mut grad = grad;\\n\\n #[allow(clippy::needless_range_loop)]\\n for i in 0..ndims_out {\\n if shape_expanded[i] == 1 && shape_grad.dims[i] != 1 {\\n grad = B::float_sum_dim(grad, i);\\n }\\n }\\n\\n B::float_reshape(grad, shape_in)\\n });\\n }\\n }\\n\\n match ExpandDim\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroExpand::<B>::new(tensor.node.id, shape.clone()))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (tensor.primitive.shape(), shape.clone()),\\n B::float_expand(tensor.primitive, shape),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::float_expand(tensor.primitive, shape)),\\n }\\n }\\n\\n fn float_sort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> FloatTensor<Self> {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n prep.finish((indices, shape), tensor)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_sort(tensor.primitive, dim, descending))\\n }\\n }\\n }\\n\\n fn float_sort_with_indices(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n descending: bool,\\n ) -> (FloatTensor<Self>, IntTensor<B>) {\\n match super::sort::SortDim\\n .prepare::<C>([tensor.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => {\\n let shape = tensor.primitive.shape();\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish((indices.clone(), shape), tensor);\\n\\n (tensor, indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let (tensor, indices) =\\n B::float_sort_with_indices(tensor.primitive, dim, descending);\\n let tensor = prep.finish(tensor);\\n\\n (tensor, indices)\\n }\\n }\\n }\\n\\n fn float_argsort(tensor: FloatTensor<Self>, dim: usize, descending: bool) -> IntTensor<B> {\\n B::float_argsort(tensor.primitive, dim, descending)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n #[derive(Debug)]\\n struct Repeat;\\n\\n #[derive(new, Debug)]\\n struct RetroRepeat<B: Backend> {\\n tensor_id: NodeID,\\n dim: usize,\\n times: usize,\\n _backend: PhantomData<B>,\\n }\\n\\n impl<B: Backend> RetroForward for RetroRepeat<B> {\\n fn forward(&self, states: &mut BackwardStates, out_node: NodeID) {\\n let tensor = states.get_state::<B::FloatTensorPrimitive>(&self.tensor_id);\\n let out = B::float_repeat_dim(tensor, self.dim, self.times);\\n states.save(out_node, out)\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 1> for Repeat {\\n type State = (usize, usize);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (dim, times) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n let mut dims = grad.shape().dims;\\n let orig_dim_size = dims[dim] / times;\\n if orig_dim_size > 1 {\\n dims[dim] = orig_dim_size;\\n let orig_dims = dims.clone();\\n dims.insert(dim + 1, times); // shape [..., orig_dim_size, times, ...]\\n let grad = B::float_reshape(grad, Shape::from(dims));\\n let grad = B::float_sum_dim(grad, dim + 1); // sum over repeat times\\n B::float_reshape(grad, Shape::from(orig_dims))\\n } else {\\n B::float_sum_dim(grad, dim)\\n }\\n });\\n }\\n }\\n\\n match Repeat\\n .prepare::<C>([tensor.node.clone()])\\n .memory_bound()\\n .retro_forward(RetroRepeat::<B>::new(tensor.node.id, dim, times))\\n .parents([&tensor])\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (dim, times),\\n B::float_repeat_dim(tensor.primitive, dim, times),\\n ),\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::float_repeat_dim(tensor.primitive, dim, times))\\n }\\n }\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: burn_tensor::FloatDType) -> FloatTensor<Self> {\\n AutodiffTensor::new(B::float_cast(tensor.primitive, dtype))\\n }\\n\\n // TODO: Implement float_prod and float_sum\\n // https://github.com/tracel-ai/burn/issues/1458\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C>\"\n}"}}},{"rowIdx":136,"cells":{"function_name":{"kind":"string","value":"embedding"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weights\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 47,\n \"name\": \"embedding\",\n \"signature\": \"fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B>\",\n \"start_line\": 15\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":137,"cells":{"function_name":{"kind":"string","value":"conv1d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 178,\n \"name\": \"conv1d\",\n \"signature\": \"fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 57\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":138,"cells":{"function_name":{"kind":"string","value":"conv_transpose1d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 313,\n \"name\": \"conv_transpose1d\",\n \"signature\": \"fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 180\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":139,"cells":{"function_name":{"kind":"string","value":"conv2d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 439,\n \"name\": \"conv2d\",\n \"signature\": \"fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 315\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":140,"cells":{"function_name":{"kind":"string","value":"deform_conv2d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"offset\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"mask\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 764,\n \"name\": \"deform_conv2d\",\n \"signature\": \"fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 441\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":141,"cells":{"function_name":{"kind":"string","value":"conv_transpose2d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 913,\n \"name\": \"conv_transpose2d\",\n \"signature\": \"fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 778\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":142,"cells":{"function_name":{"kind":"string","value":"conv3d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 1039,\n \"name\": \"conv3d\",\n \"signature\": \"fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 915\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":143,"cells":{"function_name":{"kind":"string","value":"conv_transpose3d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"weight\",\n \"type\": \"AutodiffTensor<B>\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"bias\",\n \"type\": \"Option<AutodiffTensor<B>>\"\n }\n ],\n \"end_line\": 1176,\n \"name\": \"conv_transpose3d\",\n \"signature\": \"fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 1041\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":144,"cells":{"function_name":{"kind":"string","value":"avg_pool1d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1257,\n \"name\": \"avg_pool1d\",\n \"signature\": \"fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 1193\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":145,"cells":{"function_name":{"kind":"string","value":"avg_pool2d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1323,\n \"name\": \"avg_pool2d\",\n \"signature\": \"fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 1259\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":146,"cells":{"function_name":{"kind":"string","value":"max_pool1d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1372,\n \"name\": \"max_pool1d\",\n \"signature\": \"fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 1336\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":147,"cells":{"function_name":{"kind":"string","value":"max_pool1d_with_indices"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1413,\n \"name\": \"max_pool1d_with_indices\",\n \"signature\": \"fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self>\",\n \"start_line\": 1374\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":148,"cells":{"function_name":{"kind":"string","value":"max_pool2d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1472,\n \"name\": \"max_pool2d\",\n \"signature\": \"fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 1436\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":149,"cells":{"function_name":{"kind":"string","value":"max_pool2d_with_indices"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1514,\n \"name\": \"max_pool2d_with_indices\",\n \"signature\": \"fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self>\",\n \"start_line\": 1474\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":150,"cells":{"function_name":{"kind":"string","value":"adaptive_avg_pool1d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1564,\n \"name\": \"adaptive_avg_pool1d\",\n \"signature\": \"fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B>\",\n \"start_line\": 1527\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":151,"cells":{"function_name":{"kind":"string","value":"adaptive_avg_pool2d"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1603,\n \"name\": \"adaptive_avg_pool2d\",\n \"signature\": \"fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B>\",\n \"start_line\": 1566\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":152,"cells":{"function_name":{"kind":"string","value":"interpolate"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/ops/module.rs"},"focal_code":{"kind":"string","value":"fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::Autodiff;\nuse crate::checkpoint::base::Checkpointer;\nuse crate::checkpoint::strategy::CheckpointStrategy;\nuse crate::grads::Gradients;\nuse crate::graph::NodeID;\nuse crate::ops::{Backward, Ops, unary};\nuse crate::tensor::AutodiffTensor;\n\nuse burn_tensor::backend::Backend;\nuse burn_tensor::ops::*;\n\nuse super::OpsKind;\n\nimpl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n _checkpointer: &mut Checkpointer,\n ) {\n let (weights, indices) = ops.state;\n\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\n B::embedding_backward(weights, grad, indices)\n });\n }\n }\n\n match Embedding\n .prepare::<C>([weights.node])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(prep) => prep.finish(\n (weights.primitive.clone(), indices.clone()),\n B::embedding(weights.primitive, indices),\n ),\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\n }\n }\n\n fn embedding_backward(\n _weights: AutodiffTensor<B>,\n _output: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate embedding backward.\");\n }\n\n fn conv1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv1DWithBias;\n #[derive(Debug)]\n struct Conv1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\n type State = (NodeID, NodeID, ConvOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv1d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n match bias {\n Some(bias) => match Conv1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose1d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<1>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose1DWithBias;\n #[derive(Debug)]\n struct ConvTranspose1DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose1d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose1DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose1DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv2DWithBias;\n #[derive(Debug)]\n struct Conv2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\n type State = (NodeID, NodeID, ConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv2d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv2d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn deform_conv2d(\n x: AutodiffTensor<B>,\n offset: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n mask: Option<AutodiffTensor<B>>,\n bias: Option<AutodiffTensor<B>>,\n options: DeformConvOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct DeformConv2DWithMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DWithMaskNoBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskWithBias;\n #[derive(Debug)]\n struct DeformConv2DNoMaskNoBias;\n\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 5>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\n ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_mask {\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 4>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n if let Some(node) = node_bias {\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\n }\n }\n }\n\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_offset, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, offset_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n let offset = checkpointer.retrieve_node_output(offset_state);\n let weight = checkpointer.retrieve_node_output(weight_state);\n\n let backward =\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\n\n if let Some(node) = node_x {\n grads.register::<B>(node.id, backward.x_grad)\n }\n if let Some(node) = node_offset {\n grads.register::<B>(node.id, backward.offset_grad)\n }\n if let Some(node) = node_weight {\n grads.register::<B>(node.id, backward.weight_grad)\n }\n }\n }\n\n match (mask, bias) {\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n Some(bias.primitive),\n options,\n )),\n },\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n mask.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let mask_state = prep.checkpoint(&mask);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n mask_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n Some(mask.primitive),\n None,\n options,\n )),\n },\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\n .prepare::<C>([\n x.node.clone(),\n offset.node.clone(),\n weight.node.clone(),\n bias.node.clone(),\n ])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (\n x_state,\n offset_state,\n weight_state,\n bias_state,\n options.clone(),\n ),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n Some(bias.primitive),\n options,\n )),\n },\n (None, None) => match DeformConv2DNoMaskNoBias\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let offset_state = prep.checkpoint(&offset);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, offset_state, weight_state, options.clone()),\n B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\n x.primitive,\n offset.primitive,\n weight.primitive,\n None,\n None,\n options,\n )),\n },\n }\n }\n\n fn deform_conv2d_backward(\n _x: AutodiffTensor<B>,\n _offset: AutodiffTensor<B>,\n _weight: AutodiffTensor<B>,\n _mask: Option<AutodiffTensor<B>>,\n _bias: Option<AutodiffTensor<B>>,\n _output_grad: AutodiffTensor<B>,\n _options: DeformConvOptions<2>,\n ) -> DeformConv2dBackward<Self> {\n panic!(\"Can't differentiate deform conv 2d backward.\");\n }\n\n fn conv_transpose2d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<2>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose2DWithBias;\n #[derive(Debug)]\n struct ConvTranspose2DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose2d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose2DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose2DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n fn conv3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Conv3DWithBias;\n #[derive(Debug)]\n struct Conv3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad =\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\n type State = (NodeID, NodeID, ConvOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv3d_x_backward(\n x.clone(),\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match Conv3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match Conv3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv3d(x.primitive, weight.primitive, None, options),\n )\n }\n\n OpsKind::UnTracked(prep) => {\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\n }\n },\n }\n }\n\n fn conv_transpose3d(\n x: AutodiffTensor<B>,\n weight: AutodiffTensor<B>,\n bias: Option<AutodiffTensor<B>>,\n options: ConvTransposeOptions<3>,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct ConvTranspose3DWithBias;\n #[derive(Debug)]\n struct ConvTranspose3DNoBias;\n\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 3>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight, node_bias] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, bias_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(\n x.clone(),\n weight,\n grad.clone(),\n options,\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_bias {\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\n\n fn backward(\n self,\n ops: Ops<Self::State, 2>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_x, node_weight] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, weight_state, options) = ops.state;\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\n let weight =\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\n\n if let Some(node) = node_x {\n let grad = B::conv_transpose3d_x_backward(\n weight.clone(),\n grad.clone(),\n options.clone(),\n );\n grads.register::<B>(node.id, grad)\n }\n if let Some(node) = node_weight {\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\n grads.register::<B>(node.id, grad)\n }\n }\n }\n\n match bias {\n Some(bias) => match ConvTranspose3DWithBias\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n let bias_state = prep.checkpoint(&bias);\n\n prep.finish(\n (x_state, weight_state, bias_state, options.clone()),\n B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n Some(bias.primitive),\n options,\n )),\n },\n None => match ConvTranspose3DNoBias\n .prepare::<C>([x.node.clone(), weight.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let weight_state = prep.checkpoint(&weight);\n\n prep.finish(\n (x_state, weight_state, options.clone()),\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\n x.primitive,\n weight.primitive,\n None,\n options,\n )),\n },\n }\n }\n\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\n //\n // We don't override it now because the fold operation isn't available for the backward pass.\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\n //\n // fn unfold4d(\n // x:AutodiffTensor<B>,\n // kernel_size: [usize; 2],\n // options: UnfoldOptions,\n // ) -> AutodiffTensor<B> {\n // todo!()\n // }\n\n fn avg_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\n type State = (NodeID, usize, usize, usize, bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool1d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool1d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::avg_pool2d_backward(\n x,\n grad,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n );\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(\n (x_state, kernel_size, stride, padding, count_include_pad),\n B::avg_pool2d(\n x.primitive.clone(),\n kernel_size,\n stride,\n padding,\n count_include_pad,\n ),\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n count_include_pad,\n )),\n }\n }\n\n fn avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _count_include_pad: bool,\n ) -> AutodiffTensor<B> {\n panic!(\"Can't differentiate avg pool 2d backward.\");\n }\n\n fn max_pool1d(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> AutodiffTensor<B> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool1d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n ) -> MaxPool1dWithIndices<Self> {\n match MaxPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool1dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool1d_with_indices_backward(\n x: AutodiffTensor<B>,\n kernel_size: usize,\n stride: usize,\n padding: usize,\n dilation: usize,\n output_grad: AutodiffTensor<B>,\n indices: IntTensor<B>,\n ) -> MaxPool1dBackward<Self> {\n let output = B::max_pool1d_with_indices_backward(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n output_grad.primitive,\n indices,\n );\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\n }\n\n fn max_pool2d(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> AutodiffTensor<B> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n prep.finish(\n (\n x_state,\n output.indices,\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n )\n }\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\n x.primitive,\n kernel_size,\n stride,\n padding,\n dilation,\n )),\n }\n }\n\n fn max_pool2d_with_indices(\n x: AutodiffTensor<B>,\n kernel_size: [usize; 2],\n stride: [usize; 2],\n padding: [usize; 2],\n dilation: [usize; 2],\n ) -> MaxPool2dWithIndices<Self> {\n match MaxPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n\n let output_tensor = prep.finish(\n (\n x_state,\n output.indices.clone(),\n kernel_size,\n stride,\n padding,\n dilation,\n ),\n output.output,\n );\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n OpsKind::UnTracked(prep) => {\n let output =\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\n let output_tensor = prep.finish(output.output);\n\n MaxPool2dWithIndices::new(output_tensor, output.indices)\n }\n }\n }\n\n fn max_pool2d_with_indices_backward(\n _x: AutodiffTensor<B>,\n _kernel_size: [usize; 2],\n _stride: [usize; 2],\n _padding: [usize; 2],\n _dilation: [usize; 2],\n _output_grad: AutodiffTensor<B>,\n _indices: IntTensor<B>,\n ) -> MaxPool2dBackward<Self> {\n panic!(\"Can't differentiate max pool2d with indices backward.\");\n }\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool1D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool1D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct AdaptiveAvgPool2D;\n\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\n type State = NodeID;\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let state = checkpointer.retrieve_node_output(ops.state);\n\n if let Some(node) = node_parent {\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match AdaptiveAvgPool2D\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\n }\n }\n }\n\n fn adaptive_avg_pool2d_backward(\n _x: AutodiffTensor<B>,\n _grad: AutodiffTensor<B>,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate adaptive avg pool2d backward.\");\n }\n\n fn interpolate(\n x: AutodiffTensor<B>,\n output_size: [usize; 2],\n options: InterpolateOptions,\n ) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Interpolate;\n impl<B: Backend> Backward<B, 1> for Interpolate {\n type State = (NodeID, [usize; 2], InterpolateOptions);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n\n let (x_state, output_size, options) = ops.state;\n let state = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::interpolate_backward(state, grad, output_size, options);\n grads.register::<B>(node.id, grad);\n }\n }\n }\n\n match Interpolate\n .prepare::<C>([x.node.clone()])\n .compute_bound()\n .stateful()\n {\n OpsKind::Tracked(mut prep) => {\n let x_state = prep.checkpoint(&x);\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\n prep.finish((x_state, output_size, options), output)\n }\n OpsKind::UnTracked(prep) => {\n prep.finish(B::interpolate(x.primitive, output_size, options))\n }\n }\n }\n\n fn interpolate_backward(\n _x: FloatTensor<Autodiff<B, C>>,\n _grad: FloatTensor<Autodiff<B, C>>,\n _output_size: [usize; 2],\n _options: InterpolateOptions,\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\n panic!(\"Can't differentiate interpolate backward.\");\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool1D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool1D {\n type State = (NodeID, IntTensor<B>, usize, usize, usize, usize);\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool1d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n\n#[derive(Debug)]\nstruct MaxPool2D;\n\nimpl<B: Backend> Backward<B, 1> for MaxPool2D {\n type State = (\n NodeID,\n IntTensor<B>,\n [usize; 2],\n [usize; 2],\n [usize; 2],\n [usize; 2],\n );\n\n fn backward(\n self,\n ops: Ops<Self::State, 1>,\n grads: &mut Gradients,\n checkpointer: &mut Checkpointer,\n ) {\n let [node_parent] = ops.parents;\n let grad = grads.consume::<B>(&ops.node);\n let (x_state, indices, kernel_size, stride, padding, dilation) = ops.state;\n let x = checkpointer.retrieve_node_output(x_state);\n\n if let Some(node) = node_parent {\n let grad = B::max_pool2d_with_indices_backward(\n x,\n kernel_size,\n stride,\n padding,\n dilation,\n grad,\n indices,\n );\n\n grads.register::<B>(node.id, grad.x_grad);\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct AutodiffTensor<B: Backend> {\\n pub primitive: B::FloatTensorPrimitive,\\n pub node: NodeRef,\\n pub rc: NodeRefCount,\\n}\"\n ],\n \"name\": \"x\",\n \"type\": \"AutodiffTensor<B>\"\n }\n ],\n \"end_line\": 1655,\n \"name\": \"interpolate\",\n \"signature\": \"fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B>\",\n \"start_line\": 1612\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Embedding;\\n\\n impl<B: Backend> Backward<B, 1> for Embedding {\\n type State = (B::FloatTensorPrimitive, IntTensor<B>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n _checkpointer: &mut Checkpointer,\\n ) {\\n let (weights, indices) = ops.state;\\n\\n unary::<B, _>(ops.parents, ops.node, grads, |grad| {\\n B::embedding_backward(weights, grad, indices)\\n });\\n }\\n }\\n\\n match Embedding\\n .prepare::<C>([weights.node])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(prep) => prep.finish(\\n (weights.primitive.clone(), indices.clone()),\\n B::embedding(weights.primitive, indices),\\n ),\\n OpsKind::UnTracked(prep) => prep.finish(B::embedding(weights.primitive, indices)),\\n }\\n }\\n\\n fn embedding_backward(\\n _weights: AutodiffTensor<B>,\\n _output: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate embedding backward.\\\");\\n }\\n\\n fn conv1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv1DWithBias;\\n #[derive(Debug)]\\n struct Conv1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x.clone(), weight, grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv1DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv1d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n match bias {\\n Some(bias) => match Conv1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv1d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose1d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<1>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose1DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose1DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose1DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose1d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose1DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<1>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose1d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose1d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose1DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose1DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose1d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose1d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv2DWithBias;\\n #[derive(Debug)]\\n struct Conv2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv2d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv2d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv2DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv2d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv2d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn deform_conv2d(\\n x: AutodiffTensor<B>,\\n offset: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n mask: Option<AutodiffTensor<B>>,\\n bias: Option<AutodiffTensor<B>>,\\n options: DeformConvOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DWithMaskNoBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskWithBias;\\n #[derive(Debug)]\\n struct DeformConv2DNoMaskNoBias;\\n\\n impl<B: Backend> Backward<B, 5> for DeformConv2DWithMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 5>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, bias_state, options) =\\n ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DWithMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_mask] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, mask_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let mask = Some(checkpointer.retrieve_node_output(mask_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, mask, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_mask {\\n grads.register::<B>(node.id, backward.mask_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 4> for DeformConv2DNoMaskWithBias {\\n type State = (NodeID, NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 4>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n let bias = Some(checkpointer.retrieve_node_output(bias_state));\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, bias, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n if let Some(node) = node_bias {\\n grads.register::<B>(node.id, backward.bias_grad.unwrap())\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 3> for DeformConv2DNoMaskNoBias {\\n type State = (NodeID, NodeID, NodeID, DeformConvOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_offset, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, offset_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n let offset = checkpointer.retrieve_node_output(offset_state);\\n let weight = checkpointer.retrieve_node_output(weight_state);\\n\\n let backward =\\n B::deform_conv2d_backward(x, offset, weight, None, None, grad, options);\\n\\n if let Some(node) = node_x {\\n grads.register::<B>(node.id, backward.x_grad)\\n }\\n if let Some(node) = node_offset {\\n grads.register::<B>(node.id, backward.offset_grad)\\n }\\n if let Some(node) = node_weight {\\n grads.register::<B>(node.id, backward.weight_grad)\\n }\\n }\\n }\\n\\n match (mask, bias) {\\n (Some(mask), Some(bias)) => match DeformConv2DWithMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (Some(mask), None) => match DeformConv2DWithMaskNoBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n mask.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let mask_state = prep.checkpoint(&mask);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n mask_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n Some(mask.primitive),\\n None,\\n options,\\n )),\\n },\\n (None, Some(bias)) => match DeformConv2DNoMaskWithBias\\n .prepare::<C>([\\n x.node.clone(),\\n offset.node.clone(),\\n weight.node.clone(),\\n bias.node.clone(),\\n ])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (\\n x_state,\\n offset_state,\\n weight_state,\\n bias_state,\\n options.clone(),\\n ),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n (None, None) => match DeformConv2DNoMaskNoBias\\n .prepare::<C>([x.node.clone(), offset.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let offset_state = prep.checkpoint(&offset);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, offset_state, weight_state, options.clone()),\\n B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::deform_conv2d(\\n x.primitive,\\n offset.primitive,\\n weight.primitive,\\n None,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn deform_conv2d_backward(\\n _x: AutodiffTensor<B>,\\n _offset: AutodiffTensor<B>,\\n _weight: AutodiffTensor<B>,\\n _mask: Option<AutodiffTensor<B>>,\\n _bias: Option<AutodiffTensor<B>>,\\n _output_grad: AutodiffTensor<B>,\\n _options: DeformConvOptions<2>,\\n ) -> DeformConv2dBackward<Self> {\\n panic!(\\\"Can't differentiate deform conv 2d backward.\\\");\\n }\\n\\n fn conv_transpose2d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<2>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose2DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose2DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose2DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose2d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose2DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<2>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose2d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose2d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose2DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose2DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose2d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose2d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n fn conv3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Conv3DWithBias;\\n #[derive(Debug)]\\n struct Conv3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for Conv3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad =\\n B::conv3d_weight_backward(x.clone(), weight.clone(), grad.clone(), options);\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv3d_bias_backward(x, weight, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for Conv3DNoBias {\\n type State = (NodeID, NodeID, ConvOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv3d_x_backward(\\n x.clone(),\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match Conv3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, Some(bias.primitive), options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match Conv3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::conv3d(x.primitive, weight.primitive, None, options))\\n }\\n },\\n }\\n }\\n\\n fn conv_transpose3d(\\n x: AutodiffTensor<B>,\\n weight: AutodiffTensor<B>,\\n bias: Option<AutodiffTensor<B>>,\\n options: ConvTransposeOptions<3>,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct ConvTranspose3DWithBias;\\n #[derive(Debug)]\\n struct ConvTranspose3DNoBias;\\n\\n impl<B: Backend> Backward<B, 3> for ConvTranspose3DWithBias {\\n type State = (NodeID, NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 3>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight, node_bias] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, bias_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n let bias = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(bias_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(\\n x.clone(),\\n weight,\\n grad.clone(),\\n options,\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_bias {\\n let grad = B::conv_transpose3d_bias_backward(x, bias, grad);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n impl<B: Backend> Backward<B, 2> for ConvTranspose3DNoBias {\\n type State = (NodeID, NodeID, ConvTransposeOptions<3>);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 2>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_x, node_weight] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, weight_state, options) = ops.state;\\n let x = checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(x_state);\\n let weight =\\n checkpointer.retrieve_node_output::<B::FloatTensorPrimitive>(weight_state);\\n\\n if let Some(node) = node_x {\\n let grad = B::conv_transpose3d_x_backward(\\n weight.clone(),\\n grad.clone(),\\n options.clone(),\\n );\\n grads.register::<B>(node.id, grad)\\n }\\n if let Some(node) = node_weight {\\n let grad = B::conv_transpose3d_weight_backward(x, weight, grad, options);\\n grads.register::<B>(node.id, grad)\\n }\\n }\\n }\\n\\n match bias {\\n Some(bias) => match ConvTranspose3DWithBias\\n .prepare::<C>([x.node.clone(), weight.node.clone(), bias.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n let bias_state = prep.checkpoint(&bias);\\n\\n prep.finish(\\n (x_state, weight_state, bias_state, options.clone()),\\n B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n Some(bias.primitive),\\n options,\\n )),\\n },\\n None => match ConvTranspose3DNoBias\\n .prepare::<C>([x.node.clone(), weight.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let weight_state = prep.checkpoint(&weight);\\n\\n prep.finish(\\n (x_state, weight_state, options.clone()),\\n B::conv_transpose3d(x.primitive, weight.primitive, None, options),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::conv_transpose3d(\\n x.primitive,\\n weight.primitive,\\n None,\\n options,\\n )),\\n },\\n }\\n }\\n\\n // TODO: Support a custom unfold4d operation by overriding the default implementation.\\n //\\n // We don't override it now because the fold operation isn't available for the backward pass.\\n // This implies that when autodiff is enabled, custom unfold operations defined by backends\\n // won't be used. Instead, the conv2d operation with custom weights matrix will be used.\\n // Therefore, the conv2d backward pass will be used for the unfold4d backward pass.\\n //\\n // fn unfold4d(\\n // x:AutodiffTensor<B>,\\n // kernel_size: [usize; 2],\\n // options: UnfoldOptions,\\n // ) -> AutodiffTensor<B> {\\n // todo!()\\n // }\\n\\n fn avg_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool1D {\\n type State = (NodeID, usize, usize, usize, bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool1d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool1d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AvgPool2D {\\n type State = (NodeID, [usize; 2], [usize; 2], [usize; 2], bool);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let (x_state, kernel_size, stride, padding, count_include_pad) = ops.state;\\n let x = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::avg_pool2d_backward(\\n x,\\n grad,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n );\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(\\n (x_state, kernel_size, stride, padding, count_include_pad),\\n B::avg_pool2d(\\n x.primitive.clone(),\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n ),\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::avg_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n count_include_pad,\\n )),\\n }\\n }\\n\\n fn avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _count_include_pad: bool,\\n ) -> AutodiffTensor<B> {\\n panic!(\\\"Can't differentiate avg pool 2d backward.\\\");\\n }\\n\\n fn max_pool1d(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> AutodiffTensor<B> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool1d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool1d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n ) -> MaxPool1dWithIndices<Self> {\\n match MaxPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool1d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool1dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool1d_with_indices_backward(\\n x: AutodiffTensor<B>,\\n kernel_size: usize,\\n stride: usize,\\n padding: usize,\\n dilation: usize,\\n output_grad: AutodiffTensor<B>,\\n indices: IntTensor<B>,\\n ) -> MaxPool1dBackward<Self> {\\n let output = B::max_pool1d_with_indices_backward(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n output_grad.primitive,\\n indices,\\n );\\n MaxPool1dBackward::new(AutodiffTensor::new(output.x_grad))\\n }\\n\\n fn max_pool2d(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> AutodiffTensor<B> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n prep.finish(\\n (\\n x_state,\\n output.indices,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n )\\n }\\n OpsKind::UnTracked(prep) => prep.finish(B::max_pool2d(\\n x.primitive,\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n )),\\n }\\n }\\n\\n fn max_pool2d_with_indices(\\n x: AutodiffTensor<B>,\\n kernel_size: [usize; 2],\\n stride: [usize; 2],\\n padding: [usize; 2],\\n dilation: [usize; 2],\\n ) -> MaxPool2dWithIndices<Self> {\\n match MaxPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n\\n let output_tensor = prep.finish(\\n (\\n x_state,\\n output.indices.clone(),\\n kernel_size,\\n stride,\\n padding,\\n dilation,\\n ),\\n output.output,\\n );\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n OpsKind::UnTracked(prep) => {\\n let output =\\n B::max_pool2d_with_indices(x.primitive, kernel_size, stride, padding, dilation);\\n let output_tensor = prep.finish(output.output);\\n\\n MaxPool2dWithIndices::new(output_tensor, output.indices)\\n }\\n }\\n }\\n\\n fn max_pool2d_with_indices_backward(\\n _x: AutodiffTensor<B>,\\n _kernel_size: [usize; 2],\\n _stride: [usize; 2],\\n _padding: [usize; 2],\\n _dilation: [usize; 2],\\n _output_grad: AutodiffTensor<B>,\\n _indices: IntTensor<B>,\\n ) -> MaxPool2dBackward<Self> {\\n panic!(\\\"Can't differentiate max pool2d with indices backward.\\\");\\n }\\n fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool1D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool1d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool1D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool1d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct AdaptiveAvgPool2D;\\n\\n impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {\\n type State = NodeID;\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n let state = checkpointer.retrieve_node_output(ops.state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::adaptive_avg_pool2d_backward(state, grad);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match AdaptiveAvgPool2D\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n prep.finish(x_state, B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::adaptive_avg_pool2d(x.primitive, output_size))\\n }\\n }\\n }\\n\\n fn adaptive_avg_pool2d_backward(\\n _x: AutodiffTensor<B>,\\n _grad: AutodiffTensor<B>,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate adaptive avg pool2d backward.\\\");\\n }\\n\\n fn interpolate(\\n x: AutodiffTensor<B>,\\n output_size: [usize; 2],\\n options: InterpolateOptions,\\n ) -> AutodiffTensor<B> {\\n #[derive(Debug)]\\n struct Interpolate;\\n impl<B: Backend> Backward<B, 1> for Interpolate {\\n type State = (NodeID, [usize; 2], InterpolateOptions);\\n\\n fn backward(\\n self,\\n ops: Ops<Self::State, 1>,\\n grads: &mut Gradients,\\n checkpointer: &mut Checkpointer,\\n ) {\\n let [node_parent] = ops.parents;\\n let grad = grads.consume::<B>(&ops.node);\\n\\n let (x_state, output_size, options) = ops.state;\\n let state = checkpointer.retrieve_node_output(x_state);\\n\\n if let Some(node) = node_parent {\\n let grad = B::interpolate_backward(state, grad, output_size, options);\\n grads.register::<B>(node.id, grad);\\n }\\n }\\n }\\n\\n match Interpolate\\n .prepare::<C>([x.node.clone()])\\n .compute_bound()\\n .stateful()\\n {\\n OpsKind::Tracked(mut prep) => {\\n let x_state = prep.checkpoint(&x);\\n let output = B::interpolate(x.primitive.clone(), output_size, options.clone());\\n prep.finish((x_state, output_size, options), output)\\n }\\n OpsKind::UnTracked(prep) => {\\n prep.finish(B::interpolate(x.primitive, output_size, options))\\n }\\n }\\n }\\n\\n fn interpolate_backward(\\n _x: FloatTensor<Autodiff<B, C>>,\\n _grad: FloatTensor<Autodiff<B, C>>,\\n _output_size: [usize; 2],\\n _options: InterpolateOptions,\\n ) -> <Autodiff<B> as Backend>::FloatTensorPrimitive {\\n panic!(\\\"Can't differentiate interpolate backward.\\\");\\n }\\n}\",\n \"class_signature\": \"impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>\"\n}"}}},{"rowIdx":153,"cells":{"function_name":{"kind":"string","value":"build"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/checkpoint/builder.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {\n let mut backward_states_map = HashMap::new();\n let mut retro_forwards_map = HashMap::new();\n\n // Find recursion stopping points\n let stop_nodes: Vec<NodeID> = self.find_stop_nodes();\n\n // We start by identifying how many times each node will be required.\n let n_required_map = self.build_n_required_map(&node_tree, stop_nodes);\n\n // Then we checkpoint the nodes with the corresponding n_required value\n self.insert_checkpoints(\n &mut backward_states_map,\n &mut retro_forwards_map,\n n_required_map,\n );\n\n Checkpointer::new(\n BackwardStates::new(backward_states_map),\n RetroForwards::new(retro_forwards_map),\n node_tree,\n )\n }"},"file_content":{"kind":"string","value":"use crate::{\n collections::HashMap,\n graph::{ComputingProperty, NodeID},\n tensor::AutodiffTensor,\n};\nuse alloc::{boxed::Box, sync::Arc, vec::Vec};\nuse burn_tensor::backend::Backend;\nuse core::any::Any;\n\nuse super::{\n base::{Checkpointer, NodeTree},\n retro_forward::{RetroForward, RetroForwards},\n state::{BackwardStates, State},\n};\n\n#[derive(Debug)]\n/// Determines if a node should checkpoint its computed output or its retro_forward for recomputation\n/// The action is normally created by the child of the node, once the node is determined to be needed\npub enum CheckpointingAction {\n /// The node's already computed output should be saved\n Computed {\n /// The node\n node_id: NodeID,\n /// The node's output\n state_content: Box<dyn Any + Send>,\n },\n /// The node should recompute itself when asked\n Recompute {\n /// The node\n node_id: NodeID,\n /// How the node should recompute itself\n retro_forward: Arc<dyn RetroForward>,\n },\n}\n\n// TODO: Remove that when proper client server.\nunsafe impl Send for CheckpointingAction {}\n\nimpl CheckpointingAction {\n /// Utilitary function to access the id of the node of the checkpointing action\n pub fn id(&self) -> NodeID {\n match self {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => *node_ref,\n CheckpointingAction::Recompute {\n node_id: node_ref,\n retro_forward: _,\n } => *node_ref,\n }\n }\n}\n\n#[derive(new, Debug, Default)]\n/// Accumulates checkpoints as checkpointing actions during the forward pass,\n/// and builds a checkpointer right before the backward pass\npub struct CheckpointerBuilder {\n explicit_actions: Vec<CheckpointingAction>,\n backup_actions: Vec<CheckpointingAction>,\n}\n\n/// Determines if a checkpoint should impact the n_required values (Main)\n/// or if it should just keep the state in case it's required (Backup)\n///\npub(crate) enum ActionType {\n /// Explicit actions have been explicitly requested by some operation to retrieve their state\n Explicit,\n /// Backup actions are not always needed. They exist to save the output of an operation\n /// whose child is memory bound, in case the state is indirectly needed when computing\n /// the child's retro_forward. If no explicit action ever asks for the child's output, then\n /// the backup output will go out of scope when the checkpointer is built.\n Backup,\n}\n\nimpl CheckpointerBuilder {\n pub(crate) fn checkpoint<B: Backend>(\n &mut self,\n tensor: &AutodiffTensor<B>,\n action_type: ActionType,\n ) {\n let action_list = match action_type {\n ActionType::Explicit => &mut self.explicit_actions,\n ActionType::Backup => &mut self.backup_actions,\n };\n match &tensor.node.properties {\n ComputingProperty::ComputeBound | ComputingProperty::Ambiguous => {\n action_list.push(CheckpointingAction::Computed {\n node_id: tensor.node.id,\n state_content: Box::new(tensor.primitive.clone()),\n })\n }\n ComputingProperty::MemoryBound { retro_forward } => {\n action_list.push(CheckpointingAction::Recompute {\n node_id: tensor.node.id,\n retro_forward: retro_forward.clone(),\n })\n }\n }\n }\n\n pub(crate) fn extend(&mut self, other: CheckpointerBuilder) {\n for other_action in other.explicit_actions {\n self.explicit_actions.push(other_action)\n }\n for other_unsure in other.backup_actions {\n self.backup_actions.push(other_unsure)\n }\n }\n\n pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {\n let mut backward_states_map = HashMap::new();\n let mut retro_forwards_map = HashMap::new();\n\n // Find recursion stopping points\n let stop_nodes: Vec<NodeID> = self.find_stop_nodes();\n\n // We start by identifying how many times each node will be required.\n let n_required_map = self.build_n_required_map(&node_tree, stop_nodes);\n\n // Then we checkpoint the nodes with the corresponding n_required value\n self.insert_checkpoints(\n &mut backward_states_map,\n &mut retro_forwards_map,\n n_required_map,\n );\n\n Checkpointer::new(\n BackwardStates::new(backward_states_map),\n RetroForwards::new(retro_forwards_map),\n node_tree,\n )\n }\n\n fn find_stop_nodes(&self) -> Vec<NodeID> {\n let mut stop_nodes = Vec::default();\n for action in self\n .explicit_actions\n .iter()\n .chain(self.backup_actions.iter())\n {\n match action {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => stop_nodes.push(*node_ref),\n CheckpointingAction::Recompute {\n node_id: _,\n retro_forward: _,\n } => {}\n }\n }\n stop_nodes\n }\n\n fn build_n_required_map(\n &self,\n node_tree: &NodeTree,\n stop_nodes: Vec<NodeID>,\n ) -> HashMap<NodeID, usize> {\n let mut n_required_map = HashMap::<NodeID, usize>::default();\n\n for action in self.explicit_actions.iter() {\n match action {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => {\n let id = *node_ref;\n match n_required_map.remove(&id) {\n Some(n) => {\n n_required_map.insert(id, n + 1);\n }\n None => {\n n_required_map.insert(id, 1);\n }\n };\n }\n CheckpointingAction::Recompute {\n node_id: node_ref,\n retro_forward: _,\n } => {\n let id = *node_ref;\n Self::update_n_required_of_parents(\n id,\n &mut n_required_map,\n node_tree,\n &stop_nodes,\n );\n }\n }\n }\n\n n_required_map\n }\n\n fn insert_checkpoints(\n mut self,\n backward_states_map: &mut HashMap<NodeID, State>,\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\n n_required_map: HashMap<NodeID, usize>,\n ) {\n // We do not loop over checkpointing actions anymore because they can contain\n // duplicates or miss some that are in backup. We loop over the n_required_map\n // from which we use the ids to find them again in the checkpointing actions\n for (node_id, n_required) in n_required_map {\n // We find the checkpointing action for node_id. It's likely in checkpointing_actions\n // so we check there first, otherwise it will be in backup.\n // Technically it can be there several times but can never be of both types, so we can assume the first we find is fine\n\n let action = match self\n .explicit_actions\n .iter()\n .position(|action| action.id() == node_id)\n {\n Some(pos) => self.explicit_actions.remove(pos),\n None => {\n let pos = self\n .backup_actions\n .iter()\n .position(|action| action.id() == node_id);\n self.backup_actions.remove(pos.unwrap_or_else(|| {\n panic!(\"Node {:?} is needed but never checkpointed\", &node_id)\n }))\n }\n };\n\n match action {\n CheckpointingAction::Computed {\n node_id: _,\n state_content,\n } => {\n self.checkpoint_compute(backward_states_map, node_id, state_content, n_required)\n }\n CheckpointingAction::Recompute {\n node_id: _,\n retro_forward,\n } => self.checkpoint_lazy(\n backward_states_map,\n retro_forward_map,\n node_id,\n retro_forward,\n n_required,\n ),\n };\n }\n }\n\n fn update_n_required_of_parents(\n id: NodeID,\n n_required_map: &mut HashMap<NodeID, usize>,\n node_tree: &NodeTree,\n stop_nodes: &Vec<NodeID>,\n ) {\n match n_required_map.remove(&id) {\n Some(n) => {\n n_required_map.insert(id, n + 1);\n }\n None => {\n n_required_map.insert(id, 1);\n if !stop_nodes.contains(&id) {\n if let Some(parents) = node_tree.parents(&id) {\n for p in parents {\n Self::update_n_required_of_parents(\n p,\n n_required_map,\n node_tree,\n stop_nodes,\n );\n }\n }\n }\n }\n }\n }\n\n fn checkpoint_compute(\n &self,\n backward_states_map: &mut HashMap<NodeID, State>,\n node_id: NodeID,\n state_content: Box<dyn Any + Send>,\n n_required: usize,\n ) {\n backward_states_map.insert(\n node_id,\n State::Computed {\n state_content,\n n_required,\n },\n );\n }\n\n fn checkpoint_lazy(\n &self,\n backward_states_map: &mut HashMap<NodeID, State>,\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\n node_id: NodeID,\n retro_forward: Arc<dyn RetroForward>,\n n_required: usize,\n ) {\n retro_forward_map.insert(node_id, retro_forward);\n backward_states_map.insert(node_id, State::Recompute { n_required });\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub(crate) struct NodeTree {\\n map: HashMap<NodeID, Vec<NodeID>>,\\n}\"\n ],\n \"name\": \"node_tree\",\n \"type\": \"NodeTree\"\n }\n ],\n \"end_line\": 133,\n \"name\": \"build\",\n \"signature\": \"pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer\",\n \"start_line\": 111\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl CheckpointerBuilder {\\n pub(crate) fn checkpoint<B: Backend>(\\n &mut self,\\n tensor: &AutodiffTensor<B>,\\n action_type: ActionType,\\n ) {\\n let action_list = match action_type {\\n ActionType::Explicit => &mut self.explicit_actions,\\n ActionType::Backup => &mut self.backup_actions,\\n };\\n match &tensor.node.properties {\\n ComputingProperty::ComputeBound | ComputingProperty::Ambiguous => {\\n action_list.push(CheckpointingAction::Computed {\\n node_id: tensor.node.id,\\n state_content: Box::new(tensor.primitive.clone()),\\n })\\n }\\n ComputingProperty::MemoryBound { retro_forward } => {\\n action_list.push(CheckpointingAction::Recompute {\\n node_id: tensor.node.id,\\n retro_forward: retro_forward.clone(),\\n })\\n }\\n }\\n }\\n\\n pub(crate) fn extend(&mut self, other: CheckpointerBuilder) {\\n for other_action in other.explicit_actions {\\n self.explicit_actions.push(other_action)\\n }\\n for other_unsure in other.backup_actions {\\n self.backup_actions.push(other_unsure)\\n }\\n }\\n\\n pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {\\n let mut backward_states_map = HashMap::new();\\n let mut retro_forwards_map = HashMap::new();\\n\\n // Find recursion stopping points\\n let stop_nodes: Vec<NodeID> = self.find_stop_nodes();\\n\\n // We start by identifying how many times each node will be required.\\n let n_required_map = self.build_n_required_map(&node_tree, stop_nodes);\\n\\n // Then we checkpoint the nodes with the corresponding n_required value\\n self.insert_checkpoints(\\n &mut backward_states_map,\\n &mut retro_forwards_map,\\n n_required_map,\\n );\\n\\n Checkpointer::new(\\n BackwardStates::new(backward_states_map),\\n RetroForwards::new(retro_forwards_map),\\n node_tree,\\n )\\n }\\n\\n fn find_stop_nodes(&self) -> Vec<NodeID> {\\n let mut stop_nodes = Vec::default();\\n for action in self\\n .explicit_actions\\n .iter()\\n .chain(self.backup_actions.iter())\\n {\\n match action {\\n CheckpointingAction::Computed {\\n node_id: node_ref,\\n state_content: _,\\n } => stop_nodes.push(*node_ref),\\n CheckpointingAction::Recompute {\\n node_id: _,\\n retro_forward: _,\\n } => {}\\n }\\n }\\n stop_nodes\\n }\\n\\n fn build_n_required_map(\\n &self,\\n node_tree: &NodeTree,\\n stop_nodes: Vec<NodeID>,\\n ) -> HashMap<NodeID, usize> {\\n let mut n_required_map = HashMap::<NodeID, usize>::default();\\n\\n for action in self.explicit_actions.iter() {\\n match action {\\n CheckpointingAction::Computed {\\n node_id: node_ref,\\n state_content: _,\\n } => {\\n let id = *node_ref;\\n match n_required_map.remove(&id) {\\n Some(n) => {\\n n_required_map.insert(id, n + 1);\\n }\\n None => {\\n n_required_map.insert(id, 1);\\n }\\n };\\n }\\n CheckpointingAction::Recompute {\\n node_id: node_ref,\\n retro_forward: _,\\n } => {\\n let id = *node_ref;\\n Self::update_n_required_of_parents(\\n id,\\n &mut n_required_map,\\n node_tree,\\n &stop_nodes,\\n );\\n }\\n }\\n }\\n\\n n_required_map\\n }\\n\\n fn insert_checkpoints(\\n mut self,\\n backward_states_map: &mut HashMap<NodeID, State>,\\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\\n n_required_map: HashMap<NodeID, usize>,\\n ) {\\n // We do not loop over checkpointing actions anymore because they can contain\\n // duplicates or miss some that are in backup. We loop over the n_required_map\\n // from which we use the ids to find them again in the checkpointing actions\\n for (node_id, n_required) in n_required_map {\\n // We find the checkpointing action for node_id. It's likely in checkpointing_actions\\n // so we check there first, otherwise it will be in backup.\\n // Technically it can be there several times but can never be of both types, so we can assume the first we find is fine\\n\\n let action = match self\\n .explicit_actions\\n .iter()\\n .position(|action| action.id() == node_id)\\n {\\n Some(pos) => self.explicit_actions.remove(pos),\\n None => {\\n let pos = self\\n .backup_actions\\n .iter()\\n .position(|action| action.id() == node_id);\\n self.backup_actions.remove(pos.unwrap_or_else(|| {\\n panic!(\\\"Node {:?} is needed but never checkpointed\\\", &node_id)\\n }))\\n }\\n };\\n\\n match action {\\n CheckpointingAction::Computed {\\n node_id: _,\\n state_content,\\n } => {\\n self.checkpoint_compute(backward_states_map, node_id, state_content, n_required)\\n }\\n CheckpointingAction::Recompute {\\n node_id: _,\\n retro_forward,\\n } => self.checkpoint_lazy(\\n backward_states_map,\\n retro_forward_map,\\n node_id,\\n retro_forward,\\n n_required,\\n ),\\n };\\n }\\n }\\n\\n fn update_n_required_of_parents(\\n id: NodeID,\\n n_required_map: &mut HashMap<NodeID, usize>,\\n node_tree: &NodeTree,\\n stop_nodes: &Vec<NodeID>,\\n ) {\\n match n_required_map.remove(&id) {\\n Some(n) => {\\n n_required_map.insert(id, n + 1);\\n }\\n None => {\\n n_required_map.insert(id, 1);\\n if !stop_nodes.contains(&id) {\\n if let Some(parents) = node_tree.parents(&id) {\\n for p in parents {\\n Self::update_n_required_of_parents(\\n p,\\n n_required_map,\\n node_tree,\\n stop_nodes,\\n );\\n }\\n }\\n }\\n }\\n }\\n }\\n\\n fn checkpoint_compute(\\n &self,\\n backward_states_map: &mut HashMap<NodeID, State>,\\n node_id: NodeID,\\n state_content: Box<dyn Any + Send>,\\n n_required: usize,\\n ) {\\n backward_states_map.insert(\\n node_id,\\n State::Computed {\\n state_content,\\n n_required,\\n },\\n );\\n }\\n\\n fn checkpoint_lazy(\\n &self,\\n backward_states_map: &mut HashMap<NodeID, State>,\\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\\n node_id: NodeID,\\n retro_forward: Arc<dyn RetroForward>,\\n n_required: usize,\\n ) {\\n retro_forward_map.insert(node_id, retro_forward);\\n backward_states_map.insert(node_id, State::Recompute { n_required });\\n }\\n}\",\n \"class_signature\": \"impl CheckpointerBuilder\"\n}"}}},{"rowIdx":154,"cells":{"function_name":{"kind":"string","value":"build_n_required_map"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/checkpoint/builder.rs"},"focal_code":{"kind":"string","value":"fn build_n_required_map(\n &self,\n node_tree: &NodeTree,\n stop_nodes: Vec<NodeID>,\n ) -> HashMap<NodeID, usize> {\n let mut n_required_map = HashMap::<NodeID, usize>::default();\n\n for action in self.explicit_actions.iter() {\n match action {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => {\n let id = *node_ref;\n match n_required_map.remove(&id) {\n Some(n) => {\n n_required_map.insert(id, n + 1);\n }\n None => {\n n_required_map.insert(id, 1);\n }\n };\n }\n CheckpointingAction::Recompute {\n node_id: node_ref,\n retro_forward: _,\n } => {\n let id = *node_ref;\n Self::update_n_required_of_parents(\n id,\n &mut n_required_map,\n node_tree,\n &stop_nodes,\n );\n }\n }\n }\n\n n_required_map\n }"},"file_content":{"kind":"string","value":"use crate::{\n collections::HashMap,\n graph::{ComputingProperty, NodeID},\n tensor::AutodiffTensor,\n};\nuse alloc::{boxed::Box, sync::Arc, vec::Vec};\nuse burn_tensor::backend::Backend;\nuse core::any::Any;\n\nuse super::{\n base::{Checkpointer, NodeTree},\n retro_forward::{RetroForward, RetroForwards},\n state::{BackwardStates, State},\n};\n\n#[derive(Debug)]\n/// Determines if a node should checkpoint its computed output or its retro_forward for recomputation\n/// The action is normally created by the child of the node, once the node is determined to be needed\npub enum CheckpointingAction {\n /// The node's already computed output should be saved\n Computed {\n /// The node\n node_id: NodeID,\n /// The node's output\n state_content: Box<dyn Any + Send>,\n },\n /// The node should recompute itself when asked\n Recompute {\n /// The node\n node_id: NodeID,\n /// How the node should recompute itself\n retro_forward: Arc<dyn RetroForward>,\n },\n}\n\n// TODO: Remove that when proper client server.\nunsafe impl Send for CheckpointingAction {}\n\nimpl CheckpointingAction {\n /// Utilitary function to access the id of the node of the checkpointing action\n pub fn id(&self) -> NodeID {\n match self {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => *node_ref,\n CheckpointingAction::Recompute {\n node_id: node_ref,\n retro_forward: _,\n } => *node_ref,\n }\n }\n}\n\n#[derive(new, Debug, Default)]\n/// Accumulates checkpoints as checkpointing actions during the forward pass,\n/// and builds a checkpointer right before the backward pass\npub struct CheckpointerBuilder {\n explicit_actions: Vec<CheckpointingAction>,\n backup_actions: Vec<CheckpointingAction>,\n}\n\n/// Determines if a checkpoint should impact the n_required values (Main)\n/// or if it should just keep the state in case it's required (Backup)\n///\npub(crate) enum ActionType {\n /// Explicit actions have been explicitly requested by some operation to retrieve their state\n Explicit,\n /// Backup actions are not always needed. They exist to save the output of an operation\n /// whose child is memory bound, in case the state is indirectly needed when computing\n /// the child's retro_forward. If no explicit action ever asks for the child's output, then\n /// the backup output will go out of scope when the checkpointer is built.\n Backup,\n}\n\nimpl CheckpointerBuilder {\n pub(crate) fn checkpoint<B: Backend>(\n &mut self,\n tensor: &AutodiffTensor<B>,\n action_type: ActionType,\n ) {\n let action_list = match action_type {\n ActionType::Explicit => &mut self.explicit_actions,\n ActionType::Backup => &mut self.backup_actions,\n };\n match &tensor.node.properties {\n ComputingProperty::ComputeBound | ComputingProperty::Ambiguous => {\n action_list.push(CheckpointingAction::Computed {\n node_id: tensor.node.id,\n state_content: Box::new(tensor.primitive.clone()),\n })\n }\n ComputingProperty::MemoryBound { retro_forward } => {\n action_list.push(CheckpointingAction::Recompute {\n node_id: tensor.node.id,\n retro_forward: retro_forward.clone(),\n })\n }\n }\n }\n\n pub(crate) fn extend(&mut self, other: CheckpointerBuilder) {\n for other_action in other.explicit_actions {\n self.explicit_actions.push(other_action)\n }\n for other_unsure in other.backup_actions {\n self.backup_actions.push(other_unsure)\n }\n }\n\n pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {\n let mut backward_states_map = HashMap::new();\n let mut retro_forwards_map = HashMap::new();\n\n // Find recursion stopping points\n let stop_nodes: Vec<NodeID> = self.find_stop_nodes();\n\n // We start by identifying how many times each node will be required.\n let n_required_map = self.build_n_required_map(&node_tree, stop_nodes);\n\n // Then we checkpoint the nodes with the corresponding n_required value\n self.insert_checkpoints(\n &mut backward_states_map,\n &mut retro_forwards_map,\n n_required_map,\n );\n\n Checkpointer::new(\n BackwardStates::new(backward_states_map),\n RetroForwards::new(retro_forwards_map),\n node_tree,\n )\n }\n\n fn find_stop_nodes(&self) -> Vec<NodeID> {\n let mut stop_nodes = Vec::default();\n for action in self\n .explicit_actions\n .iter()\n .chain(self.backup_actions.iter())\n {\n match action {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => stop_nodes.push(*node_ref),\n CheckpointingAction::Recompute {\n node_id: _,\n retro_forward: _,\n } => {}\n }\n }\n stop_nodes\n }\n\n fn build_n_required_map(\n &self,\n node_tree: &NodeTree,\n stop_nodes: Vec<NodeID>,\n ) -> HashMap<NodeID, usize> {\n let mut n_required_map = HashMap::<NodeID, usize>::default();\n\n for action in self.explicit_actions.iter() {\n match action {\n CheckpointingAction::Computed {\n node_id: node_ref,\n state_content: _,\n } => {\n let id = *node_ref;\n match n_required_map.remove(&id) {\n Some(n) => {\n n_required_map.insert(id, n + 1);\n }\n None => {\n n_required_map.insert(id, 1);\n }\n };\n }\n CheckpointingAction::Recompute {\n node_id: node_ref,\n retro_forward: _,\n } => {\n let id = *node_ref;\n Self::update_n_required_of_parents(\n id,\n &mut n_required_map,\n node_tree,\n &stop_nodes,\n );\n }\n }\n }\n\n n_required_map\n }\n\n fn insert_checkpoints(\n mut self,\n backward_states_map: &mut HashMap<NodeID, State>,\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\n n_required_map: HashMap<NodeID, usize>,\n ) {\n // We do not loop over checkpointing actions anymore because they can contain\n // duplicates or miss some that are in backup. We loop over the n_required_map\n // from which we use the ids to find them again in the checkpointing actions\n for (node_id, n_required) in n_required_map {\n // We find the checkpointing action for node_id. It's likely in checkpointing_actions\n // so we check there first, otherwise it will be in backup.\n // Technically it can be there several times but can never be of both types, so we can assume the first we find is fine\n\n let action = match self\n .explicit_actions\n .iter()\n .position(|action| action.id() == node_id)\n {\n Some(pos) => self.explicit_actions.remove(pos),\n None => {\n let pos = self\n .backup_actions\n .iter()\n .position(|action| action.id() == node_id);\n self.backup_actions.remove(pos.unwrap_or_else(|| {\n panic!(\"Node {:?} is needed but never checkpointed\", &node_id)\n }))\n }\n };\n\n match action {\n CheckpointingAction::Computed {\n node_id: _,\n state_content,\n } => {\n self.checkpoint_compute(backward_states_map, node_id, state_content, n_required)\n }\n CheckpointingAction::Recompute {\n node_id: _,\n retro_forward,\n } => self.checkpoint_lazy(\n backward_states_map,\n retro_forward_map,\n node_id,\n retro_forward,\n n_required,\n ),\n };\n }\n }\n\n fn update_n_required_of_parents(\n id: NodeID,\n n_required_map: &mut HashMap<NodeID, usize>,\n node_tree: &NodeTree,\n stop_nodes: &Vec<NodeID>,\n ) {\n match n_required_map.remove(&id) {\n Some(n) => {\n n_required_map.insert(id, n + 1);\n }\n None => {\n n_required_map.insert(id, 1);\n if !stop_nodes.contains(&id) {\n if let Some(parents) = node_tree.parents(&id) {\n for p in parents {\n Self::update_n_required_of_parents(\n p,\n n_required_map,\n node_tree,\n stop_nodes,\n );\n }\n }\n }\n }\n }\n }\n\n fn checkpoint_compute(\n &self,\n backward_states_map: &mut HashMap<NodeID, State>,\n node_id: NodeID,\n state_content: Box<dyn Any + Send>,\n n_required: usize,\n ) {\n backward_states_map.insert(\n node_id,\n State::Computed {\n state_content,\n n_required,\n },\n );\n }\n\n fn checkpoint_lazy(\n &self,\n backward_states_map: &mut HashMap<NodeID, State>,\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\n node_id: NodeID,\n retro_forward: Arc<dyn RetroForward>,\n n_required: usize,\n ) {\n retro_forward_map.insert(node_id, retro_forward);\n backward_states_map.insert(node_id, State::Recompute { n_required });\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub(crate) struct NodeTree {\\n map: HashMap<NodeID, Vec<NodeID>>,\\n}\"\n ],\n \"name\": \"node_tree\",\n \"type\": \"&NodeTree\"\n },\n {\n \"definitions\": [\n \"pub struct Vec<T, #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")] A: Allocator = Global> {\\n buf: RawVec<T, A>,\\n len: usize,\\n}\",\n \"pub struct NodeID {\\n /// The integer representation of the id\\n pub value: u64,\\n}\"\n ],\n \"name\": \"stop_nodes\",\n \"type\": \"Vec<NodeID>\"\n }\n ],\n \"end_line\": 195,\n \"name\": \"build_n_required_map\",\n \"signature\": \"fn build_n_required_map(\\n &self,\\n node_tree: &NodeTree,\\n stop_nodes: Vec<NodeID>,\\n ) -> HashMap<NodeID, usize>\",\n \"start_line\": 156\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl CheckpointerBuilder {\\n pub(crate) fn checkpoint<B: Backend>(\\n &mut self,\\n tensor: &AutodiffTensor<B>,\\n action_type: ActionType,\\n ) {\\n let action_list = match action_type {\\n ActionType::Explicit => &mut self.explicit_actions,\\n ActionType::Backup => &mut self.backup_actions,\\n };\\n match &tensor.node.properties {\\n ComputingProperty::ComputeBound | ComputingProperty::Ambiguous => {\\n action_list.push(CheckpointingAction::Computed {\\n node_id: tensor.node.id,\\n state_content: Box::new(tensor.primitive.clone()),\\n })\\n }\\n ComputingProperty::MemoryBound { retro_forward } => {\\n action_list.push(CheckpointingAction::Recompute {\\n node_id: tensor.node.id,\\n retro_forward: retro_forward.clone(),\\n })\\n }\\n }\\n }\\n\\n pub(crate) fn extend(&mut self, other: CheckpointerBuilder) {\\n for other_action in other.explicit_actions {\\n self.explicit_actions.push(other_action)\\n }\\n for other_unsure in other.backup_actions {\\n self.backup_actions.push(other_unsure)\\n }\\n }\\n\\n pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {\\n let mut backward_states_map = HashMap::new();\\n let mut retro_forwards_map = HashMap::new();\\n\\n // Find recursion stopping points\\n let stop_nodes: Vec<NodeID> = self.find_stop_nodes();\\n\\n // We start by identifying how many times each node will be required.\\n let n_required_map = self.build_n_required_map(&node_tree, stop_nodes);\\n\\n // Then we checkpoint the nodes with the corresponding n_required value\\n self.insert_checkpoints(\\n &mut backward_states_map,\\n &mut retro_forwards_map,\\n n_required_map,\\n );\\n\\n Checkpointer::new(\\n BackwardStates::new(backward_states_map),\\n RetroForwards::new(retro_forwards_map),\\n node_tree,\\n )\\n }\\n\\n fn find_stop_nodes(&self) -> Vec<NodeID> {\\n let mut stop_nodes = Vec::default();\\n for action in self\\n .explicit_actions\\n .iter()\\n .chain(self.backup_actions.iter())\\n {\\n match action {\\n CheckpointingAction::Computed {\\n node_id: node_ref,\\n state_content: _,\\n } => stop_nodes.push(*node_ref),\\n CheckpointingAction::Recompute {\\n node_id: _,\\n retro_forward: _,\\n } => {}\\n }\\n }\\n stop_nodes\\n }\\n\\n fn build_n_required_map(\\n &self,\\n node_tree: &NodeTree,\\n stop_nodes: Vec<NodeID>,\\n ) -> HashMap<NodeID, usize> {\\n let mut n_required_map = HashMap::<NodeID, usize>::default();\\n\\n for action in self.explicit_actions.iter() {\\n match action {\\n CheckpointingAction::Computed {\\n node_id: node_ref,\\n state_content: _,\\n } => {\\n let id = *node_ref;\\n match n_required_map.remove(&id) {\\n Some(n) => {\\n n_required_map.insert(id, n + 1);\\n }\\n None => {\\n n_required_map.insert(id, 1);\\n }\\n };\\n }\\n CheckpointingAction::Recompute {\\n node_id: node_ref,\\n retro_forward: _,\\n } => {\\n let id = *node_ref;\\n Self::update_n_required_of_parents(\\n id,\\n &mut n_required_map,\\n node_tree,\\n &stop_nodes,\\n );\\n }\\n }\\n }\\n\\n n_required_map\\n }\\n\\n fn insert_checkpoints(\\n mut self,\\n backward_states_map: &mut HashMap<NodeID, State>,\\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\\n n_required_map: HashMap<NodeID, usize>,\\n ) {\\n // We do not loop over checkpointing actions anymore because they can contain\\n // duplicates or miss some that are in backup. We loop over the n_required_map\\n // from which we use the ids to find them again in the checkpointing actions\\n for (node_id, n_required) in n_required_map {\\n // We find the checkpointing action for node_id. It's likely in checkpointing_actions\\n // so we check there first, otherwise it will be in backup.\\n // Technically it can be there several times but can never be of both types, so we can assume the first we find is fine\\n\\n let action = match self\\n .explicit_actions\\n .iter()\\n .position(|action| action.id() == node_id)\\n {\\n Some(pos) => self.explicit_actions.remove(pos),\\n None => {\\n let pos = self\\n .backup_actions\\n .iter()\\n .position(|action| action.id() == node_id);\\n self.backup_actions.remove(pos.unwrap_or_else(|| {\\n panic!(\\\"Node {:?} is needed but never checkpointed\\\", &node_id)\\n }))\\n }\\n };\\n\\n match action {\\n CheckpointingAction::Computed {\\n node_id: _,\\n state_content,\\n } => {\\n self.checkpoint_compute(backward_states_map, node_id, state_content, n_required)\\n }\\n CheckpointingAction::Recompute {\\n node_id: _,\\n retro_forward,\\n } => self.checkpoint_lazy(\\n backward_states_map,\\n retro_forward_map,\\n node_id,\\n retro_forward,\\n n_required,\\n ),\\n };\\n }\\n }\\n\\n fn update_n_required_of_parents(\\n id: NodeID,\\n n_required_map: &mut HashMap<NodeID, usize>,\\n node_tree: &NodeTree,\\n stop_nodes: &Vec<NodeID>,\\n ) {\\n match n_required_map.remove(&id) {\\n Some(n) => {\\n n_required_map.insert(id, n + 1);\\n }\\n None => {\\n n_required_map.insert(id, 1);\\n if !stop_nodes.contains(&id) {\\n if let Some(parents) = node_tree.parents(&id) {\\n for p in parents {\\n Self::update_n_required_of_parents(\\n p,\\n n_required_map,\\n node_tree,\\n stop_nodes,\\n );\\n }\\n }\\n }\\n }\\n }\\n }\\n\\n fn checkpoint_compute(\\n &self,\\n backward_states_map: &mut HashMap<NodeID, State>,\\n node_id: NodeID,\\n state_content: Box<dyn Any + Send>,\\n n_required: usize,\\n ) {\\n backward_states_map.insert(\\n node_id,\\n State::Computed {\\n state_content,\\n n_required,\\n },\\n );\\n }\\n\\n fn checkpoint_lazy(\\n &self,\\n backward_states_map: &mut HashMap<NodeID, State>,\\n retro_forward_map: &mut HashMap<NodeID, Arc<dyn RetroForward>>,\\n node_id: NodeID,\\n retro_forward: Arc<dyn RetroForward>,\\n n_required: usize,\\n ) {\\n retro_forward_map.insert(node_id, retro_forward);\\n backward_states_map.insert(node_id, State::Recompute { n_required });\\n }\\n}\",\n \"class_signature\": \"impl CheckpointerBuilder\"\n}"}}},{"rowIdx":155,"cells":{"function_name":{"kind":"string","value":"topological_sort"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/checkpoint/base.rs"},"focal_code":{"kind":"string","value":"fn topological_sort(&self, node_id: NodeID) -> Vec<NodeID> {\n match self.backward_states.get_state_ref(&node_id) {\n Some(state) => match state {\n State::Recompute { n_required: _ } => {\n let mut sorted = Vec::new();\n let parents = self.node_tree.parents(&node_id).unwrap();\n for parent_node in parents {\n let parent_sorted = self.topological_sort(parent_node);\n for ps in parent_sorted {\n if !sorted.contains(&ps) {\n sorted.push(ps)\n }\n }\n }\n sorted.push(node_id);\n sorted\n }\n State::Computed {\n state_content: _,\n n_required: _,\n } => vec![node_id],\n },\n None => panic!(\"Node {:?} is not in the backward_states. \", node_id),\n }\n }"},"file_content":{"kind":"string","value":"use super::{\n retro_forward::RetroForwards,\n state::{BackwardStates, State},\n};\nuse crate::collections::HashMap;\nuse crate::graph::NodeID;\n\nuse alloc::{vec, vec::Vec};\n\n#[derive(new, Debug)]\n/// Links a [NodeID] to its autodiff graph [NodeRef]\npub(crate) struct NodeTree {\n map: HashMap<NodeID, Vec<NodeID>>,\n}\n\nimpl NodeTree {\n /// Gives the parents of the node in the autodiff graph\n pub(crate) fn parents(&self, node_id: &NodeID) -> Option<Vec<NodeID>> {\n self.map.get(node_id).cloned()\n }\n}\n\n#[derive(new, Debug)]\n/// Struct responsible of fetching the output for a node in the autodiff graph during a backward pass\npub struct Checkpointer {\n backward_states: BackwardStates,\n retro_forwards: RetroForwards,\n node_tree: NodeTree,\n}\n\nimpl Checkpointer {\n /// Gives the output of the given node, by recursively asking parents to compute themselves\n /// or give their pre-computed tensors.\n pub fn retrieve_node_output<T>(&mut self, node_id: NodeID) -> T\n where\n T: Clone + Send + 'static,\n {\n self.topological_sort(node_id).into_iter().for_each(|node| {\n self.retro_forwards\n .execute_retro_forward(node, &mut self.backward_states)\n });\n\n self.backward_states.get_state::<T>(&node_id)\n }\n\n /// Sorts the ancestors of NodeID in a way such that all parents come before their children\n /// Useful to avoid recursivity later when mutating the states\n ///\n /// The sort on a compute bound state or a memory bound that is already computed is trivial.\n /// The match on State::Computed also serves as a stopping criterion for the sort,\n /// we don't need to look higher than that during recursivity.\n fn topological_sort(&self, node_id: NodeID) -> Vec<NodeID> {\n match self.backward_states.get_state_ref(&node_id) {\n Some(state) => match state {\n State::Recompute { n_required: _ } => {\n let mut sorted = Vec::new();\n let parents = self.node_tree.parents(&node_id).unwrap();\n for parent_node in parents {\n let parent_sorted = self.topological_sort(parent_node);\n for ps in parent_sorted {\n if !sorted.contains(&ps) {\n sorted.push(ps)\n }\n }\n }\n sorted.push(node_id);\n sorted\n }\n State::Computed {\n state_content: _,\n n_required: _,\n } => vec![node_id],\n },\n None => panic!(\"Node {:?} is not in the backward_states. \", node_id),\n }\n }\n\n #[cfg(feature = \"export_tests\")]\n /// Checks if checkpointer has been drained adequately. Useful for testing\n pub fn is_empty(&self) -> bool {\n self.backward_states.is_empty() && self.retro_forwards.is_empty()\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct NodeID {\\n /// The integer representation of the id\\n pub value: u64,\\n}\"\n ],\n \"name\": \"node_id\",\n \"type\": \"NodeID\"\n }\n ],\n \"end_line\": 76,\n \"name\": \"topological_sort\",\n \"signature\": \"fn topological_sort(&self, node_id: NodeID) -> Vec<NodeID>\",\n \"start_line\": 52\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl Checkpointer {\\n /// Gives the output of the given node, by recursively asking parents to compute themselves\\n /// or give their pre-computed tensors.\\n pub fn retrieve_node_output<T>(&mut self, node_id: NodeID) -> T\\n where\\n T: Clone + Send + 'static,\\n {\\n self.topological_sort(node_id).into_iter().for_each(|node| {\\n self.retro_forwards\\n .execute_retro_forward(node, &mut self.backward_states)\\n });\\n\\n self.backward_states.get_state::<T>(&node_id)\\n }\\n\\n /// Sorts the ancestors of NodeID in a way such that all parents come before their children\\n /// Useful to avoid recursivity later when mutating the states\\n ///\\n /// The sort on a compute bound state or a memory bound that is already computed is trivial.\\n /// The match on State::Computed also serves as a stopping criterion for the sort,\\n /// we don't need to look higher than that during recursivity.\\n fn topological_sort(&self, node_id: NodeID) -> Vec<NodeID> {\\n match self.backward_states.get_state_ref(&node_id) {\\n Some(state) => match state {\\n State::Recompute { n_required: _ } => {\\n let mut sorted = Vec::new();\\n let parents = self.node_tree.parents(&node_id).unwrap();\\n for parent_node in parents {\\n let parent_sorted = self.topological_sort(parent_node);\\n for ps in parent_sorted {\\n if !sorted.contains(&ps) {\\n sorted.push(ps)\\n }\\n }\\n }\\n sorted.push(node_id);\\n sorted\\n }\\n State::Computed {\\n state_content: _,\\n n_required: _,\\n } => vec![node_id],\\n },\\n None => panic!(\\\"Node {:?} is not in the backward_states. \\\", node_id),\\n }\\n }\\n\\n #[cfg(feature = \\\"export_tests\\\")]\\n /// Checks if checkpointer has been drained adequately. Useful for testing\\n pub fn is_empty(&self) -> bool {\\n self.backward_states.is_empty() && self.retro_forwards.is_empty()\\n }\\n}\",\n \"class_signature\": \"impl Checkpointer\"\n}"}}},{"rowIdx":156,"cells":{"function_name":{"kind":"string","value":"backward"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/runtime/server.rs"},"focal_code":{"kind":"string","value":"pub fn backward(&mut self, grads: Gradients, node_id: NodeID) -> Gradients {\n let step = self.steps.remove(&node_id).expect(\n \"Node should have a step registered, did you forget to call \\\n `Tensor::register_grad` on the tensor where you need gradients?\",\n );\n let builder = self.actions_builder.remove(&node_id).unwrap();\n\n let (tape, checkpointer) = self.build_tape(node_id, step, builder);\n\n let gradients = Self::execute_steps(tape, grads, checkpointer);\n\n // Cleanup\n self.memory_management\n .free_unavailable_nodes(|node_id: &NodeID| {\n self.steps.remove(node_id);\n self.actions_builder.remove(node_id);\n });\n\n gradients\n }"},"file_content":{"kind":"string","value":"use super::memory_management::GraphMemoryManagement;\nuse crate::{\n NodeID,\n checkpoint::{\n base::{Checkpointer, NodeTree},\n builder::CheckpointerBuilder,\n },\n collections::HashMap,\n grads::Gradients,\n graph::{StepBoxed, traversal::BreadthFirstSearch},\n tensor::NodeRefCount,\n};\nuse alloc::vec::Vec;\n\n#[derive(Default)]\npub struct AutodiffServer {\n steps: HashMap<NodeID, StepBoxed>,\n actions_builder: HashMap<NodeID, CheckpointerBuilder>,\n memory_management: GraphMemoryManagement,\n}\n\nimpl AutodiffServer {\n pub fn register(&mut self, rc: NodeRefCount, step: StepBoxed, actions: CheckpointerBuilder) {\n let parents = step.parents();\n let node_id = *rc.as_ref();\n\n self.memory_management.register(rc, parents);\n\n self.steps.insert(node_id, step);\n self.actions_builder.insert(node_id, actions);\n }\n\n pub fn backward(&mut self, grads: Gradients, node_id: NodeID) -> Gradients {\n let step = self.steps.remove(&node_id).expect(\n \"Node should have a step registered, did you forget to call \\\n `Tensor::register_grad` on the tensor where you need gradients?\",\n );\n let builder = self.actions_builder.remove(&node_id).unwrap();\n\n let (tape, checkpointer) = self.build_tape(node_id, step, builder);\n\n let gradients = Self::execute_steps(tape, grads, checkpointer);\n\n // Cleanup\n self.memory_management\n .free_unavailable_nodes(|node_id: &NodeID| {\n self.steps.remove(node_id);\n self.actions_builder.remove(node_id);\n });\n\n gradients\n }\n\n fn build_tape(\n &mut self,\n node: NodeID,\n node_step: StepBoxed,\n mut builder: CheckpointerBuilder,\n ) -> (Vec<Vec<StepBoxed>>, Checkpointer) {\n let mut tape = (0..node_step.depth())\n .map(|_| Vec::with_capacity(1))\n .collect::<Vec<_>>();\n\n let mut tree = HashMap::default();\n\n BreadthFirstSearch.traverse(node, node_step, &mut self.steps, |id, step| {\n self.memory_management.consume_node(id);\n\n let depth = step.depth();\n\n if depth == 0 {\n return;\n }\n\n if let Some(steps) = tape.get_mut(depth - 1) {\n let parents = step.parents().into_iter().filter(|s| *s != id);\n tree.insert(id, parents.collect());\n steps.push(step);\n }\n\n if let Some(node_builder) = self.actions_builder.remove(&id) {\n builder.extend(node_builder);\n }\n });\n\n let checkpointer = builder.build(NodeTree::new(tree));\n\n (tape, checkpointer)\n }\n\n fn execute_steps(\n tape: Vec<Vec<StepBoxed>>,\n mut grads: Gradients,\n mut checkpointer: Checkpointer,\n ) -> Gradients {\n tape.into_iter().rev().for_each(|steps| {\n steps\n .into_iter()\n .for_each(|step| step.step(&mut grads, &mut checkpointer))\n });\n\n #[cfg(feature = \"export_tests\")]\n // For checkpointing tests\n assert!(checkpointer.is_empty());\n\n grads\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct Gradients {\\n container: TensorContainer<GradID>,\\n}\"\n ],\n \"name\": \"grads\",\n \"type\": \"Gradients\"\n },\n {\n \"definitions\": [\n \"pub struct NodeID {\\n /// The integer representation of the id\\n pub value: u64,\\n}\"\n ],\n \"name\": \"node_id\",\n \"type\": \"NodeID\"\n }\n ],\n \"end_line\": 52,\n \"name\": \"backward\",\n \"signature\": \"pub fn backward(&mut self, grads: Gradients, node_id: NodeID) -> Gradients\",\n \"start_line\": 33\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl AutodiffServer {\\n pub fn register(&mut self, rc: NodeRefCount, step: StepBoxed, actions: CheckpointerBuilder) {\\n let parents = step.parents();\\n let node_id = *rc.as_ref();\\n\\n self.memory_management.register(rc, parents);\\n\\n self.steps.insert(node_id, step);\\n self.actions_builder.insert(node_id, actions);\\n }\\n\\n pub fn backward(&mut self, grads: Gradients, node_id: NodeID) -> Gradients {\\n let step = self.steps.remove(&node_id).expect(\\n \\\"Node should have a step registered, did you forget to call \\\\\\n `Tensor::register_grad` on the tensor where you need gradients?\\\",\\n );\\n let builder = self.actions_builder.remove(&node_id).unwrap();\\n\\n let (tape, checkpointer) = self.build_tape(node_id, step, builder);\\n\\n let gradients = Self::execute_steps(tape, grads, checkpointer);\\n\\n // Cleanup\\n self.memory_management\\n .free_unavailable_nodes(|node_id: &NodeID| {\\n self.steps.remove(node_id);\\n self.actions_builder.remove(node_id);\\n });\\n\\n gradients\\n }\\n\\n fn build_tape(\\n &mut self,\\n node: NodeID,\\n node_step: StepBoxed,\\n mut builder: CheckpointerBuilder,\\n ) -> (Vec<Vec<StepBoxed>>, Checkpointer) {\\n let mut tape = (0..node_step.depth())\\n .map(|_| Vec::with_capacity(1))\\n .collect::<Vec<_>>();\\n\\n let mut tree = HashMap::default();\\n\\n BreadthFirstSearch.traverse(node, node_step, &mut self.steps, |id, step| {\\n self.memory_management.consume_node(id);\\n\\n let depth = step.depth();\\n\\n if depth == 0 {\\n return;\\n }\\n\\n if let Some(steps) = tape.get_mut(depth - 1) {\\n let parents = step.parents().into_iter().filter(|s| *s != id);\\n tree.insert(id, parents.collect());\\n steps.push(step);\\n }\\n\\n if let Some(node_builder) = self.actions_builder.remove(&id) {\\n builder.extend(node_builder);\\n }\\n });\\n\\n let checkpointer = builder.build(NodeTree::new(tree));\\n\\n (tape, checkpointer)\\n }\\n\\n fn execute_steps(\\n tape: Vec<Vec<StepBoxed>>,\\n mut grads: Gradients,\\n mut checkpointer: Checkpointer,\\n ) -> Gradients {\\n tape.into_iter().rev().for_each(|steps| {\\n steps\\n .into_iter()\\n .for_each(|step| step.step(&mut grads, &mut checkpointer))\\n });\\n\\n #[cfg(feature = \\\"export_tests\\\")]\\n // For checkpointing tests\\n assert!(checkpointer.is_empty());\\n\\n grads\\n }\\n}\",\n \"class_signature\": \"impl AutodiffServer\"\n}"}}},{"rowIdx":157,"cells":{"function_name":{"kind":"string","value":"unavailable_propagation"},"file_path":{"kind":"string","value":"burn-main/crates/burn-autodiff/src/runtime/memory_management.rs"},"focal_code":{"kind":"string","value":"fn unavailable_propagation(&mut self, node_id: NodeID) -> NodeMemoryStatus {\n // If already visited\n if let Some(status) = self.statuses.get(&node_id) {\n return status.clone();\n }\n\n match self.nodes.get(&node_id).cloned() {\n // If node exists and any of its parents is unavailable, it is unavailable as well\n // If node exists but the parents vec is empty, it is a tensor that never had parents;\n // the status remains unknown\n Some(parents) => {\n let mut node_status = NodeMemoryStatus::Unknown;\n for parent in parents {\n let parent_status = self.unavailable_propagation(parent);\n if let NodeMemoryStatus::Unavailable = parent_status {\n node_status = NodeMemoryStatus::Unavailable;\n }\n }\n self.statuses.insert(node_id, node_status.clone());\n node_status\n }\n // If node does not exist, it was\n // deleted, so this and all its descendants are unavailable\n None => {\n self.statuses.insert(node_id, NodeMemoryStatus::Unavailable);\n NodeMemoryStatus::Unavailable\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::{\n NodeID,\n collections::{HashMap, HashSet},\n tensor::NodeRefCount,\n};\nuse alloc::{borrow::ToOwned, sync::Arc, vec, vec::Vec};\nuse core::mem;\n\n#[derive(Default, Debug)]\npub struct GraphMemoryManagement {\n nodes: HashMap<NodeRefCount, Vec<NodeID>>,\n leaves: HashSet<NodeID>,\n statuses: HashMap<NodeID, NodeMemoryStatus>,\n}\n\n#[derive(Debug, Clone, PartialEq)]\nenum NodeMemoryStatus {\n Useful,\n Unavailable,\n Unknown,\n}\n\nimpl GraphMemoryManagement {\n /// Register a new node with its parent.\n pub fn register(&mut self, node: NodeRefCount, parents: Vec<NodeID>) {\n let node_id = *node.as_ref();\n\n for parent_id in parents.iter() {\n self.leaves.remove(parent_id);\n }\n\n self.leaves.insert(node_id);\n self.nodes.insert(node, parents);\n }\n\n /// Free the node from the state.\n pub fn consume_node(&mut self, node_id: NodeID) {\n if !self.is_referenced(node_id) {\n self.leaves.remove(&node_id);\n self.nodes.remove(&node_id);\n }\n }\n\n /// Free all nodes whose backward call has become impossible\n ///\n /// This function goes into three steps, which must happen for all leaves\n /// before going into the next step. Then it deletes what can be safely deleted\n pub(crate) fn free_unavailable_nodes(&mut self, mut on_free_graph: impl FnMut(&NodeID)) {\n let leaves = self.leaves.clone();\n let mut new_leaves = HashSet::new();\n let mut deletables = Vec::new();\n\n // When consuming nodes with a backward pass, some other backward passes become\n // unavailable because some of their parents have been consumed. They are\n // identified here.\n for leaf in leaves.clone() {\n self.unavailable_propagation(leaf);\n }\n\n // Among the available nodes that remain, some may be useless if no\n // available node with a tensor reference exist in their descendance.\n // But some may seem useless from some leaf but be useful from another one,\n // hence the need to iterate on all leaves.\n self.useful_propagation(leaves.clone());\n\n // New leaves are the roots of a useful backward sub-tree.\n // Deletables are everything not marked as useful.\n for leaf in leaves {\n self.identify_leaves_and_deletables(leaf, &mut new_leaves, &mut deletables);\n }\n\n // Replace leaves by the new ones and delete everything not useful anymore\n mem::swap(&mut self.leaves, &mut new_leaves);\n\n self.clear_unused_roots(&mut deletables);\n\n self.statuses.clear();\n for node_to_delete in deletables {\n self.nodes.remove(&node_to_delete);\n on_free_graph(&node_to_delete)\n }\n }\n\n fn clear_unused_roots(&mut self, to_delete: &mut Vec<NodeID>) {\n for (id, parents) in self.nodes.iter() {\n let is_useful = matches!(\n self.statuses.get(id.as_ref()),\n Some(NodeMemoryStatus::Useful)\n );\n\n // Check if parents are either empty or absent from self.nodes\n let parents_absent = parents.iter().all(|p| !self.nodes.contains_key(p));\n\n if !is_useful && Arc::strong_count(id) == 1 && parents_absent {\n to_delete.push(*id.as_ref())\n }\n }\n }\n\n fn unavailable_propagation(&mut self, node_id: NodeID) -> NodeMemoryStatus {\n // If already visited\n if let Some(status) = self.statuses.get(&node_id) {\n return status.clone();\n }\n\n match self.nodes.get(&node_id).cloned() {\n // If node exists and any of its parents is unavailable, it is unavailable as well\n // If node exists but the parents vec is empty, it is a tensor that never had parents;\n // the status remains unknown\n Some(parents) => {\n let mut node_status = NodeMemoryStatus::Unknown;\n for parent in parents {\n let parent_status = self.unavailable_propagation(parent);\n if let NodeMemoryStatus::Unavailable = parent_status {\n node_status = NodeMemoryStatus::Unavailable;\n }\n }\n self.statuses.insert(node_id, node_status.clone());\n node_status\n }\n // If node does not exist, it was\n // deleted, so this and all its descendants are unavailable\n None => {\n self.statuses.insert(node_id, NodeMemoryStatus::Unavailable);\n NodeMemoryStatus::Unavailable\n }\n }\n }\n\n fn useful_propagation(&mut self, leaves: HashSet<NodeID>) {\n // Accumulate visited nodes\n let mut explored = HashSet::new();\n let mut tagged_useful = HashSet::new();\n\n // Queue of nodes to visit\n let mut to_tag_useful = PopNodeSet::default();\n let mut to_explore = PopNodeSet::new(leaves);\n\n // Utilitary function to iterate over a node's parents\n let parents = |node_id| {\n self.nodes\n .get(&node_id)\n .cloned()\n .unwrap_or_default()\n .into_iter()\n };\n\n loop {\n // Pop a node id, greedily looking at tag_useful ones first\n let (node_id, status) = match to_tag_useful.pop() {\n Some(node_id) => (node_id, NodeMemoryStatus::Useful),\n None => match to_explore.pop() {\n Some(node_id) => {\n let node_status = self\n .statuses\n .get(&node_id)\n .expect(\"All nodes should have received a status during unavailable_propagation\")\n .to_owned();\n\n if let NodeMemoryStatus::Unknown = node_status {\n match self.is_referenced(node_id) {\n true => (node_id, NodeMemoryStatus::Useful),\n false => (node_id, NodeMemoryStatus::Unknown),\n }\n } else {\n (node_id, node_status)\n }\n }\n None => {\n // There are no nodes in the queues anymore\n break;\n }\n },\n };\n\n match status {\n NodeMemoryStatus::Useful => {\n tagged_useful.insert(node_id);\n for parent in parents(node_id) {\n // The node can be explored, as long as it's not already tagged useful\n if !(tagged_useful.contains(&parent) || to_tag_useful.contains(&parent)) {\n to_tag_useful.insert(parent);\n }\n }\n }\n _ => {\n explored.insert(node_id);\n for parent in parents(node_id) {\n if !(explored.contains(&parent) || to_explore.contains(&parent)) {\n to_explore.insert(parent);\n }\n }\n }\n }\n\n self.statuses.insert(node_id, status);\n }\n }\n\n fn identify_leaves_and_deletables(\n &self,\n leaf_id: NodeID,\n new_leaves: &mut HashSet<NodeID>,\n to_delete: &mut Vec<NodeID>,\n ) {\n let mut visited = HashSet::new();\n let mut to_visit = vec![leaf_id];\n\n while let Some(node_id) = to_visit.pop() {\n visited.insert(node_id);\n\n match self\n .statuses\n .get(&node_id)\n .expect(\"Node should have status\")\n {\n NodeMemoryStatus::Useful => {\n new_leaves.insert(node_id);\n }\n _ => {\n to_delete.push(node_id);\n\n for parent in self\n .nodes\n .get(&node_id)\n .cloned()\n .unwrap_or_default()\n .into_iter()\n {\n if !visited.contains(&parent) {\n to_visit.push(parent);\n }\n }\n }\n };\n }\n }\n\n fn is_referenced(&self, node_id: NodeID) -> bool {\n match self.nodes.get_key_value(&node_id) {\n Some((key, _value)) => Arc::strong_count(key) > 1,\n None => panic!(\"Node should be in the nodes map\"),\n }\n }\n}\n\n/// Wrapper over hash set for fast popping of any node\n#[derive(new, Default)]\nstruct PopNodeSet {\n hash_set: HashSet<NodeID>,\n}\n\nimpl PopNodeSet {\n #[inline(always)]\n fn pop(&mut self) -> Option<NodeID> {\n self.hash_set\n .iter()\n .next()\n .copied()\n .and_then(|node_id| self.hash_set.take(&node_id))\n }\n\n #[inline(always)]\n fn contains(&self, node_id: &NodeID) -> bool {\n self.hash_set.contains(node_id)\n }\n\n #[inline(always)]\n fn insert(&mut self, node_id: NodeID) {\n self.hash_set.insert(node_id);\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct NodeID {\\n /// The integer representation of the id\\n pub value: u64,\\n}\"\n ],\n \"name\": \"node_id\",\n \"type\": \"NodeID\"\n }\n ],\n \"end_line\": 128,\n \"name\": \"unavailable_propagation\",\n \"signature\": \"fn unavailable_propagation(&mut self, node_id: NodeID) -> NodeMemoryStatus\",\n \"start_line\": 100\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl GraphMemoryManagement {\\n /// Register a new node with its parent.\\n pub fn register(&mut self, node: NodeRefCount, parents: Vec<NodeID>) {\\n let node_id = *node.as_ref();\\n\\n for parent_id in parents.iter() {\\n self.leaves.remove(parent_id);\\n }\\n\\n self.leaves.insert(node_id);\\n self.nodes.insert(node, parents);\\n }\\n\\n /// Free the node from the state.\\n pub fn consume_node(&mut self, node_id: NodeID) {\\n if !self.is_referenced(node_id) {\\n self.leaves.remove(&node_id);\\n self.nodes.remove(&node_id);\\n }\\n }\\n\\n /// Free all nodes whose backward call has become impossible\\n ///\\n /// This function goes into three steps, which must happen for all leaves\\n /// before going into the next step. Then it deletes what can be safely deleted\\n pub(crate) fn free_unavailable_nodes(&mut self, mut on_free_graph: impl FnMut(&NodeID)) {\\n let leaves = self.leaves.clone();\\n let mut new_leaves = HashSet::new();\\n let mut deletables = Vec::new();\\n\\n // When consuming nodes with a backward pass, some other backward passes become\\n // unavailable because some of their parents have been consumed. They are\\n // identified here.\\n for leaf in leaves.clone() {\\n self.unavailable_propagation(leaf);\\n }\\n\\n // Among the available nodes that remain, some may be useless if no\\n // available node with a tensor reference exist in their descendance.\\n // But some may seem useless from some leaf but be useful from another one,\\n // hence the need to iterate on all leaves.\\n self.useful_propagation(leaves.clone());\\n\\n // New leaves are the roots of a useful backward sub-tree.\\n // Deletables are everything not marked as useful.\\n for leaf in leaves {\\n self.identify_leaves_and_deletables(leaf, &mut new_leaves, &mut deletables);\\n }\\n\\n // Replace leaves by the new ones and delete everything not useful anymore\\n mem::swap(&mut self.leaves, &mut new_leaves);\\n\\n self.clear_unused_roots(&mut deletables);\\n\\n self.statuses.clear();\\n for node_to_delete in deletables {\\n self.nodes.remove(&node_to_delete);\\n on_free_graph(&node_to_delete)\\n }\\n }\\n\\n fn clear_unused_roots(&mut self, to_delete: &mut Vec<NodeID>) {\\n for (id, parents) in self.nodes.iter() {\\n let is_useful = matches!(\\n self.statuses.get(id.as_ref()),\\n Some(NodeMemoryStatus::Useful)\\n );\\n\\n // Check if parents are either empty or absent from self.nodes\\n let parents_absent = parents.iter().all(|p| !self.nodes.contains_key(p));\\n\\n if !is_useful && Arc::strong_count(id) == 1 && parents_absent {\\n to_delete.push(*id.as_ref())\\n }\\n }\\n }\\n\\n fn unavailable_propagation(&mut self, node_id: NodeID) -> NodeMemoryStatus {\\n // If already visited\\n if let Some(status) = self.statuses.get(&node_id) {\\n return status.clone();\\n }\\n\\n match self.nodes.get(&node_id).cloned() {\\n // If node exists and any of its parents is unavailable, it is unavailable as well\\n // If node exists but the parents vec is empty, it is a tensor that never had parents;\\n // the status remains unknown\\n Some(parents) => {\\n let mut node_status = NodeMemoryStatus::Unknown;\\n for parent in parents {\\n let parent_status = self.unavailable_propagation(parent);\\n if let NodeMemoryStatus::Unavailable = parent_status {\\n node_status = NodeMemoryStatus::Unavailable;\\n }\\n }\\n self.statuses.insert(node_id, node_status.clone());\\n node_status\\n }\\n // If node does not exist, it was\\n // deleted, so this and all its descendants are unavailable\\n None => {\\n self.statuses.insert(node_id, NodeMemoryStatus::Unavailable);\\n NodeMemoryStatus::Unavailable\\n }\\n }\\n }\\n\\n fn useful_propagation(&mut self, leaves: HashSet<NodeID>) {\\n // Accumulate visited nodes\\n let mut explored = HashSet::new();\\n let mut tagged_useful = HashSet::new();\\n\\n // Queue of nodes to visit\\n let mut to_tag_useful = PopNodeSet::default();\\n let mut to_explore = PopNodeSet::new(leaves);\\n\\n // Utilitary function to iterate over a node's parents\\n let parents = |node_id| {\\n self.nodes\\n .get(&node_id)\\n .cloned()\\n .unwrap_or_default()\\n .into_iter()\\n };\\n\\n loop {\\n // Pop a node id, greedily looking at tag_useful ones first\\n let (node_id, status) = match to_tag_useful.pop() {\\n Some(node_id) => (node_id, NodeMemoryStatus::Useful),\\n None => match to_explore.pop() {\\n Some(node_id) => {\\n let node_status = self\\n .statuses\\n .get(&node_id)\\n .expect(\\\"All nodes should have received a status during unavailable_propagation\\\")\\n .to_owned();\\n\\n if let NodeMemoryStatus::Unknown = node_status {\\n match self.is_referenced(node_id) {\\n true => (node_id, NodeMemoryStatus::Useful),\\n false => (node_id, NodeMemoryStatus::Unknown),\\n }\\n } else {\\n (node_id, node_status)\\n }\\n }\\n None => {\\n // There are no nodes in the queues anymore\\n break;\\n }\\n },\\n };\\n\\n match status {\\n NodeMemoryStatus::Useful => {\\n tagged_useful.insert(node_id);\\n for parent in parents(node_id) {\\n // The node can be explored, as long as it's not already tagged useful\\n if !(tagged_useful.contains(&parent) || to_tag_useful.contains(&parent)) {\\n to_tag_useful.insert(parent);\\n }\\n }\\n }\\n _ => {\\n explored.insert(node_id);\\n for parent in parents(node_id) {\\n if !(explored.contains(&parent) || to_explore.contains(&parent)) {\\n to_explore.insert(parent);\\n }\\n }\\n }\\n }\\n\\n self.statuses.insert(node_id, status);\\n }\\n }\\n\\n fn identify_leaves_and_deletables(\\n &self,\\n leaf_id: NodeID,\\n new_leaves: &mut HashSet<NodeID>,\\n to_delete: &mut Vec<NodeID>,\\n ) {\\n let mut visited = HashSet::new();\\n let mut to_visit = vec![leaf_id];\\n\\n while let Some(node_id) = to_visit.pop() {\\n visited.insert(node_id);\\n\\n match self\\n .statuses\\n .get(&node_id)\\n .expect(\\\"Node should have status\\\")\\n {\\n NodeMemoryStatus::Useful => {\\n new_leaves.insert(node_id);\\n }\\n _ => {\\n to_delete.push(node_id);\\n\\n for parent in self\\n .nodes\\n .get(&node_id)\\n .cloned()\\n .unwrap_or_default()\\n .into_iter()\\n {\\n if !visited.contains(&parent) {\\n to_visit.push(parent);\\n }\\n }\\n }\\n };\\n }\\n }\\n\\n fn is_referenced(&self, node_id: NodeID) -> bool {\\n match self.nodes.get_key_value(&node_id) {\\n Some((key, _value)) => Arc::strong_count(key) > 1,\\n None => panic!(\\\"Node should be in the nodes map\\\"),\\n }\\n }\\n}\",\n \"class_signature\": \"impl GraphMemoryManagement\"\n}"}}},{"rowIdx":158,"cells":{"function_name":{"kind":"string","value":"new"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/reduce/optimization.rs"},"focal_code":{"kind":"string","value":"pub fn new(\n trace: FuseTrace,\n trace_read_fallback: FuseTrace,\n trace_write_fallback: FuseTrace,\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n len: usize,\n reduce: FusedReduce,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n ) -> Self {\n let reduce_plane = reduce.with_strategy(ReduceStrategy {\n use_planes: true,\n shared: false,\n });\n let reduce_shared_plane = reduce.with_strategy(ReduceStrategy {\n use_planes: true,\n shared: true,\n });\n Self {\n trace,\n trace_read_fallback,\n trace_write_fallback,\n client,\n device,\n len,\n reduce,\n reduce_plane,\n reduce_shared_plane,\n fallback,\n }\n }"},"file_content":{"kind":"string","value":"use std::sync::Arc;\n\nuse burn_fusion::stream::Context;\nuse burn_ir::{ReduceDimOpIr, TensorStatus};\nuse burn_tensor::DType;\nuse cubecl::prelude::*;\nuse cubecl::reduce::instructions::{ReduceFn, ReduceFnConfig};\nuse cubecl::reduce::{BoundChecksInner, ReduceFamily, ReduceParams, ReduceStrategy, reduce_kernel};\nuse cubecl::{\n CubeCount, CubeDim, Runtime,\n client::ComputeClient,\n reduce::{LineMode, ReduceConfig, ReduceError},\n};\nuse half::{bf16, f16};\nuse serde::{Deserialize, Serialize};\n\nuse crate::CubeFusionHandle;\nuse crate::elemwise::optimization::ElemwiseRunner;\nuse crate::shared::ir::{FusePrecision, RefLayout};\nuse crate::shared::trace::{TraceError, TraceRunner};\nuse crate::shared::trace::{TuneOutput, Vectorization};\nuse crate::shared::{\n ir::{Arg, FuseBlockConfig, GlobalArgsLaunch},\n trace::FuseTrace,\n};\n\nuse super::args::{FusedReduceArgs, FusedReduceInputLaunch, FusedReduceOutputLaunch};\nuse super::tune::fused_reduce_autotune;\n\npub struct ReduceOptimization<R: Runtime> {\n pub(crate) trace: FuseTrace,\n trace_read_fallback: FuseTrace,\n trace_write_fallback: FuseTrace,\n pub(crate) client: ComputeClient<R::Server, R::Channel>,\n pub(crate) device: R::Device,\n pub(crate) len: usize,\n pub(crate) reduce: FusedReduce,\n pub(crate) reduce_plane: FusedReduce,\n pub(crate) reduce_shared_plane: FusedReduce,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n}\n\n#[derive(Clone, Copy, Serialize, Deserialize, Debug)]\npub enum ReduceInstruction {\n ArgMax,\n ArgMin,\n Mean,\n Prod,\n Sum,\n Max,\n Min,\n MaxAbs,\n}\n\npub trait ReduceFallbackFn<R: Runtime>: Send + Sync {\n fn run(\n &self,\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n dtype_out: &DType,\n dtype_acc: &DType,\n ) -> CubeFusionHandle<R>;\n}\n\n#[derive(Serialize, Deserialize, Debug)]\npub struct ReduceOptimizationState {\n trace: FuseTrace,\n trace_read_fallback: FuseTrace,\n trace_write_fallback: FuseTrace,\n pub(crate) reduce: FusedReduce,\n pub(crate) reduce_plane: FusedReduce,\n pub(crate) reduce_shared_plane: FusedReduce,\n len: usize,\n}\n\n#[derive(new, Clone, Serialize, Deserialize, Debug)]\npub struct FusedReduce {\n input: Arg,\n output: Arg,\n pub(crate) acc: FusePrecision,\n pub(crate) axis: usize,\n pub(crate) op: ReduceDimOpIr,\n strategy: ReduceStrategy,\n inst: ReduceInstruction,\n}\n\nimpl FusedReduce {\n pub fn with_strategy(&self, strategy: ReduceStrategy) -> Self {\n Self {\n input: self.input.clone(),\n output: self.output.clone(),\n acc: self.acc,\n axis: self.axis,\n op: self.op.clone(),\n strategy,\n inst: self.inst,\n }\n }\n}\n\n#[derive(Debug)]\npub enum FusedReduceError {\n LaunchError(ReduceError),\n InvalidSelection(Box<&'static str>),\n InvalidInput,\n}\n\n#[allow(clippy::too_many_arguments)]\nimpl<R: Runtime> ReduceOptimization<R> {\n pub fn new(\n trace: FuseTrace,\n trace_read_fallback: FuseTrace,\n trace_write_fallback: FuseTrace,\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n len: usize,\n reduce: FusedReduce,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n ) -> Self {\n let reduce_plane = reduce.with_strategy(ReduceStrategy {\n use_planes: true,\n shared: false,\n });\n let reduce_shared_plane = reduce.with_strategy(ReduceStrategy {\n use_planes: true,\n shared: true,\n });\n Self {\n trace,\n trace_read_fallback,\n trace_write_fallback,\n client,\n device,\n len,\n reduce,\n reduce_plane,\n reduce_shared_plane,\n fallback,\n }\n }\n /// Execute the optimization.\n pub fn execute<BT: CubeElement>(&mut self, context: &mut Context<'_, CubeFusionHandle<R>>) {\n #[cfg(feature = \"autotune\")]\n fused_reduce_autotune::<R, BT>(self, context);\n\n #[cfg(not(feature = \"autotune\"))]\n if self.execute_fused_reduce::<BT>(context).is_err() {\n self.execute_fallback::<BT>(context);\n }\n }\n\n pub fn num_output_buffers(&self) -> usize {\n self.trace_read_fallback.resources.outputs.len()\n }\n\n pub fn to_state(&self) -> ReduceOptimizationState {\n ReduceOptimizationState {\n trace: self.trace.clone(),\n trace_read_fallback: self.trace_read_fallback.clone(),\n trace_write_fallback: self.trace_write_fallback.clone(),\n reduce: self.reduce.clone(),\n reduce_plane: self.reduce_plane.clone(),\n reduce_shared_plane: self.reduce_shared_plane.clone(),\n len: self.len,\n }\n }\n\n pub fn from_state(\n device: &R::Device,\n state: ReduceOptimizationState,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n ) -> Self {\n let client = R::client(device);\n\n Self {\n trace: state.trace,\n trace_read_fallback: state.trace_read_fallback,\n trace_write_fallback: state.trace_write_fallback,\n reduce: state.reduce,\n reduce_plane: state.reduce_plane,\n reduce_shared_plane: state.reduce_shared_plane,\n fallback,\n len: state.len,\n client,\n device: device.clone(),\n }\n }\n\n pub fn execute_fused_reduce<BT: CubeElement>(\n &self,\n context: &mut Context<'_, CubeFusionHandle<R>>,\n ) -> Result<TuneOutput<R>, TraceError<FusedReduceError>> {\n FuseTrace::run::<R, BT, FusedReduce>(\n &self.trace,\n &self.client,\n &self.device,\n context,\n &self.reduce,\n )\n }\n\n pub fn execute_fused_reduce_plane<BT: CubeElement>(\n &self,\n context: &mut Context<'_, CubeFusionHandle<R>>,\n ) -> Result<TuneOutput<R>, TraceError<FusedReduceError>> {\n FuseTrace::run::<R, BT, FusedReduce>(\n &self.trace,\n &self.client,\n &self.device,\n context,\n &self.reduce_plane,\n )\n }\n\n pub fn execute_fused_reduce_shared_plane<BT: CubeElement>(\n &self,\n context: &mut Context<'_, CubeFusionHandle<R>>,\n ) -> Result<TuneOutput<R>, TraceError<FusedReduceError>> {\n FuseTrace::run::<R, BT, FusedReduce>(\n &self.trace,\n &self.client,\n &self.device,\n context,\n &self.reduce_shared_plane,\n )\n }\n\n pub fn execute_fallback<BT: CubeElement>(\n &self,\n context: &mut Context<'_, CubeFusionHandle<R>>,\n ) -> TuneOutput<R> {\n #[allow(unused_mut)] // It is used when #[cfg(test)] is true.\n let mut output_read = self\n .trace_read_fallback\n .run::<R, BT, ElemwiseRunner>(&self.client, &self.device, context, &ElemwiseRunner)\n .unwrap();\n\n let (out_tensor, out_desc) = {\n let input = context\n .tensors\n .get(&self.reduce.op.input.id)\n .unwrap()\n .clone();\n let out = context.tensors.get(&self.reduce.op.out.id).unwrap().clone();\n\n let input_handle = context\n .handles\n .get_handle(&input.id, &TensorStatus::ReadOnly);\n let acc = self.reduce.acc.into_elem().into();\n let out_handle = self.fallback.run(\n input_handle,\n &input.shape,\n self.reduce.op.axis,\n &self.reduce.inst,\n &self.reduce.op.out.dtype,\n &acc,\n );\n\n (out_handle, out)\n };\n #[cfg(feature = \"autotune-checks\")]\n if let TuneOutput::Checked { handles } = &mut output_read {\n handles.insert(\n self.reduce.op.out.id,\n (out_desc.shape.clone(), out_tensor.clone()),\n );\n }\n context.handles.register_handle(out_desc.id, out_tensor);\n let output_write = self\n .trace_write_fallback\n .run::<R, BT, ElemwiseRunner>(&self.client, &self.device, context, &ElemwiseRunner)\n .unwrap();\n\n output_read.merge(output_write)\n }\n /// Returns the number of output buffers added by fusion.\n pub fn num_ops_fused(&self) -> usize {\n self.len\n }\n}\n\nimpl<R: Runtime> Vectorization<R> for FusedReduce {}\n\nimpl<R: Runtime> TraceRunner<R> for FusedReduce {\n type Error = FusedReduceError;\n\n fn run<'a>(\n &'a self,\n client: &'a ComputeClient<R::Server, R::Channel>,\n inputs: GlobalArgsLaunch<'a, R>,\n outputs: GlobalArgsLaunch<'a, R>,\n configs: &'a [FuseBlockConfig],\n ) -> Result<(), FusedReduceError> {\n let [config_read, config_write] = [&configs[0], &configs[1]];\n self.strategy\n .validate::<R>(client)\n .map_err(FusedReduceError::LaunchError)?;\n\n let strategy = self.strategy;\n let shape = match &config_read.ref_layout {\n RefLayout::Concrete(Arg::Output(..)) => {\n outputs.shape_ref(&config_read.ref_layout, config_read.rank as usize)\n }\n _ => inputs.shape_ref(&config_read.ref_layout, config_read.rank as usize),\n };\n\n let reduce_count: u32 = shape\n .iter()\n .enumerate()\n .map(|(i, s)| if i == self.axis { 1 } else { *s as u32 })\n .product();\n\n let line_mode = match self.axis == config_read.rank as usize - 1 {\n true => LineMode::Parallel, // axis de vectorization == axis de reduce.\n false => LineMode::Perpendicular,\n };\n\n let config_reduce = ReduceConfig {\n cube_count: CubeCount::new_single(),\n cube_dim: CubeDim::new_single(),\n line_mode,\n line_size_input: config_read.width as u32,\n line_size_output: config_write.width as u32,\n bound_checks: false,\n bound_checks_inner: if strategy.use_planes {\n BoundChecksInner::Branch\n } else {\n BoundChecksInner::Mask\n },\n }\n .generate_cube_dim(client, strategy.use_planes)\n .generate_cube_count::<R>(reduce_count, &strategy);\n\n if let CubeCount::Static(x, y, z) = config_reduce.cube_count {\n let (max_x, max_y, max_z) = R::max_cube_count();\n if x > max_x || y > max_y || z > max_z {\n return Err(FusedReduceError::LaunchError(\n ReduceError::CubeCountTooLarge,\n ));\n }\n }\n\n let kwargs = ReduceKwArgs {\n client,\n inputs,\n outputs,\n axis: self.axis as u32,\n strategy: &strategy,\n config_reduce,\n config_fuse_read: config_read,\n config_fuse_write: config_write,\n input: &self.input,\n output: &self.output,\n };\n launch_reduce_mixed_precision::<R>(\n kwargs,\n self.inst,\n self.op.input.dtype,\n self.op.out.dtype,\n DType::from(self.acc.into_elem()),\n );\n\n Ok(())\n }\n}\n\nstruct ReduceKwArgs<'a, 'b, Run: Runtime> {\n client: &'b ComputeClient<Run::Server, Run::Channel>,\n inputs: GlobalArgsLaunch<'a, Run>,\n outputs: GlobalArgsLaunch<'a, Run>,\n axis: u32,\n strategy: &'b ReduceStrategy,\n config_reduce: ReduceConfig,\n config_fuse_read: &'a FuseBlockConfig,\n config_fuse_write: &'a FuseBlockConfig,\n input: &'a Arg,\n output: &'a Arg,\n}\n\nfn launch_reduce_mixed_precision<Run: Runtime>(\n kwargs: ReduceKwArgs<'_, '_, Run>,\n instruction: ReduceInstruction,\n dtype_input: DType,\n dtype_output: DType,\n dtype_acc: DType,\n) {\n let config = match instruction {\n ReduceInstruction::ArgMax => ReduceFnConfig::ArgMax,\n ReduceInstruction::ArgMin => ReduceFnConfig::ArgMin,\n ReduceInstruction::Prod => ReduceFnConfig::Prod,\n ReduceInstruction::Mean => ReduceFnConfig::Mean,\n ReduceInstruction::Sum => ReduceFnConfig::Sum,\n ReduceInstruction::Max => ReduceFnConfig::Max,\n ReduceInstruction::Min => ReduceFnConfig::Min,\n ReduceInstruction::MaxAbs => ReduceFnConfig::MaxAbs,\n };\n launch_reduce_with_family::<Run, ReduceFn>(kwargs, dtype_input, dtype_output, dtype_acc, config)\n}\n\nfn launch_reduce_with_family<Run: Runtime, Rd: ReduceFamily>(\n kwargs: ReduceKwArgs<'_, '_, Run>,\n dtype_input: DType,\n dtype_output: DType,\n dtype_acc: DType,\n config: Rd::Config,\n) {\n match dtype_input {\n DType::F64 => {\n launch_reduce_output_acc::<Run, f64, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::F32 | DType::Flex32 => {\n launch_reduce_output_acc::<Run, f32, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::F16 => {\n launch_reduce_output_acc::<Run, f16, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::BF16 => {\n launch_reduce_output_acc::<Run, bf16, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::I64 => {\n launch_reduce_output_acc::<Run, i64, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::I32 => {\n launch_reduce_output_acc::<Run, i32, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::I16 => {\n launch_reduce_output_acc::<Run, i16, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::I8 => {\n launch_reduce_output_acc::<Run, i8, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::U64 => {\n launch_reduce_output_acc::<Run, u64, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::U32 => {\n launch_reduce_output_acc::<Run, u32, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::U16 => {\n launch_reduce_output_acc::<Run, u16, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n DType::U8 => {\n launch_reduce_output_acc::<Run, u8, Rd>(kwargs, dtype_output, dtype_acc, config)\n }\n _ => panic!(\"Unsupported\"),\n }\n}\n\nfn launch_reduce_output_acc<Run: Runtime, In: Numeric, Rd: ReduceFamily>(\n kwargs: ReduceKwArgs<'_, '_, Run>,\n dtype_output: DType,\n dtype_acc: DType,\n config: Rd::Config,\n) {\n match dtype_output {\n DType::F64 => launch_reduce_acc::<Run, In, f64, Rd>(kwargs, dtype_acc, config),\n DType::F32 | DType::Flex32 => {\n launch_reduce_acc::<Run, In, f32, Rd>(kwargs, dtype_acc, config)\n }\n DType::F16 => launch_reduce_acc::<Run, In, f16, Rd>(kwargs, dtype_acc, config),\n DType::BF16 => launch_reduce_acc::<Run, In, bf16, Rd>(kwargs, dtype_acc, config),\n DType::I64 => launch_reduce_acc::<Run, In, i64, Rd>(kwargs, dtype_acc, config),\n DType::I32 => launch_reduce_acc::<Run, In, i32, Rd>(kwargs, dtype_acc, config),\n DType::I16 => launch_reduce_acc::<Run, In, i16, Rd>(kwargs, dtype_acc, config),\n DType::I8 => launch_reduce_acc::<Run, In, i8, Rd>(kwargs, dtype_acc, config),\n DType::U64 => launch_reduce_acc::<Run, In, u64, Rd>(kwargs, dtype_acc, config),\n DType::U32 => launch_reduce_acc::<Run, In, u32, Rd>(kwargs, dtype_acc, config),\n DType::U16 => launch_reduce_acc::<Run, In, u16, Rd>(kwargs, dtype_acc, config),\n DType::U8 => launch_reduce_acc::<Run, In, u8, Rd>(kwargs, dtype_acc, config),\n _ => panic!(\"Unsupported\"),\n }\n}\n\nfn launch_reduce_acc<Run: Runtime, In: Numeric, Out: Numeric, Rd: ReduceFamily>(\n kwargs: ReduceKwArgs<'_, '_, Run>,\n dtype_acc: DType,\n config: Rd::Config,\n) {\n match dtype_acc {\n DType::F64 => launch_reduce::<Run, In, Out, f64, Rd>(kwargs, config),\n DType::F32 | DType::Flex32 => launch_reduce::<Run, In, Out, f32, Rd>(kwargs, config),\n DType::F16 => launch_reduce::<Run, In, Out, f16, Rd>(kwargs, config),\n DType::BF16 => launch_reduce::<Run, In, Out, bf16, Rd>(kwargs, config),\n DType::I64 => launch_reduce::<Run, In, Out, i64, Rd>(kwargs, config),\n DType::I32 => launch_reduce::<Run, In, Out, i32, Rd>(kwargs, config),\n DType::I16 => launch_reduce::<Run, In, Out, i16, Rd>(kwargs, config),\n DType::I8 => launch_reduce::<Run, In, Out, i8, Rd>(kwargs, config),\n DType::U64 => launch_reduce::<Run, In, Out, u64, Rd>(kwargs, config),\n DType::U32 => launch_reduce::<Run, In, Out, u32, Rd>(kwargs, config),\n DType::U16 => launch_reduce::<Run, In, Out, u16, Rd>(kwargs, config),\n DType::U8 => launch_reduce::<Run, In, Out, u8, Rd>(kwargs, config),\n _ => panic!(\"Unsupported\"),\n }\n}\n\nfn launch_reduce<Run: Runtime, In: Numeric, Acc: Numeric, Out: Numeric, Rd: ReduceFamily>(\n kwargs: ReduceKwArgs<'_, '_, Run>,\n config: Rd::Config,\n) {\n let settings = ReduceParams {\n shared: kwargs.strategy.shared.then(|| {\n if kwargs.strategy.use_planes {\n kwargs.config_reduce.cube_dim.y\n } else {\n kwargs.config_reduce.cube_dim.num_elems()\n }\n }),\n use_planes: kwargs.strategy.use_planes,\n line_size_input: kwargs.config_reduce.line_size_input,\n line_size_output: kwargs.config_reduce.line_size_output,\n line_mode: kwargs.config_reduce.line_mode,\n bound_checks: kwargs.config_reduce.bound_checks,\n bound_checks_inner: kwargs.config_reduce.bound_checks_inner,\n };\n\n unsafe {\n reduce_kernel::launch_unchecked::<In, Out, Acc, Rd, FusedReduceArgs, Run>(\n kwargs.client,\n kwargs.config_reduce.cube_count,\n kwargs.config_reduce.cube_dim,\n FusedReduceInputLaunch::new(kwargs.inputs, kwargs.config_fuse_read, kwargs.input),\n FusedReduceOutputLaunch::new(kwargs.outputs, kwargs.config_fuse_write, kwargs.output),\n ScalarArg::new(kwargs.axis),\n settings,\n config,\n );\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct FuseTrace {\\n pub blocks: Vec<FuseBlock>,\\n pub resources: FuseResources,\\n}\"\n ],\n \"name\": \"trace\",\n \"type\": \"FuseTrace\"\n },\n {\n \"definitions\": [\n \"pub struct FuseTrace {\\n pub blocks: Vec<FuseBlock>,\\n pub resources: FuseResources,\\n}\"\n ],\n \"name\": \"trace_read_fallback\",\n \"type\": \"FuseTrace\"\n },\n {\n \"definitions\": [\n \"pub struct FuseTrace {\\n pub blocks: Vec<FuseBlock>,\\n pub resources: FuseResources,\\n}\"\n ],\n \"name\": \"trace_write_fallback\",\n \"type\": \"FuseTrace\"\n },\n {\n \"definitions\": [\n \"pub struct FusedReduce {\\n input: Arg,\\n output: Arg,\\n pub(crate) acc: FusePrecision,\\n pub(crate) axis: usize,\\n pub(crate) op: ReduceDimOpIr,\\n strategy: ReduceStrategy,\\n inst: ReduceInstruction,\\n}\"\n ],\n \"name\": \"reduce\",\n \"type\": \"FusedReduce\"\n },\n {\n \"definitions\": [\n \"> {\\n ptr: NonNull<ArcInner<T>>,\\n phantom: PhantomData<ArcInner<T>>,\\n alloc: A,\\n}\"\n ],\n \"name\": \"fallback\",\n \"type\": \"Arc<dyn ReduceFallbackFn<R>>\"\n }\n ],\n \"end_line\": 142,\n \"name\": \"new\",\n \"signature\": \"pub fn new(\\n trace: FuseTrace,\\n trace_read_fallback: FuseTrace,\\n trace_write_fallback: FuseTrace,\\n client: ComputeClient<R::Server, R::Channel>,\\n device: R::Device,\\n len: usize,\\n reduce: FusedReduce,\\n fallback: Arc<dyn ReduceFallbackFn<R>>,\\n ) -> Self\",\n \"start_line\": 112\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R: Runtime> ReduceOptimization<R> {\\n pub fn new(\\n trace: FuseTrace,\\n trace_read_fallback: FuseTrace,\\n trace_write_fallback: FuseTrace,\\n client: ComputeClient<R::Server, R::Channel>,\\n device: R::Device,\\n len: usize,\\n reduce: FusedReduce,\\n fallback: Arc<dyn ReduceFallbackFn<R>>,\\n ) -> Self {\\n let reduce_plane = reduce.with_strategy(ReduceStrategy {\\n use_planes: true,\\n shared: false,\\n });\\n let reduce_shared_plane = reduce.with_strategy(ReduceStrategy {\\n use_planes: true,\\n shared: true,\\n });\\n Self {\\n trace,\\n trace_read_fallback,\\n trace_write_fallback,\\n client,\\n device,\\n len,\\n reduce,\\n reduce_plane,\\n reduce_shared_plane,\\n fallback,\\n }\\n }\\n /// Execute the optimization.\\n pub fn execute<BT: CubeElement>(&mut self, context: &mut Context<'_, CubeFusionHandle<R>>) {\\n #[cfg(feature = \\\"autotune\\\")]\\n fused_reduce_autotune::<R, BT>(self, context);\\n\\n #[cfg(not(feature = \\\"autotune\\\"))]\\n if self.execute_fused_reduce::<BT>(context).is_err() {\\n self.execute_fallback::<BT>(context);\\n }\\n }\\n\\n pub fn num_output_buffers(&self) -> usize {\\n self.trace_read_fallback.resources.outputs.len()\\n }\\n\\n pub fn to_state(&self) -> ReduceOptimizationState {\\n ReduceOptimizationState {\\n trace: self.trace.clone(),\\n trace_read_fallback: self.trace_read_fallback.clone(),\\n trace_write_fallback: self.trace_write_fallback.clone(),\\n reduce: self.reduce.clone(),\\n reduce_plane: self.reduce_plane.clone(),\\n reduce_shared_plane: self.reduce_shared_plane.clone(),\\n len: self.len,\\n }\\n }\\n\\n pub fn from_state(\\n device: &R::Device,\\n state: ReduceOptimizationState,\\n fallback: Arc<dyn ReduceFallbackFn<R>>,\\n ) -> Self {\\n let client = R::client(device);\\n\\n Self {\\n trace: state.trace,\\n trace_read_fallback: state.trace_read_fallback,\\n trace_write_fallback: state.trace_write_fallback,\\n reduce: state.reduce,\\n reduce_plane: state.reduce_plane,\\n reduce_shared_plane: state.reduce_shared_plane,\\n fallback,\\n len: state.len,\\n client,\\n device: device.clone(),\\n }\\n }\\n\\n pub fn execute_fused_reduce<BT: CubeElement>(\\n &self,\\n context: &mut Context<'_, CubeFusionHandle<R>>,\\n ) -> Result<TuneOutput<R>, TraceError<FusedReduceError>> {\\n FuseTrace::run::<R, BT, FusedReduce>(\\n &self.trace,\\n &self.client,\\n &self.device,\\n context,\\n &self.reduce,\\n )\\n }\\n\\n pub fn execute_fused_reduce_plane<BT: CubeElement>(\\n &self,\\n context: &mut Context<'_, CubeFusionHandle<R>>,\\n ) -> Result<TuneOutput<R>, TraceError<FusedReduceError>> {\\n FuseTrace::run::<R, BT, FusedReduce>(\\n &self.trace,\\n &self.client,\\n &self.device,\\n context,\\n &self.reduce_plane,\\n )\\n }\\n\\n pub fn execute_fused_reduce_shared_plane<BT: CubeElement>(\\n &self,\\n context: &mut Context<'_, CubeFusionHandle<R>>,\\n ) -> Result<TuneOutput<R>, TraceError<FusedReduceError>> {\\n FuseTrace::run::<R, BT, FusedReduce>(\\n &self.trace,\\n &self.client,\\n &self.device,\\n context,\\n &self.reduce_shared_plane,\\n )\\n }\\n\\n pub fn execute_fallback<BT: CubeElement>(\\n &self,\\n context: &mut Context<'_, CubeFusionHandle<R>>,\\n ) -> TuneOutput<R> {\\n #[allow(unused_mut)] // It is used when #[cfg(test)] is true.\\n let mut output_read = self\\n .trace_read_fallback\\n .run::<R, BT, ElemwiseRunner>(&self.client, &self.device, context, &ElemwiseRunner)\\n .unwrap();\\n\\n let (out_tensor, out_desc) = {\\n let input = context\\n .tensors\\n .get(&self.reduce.op.input.id)\\n .unwrap()\\n .clone();\\n let out = context.tensors.get(&self.reduce.op.out.id).unwrap().clone();\\n\\n let input_handle = context\\n .handles\\n .get_handle(&input.id, &TensorStatus::ReadOnly);\\n let acc = self.reduce.acc.into_elem().into();\\n let out_handle = self.fallback.run(\\n input_handle,\\n &input.shape,\\n self.reduce.op.axis,\\n &self.reduce.inst,\\n &self.reduce.op.out.dtype,\\n &acc,\\n );\\n\\n (out_handle, out)\\n };\\n #[cfg(feature = \\\"autotune-checks\\\")]\\n if let TuneOutput::Checked { handles } = &mut output_read {\\n handles.insert(\\n self.reduce.op.out.id,\\n (out_desc.shape.clone(), out_tensor.clone()),\\n );\\n }\\n context.handles.register_handle(out_desc.id, out_tensor);\\n let output_write = self\\n .trace_write_fallback\\n .run::<R, BT, ElemwiseRunner>(&self.client, &self.device, context, &ElemwiseRunner)\\n .unwrap();\\n\\n output_read.merge(output_write)\\n }\\n /// Returns the number of output buffers added by fusion.\\n pub fn num_ops_fused(&self) -> usize {\\n self.len\\n }\\n}\",\n \"class_signature\": \"impl<R: Runtime> ReduceOptimization<R>\"\n}"}}},{"rowIdx":159,"cells":{"function_name":{"kind":"string","value":"new"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/reduce/builder.rs"},"focal_code":{"kind":"string","value":"pub fn new(\n device: R::Device,\n bool_precision: FusePrecision,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n ) -> Self {\n let client = R::client(&device);\n let props = client.properties();\n let max_bindings = props.hardware_properties().max_bindings;\n let settings_read = FuseSettings {\n broadcast: true,\n output_shape_updates: true,\n inplace: true,\n vectorization: VectorizationSetting::Activated,\n };\n let settings_write = FuseSettings {\n broadcast: true,\n output_shape_updates: false,\n inplace: true,\n vectorization: VectorizationSetting::SmallerOrEqualThanPreviousBlock,\n };\n\n Self {\n builder: FuseOptimizationBuilder::new(max_bindings, bool_precision, settings_read),\n builder_read_fallback: FuseOptimizationBuilder::new(\n max_bindings,\n bool_precision,\n settings_read,\n ),\n builder_write_fallback: FuseOptimizationBuilder::new(\n max_bindings,\n bool_precision,\n settings_write,\n ),\n device,\n reduce: None,\n status: OptimizationStatus::Open,\n fallback,\n }\n }"},"file_content":{"kind":"string","value":"use std::sync::Arc;\n\nuse super::optimization::ReduceInstruction;\nuse burn_fusion::{OptimizationBuilder, OptimizationStatus};\nuse burn_ir::{NumericOperationIr, OperationIr, ReduceDimOpIr};\nuse cubecl::{Runtime, reduce::ReduceStrategy};\n\nuse crate::{\n CubeOptimization,\n shared::{\n builder::FuseOptimizationBuilder,\n ir::FusePrecision,\n settings::{FuseSettings, VectorizationSetting},\n },\n};\n\nuse super::optimization::{FusedReduce, ReduceFallbackFn, ReduceOptimization};\n\n/// Fused element wise operations that are normally memory bound.\npub struct ReduceBuilder<R: Runtime> {\n builder: FuseOptimizationBuilder,\n builder_read_fallback: FuseOptimizationBuilder,\n builder_write_fallback: FuseOptimizationBuilder,\n device: R::Device,\n reduce: Option<FusedReduce>,\n status: OptimizationStatus,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n}\n\nimpl<R: Runtime> ReduceBuilder<R> {\n pub fn new(\n device: R::Device,\n bool_precision: FusePrecision,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n ) -> Self {\n let client = R::client(&device);\n let props = client.properties();\n let max_bindings = props.hardware_properties().max_bindings;\n let settings_read = FuseSettings {\n broadcast: true,\n output_shape_updates: true,\n inplace: true,\n vectorization: VectorizationSetting::Activated,\n };\n let settings_write = FuseSettings {\n broadcast: true,\n output_shape_updates: false,\n inplace: true,\n vectorization: VectorizationSetting::SmallerOrEqualThanPreviousBlock,\n };\n\n Self {\n builder: FuseOptimizationBuilder::new(max_bindings, bool_precision, settings_read),\n builder_read_fallback: FuseOptimizationBuilder::new(\n max_bindings,\n bool_precision,\n settings_read,\n ),\n builder_write_fallback: FuseOptimizationBuilder::new(\n max_bindings,\n bool_precision,\n settings_write,\n ),\n device,\n reduce: None,\n status: OptimizationStatus::Open,\n fallback,\n }\n }\n\n fn on_reduce(&mut self, op: &ReduceDimOpIr, inst: ReduceInstruction) {\n if self.builder.current_output_shape != op.input.shape {\n self.builder.close();\n self.builder_read_fallback.close();\n self.status = OptimizationStatus::Closed;\n return;\n }\n\n let Some([input]) = self\n .builder\n .next_block([&op.input], self.builder_write_fallback.settings)\n else {\n self.builder.close();\n self.builder_read_fallback.close();\n self.status = OptimizationStatus::Closed;\n return;\n };\n\n let output = self.builder.output_unhandled(&op.out);\n let axis = op.axis;\n\n // We only activate fuse-on-write when the reduction isn't on the last dimension, otherwise\n // vectorization is impossible. Only [LineMode::Perpendicular] supports vectorization.\n //\n // We could still fuse some output operations, but it would probably lead to worse performance.\n let fuse_on_write_activated = axis != op.input.shape.len() - 1;\n\n if fuse_on_write_activated {\n self.status = OptimizationStatus::Open;\n } else {\n self.status = OptimizationStatus::Closed;\n }\n\n let acc = match inst {\n ReduceInstruction::Mean | ReduceInstruction::Prod | ReduceInstruction::Sum => {\n match input.precision() {\n FusePrecision::F16 | FusePrecision::BF16 => FusePrecision::F32,\n FusePrecision::I16 | FusePrecision::I8 => FusePrecision::I32,\n FusePrecision::U16 | FusePrecision::U8 => FusePrecision::U32,\n _ => input.precision(),\n }\n }\n _ => input.precision(),\n };\n\n self.reduce = Some(FusedReduce::new(\n input,\n output,\n acc,\n axis,\n op.clone(),\n ReduceStrategy {\n shared: false,\n use_planes: false,\n },\n inst,\n ));\n self.builder_read_fallback.close();\n }\n\n fn on_elemwise_read(&mut self, operation: &OperationIr) {\n self.builder.register(operation);\n\n if self.builder_read_fallback.len() < self.builder.len() {\n self.builder_read_fallback.register(operation);\n }\n\n self.status = self.builder.status();\n }\n\n fn on_elemwise_write(&mut self, operation: &OperationIr) {\n self.builder.register(operation);\n\n let num_ops_write = self.builder.len() - self.builder_read_fallback.len();\n\n if self.builder_write_fallback.len() < num_ops_write {\n self.builder_write_fallback.register(operation);\n }\n\n self.status = self.builder.status();\n }\n}\n\nimpl<R: Runtime> OptimizationBuilder<CubeOptimization<R>> for ReduceBuilder<R> {\n fn register(&mut self, operation: &OperationIr) {\n if let OptimizationStatus::Closed = self.status {\n return;\n }\n\n if self.reduce.is_none() {\n if let OperationIr::NumericFloat(_, op) = operation {\n match op {\n NumericOperationIr::SumDim(op) => {\n self.on_reduce(op, ReduceInstruction::Sum);\n }\n NumericOperationIr::MeanDim(op) => {\n self.on_reduce(op, ReduceInstruction::Mean);\n }\n NumericOperationIr::ProdDim(op) => {\n self.on_reduce(op, ReduceInstruction::Prod);\n }\n NumericOperationIr::ArgMax(op) => {\n self.on_reduce(op, ReduceInstruction::ArgMax);\n }\n NumericOperationIr::ArgMin(op) => {\n self.on_reduce(op, ReduceInstruction::ArgMin);\n }\n NumericOperationIr::MinDim(op) => {\n self.on_reduce(op, ReduceInstruction::Min);\n }\n NumericOperationIr::MaxDim(op) => {\n self.on_reduce(op, ReduceInstruction::Max);\n }\n NumericOperationIr::MaxAbsDim(op) => {\n self.on_reduce(op, ReduceInstruction::MaxAbs);\n }\n _ => {\n self.on_elemwise_read(operation);\n }\n };\n } else if let OperationIr::NumericInt(_, op) = operation {\n match op {\n NumericOperationIr::SumDim(op) => {\n self.on_reduce(op, ReduceInstruction::Sum);\n }\n NumericOperationIr::MeanDim(op) => {\n self.on_reduce(op, ReduceInstruction::Mean);\n }\n NumericOperationIr::ProdDim(op) => {\n self.on_reduce(op, ReduceInstruction::Prod);\n }\n NumericOperationIr::ArgMax(op) => {\n self.on_reduce(op, ReduceInstruction::ArgMax);\n }\n NumericOperationIr::ArgMin(op) => {\n self.on_reduce(op, ReduceInstruction::ArgMin);\n }\n NumericOperationIr::MinDim(op) => {\n self.on_reduce(op, ReduceInstruction::Min);\n }\n NumericOperationIr::MaxDim(op) => {\n self.on_reduce(op, ReduceInstruction::Max);\n }\n NumericOperationIr::MaxAbsDim(op) => {\n self.on_reduce(op, ReduceInstruction::MaxAbs);\n }\n _ => {\n self.on_elemwise_read(operation);\n }\n };\n } else {\n self.on_elemwise_read(operation);\n }\n } else {\n self.on_elemwise_write(operation);\n }\n }\n\n fn build(&self) -> CubeOptimization<R> {\n let client = R::client(&self.device);\n let trace = self.builder.build();\n let trace_read_fallback = self.builder_read_fallback.build();\n let trace_write_fallback = self.builder_write_fallback.build();\n let fuse_reduce = self.reduce.as_ref().unwrap();\n\n let reduce = ReduceOptimization::<R>::new(\n trace,\n trace_read_fallback,\n trace_write_fallback,\n client,\n self.device.clone(),\n self.len(),\n fuse_reduce.clone(),\n self.fallback.clone(),\n );\n\n CubeOptimization::Reduce(reduce)\n }\n\n fn reset(&mut self) {\n self.builder.reset();\n self.builder_read_fallback.reset();\n self.builder_write_fallback.reset();\n self.reduce = None;\n self.status = OptimizationStatus::Open;\n }\n\n fn status(&self) -> burn_fusion::OptimizationStatus {\n self.status\n }\n\n fn properties(&self) -> burn_fusion::OptimizationProperties {\n let mut properties = self.builder.properties();\n\n if self.reduce.is_some() {\n properties.ready = true;\n properties.score += 1;\n } else {\n properties.ready = false;\n };\n\n properties\n }\n\n fn len(&self) -> usize {\n self.builder.len() + if self.reduce.is_some() { 1 } else { 0 }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub enum FusePrecision {\\n F32,\\n Flex32,\\n F16,\\n BF16,\\n I64,\\n I32,\\n I16,\\n I8,\\n U64,\\n U32,\\n U16,\\n U8,\\n Bool,\\n}\"\n ],\n \"name\": \"bool_precision\",\n \"type\": \"FusePrecision\"\n },\n {\n \"definitions\": [\n \"> {\\n ptr: NonNull<ArcInner<T>>,\\n phantom: PhantomData<ArcInner<T>>,\\n alloc: A,\\n}\"\n ],\n \"name\": \"fallback\",\n \"type\": \"Arc<dyn ReduceFallbackFn<R>>\"\n }\n ],\n \"end_line\": 69,\n \"name\": \"new\",\n \"signature\": \"pub fn new(\\n device: R::Device,\\n bool_precision: FusePrecision,\\n fallback: Arc<dyn ReduceFallbackFn<R>>,\\n ) -> Self\",\n \"start_line\": 31\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R: Runtime> ReduceBuilder<R> {\\n pub fn new(\\n device: R::Device,\\n bool_precision: FusePrecision,\\n fallback: Arc<dyn ReduceFallbackFn<R>>,\\n ) -> Self {\\n let client = R::client(&device);\\n let props = client.properties();\\n let max_bindings = props.hardware_properties().max_bindings;\\n let settings_read = FuseSettings {\\n broadcast: true,\\n output_shape_updates: true,\\n inplace: true,\\n vectorization: VectorizationSetting::Activated,\\n };\\n let settings_write = FuseSettings {\\n broadcast: true,\\n output_shape_updates: false,\\n inplace: true,\\n vectorization: VectorizationSetting::SmallerOrEqualThanPreviousBlock,\\n };\\n\\n Self {\\n builder: FuseOptimizationBuilder::new(max_bindings, bool_precision, settings_read),\\n builder_read_fallback: FuseOptimizationBuilder::new(\\n max_bindings,\\n bool_precision,\\n settings_read,\\n ),\\n builder_write_fallback: FuseOptimizationBuilder::new(\\n max_bindings,\\n bool_precision,\\n settings_write,\\n ),\\n device,\\n reduce: None,\\n status: OptimizationStatus::Open,\\n fallback,\\n }\\n }\\n\\n fn on_reduce(&mut self, op: &ReduceDimOpIr, inst: ReduceInstruction) {\\n if self.builder.current_output_shape != op.input.shape {\\n self.builder.close();\\n self.builder_read_fallback.close();\\n self.status = OptimizationStatus::Closed;\\n return;\\n }\\n\\n let Some([input]) = self\\n .builder\\n .next_block([&op.input], self.builder_write_fallback.settings)\\n else {\\n self.builder.close();\\n self.builder_read_fallback.close();\\n self.status = OptimizationStatus::Closed;\\n return;\\n };\\n\\n let output = self.builder.output_unhandled(&op.out);\\n let axis = op.axis;\\n\\n // We only activate fuse-on-write when the reduction isn't on the last dimension, otherwise\\n // vectorization is impossible. Only [LineMode::Perpendicular] supports vectorization.\\n //\\n // We could still fuse some output operations, but it would probably lead to worse performance.\\n let fuse_on_write_activated = axis != op.input.shape.len() - 1;\\n\\n if fuse_on_write_activated {\\n self.status = OptimizationStatus::Open;\\n } else {\\n self.status = OptimizationStatus::Closed;\\n }\\n\\n let acc = match inst {\\n ReduceInstruction::Mean | ReduceInstruction::Prod | ReduceInstruction::Sum => {\\n match input.precision() {\\n FusePrecision::F16 | FusePrecision::BF16 => FusePrecision::F32,\\n FusePrecision::I16 | FusePrecision::I8 => FusePrecision::I32,\\n FusePrecision::U16 | FusePrecision::U8 => FusePrecision::U32,\\n _ => input.precision(),\\n }\\n }\\n _ => input.precision(),\\n };\\n\\n self.reduce = Some(FusedReduce::new(\\n input,\\n output,\\n acc,\\n axis,\\n op.clone(),\\n ReduceStrategy {\\n shared: false,\\n use_planes: false,\\n },\\n inst,\\n ));\\n self.builder_read_fallback.close();\\n }\\n\\n fn on_elemwise_read(&mut self, operation: &OperationIr) {\\n self.builder.register(operation);\\n\\n if self.builder_read_fallback.len() < self.builder.len() {\\n self.builder_read_fallback.register(operation);\\n }\\n\\n self.status = self.builder.status();\\n }\\n\\n fn on_elemwise_write(&mut self, operation: &OperationIr) {\\n self.builder.register(operation);\\n\\n let num_ops_write = self.builder.len() - self.builder_read_fallback.len();\\n\\n if self.builder_write_fallback.len() < num_ops_write {\\n self.builder_write_fallback.register(operation);\\n }\\n\\n self.status = self.builder.status();\\n }\\n}\",\n \"class_signature\": \"impl<R: Runtime> ReduceBuilder<R>\"\n}"}}},{"rowIdx":160,"cells":{"function_name":{"kind":"string","value":"read"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/io.rs"},"focal_code":{"kind":"string","value":"pub fn read(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n ref_pos: u32,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n match arg {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!global.broadcasted && line_size != config.width as u32] {\n read_input_aligned(inputs, locals, pos, ref_pos, layout, config, None)\n } else {\n read_input(inputs, locals, pos, ref_pos, layout, config, None)\n }\n }\n Arg::Output(pos, _precision, layout) => {\n read_output(inputs, outputs, locals, pos, ref_pos, layout, config)\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => Line::cast_from(locals.l_f32.find(pos)),\n FusePrecision::F16 => Line::cast_from(locals.l_f16.find(pos)),\n FusePrecision::BF16 => Line::cast_from(locals.l_bf16.find(pos)),\n FusePrecision::U64 => Line::cast_from(locals.l_u64.find(pos)),\n FusePrecision::U32 => Line::cast_from(locals.l_u32.find(pos)),\n FusePrecision::U16 => Line::cast_from(locals.l_u16.find(pos)),\n FusePrecision::U8 => Line::cast_from(locals.l_u8.find(pos)),\n FusePrecision::I64 => Line::cast_from(locals.l_i64.find(pos)),\n FusePrecision::I32 => Line::cast_from(locals.l_i32.find(pos)),\n FusePrecision::I16 => Line::cast_from(locals.l_i16.find(pos)),\n FusePrecision::I8 => Line::cast_from(locals.l_i8.find(pos)),\n FusePrecision::Bool => Line::cast_from(locals.l_bool.find(pos)),\n },\n Arg::Scalar(..) => {\n let scalar = read_scalar::<C>(inputs, arg);\n Line::new(scalar)\n }\n Arg::ScalarShape(_) => {\n let scalar = read_scalar_shape(inputs, arg);\n Line::cast_from(scalar)\n }\n Arg::Literal(val, _precision) => Line::new(from_const_int::<C>(val)),\n Arg::InputReshaped {\n original,\n shape,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be reshaped\")],\n },\n Arg::InputSwapDims {\n original,\n dims,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be swapped dims\")],\n },\n }\n}"},"file_content":{"kind":"string","value":"use super::{DYN_ELEM_ID, ir::*, tensor::GlobalTensor};\nuse cubecl::{\n intrinsic,\n ir::{ExpandElement, Variable},\n prelude::*,\n};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\npub enum Transform {\n Reshape(Sequence<Arg>),\n SwapDims(u32, u32),\n}\n\n#[cube]\n/// Read the value from the [arg](Arg) and cast it to the generic cube primitive.\npub fn read<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n ref_pos: u32,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n match arg {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!global.broadcasted && line_size != config.width as u32] {\n read_input_aligned(inputs, locals, pos, ref_pos, layout, config, None)\n } else {\n read_input(inputs, locals, pos, ref_pos, layout, config, None)\n }\n }\n Arg::Output(pos, _precision, layout) => {\n read_output(inputs, outputs, locals, pos, ref_pos, layout, config)\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => Line::cast_from(locals.l_f32.find(pos)),\n FusePrecision::F16 => Line::cast_from(locals.l_f16.find(pos)),\n FusePrecision::BF16 => Line::cast_from(locals.l_bf16.find(pos)),\n FusePrecision::U64 => Line::cast_from(locals.l_u64.find(pos)),\n FusePrecision::U32 => Line::cast_from(locals.l_u32.find(pos)),\n FusePrecision::U16 => Line::cast_from(locals.l_u16.find(pos)),\n FusePrecision::U8 => Line::cast_from(locals.l_u8.find(pos)),\n FusePrecision::I64 => Line::cast_from(locals.l_i64.find(pos)),\n FusePrecision::I32 => Line::cast_from(locals.l_i32.find(pos)),\n FusePrecision::I16 => Line::cast_from(locals.l_i16.find(pos)),\n FusePrecision::I8 => Line::cast_from(locals.l_i8.find(pos)),\n FusePrecision::Bool => Line::cast_from(locals.l_bool.find(pos)),\n },\n Arg::Scalar(..) => {\n let scalar = read_scalar::<C>(inputs, arg);\n Line::new(scalar)\n }\n Arg::ScalarShape(_) => {\n let scalar = read_scalar_shape(inputs, arg);\n Line::cast_from(scalar)\n }\n Arg::Literal(val, _precision) => Line::new(from_const_int::<C>(val)),\n Arg::InputReshaped {\n original,\n shape,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be reshaped\")],\n },\n Arg::InputSwapDims {\n original,\n dims,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be swapped dims\")],\n },\n }\n}\n\n#[cube]\npub fn read_scalar<C: CubePrimitive>(inputs: &GlobalArgs, #[comptime] arg: Arg) -> C {\n match arg {\n Arg::Scalar(pos, _precision) => {\n let scalar = inputs.scalars.index(pos);\n scalar.read::<C>()\n }\n _ => comptime![panic!(\"Not a scalar\")],\n }\n}\n\n#[cube]\npub fn read_scalar_shape(inputs: &GlobalArgs, #[comptime] arg: Arg) -> u32 {\n match arg {\n Arg::ScalarShape(pos) => *inputs.reshapes.index(pos),\n _ => comptime![panic!(\"Not a scalar shape\")],\n }\n}\n\n#[cube]\npub fn read_input<C: CubePrimitive>(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let tensor = inputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => get_offset(inputs, locals, tensor, ref_pos, None, config, transform),\n };\n Line::cast_from(tensor.tensor[offset])\n}\n\n#[cube]\npub fn read_input_window<C: CubePrimitive>(\n inputs: &GlobalArgs,\n #[comptime] pos: u32,\n start: u32,\n end: u32,\n) -> Slice<Line<C>> {\n let tensor = inputs.tensors.index(pos);\n let slice = tensor.tensor.slice(start, end);\n slice.try_cast_unchecked()\n}\n\n#[cube]\npub fn read_input_aligned<C: CubePrimitive>(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let mut result: Line<C> = Line::<C>::empty(comptime![config.width as u32]);\n let tensor = inputs.tensors.index(pos);\n\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n // Very brute force, not really efficient, but not easy to optimize and not a very\n // frequent workflow.\n let ref_pos = ref_pos * comptime![config.width as u32];\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = reshaped_index(\n inputs,\n locals,\n ref_pos + i,\n config.rank,\n comptime![shape.clone()],\n );\n let index = reshaped_index_to_original_index(&tensor.tensor, index, config.rank);\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let i = comptime![swap_dims_transform(&(config.rank - 1), (dim1, dim2))];\n let stride = tensor.tensor.stride(comptime![i]);\n\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n None => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let stride = tensor.tensor.stride(comptime![config.rank - 1]);\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n }\n\n result\n}\n\n#[cube]\npub fn get_offset_aligned(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n tensor: &GlobalTensor,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match layout {\n LayoutInfo::SameAsRef | LayoutInfo::IsRef => {\n (ref_pos * locals.ref_line_size) / tensor.tensor.line_size()\n }\n LayoutInfo::Unknown => get_offset(\n inputs,\n locals,\n tensor,\n ref_pos,\n None,\n config,\n comptime!(transform.clone()),\n ),\n }\n}\n\n#[cube]\npub fn read_output<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n let tensor = outputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => get_offset(inputs, locals, tensor, ref_pos, None, config, None),\n };\n Line::cast_from(tensor.tensor[offset])\n}\n\n#[cube]\n/// Write the given value at the [arg](Arg) position.\npub fn write<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &mut GlobalArgs,\n locals: &mut LocalArgs,\n ref_pos: u32,\n value: Line<C>,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) {\n match arg {\n Arg::Output(pos, precision, layout) => {\n let tensor = outputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => {\n get_offset(inputs, locals, tensor, ref_pos, None, config, None)\n }\n };\n let tensor = outputs.tensors.index_mut(pos);\n set_polyfill::<NumericExpand<DYN_ELEM_ID>>(comptime![precision.into_elem()]);\n tensor.tensor[offset] = Line::cast_from(value);\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => {\n locals.l_f32.insert(pos, Line::cast_from(value))\n }\n FusePrecision::F16 => locals.l_f16.insert(pos, Line::cast_from(value)),\n FusePrecision::BF16 => locals.l_bf16.insert(pos, Line::cast_from(value)),\n FusePrecision::U64 => locals.l_u64.insert(pos, Line::cast_from(value)),\n FusePrecision::U32 => locals.l_u32.insert(pos, Line::cast_from(value)),\n FusePrecision::U16 => locals.l_u16.insert(pos, Line::cast_from(value)),\n FusePrecision::U8 => locals.l_u8.insert(pos, Line::cast_from(value)),\n FusePrecision::I64 => locals.l_i64.insert(pos, Line::cast_from(value)),\n FusePrecision::I32 => locals.l_i32.insert(pos, Line::cast_from(value)),\n FusePrecision::I16 => locals.l_i16.insert(pos, Line::cast_from(value)),\n FusePrecision::I8 => locals.l_i8.insert(pos, Line::cast_from(value)),\n FusePrecision::Bool => locals.l_bool.insert(pos, Line::cast_from(value)),\n },\n _ => comptime![panic!(\"Can't write into inputs and scalars\")],\n }\n}\n\n#[cube]\npub(crate) fn global_offset(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n index: u32,\n #[comptime] arg: Arg,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match arg {\n Arg::Input(pos, _precision, _layout) => {\n let tensor = inputs.tensors.index(pos);\n get_offset(inputs, locals, tensor, index, range, config, None)\n }\n Arg::Output(pos, _precision, _layout) => {\n let tensor = outputs.tensors.index(pos);\n get_offset(inputs, locals, tensor, index, range, config, None)\n }\n _ => todo!(),\n }\n}\n\n#[cube]\nfn get_offset(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n tensor: &GlobalTensor,\n ref_pos: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n index_offset_with_layout(\n inputs,\n tensor,\n locals,\n ref_pos,\n range,\n config.rank,\n transform,\n )\n}\n\n#[cube]\npub fn global_line_size(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n u32::cast_from(tensor.tensor.line_size())\n}\n\n#[cube]\npub fn global_rank(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.rank()\n}\n\n#[cube]\npub fn global_len(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.len()\n}\n\n#[cube]\npub fn global_buffer_len(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.buffer_len()\n}\n\n#[cube]\npub fn ref_len(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match comptime![config.ref_layout.clone()] {\n RefLayout::Concrete(arg) => match comptime![arg] {\n Arg::Input(index, _, _) => global_len(inputs, index),\n Arg::Output(index, _, _) => global_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(..) => num_elements(locals, config),\n }\n}\n\n#[cube]\npub fn ref_buffer_len(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match comptime![config.ref_layout.clone()] {\n RefLayout::Concrete(arg) => match comptime![arg] {\n Arg::Input(index, _, _) => global_buffer_len(inputs, index),\n Arg::Output(index, _, _) => global_buffer_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(VirtualLayout::SwapDims(arg, ..)) => match arg {\n Arg::Input(index, _, _) => global_buffer_len(inputs, index),\n Arg::Output(index, _, _) => global_buffer_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(VirtualLayout::Reshaped(..)) => num_elements(locals, config),\n }\n}\n\n#[cube]\npub fn num_elements(locals: &LocalArgs, #[comptime] config: &FuseBlockConfig) -> u32 {\n let mut length = 1u32;\n\n for i in 0..config.rank {\n length *= locals.ref_shape[i];\n }\n\n length\n}\n\n#[cube]\npub fn ref_shape(locals: &LocalArgs, dim: u32) -> u32 {\n locals.ref_shape[dim]\n}\n\n#[cube]\npub fn ref_stride(locals: &LocalArgs, dim: u32) -> u32 {\n locals.ref_strides[dim]\n}\n\n#[cube]\npub fn global_shape(global: &GlobalArgs, dim: u32, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.shape(dim)\n}\n\n#[cube]\npub fn global_stride(global: &GlobalArgs, dim: u32, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.stride(dim)\n}\n\n#[cube]\nfn index_offset_with_layout(\n inputs: &GlobalArgs,\n tensor: &GlobalTensor,\n locals: &LocalArgs,\n index: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] rank: u32,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n comptime![assert!(\n range.is_none(),\n \"Can't get a range on a reshaped tensor.\"\n )];\n\n let index = index * locals.ref_line_size;\n let index = reshaped_index(inputs, locals, index, rank, shape);\n reshaped_index_to_original_index(&tensor.tensor, index, rank)\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let index = comptime![swap_dims_transform(&i, (dim1, dim2))];\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(index) * tensor.tensor.stride(index);\n }\n\n offset / tensor.tensor.line_size()\n }\n None => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(i) * tensor.tensor.stride(i);\n }\n\n offset / tensor.tensor.line_size()\n }\n }\n}\n\npub(crate) fn swap_dims_transform<I: Index + Clone>(i: &I, dims: (u32, u32)) -> u32 {\n let i_cloned: I = i.clone();\n let i = i_cloned.value().as_const().unwrap().as_u32();\n\n if i == dims.0 {\n dims.1\n } else if i == dims.1 {\n dims.0\n } else {\n i\n }\n}\n\n#[cube]\n#[allow(clippy::clone_on_copy)]\n/// The index the input tensor would be at if it was contiguous.\nfn reshaped_index(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n index: u32,\n #[comptime] rank: u32,\n #[comptime] shape: Sequence<Arg>,\n) -> u32 {\n let mut offset = 0u32;\n let mut stride_curr = 1u32;\n\n #[unroll]\n for r in 0..rank {\n let i = reverse_index(rank, r);\n let arg = comptime![shape.index(i)];\n let shape_i = read_scalar_shape(inputs, comptime![arg.clone()]);\n let ogwl = index / locals.ref_strides[i];\n\n offset += ogwl % shape_i * stride_curr;\n\n stride_curr *= shape_i;\n }\n\n offset\n}\n\n#[allow(unreachable_code)]\n#[cube]\n#[allow(clippy::clone_on_copy)]\nfn reshaped_index_to_original_index<C: CubePrimitive>(\n original: &Tensor<Line<C>>,\n index_reshaped: u32,\n #[comptime] rank: u32,\n) -> u32 {\n let mut remaining = index_reshaped;\n let mut offset = 0;\n\n #[unroll]\n for r in 0..rank {\n let i = reverse_index(rank, r);\n let shape = original.shape(i);\n let stride = original.stride(i);\n\n let coordinate = remaining % shape;\n\n remaining /= shape;\n offset += coordinate * stride;\n }\n\n offset / original.line_size()\n}\n\n#[cube]\n#[allow(unused_variables)]\npub(crate) fn reverse_index(#[comptime] rank: u32, iter: u32) -> comptime_type!(u32) {\n intrinsic!(|_| {\n let elem = iter.constant().map(|cons| cons.as_u32()).unwrap();\n rank - elem - 1\n })\n}\n\n/// Generic way to construct any [`CubePrimitive`] from an int. Used for fusion.\n#[allow(unused_variables)]\n#[cube]\nfn from_const_int<C: CubePrimitive>(#[comptime] value: u32) -> C {\n intrinsic!(|scope| {\n let constant: ExpandElement = value.into();\n let constant_c = constant.as_const().unwrap().cast_to(C::as_elem(scope));\n ExpandElement::Plain(Variable::constant(constant_c)).into()\n })\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct GlobalArgs {\\n pub tensors: Sequence<GlobalTensor>,\\n pub scalars: Sequence<GlobalScalar>,\\n pub reshapes: Sequence<u32>,\\n}\"\n ],\n \"name\": \"inputs\",\n \"type\": \"&GlobalArgs\"\n },\n {\n \"definitions\": [\n \"pub struct GlobalArgs {\\n pub tensors: Sequence<GlobalTensor>,\\n pub scalars: Sequence<GlobalScalar>,\\n pub reshapes: Sequence<u32>,\\n}\"\n ],\n \"name\": \"outputs\",\n \"type\": \"&GlobalArgs\"\n },\n {\n \"definitions\": [\n \"pub struct LocalArgs {\\n pub l_f32: Registry<u32, Line<f32>>,\\n pub l_f16: Registry<u32, Line<f16>>,\\n pub l_bf16: Registry<u32, Line<bf16>>,\\n pub l_i64: Registry<u32, Line<i64>>,\\n pub l_i32: Registry<u32, Line<i32>>,\\n pub l_i16: Registry<u32, Line<i16>>,\\n pub l_i8: Registry<u32, Line<i8>>,\\n pub l_u64: Registry<u32, Line<u64>>,\\n pub l_u32: Registry<u32, Line<u32>>,\\n pub l_u16: Registry<u32, Line<u16>>,\\n pub l_u8: Registry<u32, Line<u8>>,\\n pub l_bool: Registry<u32, Line<bool>>,\\n pub ref_shape: Slice<u32>,\\n pub ref_strides: Slice<u32>,\\n #[cube(comptime)]\\n pub ref_line_size: u32,\\n}\"\n ],\n \"name\": \"locals\",\n \"type\": \"&LocalArgs\"\n },\n {\n \"definitions\": [\n \"pub enum Arg {\\n Input(u32, FusePrecision, LayoutInfo),\\n Local(u32, FusePrecision),\\n Output(u32, FusePrecision, LayoutInfo),\\n Scalar(u32, FusePrecision),\\n ScalarShape(u32),\\n /// Only constant that can be encoded into an u32 can be used as literal.\\n Literal(u32, FusePrecision),\\n InputReshaped {\\n original: Box<Arg>,\\n shape: Sequence<Arg>,\\n broadcasted: bool,\\n },\\n InputSwapDims {\\n original: Box<Arg>,\\n dims: (u32, u32),\\n broadcasted: bool,\\n },\\n}\"\n ],\n \"name\": \"arg\",\n \"type\": \"Arg\"\n },\n {\n \"definitions\": [\n \"pub struct FuseBlockConfig {\\n pub rank: u32,\\n pub ref_layout: RefLayout,\\n pub ops: Sequence<FuseOp>,\\n pub width: u8,\\n}\"\n ],\n \"name\": \"config\",\n \"type\": \"&FuseBlockConfig\"\n }\n ],\n \"end_line\": 129,\n \"name\": \"read\",\n \"signature\": \"pub fn read(\\n inputs: &GlobalArgs,\\n outputs: &GlobalArgs,\\n locals: &LocalArgs,\\n ref_pos: u32,\\n #[comptime] arg: Arg,\\n #[comptime] config: &FuseBlockConfig,\\n) -> Line<C>\",\n \"start_line\": 17\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":161,"cells":{"function_name":{"kind":"string","value":"read_input_aligned"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/io.rs"},"focal_code":{"kind":"string","value":"pub fn read_input_aligned(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let mut result: Line<C> = Line::<C>::empty(comptime![config.width as u32]);\n let tensor = inputs.tensors.index(pos);\n\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n // Very brute force, not really efficient, but not easy to optimize and not a very\n // frequent workflow.\n let ref_pos = ref_pos * comptime![config.width as u32];\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = reshaped_index(\n inputs,\n locals,\n ref_pos + i,\n config.rank,\n comptime![shape.clone()],\n );\n let index = reshaped_index_to_original_index(&tensor.tensor, index, config.rank);\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let i = comptime![swap_dims_transform(&(config.rank - 1), (dim1, dim2))];\n let stride = tensor.tensor.stride(comptime![i]);\n\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n None => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let stride = tensor.tensor.stride(comptime![config.rank - 1]);\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n }\n\n result\n}"},"file_content":{"kind":"string","value":"use super::{DYN_ELEM_ID, ir::*, tensor::GlobalTensor};\nuse cubecl::{\n intrinsic,\n ir::{ExpandElement, Variable},\n prelude::*,\n};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\npub enum Transform {\n Reshape(Sequence<Arg>),\n SwapDims(u32, u32),\n}\n\n#[cube]\n/// Read the value from the [arg](Arg) and cast it to the generic cube primitive.\npub fn read<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n ref_pos: u32,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n match arg {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!global.broadcasted && line_size != config.width as u32] {\n read_input_aligned(inputs, locals, pos, ref_pos, layout, config, None)\n } else {\n read_input(inputs, locals, pos, ref_pos, layout, config, None)\n }\n }\n Arg::Output(pos, _precision, layout) => {\n read_output(inputs, outputs, locals, pos, ref_pos, layout, config)\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => Line::cast_from(locals.l_f32.find(pos)),\n FusePrecision::F16 => Line::cast_from(locals.l_f16.find(pos)),\n FusePrecision::BF16 => Line::cast_from(locals.l_bf16.find(pos)),\n FusePrecision::U64 => Line::cast_from(locals.l_u64.find(pos)),\n FusePrecision::U32 => Line::cast_from(locals.l_u32.find(pos)),\n FusePrecision::U16 => Line::cast_from(locals.l_u16.find(pos)),\n FusePrecision::U8 => Line::cast_from(locals.l_u8.find(pos)),\n FusePrecision::I64 => Line::cast_from(locals.l_i64.find(pos)),\n FusePrecision::I32 => Line::cast_from(locals.l_i32.find(pos)),\n FusePrecision::I16 => Line::cast_from(locals.l_i16.find(pos)),\n FusePrecision::I8 => Line::cast_from(locals.l_i8.find(pos)),\n FusePrecision::Bool => Line::cast_from(locals.l_bool.find(pos)),\n },\n Arg::Scalar(..) => {\n let scalar = read_scalar::<C>(inputs, arg);\n Line::new(scalar)\n }\n Arg::ScalarShape(_) => {\n let scalar = read_scalar_shape(inputs, arg);\n Line::cast_from(scalar)\n }\n Arg::Literal(val, _precision) => Line::new(from_const_int::<C>(val)),\n Arg::InputReshaped {\n original,\n shape,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be reshaped\")],\n },\n Arg::InputSwapDims {\n original,\n dims,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be swapped dims\")],\n },\n }\n}\n\n#[cube]\npub fn read_scalar<C: CubePrimitive>(inputs: &GlobalArgs, #[comptime] arg: Arg) -> C {\n match arg {\n Arg::Scalar(pos, _precision) => {\n let scalar = inputs.scalars.index(pos);\n scalar.read::<C>()\n }\n _ => comptime![panic!(\"Not a scalar\")],\n }\n}\n\n#[cube]\npub fn read_scalar_shape(inputs: &GlobalArgs, #[comptime] arg: Arg) -> u32 {\n match arg {\n Arg::ScalarShape(pos) => *inputs.reshapes.index(pos),\n _ => comptime![panic!(\"Not a scalar shape\")],\n }\n}\n\n#[cube]\npub fn read_input<C: CubePrimitive>(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let tensor = inputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => get_offset(inputs, locals, tensor, ref_pos, None, config, transform),\n };\n Line::cast_from(tensor.tensor[offset])\n}\n\n#[cube]\npub fn read_input_window<C: CubePrimitive>(\n inputs: &GlobalArgs,\n #[comptime] pos: u32,\n start: u32,\n end: u32,\n) -> Slice<Line<C>> {\n let tensor = inputs.tensors.index(pos);\n let slice = tensor.tensor.slice(start, end);\n slice.try_cast_unchecked()\n}\n\n#[cube]\npub fn read_input_aligned<C: CubePrimitive>(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let mut result: Line<C> = Line::<C>::empty(comptime![config.width as u32]);\n let tensor = inputs.tensors.index(pos);\n\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n // Very brute force, not really efficient, but not easy to optimize and not a very\n // frequent workflow.\n let ref_pos = ref_pos * comptime![config.width as u32];\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = reshaped_index(\n inputs,\n locals,\n ref_pos + i,\n config.rank,\n comptime![shape.clone()],\n );\n let index = reshaped_index_to_original_index(&tensor.tensor, index, config.rank);\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let i = comptime![swap_dims_transform(&(config.rank - 1), (dim1, dim2))];\n let stride = tensor.tensor.stride(comptime![i]);\n\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n None => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let stride = tensor.tensor.stride(comptime![config.rank - 1]);\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n }\n\n result\n}\n\n#[cube]\npub fn get_offset_aligned(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n tensor: &GlobalTensor,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match layout {\n LayoutInfo::SameAsRef | LayoutInfo::IsRef => {\n (ref_pos * locals.ref_line_size) / tensor.tensor.line_size()\n }\n LayoutInfo::Unknown => get_offset(\n inputs,\n locals,\n tensor,\n ref_pos,\n None,\n config,\n comptime!(transform.clone()),\n ),\n }\n}\n\n#[cube]\npub fn read_output<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n let tensor = outputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => get_offset(inputs, locals, tensor, ref_pos, None, config, None),\n };\n Line::cast_from(tensor.tensor[offset])\n}\n\n#[cube]\n/// Write the given value at the [arg](Arg) position.\npub fn write<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &mut GlobalArgs,\n locals: &mut LocalArgs,\n ref_pos: u32,\n value: Line<C>,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) {\n match arg {\n Arg::Output(pos, precision, layout) => {\n let tensor = outputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => {\n get_offset(inputs, locals, tensor, ref_pos, None, config, None)\n }\n };\n let tensor = outputs.tensors.index_mut(pos);\n set_polyfill::<NumericExpand<DYN_ELEM_ID>>(comptime![precision.into_elem()]);\n tensor.tensor[offset] = Line::cast_from(value);\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => {\n locals.l_f32.insert(pos, Line::cast_from(value))\n }\n FusePrecision::F16 => locals.l_f16.insert(pos, Line::cast_from(value)),\n FusePrecision::BF16 => locals.l_bf16.insert(pos, Line::cast_from(value)),\n FusePrecision::U64 => locals.l_u64.insert(pos, Line::cast_from(value)),\n FusePrecision::U32 => locals.l_u32.insert(pos, Line::cast_from(value)),\n FusePrecision::U16 => locals.l_u16.insert(pos, Line::cast_from(value)),\n FusePrecision::U8 => locals.l_u8.insert(pos, Line::cast_from(value)),\n FusePrecision::I64 => locals.l_i64.insert(pos, Line::cast_from(value)),\n FusePrecision::I32 => locals.l_i32.insert(pos, Line::cast_from(value)),\n FusePrecision::I16 => locals.l_i16.insert(pos, Line::cast_from(value)),\n FusePrecision::I8 => locals.l_i8.insert(pos, Line::cast_from(value)),\n FusePrecision::Bool => locals.l_bool.insert(pos, Line::cast_from(value)),\n },\n _ => comptime![panic!(\"Can't write into inputs and scalars\")],\n }\n}\n\n#[cube]\npub(crate) fn global_offset(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n index: u32,\n #[comptime] arg: Arg,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match arg {\n Arg::Input(pos, _precision, _layout) => {\n let tensor = inputs.tensors.index(pos);\n get_offset(inputs, locals, tensor, index, range, config, None)\n }\n Arg::Output(pos, _precision, _layout) => {\n let tensor = outputs.tensors.index(pos);\n get_offset(inputs, locals, tensor, index, range, config, None)\n }\n _ => todo!(),\n }\n}\n\n#[cube]\nfn get_offset(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n tensor: &GlobalTensor,\n ref_pos: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n index_offset_with_layout(\n inputs,\n tensor,\n locals,\n ref_pos,\n range,\n config.rank,\n transform,\n )\n}\n\n#[cube]\npub fn global_line_size(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n u32::cast_from(tensor.tensor.line_size())\n}\n\n#[cube]\npub fn global_rank(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.rank()\n}\n\n#[cube]\npub fn global_len(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.len()\n}\n\n#[cube]\npub fn global_buffer_len(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.buffer_len()\n}\n\n#[cube]\npub fn ref_len(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match comptime![config.ref_layout.clone()] {\n RefLayout::Concrete(arg) => match comptime![arg] {\n Arg::Input(index, _, _) => global_len(inputs, index),\n Arg::Output(index, _, _) => global_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(..) => num_elements(locals, config),\n }\n}\n\n#[cube]\npub fn ref_buffer_len(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match comptime![config.ref_layout.clone()] {\n RefLayout::Concrete(arg) => match comptime![arg] {\n Arg::Input(index, _, _) => global_buffer_len(inputs, index),\n Arg::Output(index, _, _) => global_buffer_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(VirtualLayout::SwapDims(arg, ..)) => match arg {\n Arg::Input(index, _, _) => global_buffer_len(inputs, index),\n Arg::Output(index, _, _) => global_buffer_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(VirtualLayout::Reshaped(..)) => num_elements(locals, config),\n }\n}\n\n#[cube]\npub fn num_elements(locals: &LocalArgs, #[comptime] config: &FuseBlockConfig) -> u32 {\n let mut length = 1u32;\n\n for i in 0..config.rank {\n length *= locals.ref_shape[i];\n }\n\n length\n}\n\n#[cube]\npub fn ref_shape(locals: &LocalArgs, dim: u32) -> u32 {\n locals.ref_shape[dim]\n}\n\n#[cube]\npub fn ref_stride(locals: &LocalArgs, dim: u32) -> u32 {\n locals.ref_strides[dim]\n}\n\n#[cube]\npub fn global_shape(global: &GlobalArgs, dim: u32, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.shape(dim)\n}\n\n#[cube]\npub fn global_stride(global: &GlobalArgs, dim: u32, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.stride(dim)\n}\n\n#[cube]\nfn index_offset_with_layout(\n inputs: &GlobalArgs,\n tensor: &GlobalTensor,\n locals: &LocalArgs,\n index: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] rank: u32,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n comptime![assert!(\n range.is_none(),\n \"Can't get a range on a reshaped tensor.\"\n )];\n\n let index = index * locals.ref_line_size;\n let index = reshaped_index(inputs, locals, index, rank, shape);\n reshaped_index_to_original_index(&tensor.tensor, index, rank)\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let index = comptime![swap_dims_transform(&i, (dim1, dim2))];\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(index) * tensor.tensor.stride(index);\n }\n\n offset / tensor.tensor.line_size()\n }\n None => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(i) * tensor.tensor.stride(i);\n }\n\n offset / tensor.tensor.line_size()\n }\n }\n}\n\npub(crate) fn swap_dims_transform<I: Index + Clone>(i: &I, dims: (u32, u32)) -> u32 {\n let i_cloned: I = i.clone();\n let i = i_cloned.value().as_const().unwrap().as_u32();\n\n if i == dims.0 {\n dims.1\n } else if i == dims.1 {\n dims.0\n } else {\n i\n }\n}\n\n#[cube]\n#[allow(clippy::clone_on_copy)]\n/// The index the input tensor would be at if it was contiguous.\nfn reshaped_index(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n index: u32,\n #[comptime] rank: u32,\n #[comptime] shape: Sequence<Arg>,\n) -> u32 {\n let mut offset = 0u32;\n let mut stride_curr = 1u32;\n\n #[unroll]\n for r in 0..rank {\n let i = reverse_index(rank, r);\n let arg = comptime![shape.index(i)];\n let shape_i = read_scalar_shape(inputs, comptime![arg.clone()]);\n let ogwl = index / locals.ref_strides[i];\n\n offset += ogwl % shape_i * stride_curr;\n\n stride_curr *= shape_i;\n }\n\n offset\n}\n\n#[allow(unreachable_code)]\n#[cube]\n#[allow(clippy::clone_on_copy)]\nfn reshaped_index_to_original_index<C: CubePrimitive>(\n original: &Tensor<Line<C>>,\n index_reshaped: u32,\n #[comptime] rank: u32,\n) -> u32 {\n let mut remaining = index_reshaped;\n let mut offset = 0;\n\n #[unroll]\n for r in 0..rank {\n let i = reverse_index(rank, r);\n let shape = original.shape(i);\n let stride = original.stride(i);\n\n let coordinate = remaining % shape;\n\n remaining /= shape;\n offset += coordinate * stride;\n }\n\n offset / original.line_size()\n}\n\n#[cube]\n#[allow(unused_variables)]\npub(crate) fn reverse_index(#[comptime] rank: u32, iter: u32) -> comptime_type!(u32) {\n intrinsic!(|_| {\n let elem = iter.constant().map(|cons| cons.as_u32()).unwrap();\n rank - elem - 1\n })\n}\n\n/// Generic way to construct any [`CubePrimitive`] from an int. Used for fusion.\n#[allow(unused_variables)]\n#[cube]\nfn from_const_int<C: CubePrimitive>(#[comptime] value: u32) -> C {\n intrinsic!(|scope| {\n let constant: ExpandElement = value.into();\n let constant_c = constant.as_const().unwrap().cast_to(C::as_elem(scope));\n ExpandElement::Plain(Variable::constant(constant_c)).into()\n })\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct GlobalArgs {\\n pub tensors: Sequence<GlobalTensor>,\\n pub scalars: Sequence<GlobalScalar>,\\n pub reshapes: Sequence<u32>,\\n}\"\n ],\n \"name\": \"inputs\",\n \"type\": \"&GlobalArgs\"\n },\n {\n \"definitions\": [\n \"pub struct LocalArgs {\\n pub l_f32: Registry<u32, Line<f32>>,\\n pub l_f16: Registry<u32, Line<f16>>,\\n pub l_bf16: Registry<u32, Line<bf16>>,\\n pub l_i64: Registry<u32, Line<i64>>,\\n pub l_i32: Registry<u32, Line<i32>>,\\n pub l_i16: Registry<u32, Line<i16>>,\\n pub l_i8: Registry<u32, Line<i8>>,\\n pub l_u64: Registry<u32, Line<u64>>,\\n pub l_u32: Registry<u32, Line<u32>>,\\n pub l_u16: Registry<u32, Line<u16>>,\\n pub l_u8: Registry<u32, Line<u8>>,\\n pub l_bool: Registry<u32, Line<bool>>,\\n pub ref_shape: Slice<u32>,\\n pub ref_strides: Slice<u32>,\\n #[cube(comptime)]\\n pub ref_line_size: u32,\\n}\"\n ],\n \"name\": \"locals\",\n \"type\": \"&LocalArgs\"\n },\n {\n \"definitions\": [\n \"pub enum LayoutInfo {\\n /// The layout if the same as the reference.\\n SameAsRef,\\n /// The reference layout.\\n IsRef,\\n /// The layout if unknown.\\n Unknown,\\n}\"\n ],\n \"name\": \"layout\",\n \"type\": \"LayoutInfo\"\n },\n {\n \"definitions\": [\n \"pub struct FuseBlockConfig {\\n pub rank: u32,\\n pub ref_layout: RefLayout,\\n pub ops: Sequence<FuseOp>,\\n pub width: u8,\\n}\"\n ],\n \"name\": \"config\",\n \"type\": \"&FuseBlockConfig\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\",\n \"pub enum Transform {\\n Reshape(Sequence<Arg>),\\n SwapDims(u32, u32),\\n}\"\n ],\n \"name\": \"transform\",\n \"type\": \"Option<Transform>\"\n }\n ],\n \"end_line\": 237,\n \"name\": \"read_input_aligned\",\n \"signature\": \"pub fn read_input_aligned(\\n inputs: &GlobalArgs,\\n locals: &LocalArgs,\\n #[comptime] pos: u32,\\n ref_pos: u32,\\n #[comptime] layout: LayoutInfo,\\n #[comptime] config: &FuseBlockConfig,\\n #[comptime] transform: Option<Transform>,\\n) -> Line<C>\",\n \"start_line\": 182\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":162,"cells":{"function_name":{"kind":"string","value":"index_offset_with_layout"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/io.rs"},"focal_code":{"kind":"string","value":"fn index_offset_with_layout(\n inputs: &GlobalArgs,\n tensor: &GlobalTensor,\n locals: &LocalArgs,\n index: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] rank: u32,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n comptime![assert!(\n range.is_none(),\n \"Can't get a range on a reshaped tensor.\"\n )];\n\n let index = index * locals.ref_line_size;\n let index = reshaped_index(inputs, locals, index, rank, shape);\n reshaped_index_to_original_index(&tensor.tensor, index, rank)\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let index = comptime![swap_dims_transform(&i, (dim1, dim2))];\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(index) * tensor.tensor.stride(index);\n }\n\n offset / tensor.tensor.line_size()\n }\n None => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(i) * tensor.tensor.stride(i);\n }\n\n offset / tensor.tensor.line_size()\n }\n }\n}"},"file_content":{"kind":"string","value":"use super::{DYN_ELEM_ID, ir::*, tensor::GlobalTensor};\nuse cubecl::{\n intrinsic,\n ir::{ExpandElement, Variable},\n prelude::*,\n};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\npub enum Transform {\n Reshape(Sequence<Arg>),\n SwapDims(u32, u32),\n}\n\n#[cube]\n/// Read the value from the [arg](Arg) and cast it to the generic cube primitive.\npub fn read<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n ref_pos: u32,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n match arg {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!global.broadcasted && line_size != config.width as u32] {\n read_input_aligned(inputs, locals, pos, ref_pos, layout, config, None)\n } else {\n read_input(inputs, locals, pos, ref_pos, layout, config, None)\n }\n }\n Arg::Output(pos, _precision, layout) => {\n read_output(inputs, outputs, locals, pos, ref_pos, layout, config)\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => Line::cast_from(locals.l_f32.find(pos)),\n FusePrecision::F16 => Line::cast_from(locals.l_f16.find(pos)),\n FusePrecision::BF16 => Line::cast_from(locals.l_bf16.find(pos)),\n FusePrecision::U64 => Line::cast_from(locals.l_u64.find(pos)),\n FusePrecision::U32 => Line::cast_from(locals.l_u32.find(pos)),\n FusePrecision::U16 => Line::cast_from(locals.l_u16.find(pos)),\n FusePrecision::U8 => Line::cast_from(locals.l_u8.find(pos)),\n FusePrecision::I64 => Line::cast_from(locals.l_i64.find(pos)),\n FusePrecision::I32 => Line::cast_from(locals.l_i32.find(pos)),\n FusePrecision::I16 => Line::cast_from(locals.l_i16.find(pos)),\n FusePrecision::I8 => Line::cast_from(locals.l_i8.find(pos)),\n FusePrecision::Bool => Line::cast_from(locals.l_bool.find(pos)),\n },\n Arg::Scalar(..) => {\n let scalar = read_scalar::<C>(inputs, arg);\n Line::new(scalar)\n }\n Arg::ScalarShape(_) => {\n let scalar = read_scalar_shape(inputs, arg);\n Line::cast_from(scalar)\n }\n Arg::Literal(val, _precision) => Line::new(from_const_int::<C>(val)),\n Arg::InputReshaped {\n original,\n shape,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::Reshape(shape))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be reshaped\")],\n },\n Arg::InputSwapDims {\n original,\n dims,\n broadcasted,\n } => match comptime![original.as_ref().clone()] {\n Arg::Input(pos, _precision, layout) => {\n let global = inputs.tensors.index(pos);\n let line_size = global.tensor.line_size();\n\n if comptime![!broadcasted && line_size != config.width as u32] {\n read_input_aligned(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n } else {\n read_input(\n inputs,\n locals,\n pos,\n ref_pos,\n layout,\n config,\n comptime![Some(Transform::SwapDims(dims.0, dims.1))],\n )\n }\n }\n _ => comptime![panic!(\"Only input can be swapped dims\")],\n },\n }\n}\n\n#[cube]\npub fn read_scalar<C: CubePrimitive>(inputs: &GlobalArgs, #[comptime] arg: Arg) -> C {\n match arg {\n Arg::Scalar(pos, _precision) => {\n let scalar = inputs.scalars.index(pos);\n scalar.read::<C>()\n }\n _ => comptime![panic!(\"Not a scalar\")],\n }\n}\n\n#[cube]\npub fn read_scalar_shape(inputs: &GlobalArgs, #[comptime] arg: Arg) -> u32 {\n match arg {\n Arg::ScalarShape(pos) => *inputs.reshapes.index(pos),\n _ => comptime![panic!(\"Not a scalar shape\")],\n }\n}\n\n#[cube]\npub fn read_input<C: CubePrimitive>(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let tensor = inputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => get_offset(inputs, locals, tensor, ref_pos, None, config, transform),\n };\n Line::cast_from(tensor.tensor[offset])\n}\n\n#[cube]\npub fn read_input_window<C: CubePrimitive>(\n inputs: &GlobalArgs,\n #[comptime] pos: u32,\n start: u32,\n end: u32,\n) -> Slice<Line<C>> {\n let tensor = inputs.tensors.index(pos);\n let slice = tensor.tensor.slice(start, end);\n slice.try_cast_unchecked()\n}\n\n#[cube]\npub fn read_input_aligned<C: CubePrimitive>(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> Line<C> {\n let mut result: Line<C> = Line::<C>::empty(comptime![config.width as u32]);\n let tensor = inputs.tensors.index(pos);\n\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n // Very brute force, not really efficient, but not easy to optimize and not a very\n // frequent workflow.\n let ref_pos = ref_pos * comptime![config.width as u32];\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = reshaped_index(\n inputs,\n locals,\n ref_pos + i,\n config.rank,\n comptime![shape.clone()],\n );\n let index = reshaped_index_to_original_index(&tensor.tensor, index, config.rank);\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let i = comptime![swap_dims_transform(&(config.rank - 1), (dim1, dim2))];\n let stride = tensor.tensor.stride(comptime![i]);\n\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n None => {\n let offset =\n get_offset_aligned(inputs, locals, tensor, ref_pos, layout, config, transform);\n let stride = tensor.tensor.stride(comptime![config.rank - 1]);\n #[unroll]\n for i in 0u32..comptime!(config.width as u32) {\n let index = offset + i * stride;\n result[i] = C::cast_from(tensor.tensor[index][0])\n }\n }\n }\n\n result\n}\n\n#[cube]\npub fn get_offset_aligned(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n tensor: &GlobalTensor,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match layout {\n LayoutInfo::SameAsRef | LayoutInfo::IsRef => {\n (ref_pos * locals.ref_line_size) / tensor.tensor.line_size()\n }\n LayoutInfo::Unknown => get_offset(\n inputs,\n locals,\n tensor,\n ref_pos,\n None,\n config,\n comptime!(transform.clone()),\n ),\n }\n}\n\n#[cube]\npub fn read_output<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n pos: u32,\n ref_pos: u32,\n #[comptime] layout: LayoutInfo,\n #[comptime] config: &FuseBlockConfig,\n) -> Line<C> {\n let tensor = outputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => get_offset(inputs, locals, tensor, ref_pos, None, config, None),\n };\n Line::cast_from(tensor.tensor[offset])\n}\n\n#[cube]\n/// Write the given value at the [arg](Arg) position.\npub fn write<C: CubePrimitive>(\n inputs: &GlobalArgs,\n outputs: &mut GlobalArgs,\n locals: &mut LocalArgs,\n ref_pos: u32,\n value: Line<C>,\n #[comptime] arg: Arg,\n #[comptime] config: &FuseBlockConfig,\n) {\n match arg {\n Arg::Output(pos, precision, layout) => {\n let tensor = outputs.tensors.index(pos);\n let offset = match layout {\n LayoutInfo::SameAsRef => ref_pos,\n LayoutInfo::IsRef => ref_pos,\n LayoutInfo::Unknown => {\n get_offset(inputs, locals, tensor, ref_pos, None, config, None)\n }\n };\n let tensor = outputs.tensors.index_mut(pos);\n set_polyfill::<NumericExpand<DYN_ELEM_ID>>(comptime![precision.into_elem()]);\n tensor.tensor[offset] = Line::cast_from(value);\n }\n Arg::Local(pos, precision) => match comptime![precision] {\n FusePrecision::F32 | FusePrecision::Flex32 => {\n locals.l_f32.insert(pos, Line::cast_from(value))\n }\n FusePrecision::F16 => locals.l_f16.insert(pos, Line::cast_from(value)),\n FusePrecision::BF16 => locals.l_bf16.insert(pos, Line::cast_from(value)),\n FusePrecision::U64 => locals.l_u64.insert(pos, Line::cast_from(value)),\n FusePrecision::U32 => locals.l_u32.insert(pos, Line::cast_from(value)),\n FusePrecision::U16 => locals.l_u16.insert(pos, Line::cast_from(value)),\n FusePrecision::U8 => locals.l_u8.insert(pos, Line::cast_from(value)),\n FusePrecision::I64 => locals.l_i64.insert(pos, Line::cast_from(value)),\n FusePrecision::I32 => locals.l_i32.insert(pos, Line::cast_from(value)),\n FusePrecision::I16 => locals.l_i16.insert(pos, Line::cast_from(value)),\n FusePrecision::I8 => locals.l_i8.insert(pos, Line::cast_from(value)),\n FusePrecision::Bool => locals.l_bool.insert(pos, Line::cast_from(value)),\n },\n _ => comptime![panic!(\"Can't write into inputs and scalars\")],\n }\n}\n\n#[cube]\npub(crate) fn global_offset(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n index: u32,\n #[comptime] arg: Arg,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match arg {\n Arg::Input(pos, _precision, _layout) => {\n let tensor = inputs.tensors.index(pos);\n get_offset(inputs, locals, tensor, index, range, config, None)\n }\n Arg::Output(pos, _precision, _layout) => {\n let tensor = outputs.tensors.index(pos);\n get_offset(inputs, locals, tensor, index, range, config, None)\n }\n _ => todo!(),\n }\n}\n\n#[cube]\nfn get_offset(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n tensor: &GlobalTensor,\n ref_pos: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] config: &FuseBlockConfig,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n index_offset_with_layout(\n inputs,\n tensor,\n locals,\n ref_pos,\n range,\n config.rank,\n transform,\n )\n}\n\n#[cube]\npub fn global_line_size(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n u32::cast_from(tensor.tensor.line_size())\n}\n\n#[cube]\npub fn global_rank(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.rank()\n}\n\n#[cube]\npub fn global_len(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.len()\n}\n\n#[cube]\npub fn global_buffer_len(global: &GlobalArgs, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.buffer_len()\n}\n\n#[cube]\npub fn ref_len(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match comptime![config.ref_layout.clone()] {\n RefLayout::Concrete(arg) => match comptime![arg] {\n Arg::Input(index, _, _) => global_len(inputs, index),\n Arg::Output(index, _, _) => global_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(..) => num_elements(locals, config),\n }\n}\n\n#[cube]\npub fn ref_buffer_len(\n inputs: &GlobalArgs,\n outputs: &GlobalArgs,\n locals: &LocalArgs,\n #[comptime] config: &FuseBlockConfig,\n) -> u32 {\n match comptime![config.ref_layout.clone()] {\n RefLayout::Concrete(arg) => match comptime![arg] {\n Arg::Input(index, _, _) => global_buffer_len(inputs, index),\n Arg::Output(index, _, _) => global_buffer_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(VirtualLayout::SwapDims(arg, ..)) => match arg {\n Arg::Input(index, _, _) => global_buffer_len(inputs, index),\n Arg::Output(index, _, _) => global_buffer_len(outputs, index),\n _ => panic!(\"Invalid concrete ref layout.\"),\n },\n RefLayout::Virtual(VirtualLayout::Reshaped(..)) => num_elements(locals, config),\n }\n}\n\n#[cube]\npub fn num_elements(locals: &LocalArgs, #[comptime] config: &FuseBlockConfig) -> u32 {\n let mut length = 1u32;\n\n for i in 0..config.rank {\n length *= locals.ref_shape[i];\n }\n\n length\n}\n\n#[cube]\npub fn ref_shape(locals: &LocalArgs, dim: u32) -> u32 {\n locals.ref_shape[dim]\n}\n\n#[cube]\npub fn ref_stride(locals: &LocalArgs, dim: u32) -> u32 {\n locals.ref_strides[dim]\n}\n\n#[cube]\npub fn global_shape(global: &GlobalArgs, dim: u32, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.shape(dim)\n}\n\n#[cube]\npub fn global_stride(global: &GlobalArgs, dim: u32, #[comptime] pos: u32) -> u32 {\n let tensor = global.tensors.index(pos);\n tensor.tensor.stride(dim)\n}\n\n#[cube]\nfn index_offset_with_layout(\n inputs: &GlobalArgs,\n tensor: &GlobalTensor,\n locals: &LocalArgs,\n index: u32,\n #[comptime] range: Option<(u32, u32)>,\n #[comptime] rank: u32,\n #[comptime] transform: Option<Transform>,\n) -> u32 {\n match comptime![transform.clone()] {\n Some(Transform::Reshape(shape)) => {\n comptime![assert!(\n range.is_none(),\n \"Can't get a range on a reshaped tensor.\"\n )];\n\n let index = index * locals.ref_line_size;\n let index = reshaped_index(inputs, locals, index, rank, shape);\n reshaped_index_to_original_index(&tensor.tensor, index, rank)\n }\n Some(Transform::SwapDims(dim1, dim2)) => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let index = comptime![swap_dims_transform(&i, (dim1, dim2))];\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(index) * tensor.tensor.stride(index);\n }\n\n offset / tensor.tensor.line_size()\n }\n None => {\n let (start, end) = comptime! {match range {\n Some(range) => range,\n None => (0u32, rank),\n }};\n\n let offset_ref = index * locals.ref_line_size;\n let mut offset = 0u32;\n\n #[unroll]\n for i in start..end {\n let ogwl = offset_ref / locals.ref_strides[i];\n offset += ogwl % tensor.tensor.shape(i) * tensor.tensor.stride(i);\n }\n\n offset / tensor.tensor.line_size()\n }\n }\n}\n\npub(crate) fn swap_dims_transform<I: Index + Clone>(i: &I, dims: (u32, u32)) -> u32 {\n let i_cloned: I = i.clone();\n let i = i_cloned.value().as_const().unwrap().as_u32();\n\n if i == dims.0 {\n dims.1\n } else if i == dims.1 {\n dims.0\n } else {\n i\n }\n}\n\n#[cube]\n#[allow(clippy::clone_on_copy)]\n/// The index the input tensor would be at if it was contiguous.\nfn reshaped_index(\n inputs: &GlobalArgs,\n locals: &LocalArgs,\n index: u32,\n #[comptime] rank: u32,\n #[comptime] shape: Sequence<Arg>,\n) -> u32 {\n let mut offset = 0u32;\n let mut stride_curr = 1u32;\n\n #[unroll]\n for r in 0..rank {\n let i = reverse_index(rank, r);\n let arg = comptime![shape.index(i)];\n let shape_i = read_scalar_shape(inputs, comptime![arg.clone()]);\n let ogwl = index / locals.ref_strides[i];\n\n offset += ogwl % shape_i * stride_curr;\n\n stride_curr *= shape_i;\n }\n\n offset\n}\n\n#[allow(unreachable_code)]\n#[cube]\n#[allow(clippy::clone_on_copy)]\nfn reshaped_index_to_original_index<C: CubePrimitive>(\n original: &Tensor<Line<C>>,\n index_reshaped: u32,\n #[comptime] rank: u32,\n) -> u32 {\n let mut remaining = index_reshaped;\n let mut offset = 0;\n\n #[unroll]\n for r in 0..rank {\n let i = reverse_index(rank, r);\n let shape = original.shape(i);\n let stride = original.stride(i);\n\n let coordinate = remaining % shape;\n\n remaining /= shape;\n offset += coordinate * stride;\n }\n\n offset / original.line_size()\n}\n\n#[cube]\n#[allow(unused_variables)]\npub(crate) fn reverse_index(#[comptime] rank: u32, iter: u32) -> comptime_type!(u32) {\n intrinsic!(|_| {\n let elem = iter.constant().map(|cons| cons.as_u32()).unwrap();\n rank - elem - 1\n })\n}\n\n/// Generic way to construct any [`CubePrimitive`] from an int. Used for fusion.\n#[allow(unused_variables)]\n#[cube]\nfn from_const_int<C: CubePrimitive>(#[comptime] value: u32) -> C {\n intrinsic!(|scope| {\n let constant: ExpandElement = value.into();\n let constant_c = constant.as_const().unwrap().cast_to(C::as_elem(scope));\n ExpandElement::Plain(Variable::constant(constant_c)).into()\n })\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct GlobalArgs {\\n pub tensors: Sequence<GlobalTensor>,\\n pub scalars: Sequence<GlobalScalar>,\\n pub reshapes: Sequence<u32>,\\n}\"\n ],\n \"name\": \"inputs\",\n \"type\": \"&GlobalArgs\"\n },\n {\n \"definitions\": [\n \"pub struct GlobalTensor {\\n pub tensor: Tensor<Line<NumericExpand<DYN_ELEM_ID>>>,\\n #[cube(comptime)]\\n pub elem: Elem,\\n #[cube(comptime)]\\n pub broadcasted: bool,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"&GlobalTensor\"\n },\n {\n \"definitions\": [\n \"pub struct LocalArgs {\\n pub l_f32: Registry<u32, Line<f32>>,\\n pub l_f16: Registry<u32, Line<f16>>,\\n pub l_bf16: Registry<u32, Line<bf16>>,\\n pub l_i64: Registry<u32, Line<i64>>,\\n pub l_i32: Registry<u32, Line<i32>>,\\n pub l_i16: Registry<u32, Line<i16>>,\\n pub l_i8: Registry<u32, Line<i8>>,\\n pub l_u64: Registry<u32, Line<u64>>,\\n pub l_u32: Registry<u32, Line<u32>>,\\n pub l_u16: Registry<u32, Line<u16>>,\\n pub l_u8: Registry<u32, Line<u8>>,\\n pub l_bool: Registry<u32, Line<bool>>,\\n pub ref_shape: Slice<u32>,\\n pub ref_strides: Slice<u32>,\\n #[cube(comptime)]\\n pub ref_line_size: u32,\\n}\"\n ],\n \"name\": \"locals\",\n \"type\": \"&LocalArgs\"\n },\n {\n \"definitions\": [\n \"pub enum Option<T> {\\n /// No value.\\n #[lang = \\\"None\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n None,\\n /// Some value of type `T`.\\n #[lang = \\\"Some\\\"]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n Some(#[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")] T),\\n}\"\n ],\n \"name\": \"range\",\n \"type\": \"Option<(u32, u32\"\n }\n ],\n \"end_line\": 526,\n \"name\": \"index_offset_with_layout\",\n \"signature\": \"fn index_offset_with_layout(\\n inputs: &GlobalArgs,\\n tensor: &GlobalTensor,\\n locals: &LocalArgs,\\n index: u32,\\n #[comptime] range: Option<(u32, u32)>,\\n #[comptime] rank: u32,\\n #[comptime] transform: Option<Transform>,\\n) -> u32\",\n \"start_line\": 470\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":163,"cells":{"function_name":{"kind":"string","value":"next_block"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/builder.rs"},"focal_code":{"kind":"string","value":"pub fn next_block(\n &mut self,\n arguments: [&TensorIr; N],\n settings: FuseSettings,\n ) -> Option<[Arg; N]> {\n let mut is_success = true;\n let args = arguments.map(|arg| {\n // We need to register the argument as input in the current block so that we retrieve\n // its value locally.\n let input = self.builder.builder.input(arg);\n\n if input.is_none() {\n is_success = false;\n } else {\n // This flag the new input local value as local output to be used in a following\n // block.\n self.builder.builder.block_local_output(arg);\n }\n\n input\n });\n\n let args = if !is_success {\n return None;\n } else {\n args.map(|arg| arg.unwrap())\n };\n\n let current_output_shape = core::mem::take(&mut self.current_output_shape);\n\n self.builder\n .builder\n .next_block(current_output_shape, settings);\n\n self.settings = settings;\n self.status = OptimizationStatus::Open;\n\n Some(args)\n }"},"file_content":{"kind":"string","value":"use super::{\n ir::{Arg, BinaryFuseArgs, FuseOp, FusePrecision, UnaryFuseArgs},\n settings::FuseSettings,\n trace::{FuseTrace, FuseTraceBuilder},\n};\nuse burn_fusion::{OptimizationBuilder, OptimizationProperties, OptimizationStatus};\nuse burn_ir::{\n BaseOperationIr, BinaryOpIr, FloatOperationIr, NumericOperationIr, OperationIr, ScalarOpIr,\n TensorIr, UnaryOpIr,\n};\nuse burn_tensor::Element;\nuse cubecl::ir::Elem;\n\n/// The base optimization builder that can be used to fuse all elemwise operations.\n///\n/// This builder doesn't create a ready-to-execute kernel, but rather generates a\n/// [trace](FuseTrace) that be used with a [runner](super::trace::TraceRunner).\n///\n/// Since this builder supports fusing multiple blocks, you can fuse any compute-bound operations\n/// with the combination of fuse-on-read and fuse-on-write strategy.\n#[derive(Debug)]\npub(crate) struct FuseOptimizationBuilder {\n builder: TryFuseBuilder,\n pub(crate) settings: FuseSettings,\n pub(crate) current_output_shape: Vec<usize>,\n status: OptimizationStatus,\n pub(crate) num_ops: usize,\n pub(crate) num_views: usize,\n max_bindings: u32,\n}\n\nimpl OptimizationBuilder<FuseTrace> for FuseOptimizationBuilder {\n fn register(&mut self, op: &OperationIr) {\n if let OptimizationStatus::Closed = self.status {\n return;\n }\n\n match op {\n OperationIr::BaseFloat(ops) => {\n if !self.register_base(ops) {\n self.status = OptimizationStatus::Closed;\n return;\n }\n }\n OperationIr::BaseInt(ops) => {\n if !self.register_base(ops) {\n self.status = OptimizationStatus::Closed;\n return;\n }\n }\n OperationIr::Float(_dtype, ops) => {\n if !self.register_float(ops) {\n self.status = OptimizationStatus::Closed;\n return;\n }\n }\n OperationIr::NumericFloat(_dtype, ops) => {\n if !self.register_numeric::<f32>(ops) {\n self.status = OptimizationStatus::Closed;\n return;\n }\n }\n OperationIr::NumericInt(_dtype, ops) => {\n if !self.register_numeric::<i32>(ops) {\n self.status = OptimizationStatus::Closed;\n return;\n }\n }\n OperationIr::BaseBool(ops) => {\n if !self.register_base(ops) {\n self.status = OptimizationStatus::Closed;\n return;\n }\n }\n _ => {\n self.status = OptimizationStatus::Closed;\n return;\n }\n };\n\n self.status = OptimizationStatus::Open;\n self.num_ops += 1;\n }\n\n fn build(&self) -> FuseTrace {\n self.builder.build(self.current_output_shape.clone())\n }\n\n fn len(&self) -> usize {\n self.num_ops\n }\n\n fn reset(&mut self) {\n self.num_ops = 0;\n self.status = OptimizationStatus::Open;\n self.builder = TryFuseBuilder::new(\n self.max_bindings,\n self.builder.builder.bool_precision,\n self.settings,\n );\n self.current_output_shape.clear();\n }\n\n fn status(&self) -> OptimizationStatus {\n self.status\n }\n\n fn properties(&self) -> OptimizationProperties {\n let ready = self.num_ops > 0;\n\n OptimizationProperties {\n ready,\n score: self.num_ops as u64,\n }\n }\n}\n\nimpl FuseOptimizationBuilder {\n /// Create a new builder.\n pub fn new(max_bindings: u32, bool_precision: FusePrecision, settings: FuseSettings) -> Self {\n Self {\n builder: TryFuseBuilder::new(max_bindings, bool_precision, settings),\n settings,\n num_ops: 0,\n num_views: 0,\n max_bindings,\n current_output_shape: Vec::new(),\n status: OptimizationStatus::Open,\n }\n }\n\n /// Closes the builder.\n pub fn close(&mut self) {\n self.status = OptimizationStatus::Closed;\n }\n\n /// Declares an input tensor argument where the kernel is responsible to load.\n pub fn input_unhandled(&mut self, tensor: &TensorIr) -> Arg {\n self.builder.builder.input_unhandled(tensor)\n }\n\n /// Declares an output tensor argument where the kernel is responsible to write values.\n ///\n /// Normally you don't have to declare outputs explicitly before they are going to be\n /// registered based on the operations [registered](Self::register).\n pub fn output_unhandled(&mut self, tensor: &TensorIr) -> Arg {\n if self.current_output_shape.is_empty() {\n self.current_output_shape = tensor.shape.clone();\n } else if self.current_output_shape.iter().sum::<usize>() < tensor.shape.iter().sum() {\n // The larguest shape win.\n self.current_output_shape = tensor.shape.clone();\n }\n\n self.builder.builder.output_unhandled(tensor)\n }\n\n /// Closes the previous block and declares a new one.\n ///\n /// The arguments that will be used in the following block need to be passed as parameters.\n /// They are going to be returned as [arguments](Arg), used to be retrieved in the kernel that\n /// uses it.\n pub fn next_block<const N: usize>(\n &mut self,\n arguments: [&TensorIr; N],\n settings: FuseSettings,\n ) -> Option<[Arg; N]> {\n let mut is_success = true;\n let args = arguments.map(|arg| {\n // We need to register the argument as input in the current block so that we retrieve\n // its value locally.\n let input = self.builder.builder.input(arg);\n\n if input.is_none() {\n is_success = false;\n } else {\n // This flag the new input local value as local output to be used in a following\n // block.\n self.builder.builder.block_local_output(arg);\n }\n\n input\n });\n\n let args = if !is_success {\n return None;\n } else {\n args.map(|arg| arg.unwrap())\n };\n\n let current_output_shape = core::mem::take(&mut self.current_output_shape);\n\n self.builder\n .builder\n .next_block(current_output_shape, settings);\n\n self.settings = settings;\n self.status = OptimizationStatus::Open;\n\n Some(args)\n }\n\n fn register_base(&mut self, ops: &BaseOperationIr) -> bool {\n match ops {\n BaseOperationIr::Equal(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Equal(BinaryFuseArgs { lhs, rhs, out })\n }),\n BaseOperationIr::Cast(desc) => self.register_unary_ops(desc, |input, out| {\n FuseOp::Assign(UnaryFuseArgs { input, out })\n }),\n BaseOperationIr::SwapDims(desc) => {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n if self.builder.register(|build| {\n build.input_swap_dims(\n &desc.input,\n &desc.out,\n (desc.dim1 as u32, desc.dim2 as u32),\n )?;\n\n Some(())\n }) {\n self.num_views += 1;\n true\n } else {\n false\n }\n }\n BaseOperationIr::Reshape(desc) => {\n if desc.input.shape == desc.out.shape {\n return self.register_unary_ops(desc, |input, out| {\n FuseOp::Assign(UnaryFuseArgs { input, out })\n });\n }\n\n if desc.input.shape.len() > desc.out.shape.len() {\n // Not yet supported.\n return false;\n }\n\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n if self.builder.register(|build| {\n build.input_reshaped(&desc.input, &desc.out)?;\n Some(())\n }) {\n self.num_views += 1;\n true\n } else {\n false\n }\n }\n _ => false,\n }\n }\n\n fn register_float(&mut self, ops: &FloatOperationIr) -> bool {\n match ops {\n FloatOperationIr::Exp(desc) => self\n .register_unary_ops(desc, |input, out| FuseOp::Exp(UnaryFuseArgs { input, out })),\n FloatOperationIr::Log(desc) => self\n .register_unary_ops(desc, |input, out| FuseOp::Log(UnaryFuseArgs { input, out })),\n FloatOperationIr::Log1p(desc) => self.register_unary_ops(desc, |input, out| {\n FuseOp::Log1p(UnaryFuseArgs { input, out })\n }),\n FloatOperationIr::Cos(desc) => self\n .register_unary_ops(desc, |input, out| FuseOp::Cos(UnaryFuseArgs { input, out })),\n FloatOperationIr::Sin(desc) => self\n .register_unary_ops(desc, |input, out| FuseOp::Sin(UnaryFuseArgs { input, out })),\n FloatOperationIr::PowfScalar(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Powf(BinaryFuseArgs { lhs, rhs, out })\n }),\n FloatOperationIr::Tanh(desc) => self.register_unary_ops(desc, |input, out| {\n FuseOp::Tanh(UnaryFuseArgs { input, out })\n }),\n FloatOperationIr::Erf(desc) => self\n .register_unary_ops(desc, |input, out| FuseOp::Erf(UnaryFuseArgs { input, out })),\n FloatOperationIr::Recip(desc) => self.register_unary_ops(desc, |input, out| {\n FuseOp::Recip(UnaryFuseArgs { input, out })\n }),\n _ => false,\n }\n }\n\n fn register_numeric<E: Element>(&mut self, op: &NumericOperationIr<E>) -> bool {\n match op {\n NumericOperationIr::Add(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Add(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::AddScalar(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Add(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::Sub(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Sub(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::SubScalar(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Sub(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::Mul(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Mul(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::MulScalar(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Mul(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::Div(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Div(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::DivScalar(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Div(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::Abs(desc) => self\n .register_unary_ops(desc, |input, out| FuseOp::Abs(UnaryFuseArgs { input, out })),\n NumericOperationIr::Lower(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Lower(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::LowerElem(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Lower(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::Greater(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::Greater(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::GreaterElem(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Greater(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::LowerEqual(desc) => self\n .register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::LowerEqual(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::LowerEqualElem(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::LowerEqual(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::GreaterEqual(desc) => self\n .register_binary_ops(desc, |lhs, rhs, out| {\n FuseOp::GreaterEqual(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::GreaterEqualElem(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::GreaterEqual(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::EqualElem(desc) => self\n .register_scalar_ops(desc, |lhs, rhs, out| {\n FuseOp::Equal(BinaryFuseArgs { lhs, rhs, out })\n }),\n NumericOperationIr::MaskWhere(desc) => {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let cond = build.input(&desc.mask)?;\n let lhs = build.input(&desc.value)?;\n let rhs = build.input(&desc.tensor)?;\n let out = build.output(&desc.out)?;\n\n build.register_operation(FuseOp::ConditionalAssign {\n cond,\n lhs,\n rhs,\n out,\n });\n\n Some(())\n })\n }\n NumericOperationIr::MaskFill(desc) => {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let cond = build.input(&desc.mask)?;\n let lhs = build.scalar(&desc.value, desc.out.dtype);\n let rhs = build.input(&desc.tensor)?;\n let out = build.output(&desc.out)?;\n\n build.register_operation(FuseOp::ConditionalAssign {\n cond,\n lhs,\n rhs,\n out,\n });\n\n Some(())\n })\n }\n NumericOperationIr::Ones(desc) => {\n if !self.output_is_compatible(desc) {\n return false;\n }\n\n let elem: Elem = desc.dtype.into();\n let precision = elem.into();\n let input = Arg::Literal(1, precision);\n\n self.builder.register(|build| {\n let out = build.output(desc)?;\n\n build.register_operation(FuseOp::Assign(UnaryFuseArgs { input, out }));\n\n Some(())\n })\n }\n NumericOperationIr::Zeros(desc) => {\n if !self.output_is_compatible(desc) {\n return false;\n }\n\n let elem: Elem = desc.dtype.into();\n let precision = elem.into();\n let input = Arg::Literal(0, precision);\n\n self.builder.register(|build| {\n let out = build.output(desc)?;\n\n build.register_operation(FuseOp::Assign(UnaryFuseArgs { input, out }));\n\n Some(())\n })\n }\n NumericOperationIr::Full((desc, elem)) => {\n if !self.output_is_compatible(desc) {\n return false;\n }\n\n self.builder.register(|build| {\n let input = build.scalar(elem, desc.dtype);\n let out = build.output(desc)?;\n\n build.register_operation(FuseOp::Assign(UnaryFuseArgs { input, out }));\n\n Some(())\n })\n }\n NumericOperationIr::Gather(desc) => {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let input = build.input_indexed(&desc.tensor)?;\n let indices = build.input(&desc.indices)?;\n let output = build.output(&desc.out)?;\n\n build.register_operation(FuseOp::Gather {\n input,\n indices,\n output,\n dim: desc.dim as u32,\n });\n\n Some(())\n })\n }\n NumericOperationIr::Select(desc) => {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let input = build.input_indexed(&desc.tensor)?;\n let indices = build.input_indexed(&desc.indices)?;\n let output = build.output(&desc.out)?;\n\n build.register_operation(FuseOp::Select {\n input,\n indices,\n output,\n dim: desc.dim as u32,\n });\n\n Some(())\n })\n }\n _ => false,\n }\n }\n\n fn register_binary_ops<Func>(&mut self, desc: &BinaryOpIr, func: Func) -> bool\n where\n Func: Fn(Arg, Arg, Arg) -> FuseOp,\n {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let lhs = build.input(&desc.lhs)?;\n let rhs = build.input(&desc.rhs)?;\n let out = build.output(&desc.out)?;\n\n build.register_operation(func(lhs, rhs, out));\n\n Some(())\n })\n }\n\n fn register_unary_ops<Func>(&mut self, desc: &UnaryOpIr, func: Func) -> bool\n where\n Func: Fn(Arg, Arg) -> FuseOp,\n {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let input = build.input(&desc.input)?;\n let out = build.output(&desc.out)?;\n build.register_operation(func(input, out));\n Some(())\n })\n }\n\n fn register_scalar_ops<Func, E: Element>(&mut self, desc: &ScalarOpIr<E>, func: Func) -> bool\n where\n Func: Fn(Arg, Arg, Arg) -> FuseOp,\n {\n if !self.output_is_compatible(&desc.out) {\n return false;\n }\n\n self.builder.register(|build| {\n let elem = desc.lhs.dtype;\n let lhs = build.input(&desc.lhs)?;\n let rhs = build.scalar(&desc.rhs, elem);\n let out = build.output(&desc.out)?;\n\n build.register_operation(func(lhs, rhs, out));\n\n Some(())\n })\n }\n\n fn output_is_compatible(&mut self, out: &TensorIr) -> bool {\n if self.current_output_shape.is_empty() {\n self.current_output_shape.clone_from(&out.shape);\n return true;\n }\n\n let rank = self.current_output_shape.len();\n\n // Rank should be equal.\n if rank != out.shape.len() {\n return false;\n }\n\n let mut updated = self.current_output_shape.clone();\n\n #[allow(clippy::needless_range_loop)]\n for i in 0..rank {\n let curr = self.current_output_shape[i];\n let new = out.shape[i];\n\n if curr == new {\n continue;\n }\n\n // Broadcast not enabled.\n if !self.settings.broadcast {\n return false;\n }\n\n // Broadcasted on new dim.\n if new == 0 {\n continue;\n }\n\n // Broadcasted on curr dim - update reference output shape.\n if curr == 0 && self.settings.output_shape_updates {\n updated[i] = new;\n continue;\n }\n\n return false;\n }\n\n if updated != out.shape {\n return false;\n }\n self.current_output_shape.clone_from_slice(&out.shape);\n\n true\n }\n}\n\n#[derive(Debug)]\n/// Builder wrapper to limit the number of bindings in generated kernels.\nstruct TryFuseBuilder {\n builder: FuseTraceBuilder,\n max_bindings: u32,\n max_ops: u32,\n added_ops: bool,\n}\n\nimpl TryFuseBuilder {\n fn new(max_bindings: u32, bool_precision: FusePrecision, settings: FuseSettings) -> Self {\n Self {\n builder: FuseTraceBuilder::new(bool_precision, settings),\n max_bindings,\n // A good default, avoid errors with for loops over only memory\n // bound operations.\n max_ops: 64,\n added_ops: false,\n }\n }\n\n fn register(&mut self, add_ops: impl FnOnce(&mut FuseTraceBuilder) -> Option<()>) -> bool {\n if self.builder.num_ops_fused() > self.max_ops {\n return false;\n }\n\n // Always allow the first operation to be added.\n if !self.added_ops {\n self.added_ops = true;\n\n if add_ops(&mut self.builder).is_none() {\n return false;\n }\n return true;\n }\n\n let mut cloned = self.builder.clone();\n if add_ops(&mut cloned).is_none() {\n return false;\n }\n\n if cloned.estimate_bindings() > self.max_bindings {\n return false;\n }\n\n self.builder = cloned;\n true\n }\n\n fn build(&self, shape: Vec<usize>) -> FuseTrace {\n self.builder.build(shape)\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct FuseSettings {\\n /// Enables broadcasting of shapes.\\n pub broadcast: bool,\\n /// Enables output shape updates.\\n ///\\n /// When broadcast is enabled, the output shape can become bigger after a fusion,\\n /// therefore an update is needed.\\n pub output_shape_updates: bool,\\n /// Enables the reuse of input buffers.\\n pub inplace: bool,\\n /// Whether vectorization is enabled.\\n pub vectorization: VectorizationSetting,\\n}\"\n ],\n \"name\": \"settings\",\n \"type\": \"FuseSettings\"\n }\n ],\n \"end_line\": 200,\n \"name\": \"next_block\",\n \"signature\": \"pub fn next_block(\\n &mut self,\\n arguments: [&TensorIr; N],\\n settings: FuseSettings,\\n ) -> Option<[Arg; N]>\",\n \"start_line\": 162\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl FuseOptimizationBuilder {\\n /// Create a new builder.\\n pub fn new(max_bindings: u32, bool_precision: FusePrecision, settings: FuseSettings) -> Self {\\n Self {\\n builder: TryFuseBuilder::new(max_bindings, bool_precision, settings),\\n settings,\\n num_ops: 0,\\n num_views: 0,\\n max_bindings,\\n current_output_shape: Vec::new(),\\n status: OptimizationStatus::Open,\\n }\\n }\\n\\n /// Closes the builder.\\n pub fn close(&mut self) {\\n self.status = OptimizationStatus::Closed;\\n }\\n\\n /// Declares an input tensor argument where the kernel is responsible to load.\\n pub fn input_unhandled(&mut self, tensor: &TensorIr) -> Arg {\\n self.builder.builder.input_unhandled(tensor)\\n }\\n\\n /// Declares an output tensor argument where the kernel is responsible to write values.\\n ///\\n /// Normally you don't have to declare outputs explicitly before they are going to be\\n /// registered based on the operations [registered](Self::register).\\n pub fn output_unhandled(&mut self, tensor: &TensorIr) -> Arg {\\n if self.current_output_shape.is_empty() {\\n self.current_output_shape = tensor.shape.clone();\\n } else if self.current_output_shape.iter().sum::<usize>() < tensor.shape.iter().sum() {\\n // The larguest shape win.\\n self.current_output_shape = tensor.shape.clone();\\n }\\n\\n self.builder.builder.output_unhandled(tensor)\\n }\\n\\n /// Closes the previous block and declares a new one.\\n ///\\n /// The arguments that will be used in the following block need to be passed as parameters.\\n /// They are going to be returned as [arguments](Arg), used to be retrieved in the kernel that\\n /// uses it.\\n pub fn next_block<const N: usize>(\\n &mut self,\\n arguments: [&TensorIr; N],\\n settings: FuseSettings,\\n ) -> Option<[Arg; N]> {\\n let mut is_success = true;\\n let args = arguments.map(|arg| {\\n // We need to register the argument as input in the current block so that we retrieve\\n // its value locally.\\n let input = self.builder.builder.input(arg);\\n\\n if input.is_none() {\\n is_success = false;\\n } else {\\n // This flag the new input local value as local output to be used in a following\\n // block.\\n self.builder.builder.block_local_output(arg);\\n }\\n\\n input\\n });\\n\\n let args = if !is_success {\\n return None;\\n } else {\\n args.map(|arg| arg.unwrap())\\n };\\n\\n let current_output_shape = core::mem::take(&mut self.current_output_shape);\\n\\n self.builder\\n .builder\\n .next_block(current_output_shape, settings);\\n\\n self.settings = settings;\\n self.status = OptimizationStatus::Open;\\n\\n Some(args)\\n }\\n\\n fn register_base(&mut self, ops: &BaseOperationIr) -> bool {\\n match ops {\\n BaseOperationIr::Equal(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Equal(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n BaseOperationIr::Cast(desc) => self.register_unary_ops(desc, |input, out| {\\n FuseOp::Assign(UnaryFuseArgs { input, out })\\n }),\\n BaseOperationIr::SwapDims(desc) => {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n if self.builder.register(|build| {\\n build.input_swap_dims(\\n &desc.input,\\n &desc.out,\\n (desc.dim1 as u32, desc.dim2 as u32),\\n )?;\\n\\n Some(())\\n }) {\\n self.num_views += 1;\\n true\\n } else {\\n false\\n }\\n }\\n BaseOperationIr::Reshape(desc) => {\\n if desc.input.shape == desc.out.shape {\\n return self.register_unary_ops(desc, |input, out| {\\n FuseOp::Assign(UnaryFuseArgs { input, out })\\n });\\n }\\n\\n if desc.input.shape.len() > desc.out.shape.len() {\\n // Not yet supported.\\n return false;\\n }\\n\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n if self.builder.register(|build| {\\n build.input_reshaped(&desc.input, &desc.out)?;\\n Some(())\\n }) {\\n self.num_views += 1;\\n true\\n } else {\\n false\\n }\\n }\\n _ => false,\\n }\\n }\\n\\n fn register_float(&mut self, ops: &FloatOperationIr) -> bool {\\n match ops {\\n FloatOperationIr::Exp(desc) => self\\n .register_unary_ops(desc, |input, out| FuseOp::Exp(UnaryFuseArgs { input, out })),\\n FloatOperationIr::Log(desc) => self\\n .register_unary_ops(desc, |input, out| FuseOp::Log(UnaryFuseArgs { input, out })),\\n FloatOperationIr::Log1p(desc) => self.register_unary_ops(desc, |input, out| {\\n FuseOp::Log1p(UnaryFuseArgs { input, out })\\n }),\\n FloatOperationIr::Cos(desc) => self\\n .register_unary_ops(desc, |input, out| FuseOp::Cos(UnaryFuseArgs { input, out })),\\n FloatOperationIr::Sin(desc) => self\\n .register_unary_ops(desc, |input, out| FuseOp::Sin(UnaryFuseArgs { input, out })),\\n FloatOperationIr::PowfScalar(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Powf(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n FloatOperationIr::Tanh(desc) => self.register_unary_ops(desc, |input, out| {\\n FuseOp::Tanh(UnaryFuseArgs { input, out })\\n }),\\n FloatOperationIr::Erf(desc) => self\\n .register_unary_ops(desc, |input, out| FuseOp::Erf(UnaryFuseArgs { input, out })),\\n FloatOperationIr::Recip(desc) => self.register_unary_ops(desc, |input, out| {\\n FuseOp::Recip(UnaryFuseArgs { input, out })\\n }),\\n _ => false,\\n }\\n }\\n\\n fn register_numeric<E: Element>(&mut self, op: &NumericOperationIr<E>) -> bool {\\n match op {\\n NumericOperationIr::Add(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Add(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::AddScalar(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Add(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::Sub(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Sub(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::SubScalar(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Sub(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::Mul(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Mul(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::MulScalar(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Mul(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::Div(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Div(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::DivScalar(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Div(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::Abs(desc) => self\\n .register_unary_ops(desc, |input, out| FuseOp::Abs(UnaryFuseArgs { input, out })),\\n NumericOperationIr::Lower(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Lower(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::LowerElem(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Lower(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::Greater(desc) => self.register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::Greater(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::GreaterElem(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Greater(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::LowerEqual(desc) => self\\n .register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::LowerEqual(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::LowerEqualElem(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::LowerEqual(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::GreaterEqual(desc) => self\\n .register_binary_ops(desc, |lhs, rhs, out| {\\n FuseOp::GreaterEqual(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::GreaterEqualElem(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::GreaterEqual(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::EqualElem(desc) => self\\n .register_scalar_ops(desc, |lhs, rhs, out| {\\n FuseOp::Equal(BinaryFuseArgs { lhs, rhs, out })\\n }),\\n NumericOperationIr::MaskWhere(desc) => {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let cond = build.input(&desc.mask)?;\\n let lhs = build.input(&desc.value)?;\\n let rhs = build.input(&desc.tensor)?;\\n let out = build.output(&desc.out)?;\\n\\n build.register_operation(FuseOp::ConditionalAssign {\\n cond,\\n lhs,\\n rhs,\\n out,\\n });\\n\\n Some(())\\n })\\n }\\n NumericOperationIr::MaskFill(desc) => {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let cond = build.input(&desc.mask)?;\\n let lhs = build.scalar(&desc.value, desc.out.dtype);\\n let rhs = build.input(&desc.tensor)?;\\n let out = build.output(&desc.out)?;\\n\\n build.register_operation(FuseOp::ConditionalAssign {\\n cond,\\n lhs,\\n rhs,\\n out,\\n });\\n\\n Some(())\\n })\\n }\\n NumericOperationIr::Ones(desc) => {\\n if !self.output_is_compatible(desc) {\\n return false;\\n }\\n\\n let elem: Elem = desc.dtype.into();\\n let precision = elem.into();\\n let input = Arg::Literal(1, precision);\\n\\n self.builder.register(|build| {\\n let out = build.output(desc)?;\\n\\n build.register_operation(FuseOp::Assign(UnaryFuseArgs { input, out }));\\n\\n Some(())\\n })\\n }\\n NumericOperationIr::Zeros(desc) => {\\n if !self.output_is_compatible(desc) {\\n return false;\\n }\\n\\n let elem: Elem = desc.dtype.into();\\n let precision = elem.into();\\n let input = Arg::Literal(0, precision);\\n\\n self.builder.register(|build| {\\n let out = build.output(desc)?;\\n\\n build.register_operation(FuseOp::Assign(UnaryFuseArgs { input, out }));\\n\\n Some(())\\n })\\n }\\n NumericOperationIr::Full((desc, elem)) => {\\n if !self.output_is_compatible(desc) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let input = build.scalar(elem, desc.dtype);\\n let out = build.output(desc)?;\\n\\n build.register_operation(FuseOp::Assign(UnaryFuseArgs { input, out }));\\n\\n Some(())\\n })\\n }\\n NumericOperationIr::Gather(desc) => {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let input = build.input_indexed(&desc.tensor)?;\\n let indices = build.input(&desc.indices)?;\\n let output = build.output(&desc.out)?;\\n\\n build.register_operation(FuseOp::Gather {\\n input,\\n indices,\\n output,\\n dim: desc.dim as u32,\\n });\\n\\n Some(())\\n })\\n }\\n NumericOperationIr::Select(desc) => {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let input = build.input_indexed(&desc.tensor)?;\\n let indices = build.input_indexed(&desc.indices)?;\\n let output = build.output(&desc.out)?;\\n\\n build.register_operation(FuseOp::Select {\\n input,\\n indices,\\n output,\\n dim: desc.dim as u32,\\n });\\n\\n Some(())\\n })\\n }\\n _ => false,\\n }\\n }\\n\\n fn register_binary_ops<Func>(&mut self, desc: &BinaryOpIr, func: Func) -> bool\\n where\\n Func: Fn(Arg, Arg, Arg) -> FuseOp,\\n {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let lhs = build.input(&desc.lhs)?;\\n let rhs = build.input(&desc.rhs)?;\\n let out = build.output(&desc.out)?;\\n\\n build.register_operation(func(lhs, rhs, out));\\n\\n Some(())\\n })\\n }\\n\\n fn register_unary_ops<Func>(&mut self, desc: &UnaryOpIr, func: Func) -> bool\\n where\\n Func: Fn(Arg, Arg) -> FuseOp,\\n {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let input = build.input(&desc.input)?;\\n let out = build.output(&desc.out)?;\\n build.register_operation(func(input, out));\\n Some(())\\n })\\n }\\n\\n fn register_scalar_ops<Func, E: Element>(&mut self, desc: &ScalarOpIr<E>, func: Func) -> bool\\n where\\n Func: Fn(Arg, Arg, Arg) -> FuseOp,\\n {\\n if !self.output_is_compatible(&desc.out) {\\n return false;\\n }\\n\\n self.builder.register(|build| {\\n let elem = desc.lhs.dtype;\\n let lhs = build.input(&desc.lhs)?;\\n let rhs = build.scalar(&desc.rhs, elem);\\n let out = build.output(&desc.out)?;\\n\\n build.register_operation(func(lhs, rhs, out));\\n\\n Some(())\\n })\\n }\\n\\n fn output_is_compatible(&mut self, out: &TensorIr) -> bool {\\n if self.current_output_shape.is_empty() {\\n self.current_output_shape.clone_from(&out.shape);\\n return true;\\n }\\n\\n let rank = self.current_output_shape.len();\\n\\n // Rank should be equal.\\n if rank != out.shape.len() {\\n return false;\\n }\\n\\n let mut updated = self.current_output_shape.clone();\\n\\n #[allow(clippy::needless_range_loop)]\\n for i in 0..rank {\\n let curr = self.current_output_shape[i];\\n let new = out.shape[i];\\n\\n if curr == new {\\n continue;\\n }\\n\\n // Broadcast not enabled.\\n if !self.settings.broadcast {\\n return false;\\n }\\n\\n // Broadcasted on new dim.\\n if new == 0 {\\n continue;\\n }\\n\\n // Broadcasted on curr dim - update reference output shape.\\n if curr == 0 && self.settings.output_shape_updates {\\n updated[i] = new;\\n continue;\\n }\\n\\n return false;\\n }\\n\\n if updated != out.shape {\\n return false;\\n }\\n self.current_output_shape.clone_from_slice(&out.shape);\\n\\n true\\n }\\n}\",\n \"class_signature\": \"impl FuseOptimizationBuilder\"\n}"}}},{"rowIdx":164,"cells":{"function_name":{"kind":"string","value":"shape_ref"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/ir.rs"},"focal_code":{"kind":"string","value":"pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\n match ref_layout {\n RefLayout::Concrete(arg) => self.shape(arg),\n RefLayout::Virtual(layout) => match layout {\n VirtualLayout::SwapDims(original, dims) => {\n let mut shape = self.shape(original);\n shape.swap(dims.0 as usize, dims.1 as usize);\n shape\n }\n VirtualLayout::Reshaped(start) => {\n let start = *start as usize;\n let end = start + rank;\n self.reshapes.values[start..end]\n .iter()\n .map(|s| s.elem as usize)\n .collect()\n }\n },\n }\n }"},"file_content":{"kind":"string","value":"use burn_tensor::DType;\nuse cubecl::ir::Elem;\nuse cubecl::prelude::*;\nuse half::{bf16, f16};\nuse serde::{Deserialize, Serialize};\n\nuse super::tensor::{GlobalScalar, GlobalTensor};\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\n/// Argument to a [fuse operation](FuseOp).\npub enum Arg {\n Input(u32, FusePrecision, LayoutInfo),\n Local(u32, FusePrecision),\n Output(u32, FusePrecision, LayoutInfo),\n Scalar(u32, FusePrecision),\n ScalarShape(u32),\n /// Only constant that can be encoded into an u32 can be used as literal.\n Literal(u32, FusePrecision),\n InputReshaped {\n original: Box<Arg>,\n shape: Sequence<Arg>,\n broadcasted: bool,\n },\n InputSwapDims {\n original: Box<Arg>,\n dims: (u32, u32),\n broadcasted: bool,\n },\n}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\n/// Layout information.\npub enum LayoutInfo {\n /// The layout if the same as the reference.\n SameAsRef,\n /// The reference layout.\n IsRef,\n /// The layout if unknown.\n Unknown,\n}\n\nimpl Arg {\n pub fn precision(&self) -> FusePrecision {\n *match self {\n Arg::Input(_, p, _) => p,\n Arg::Local(_, p) => p,\n Arg::Output(_, p, _) => p,\n Arg::Scalar(_, p) => p,\n Arg::Literal(_, p) => p,\n Arg::ScalarShape(_) => return FusePrecision::U32,\n Arg::InputReshaped { original, .. } => return original.precision(),\n Arg::InputSwapDims { original, .. } => return original.precision(),\n }\n }\n}\n\nimpl CubeType for Arg {\n type ExpandType = Self;\n}\n\nimpl IntoMut for Arg {\n fn into_mut(self, _context: &mut Scope) -> Self {\n self\n }\n}\n\nimpl IntoRuntime for Arg {\n fn __expand_runtime_method(self, _context: &mut Scope) -> Self::ExpandType {\n self\n }\n}\n\nimpl CubeDebug for Arg {}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Operations that can be executed and fused automatically using a fuse-on-read and/or\n/// fuse-on-write strategy.\npub enum FuseOp {\n Add(BinaryFuseArgs),\n Sub(BinaryFuseArgs),\n Mul(BinaryFuseArgs),\n Div(BinaryFuseArgs),\n Powf(BinaryFuseArgs),\n Abs(UnaryFuseArgs),\n Exp(UnaryFuseArgs),\n Log(UnaryFuseArgs),\n Log1p(UnaryFuseArgs),\n Cos(UnaryFuseArgs),\n Sin(UnaryFuseArgs),\n Tanh(UnaryFuseArgs),\n Erf(UnaryFuseArgs),\n Recip(UnaryFuseArgs),\n Assign(UnaryFuseArgs),\n Equal(BinaryFuseArgs),\n Lower(BinaryFuseArgs),\n Greater(BinaryFuseArgs),\n LowerEqual(BinaryFuseArgs),\n GreaterEqual(BinaryFuseArgs),\n ConditionalAssign {\n cond: Arg,\n lhs: Arg,\n rhs: Arg,\n out: Arg,\n },\n Gather {\n input: Arg,\n indices: Arg,\n output: Arg,\n dim: u32,\n },\n Select {\n input: Arg,\n indices: Arg,\n output: Arg,\n dim: u32,\n },\n}\n\nimpl FuseOp {\n /// Element type used for the computation.\n pub(crate) fn cmp_elem(&self) -> Elem {\n match self {\n FuseOp::Add(op) => op.lhs.precision().into_elem(),\n FuseOp::Sub(op) => op.lhs.precision().into_elem(),\n FuseOp::Mul(op) => op.lhs.precision().into_elem(),\n FuseOp::Div(op) => op.lhs.precision().into_elem(),\n FuseOp::Powf(op) => op.lhs.precision().into_elem(),\n FuseOp::Abs(op) => op.out.precision().into_elem(),\n FuseOp::Exp(op) => op.out.precision().into_elem(),\n FuseOp::Log(op) => op.out.precision().into_elem(),\n FuseOp::Log1p(op) => op.out.precision().into_elem(),\n FuseOp::Cos(op) => op.out.precision().into_elem(),\n FuseOp::Sin(op) => op.out.precision().into_elem(),\n FuseOp::Tanh(op) => op.out.precision().into_elem(),\n FuseOp::Erf(op) => op.out.precision().into_elem(),\n FuseOp::Recip(op) => op.out.precision().into_elem(),\n FuseOp::Assign(op) => op.out.precision().into_elem(),\n FuseOp::Equal(op) => op.lhs.precision().into_elem(),\n FuseOp::Lower(op) => op.lhs.precision().into_elem(),\n FuseOp::Greater(op) => op.lhs.precision().into_elem(),\n FuseOp::LowerEqual(op) => op.lhs.precision().into_elem(),\n FuseOp::GreaterEqual(op) => op.lhs.precision().into_elem(),\n FuseOp::ConditionalAssign { out, .. } => out.precision().into_elem(),\n FuseOp::Gather { output, .. } => output.precision().into_elem(),\n FuseOp::Select { output, .. } => output.precision().into_elem(),\n }\n }\n}\n\n#[derive(CubeType, CubeLaunch, Default)]\n/// Global arguments that are used for fusing [element wise operations](ElemwiseOp).\npub struct GlobalArgs {\n pub tensors: Sequence<GlobalTensor>,\n pub scalars: Sequence<GlobalScalar>,\n pub reshapes: Sequence<u32>,\n}\n\nimpl<R: Runtime> Default for GlobalArgsLaunch<'_, R> {\n fn default() -> Self {\n Self {\n tensors: Default::default(),\n scalars: Default::default(),\n reshapes: Default::default(),\n _phantom_runtime: std::marker::PhantomData,\n _phantom_a: std::marker::PhantomData,\n }\n }\n}\n\nimpl<R: Runtime> core::fmt::Debug for GlobalArgsLaunch<'_, R> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"({:?})\", self.tensors.values)\n }\n}\n\nimpl<R: Runtime> GlobalArgsLaunch<'_, R> {\n /// Get the shape of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn shape(&self, arg: &Arg) -> Vec<usize> {\n match self.resolve_arg(arg) {\n TensorArg::Handle { handle, .. } => handle.shape.to_vec(),\n TensorArg::Alias { .. } => panic!(\"Unsupported yet\"),\n }\n }\n\n /// Shape used by the reference tensor.\n pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\n match ref_layout {\n RefLayout::Concrete(arg) => self.shape(arg),\n RefLayout::Virtual(layout) => match layout {\n VirtualLayout::SwapDims(original, dims) => {\n let mut shape = self.shape(original);\n shape.swap(dims.0 as usize, dims.1 as usize);\n shape\n }\n VirtualLayout::Reshaped(start) => {\n let start = *start as usize;\n let end = start + rank;\n self.reshapes.values[start..end]\n .iter()\n .map(|s| s.elem as usize)\n .collect()\n }\n },\n }\n }\n\n /// Get the strides of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn strides(&self, arg: &Arg) -> Vec<usize> {\n match self.resolve_arg(arg) {\n TensorArg::Handle { handle, .. } => handle.strides.to_vec(),\n TensorArg::Alias { .. } => panic!(\"Unsupported yet\"),\n }\n }\n\n pub fn strides_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\n match ref_layout {\n RefLayout::Concrete(arg) => self.strides(arg),\n // When not concrete, we operate on the contiguous layout.\n _ => {\n let shape = self.shape_ref(ref_layout, rank);\n let mut strides = vec![0; shape.len()];\n\n let mut current = 1;\n shape.iter().enumerate().rev().for_each(|(index, val)| {\n strides[index] = current;\n current *= val;\n });\n\n strides\n }\n }\n }\n\n /// Get the line size of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn line_size(&self, arg: &Arg) -> u8 {\n match self.resolve_arg(arg) {\n TensorArg::Handle {\n vectorization_factor,\n ..\n } => *vectorization_factor,\n TensorArg::Alias { .. } => panic!(\"Unsupported yet\"),\n }\n }\n\n /// Resolve the [argument](Arg) to a [tensor argument](TensorArg).\n ///\n /// # Panics\n ///\n /// If the argument isn't a global input or output tensor.\n pub fn resolve_arg(&self, arg: &Arg) -> &TensorArg<'_, R> {\n match arg {\n Arg::Input(pos, _, _) => &self.tensors.values[*pos as usize].tensor,\n Arg::Output(pos, _, _) => &self.tensors.values[*pos as usize].tensor,\n _ => panic!(\"Arg not found\"),\n }\n }\n}\n\n#[derive(CubeType)]\n/// Keep track of all local variables that are used as argument in fused\n/// [element wise operations](ElemwiseOp).\npub struct LocalArgs {\n pub l_f32: Registry<u32, Line<f32>>,\n pub l_f16: Registry<u32, Line<f16>>,\n pub l_bf16: Registry<u32, Line<bf16>>,\n pub l_i64: Registry<u32, Line<i64>>,\n pub l_i32: Registry<u32, Line<i32>>,\n pub l_i16: Registry<u32, Line<i16>>,\n pub l_i8: Registry<u32, Line<i8>>,\n pub l_u64: Registry<u32, Line<u64>>,\n pub l_u32: Registry<u32, Line<u32>>,\n pub l_u16: Registry<u32, Line<u16>>,\n pub l_u8: Registry<u32, Line<u8>>,\n pub l_bool: Registry<u32, Line<bool>>,\n pub ref_shape: Slice<u32>,\n pub ref_strides: Slice<u32>,\n #[cube(comptime)]\n pub ref_line_size: u32,\n}\n\n#[cube]\nimpl LocalArgs {\n pub fn new(\n ref_shape: Slice<u32>,\n ref_strides: Slice<u32>,\n #[comptime] ref_line_size: u32,\n ) -> LocalArgs {\n LocalArgs {\n l_f32: Registry::<u32, Line<f32>>::new(),\n l_f16: Registry::<u32, Line<f16>>::new(),\n l_bf16: Registry::<u32, Line<bf16>>::new(),\n l_i64: Registry::<u32, Line<i64>>::new(),\n l_i32: Registry::<u32, Line<i32>>::new(),\n l_i16: Registry::<u32, Line<i16>>::new(),\n l_i8: Registry::<u32, Line<i8>>::new(),\n l_u64: Registry::<u32, Line<u64>>::new(),\n l_u32: Registry::<u32, Line<u32>>::new(),\n l_u16: Registry::<u32, Line<u16>>::new(),\n l_u8: Registry::<u32, Line<u8>>::new(),\n l_bool: Registry::<u32, Line<bool>>::new(),\n ref_shape,\n ref_strides,\n ref_line_size,\n }\n }\n}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Unary [element wise operation](ElemwiseOp) arguments.\npub struct UnaryFuseArgs {\n pub input: Arg,\n pub out: Arg,\n}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Binary [element wise operation](ElemwiseOp) arguments.\npub struct BinaryFuseArgs {\n pub lhs: Arg,\n pub rhs: Arg,\n pub out: Arg,\n}\n\n#[derive(\n CubeType, Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize,\n)]\n/// Precisions supported by [element wise operations](ElemwiseOp).\npub enum FusePrecision {\n F32,\n Flex32,\n F16,\n BF16,\n I64,\n I32,\n I16,\n I8,\n U64,\n U32,\n U16,\n U8,\n Bool,\n}\n\nimpl From<Elem> for FusePrecision {\n fn from(value: Elem) -> Self {\n match value {\n Elem::Float(kind) => match kind {\n cubecl::ir::FloatKind::F16 => Self::F16,\n cubecl::ir::FloatKind::BF16 => Self::BF16,\n cubecl::ir::FloatKind::F32 => Self::F32,\n cubecl::ir::FloatKind::Flex32 => Self::Flex32,\n _ => panic!(\"Unsupported precision for fusion: {value}\"),\n },\n Elem::Int(kind) => match kind {\n cubecl::ir::IntKind::I64 => Self::I64,\n cubecl::ir::IntKind::I32 => Self::I32,\n cubecl::ir::IntKind::I16 => Self::I16,\n cubecl::ir::IntKind::I8 => Self::I8,\n },\n Elem::UInt(kind) => match kind {\n cubecl::ir::UIntKind::U64 => Self::U64,\n cubecl::ir::UIntKind::U32 => Self::U32,\n cubecl::ir::UIntKind::U16 => Self::U16,\n cubecl::ir::UIntKind::U8 => Self::U8,\n },\n Elem::Bool => Self::Bool,\n _ => panic!(\"Unsupported precision for fusion: {value}\"),\n }\n }\n}\nimpl FusePrecision {\n pub fn into_elem(self) -> Elem {\n match self {\n FusePrecision::F32 => Elem::Float(cubecl::ir::FloatKind::F32),\n FusePrecision::Flex32 => Elem::Float(cubecl::ir::FloatKind::Flex32),\n FusePrecision::F16 => Elem::Float(cubecl::ir::FloatKind::F16),\n FusePrecision::BF16 => Elem::Float(cubecl::ir::FloatKind::BF16),\n FusePrecision::I64 => Elem::Int(cubecl::ir::IntKind::I64),\n FusePrecision::I32 => Elem::Int(cubecl::ir::IntKind::I32),\n FusePrecision::I16 => Elem::Int(cubecl::ir::IntKind::I16),\n FusePrecision::I8 => Elem::Int(cubecl::ir::IntKind::I8),\n FusePrecision::U64 => Elem::UInt(cubecl::ir::UIntKind::U64),\n FusePrecision::U32 => Elem::UInt(cubecl::ir::UIntKind::U32),\n FusePrecision::U16 => Elem::UInt(cubecl::ir::UIntKind::U16),\n FusePrecision::U8 => Elem::UInt(cubecl::ir::UIntKind::U8),\n FusePrecision::Bool => Elem::Bool,\n }\n }\n}\n\nimpl From<DType> for FusePrecision {\n fn from(value: DType) -> Self {\n match value {\n DType::F32 => Self::F32,\n DType::Flex32 => Self::Flex32,\n DType::F16 => Self::F16,\n DType::BF16 => Self::BF16,\n DType::I64 => Self::I64,\n DType::I32 => Self::I32,\n DType::I16 => Self::I16,\n DType::I8 => Self::I8,\n DType::U64 => Self::U64,\n DType::U32 => Self::U32,\n DType::U16 => Self::U16,\n DType::U8 => Self::U8,\n DType::Bool => Self::Bool,\n _ => panic!(\"Unsupported\"),\n }\n }\n}\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Configuration that encapsulates all comptime information necessary for element wise fusion.\npub struct FuseBlockConfig {\n pub rank: u32,\n pub ref_layout: RefLayout,\n pub ops: Sequence<FuseOp>,\n pub width: u8,\n}\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// A reference layout determines how a fuse execution will access elements in tensors.\n///\n/// It can either follow the same layout as a concrete tensor, or follow a virtual layout.\npub enum RefLayout {\n Concrete(Arg),\n Virtual(VirtualLayout),\n}\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// A virtual layout is always contiguous and retrieve its shape from either a reshape tensor or a\n/// tensor with swap dimensions.\npub enum VirtualLayout {\n Reshaped(u32),\n SwapDims(Arg, (u32, u32)),\n}\n\nimpl Arg {\n /// Add layout information; it's going to impact how the input or output is read\n /// and written to.\n pub fn add_layout_info(&mut self, layout: LayoutInfo) {\n match self {\n Arg::Input(_, _, old) => {\n *old = layout;\n }\n Arg::Output(_, _, old) => {\n *old = layout;\n }\n _ => {}\n }\n }\n}\n\nimpl RegistryQuery<Self> for Arg {}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub enum RefLayout {\\n Concrete(Arg),\\n Virtual(VirtualLayout),\\n}\"\n ],\n \"name\": \"ref_layout\",\n \"type\": \"&RefLayout\"\n }\n ],\n \"end_line\": 209,\n \"name\": \"shape_ref\",\n \"signature\": \"pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize>\",\n \"start_line\": 190\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R: Runtime> GlobalArgsLaunch<'_, R> {\\n /// Get the shape of the given [argument](Arg).\\n ///\\n /// # Panics\\n ///\\n /// If the argument doesn't have an handle.\\n pub fn shape(&self, arg: &Arg) -> Vec<usize> {\\n match self.resolve_arg(arg) {\\n TensorArg::Handle { handle, .. } => handle.shape.to_vec(),\\n TensorArg::Alias { .. } => panic!(\\\"Unsupported yet\\\"),\\n }\\n }\\n\\n /// Shape used by the reference tensor.\\n pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\\n match ref_layout {\\n RefLayout::Concrete(arg) => self.shape(arg),\\n RefLayout::Virtual(layout) => match layout {\\n VirtualLayout::SwapDims(original, dims) => {\\n let mut shape = self.shape(original);\\n shape.swap(dims.0 as usize, dims.1 as usize);\\n shape\\n }\\n VirtualLayout::Reshaped(start) => {\\n let start = *start as usize;\\n let end = start + rank;\\n self.reshapes.values[start..end]\\n .iter()\\n .map(|s| s.elem as usize)\\n .collect()\\n }\\n },\\n }\\n }\\n\\n /// Get the strides of the given [argument](Arg).\\n ///\\n /// # Panics\\n ///\\n /// If the argument doesn't have an handle.\\n pub fn strides(&self, arg: &Arg) -> Vec<usize> {\\n match self.resolve_arg(arg) {\\n TensorArg::Handle { handle, .. } => handle.strides.to_vec(),\\n TensorArg::Alias { .. } => panic!(\\\"Unsupported yet\\\"),\\n }\\n }\\n\\n pub fn strides_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\\n match ref_layout {\\n RefLayout::Concrete(arg) => self.strides(arg),\\n // When not concrete, we operate on the contiguous layout.\\n _ => {\\n let shape = self.shape_ref(ref_layout, rank);\\n let mut strides = vec![0; shape.len()];\\n\\n let mut current = 1;\\n shape.iter().enumerate().rev().for_each(|(index, val)| {\\n strides[index] = current;\\n current *= val;\\n });\\n\\n strides\\n }\\n }\\n }\\n\\n /// Get the line size of the given [argument](Arg).\\n ///\\n /// # Panics\\n ///\\n /// If the argument doesn't have an handle.\\n pub fn line_size(&self, arg: &Arg) -> u8 {\\n match self.resolve_arg(arg) {\\n TensorArg::Handle {\\n vectorization_factor,\\n ..\\n } => *vectorization_factor,\\n TensorArg::Alias { .. } => panic!(\\\"Unsupported yet\\\"),\\n }\\n }\\n\\n /// Resolve the [argument](Arg) to a [tensor argument](TensorArg).\\n ///\\n /// # Panics\\n ///\\n /// If the argument isn't a global input or output tensor.\\n pub fn resolve_arg(&self, arg: &Arg) -> &TensorArg<'_, R> {\\n match arg {\\n Arg::Input(pos, _, _) => &self.tensors.values[*pos as usize].tensor,\\n Arg::Output(pos, _, _) => &self.tensors.values[*pos as usize].tensor,\\n _ => panic!(\\\"Arg not found\\\"),\\n }\\n }\\n}\",\n \"class_signature\": \"impl<R: Runtime> GlobalArgsLaunch<'_, R>\"\n}"}}},{"rowIdx":165,"cells":{"function_name":{"kind":"string","value":"from"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/ir.rs"},"focal_code":{"kind":"string","value":"fn from(value: Elem) -> Self {\n match value {\n Elem::Float(kind) => match kind {\n cubecl::ir::FloatKind::F16 => Self::F16,\n cubecl::ir::FloatKind::BF16 => Self::BF16,\n cubecl::ir::FloatKind::F32 => Self::F32,\n cubecl::ir::FloatKind::Flex32 => Self::Flex32,\n _ => panic!(\"Unsupported precision for fusion: {value}\"),\n },\n Elem::Int(kind) => match kind {\n cubecl::ir::IntKind::I64 => Self::I64,\n cubecl::ir::IntKind::I32 => Self::I32,\n cubecl::ir::IntKind::I16 => Self::I16,\n cubecl::ir::IntKind::I8 => Self::I8,\n },\n Elem::UInt(kind) => match kind {\n cubecl::ir::UIntKind::U64 => Self::U64,\n cubecl::ir::UIntKind::U32 => Self::U32,\n cubecl::ir::UIntKind::U16 => Self::U16,\n cubecl::ir::UIntKind::U8 => Self::U8,\n },\n Elem::Bool => Self::Bool,\n _ => panic!(\"Unsupported precision for fusion: {value}\"),\n }\n }"},"file_content":{"kind":"string","value":"use burn_tensor::DType;\nuse cubecl::ir::Elem;\nuse cubecl::prelude::*;\nuse half::{bf16, f16};\nuse serde::{Deserialize, Serialize};\n\nuse super::tensor::{GlobalScalar, GlobalTensor};\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\n/// Argument to a [fuse operation](FuseOp).\npub enum Arg {\n Input(u32, FusePrecision, LayoutInfo),\n Local(u32, FusePrecision),\n Output(u32, FusePrecision, LayoutInfo),\n Scalar(u32, FusePrecision),\n ScalarShape(u32),\n /// Only constant that can be encoded into an u32 can be used as literal.\n Literal(u32, FusePrecision),\n InputReshaped {\n original: Box<Arg>,\n shape: Sequence<Arg>,\n broadcasted: bool,\n },\n InputSwapDims {\n original: Box<Arg>,\n dims: (u32, u32),\n broadcasted: bool,\n },\n}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]\n/// Layout information.\npub enum LayoutInfo {\n /// The layout if the same as the reference.\n SameAsRef,\n /// The reference layout.\n IsRef,\n /// The layout if unknown.\n Unknown,\n}\n\nimpl Arg {\n pub fn precision(&self) -> FusePrecision {\n *match self {\n Arg::Input(_, p, _) => p,\n Arg::Local(_, p) => p,\n Arg::Output(_, p, _) => p,\n Arg::Scalar(_, p) => p,\n Arg::Literal(_, p) => p,\n Arg::ScalarShape(_) => return FusePrecision::U32,\n Arg::InputReshaped { original, .. } => return original.precision(),\n Arg::InputSwapDims { original, .. } => return original.precision(),\n }\n }\n}\n\nimpl CubeType for Arg {\n type ExpandType = Self;\n}\n\nimpl IntoMut for Arg {\n fn into_mut(self, _context: &mut Scope) -> Self {\n self\n }\n}\n\nimpl IntoRuntime for Arg {\n fn __expand_runtime_method(self, _context: &mut Scope) -> Self::ExpandType {\n self\n }\n}\n\nimpl CubeDebug for Arg {}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Operations that can be executed and fused automatically using a fuse-on-read and/or\n/// fuse-on-write strategy.\npub enum FuseOp {\n Add(BinaryFuseArgs),\n Sub(BinaryFuseArgs),\n Mul(BinaryFuseArgs),\n Div(BinaryFuseArgs),\n Powf(BinaryFuseArgs),\n Abs(UnaryFuseArgs),\n Exp(UnaryFuseArgs),\n Log(UnaryFuseArgs),\n Log1p(UnaryFuseArgs),\n Cos(UnaryFuseArgs),\n Sin(UnaryFuseArgs),\n Tanh(UnaryFuseArgs),\n Erf(UnaryFuseArgs),\n Recip(UnaryFuseArgs),\n Assign(UnaryFuseArgs),\n Equal(BinaryFuseArgs),\n Lower(BinaryFuseArgs),\n Greater(BinaryFuseArgs),\n LowerEqual(BinaryFuseArgs),\n GreaterEqual(BinaryFuseArgs),\n ConditionalAssign {\n cond: Arg,\n lhs: Arg,\n rhs: Arg,\n out: Arg,\n },\n Gather {\n input: Arg,\n indices: Arg,\n output: Arg,\n dim: u32,\n },\n Select {\n input: Arg,\n indices: Arg,\n output: Arg,\n dim: u32,\n },\n}\n\nimpl FuseOp {\n /// Element type used for the computation.\n pub(crate) fn cmp_elem(&self) -> Elem {\n match self {\n FuseOp::Add(op) => op.lhs.precision().into_elem(),\n FuseOp::Sub(op) => op.lhs.precision().into_elem(),\n FuseOp::Mul(op) => op.lhs.precision().into_elem(),\n FuseOp::Div(op) => op.lhs.precision().into_elem(),\n FuseOp::Powf(op) => op.lhs.precision().into_elem(),\n FuseOp::Abs(op) => op.out.precision().into_elem(),\n FuseOp::Exp(op) => op.out.precision().into_elem(),\n FuseOp::Log(op) => op.out.precision().into_elem(),\n FuseOp::Log1p(op) => op.out.precision().into_elem(),\n FuseOp::Cos(op) => op.out.precision().into_elem(),\n FuseOp::Sin(op) => op.out.precision().into_elem(),\n FuseOp::Tanh(op) => op.out.precision().into_elem(),\n FuseOp::Erf(op) => op.out.precision().into_elem(),\n FuseOp::Recip(op) => op.out.precision().into_elem(),\n FuseOp::Assign(op) => op.out.precision().into_elem(),\n FuseOp::Equal(op) => op.lhs.precision().into_elem(),\n FuseOp::Lower(op) => op.lhs.precision().into_elem(),\n FuseOp::Greater(op) => op.lhs.precision().into_elem(),\n FuseOp::LowerEqual(op) => op.lhs.precision().into_elem(),\n FuseOp::GreaterEqual(op) => op.lhs.precision().into_elem(),\n FuseOp::ConditionalAssign { out, .. } => out.precision().into_elem(),\n FuseOp::Gather { output, .. } => output.precision().into_elem(),\n FuseOp::Select { output, .. } => output.precision().into_elem(),\n }\n }\n}\n\n#[derive(CubeType, CubeLaunch, Default)]\n/// Global arguments that are used for fusing [element wise operations](ElemwiseOp).\npub struct GlobalArgs {\n pub tensors: Sequence<GlobalTensor>,\n pub scalars: Sequence<GlobalScalar>,\n pub reshapes: Sequence<u32>,\n}\n\nimpl<R: Runtime> Default for GlobalArgsLaunch<'_, R> {\n fn default() -> Self {\n Self {\n tensors: Default::default(),\n scalars: Default::default(),\n reshapes: Default::default(),\n _phantom_runtime: std::marker::PhantomData,\n _phantom_a: std::marker::PhantomData,\n }\n }\n}\n\nimpl<R: Runtime> core::fmt::Debug for GlobalArgsLaunch<'_, R> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"({:?})\", self.tensors.values)\n }\n}\n\nimpl<R: Runtime> GlobalArgsLaunch<'_, R> {\n /// Get the shape of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn shape(&self, arg: &Arg) -> Vec<usize> {\n match self.resolve_arg(arg) {\n TensorArg::Handle { handle, .. } => handle.shape.to_vec(),\n TensorArg::Alias { .. } => panic!(\"Unsupported yet\"),\n }\n }\n\n /// Shape used by the reference tensor.\n pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\n match ref_layout {\n RefLayout::Concrete(arg) => self.shape(arg),\n RefLayout::Virtual(layout) => match layout {\n VirtualLayout::SwapDims(original, dims) => {\n let mut shape = self.shape(original);\n shape.swap(dims.0 as usize, dims.1 as usize);\n shape\n }\n VirtualLayout::Reshaped(start) => {\n let start = *start as usize;\n let end = start + rank;\n self.reshapes.values[start..end]\n .iter()\n .map(|s| s.elem as usize)\n .collect()\n }\n },\n }\n }\n\n /// Get the strides of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn strides(&self, arg: &Arg) -> Vec<usize> {\n match self.resolve_arg(arg) {\n TensorArg::Handle { handle, .. } => handle.strides.to_vec(),\n TensorArg::Alias { .. } => panic!(\"Unsupported yet\"),\n }\n }\n\n pub fn strides_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {\n match ref_layout {\n RefLayout::Concrete(arg) => self.strides(arg),\n // When not concrete, we operate on the contiguous layout.\n _ => {\n let shape = self.shape_ref(ref_layout, rank);\n let mut strides = vec![0; shape.len()];\n\n let mut current = 1;\n shape.iter().enumerate().rev().for_each(|(index, val)| {\n strides[index] = current;\n current *= val;\n });\n\n strides\n }\n }\n }\n\n /// Get the line size of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn line_size(&self, arg: &Arg) -> u8 {\n match self.resolve_arg(arg) {\n TensorArg::Handle {\n vectorization_factor,\n ..\n } => *vectorization_factor,\n TensorArg::Alias { .. } => panic!(\"Unsupported yet\"),\n }\n }\n\n /// Resolve the [argument](Arg) to a [tensor argument](TensorArg).\n ///\n /// # Panics\n ///\n /// If the argument isn't a global input or output tensor.\n pub fn resolve_arg(&self, arg: &Arg) -> &TensorArg<'_, R> {\n match arg {\n Arg::Input(pos, _, _) => &self.tensors.values[*pos as usize].tensor,\n Arg::Output(pos, _, _) => &self.tensors.values[*pos as usize].tensor,\n _ => panic!(\"Arg not found\"),\n }\n }\n}\n\n#[derive(CubeType)]\n/// Keep track of all local variables that are used as argument in fused\n/// [element wise operations](ElemwiseOp).\npub struct LocalArgs {\n pub l_f32: Registry<u32, Line<f32>>,\n pub l_f16: Registry<u32, Line<f16>>,\n pub l_bf16: Registry<u32, Line<bf16>>,\n pub l_i64: Registry<u32, Line<i64>>,\n pub l_i32: Registry<u32, Line<i32>>,\n pub l_i16: Registry<u32, Line<i16>>,\n pub l_i8: Registry<u32, Line<i8>>,\n pub l_u64: Registry<u32, Line<u64>>,\n pub l_u32: Registry<u32, Line<u32>>,\n pub l_u16: Registry<u32, Line<u16>>,\n pub l_u8: Registry<u32, Line<u8>>,\n pub l_bool: Registry<u32, Line<bool>>,\n pub ref_shape: Slice<u32>,\n pub ref_strides: Slice<u32>,\n #[cube(comptime)]\n pub ref_line_size: u32,\n}\n\n#[cube]\nimpl LocalArgs {\n pub fn new(\n ref_shape: Slice<u32>,\n ref_strides: Slice<u32>,\n #[comptime] ref_line_size: u32,\n ) -> LocalArgs {\n LocalArgs {\n l_f32: Registry::<u32, Line<f32>>::new(),\n l_f16: Registry::<u32, Line<f16>>::new(),\n l_bf16: Registry::<u32, Line<bf16>>::new(),\n l_i64: Registry::<u32, Line<i64>>::new(),\n l_i32: Registry::<u32, Line<i32>>::new(),\n l_i16: Registry::<u32, Line<i16>>::new(),\n l_i8: Registry::<u32, Line<i8>>::new(),\n l_u64: Registry::<u32, Line<u64>>::new(),\n l_u32: Registry::<u32, Line<u32>>::new(),\n l_u16: Registry::<u32, Line<u16>>::new(),\n l_u8: Registry::<u32, Line<u8>>::new(),\n l_bool: Registry::<u32, Line<bool>>::new(),\n ref_shape,\n ref_strides,\n ref_line_size,\n }\n }\n}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Unary [element wise operation](ElemwiseOp) arguments.\npub struct UnaryFuseArgs {\n pub input: Arg,\n pub out: Arg,\n}\n\n#[derive(CubeType, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Binary [element wise operation](ElemwiseOp) arguments.\npub struct BinaryFuseArgs {\n pub lhs: Arg,\n pub rhs: Arg,\n pub out: Arg,\n}\n\n#[derive(\n CubeType, Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize,\n)]\n/// Precisions supported by [element wise operations](ElemwiseOp).\npub enum FusePrecision {\n F32,\n Flex32,\n F16,\n BF16,\n I64,\n I32,\n I16,\n I8,\n U64,\n U32,\n U16,\n U8,\n Bool,\n}\n\nimpl From<Elem> for FusePrecision {\n fn from(value: Elem) -> Self {\n match value {\n Elem::Float(kind) => match kind {\n cubecl::ir::FloatKind::F16 => Self::F16,\n cubecl::ir::FloatKind::BF16 => Self::BF16,\n cubecl::ir::FloatKind::F32 => Self::F32,\n cubecl::ir::FloatKind::Flex32 => Self::Flex32,\n _ => panic!(\"Unsupported precision for fusion: {value}\"),\n },\n Elem::Int(kind) => match kind {\n cubecl::ir::IntKind::I64 => Self::I64,\n cubecl::ir::IntKind::I32 => Self::I32,\n cubecl::ir::IntKind::I16 => Self::I16,\n cubecl::ir::IntKind::I8 => Self::I8,\n },\n Elem::UInt(kind) => match kind {\n cubecl::ir::UIntKind::U64 => Self::U64,\n cubecl::ir::UIntKind::U32 => Self::U32,\n cubecl::ir::UIntKind::U16 => Self::U16,\n cubecl::ir::UIntKind::U8 => Self::U8,\n },\n Elem::Bool => Self::Bool,\n _ => panic!(\"Unsupported precision for fusion: {value}\"),\n }\n }\n}\nimpl FusePrecision {\n pub fn into_elem(self) -> Elem {\n match self {\n FusePrecision::F32 => Elem::Float(cubecl::ir::FloatKind::F32),\n FusePrecision::Flex32 => Elem::Float(cubecl::ir::FloatKind::Flex32),\n FusePrecision::F16 => Elem::Float(cubecl::ir::FloatKind::F16),\n FusePrecision::BF16 => Elem::Float(cubecl::ir::FloatKind::BF16),\n FusePrecision::I64 => Elem::Int(cubecl::ir::IntKind::I64),\n FusePrecision::I32 => Elem::Int(cubecl::ir::IntKind::I32),\n FusePrecision::I16 => Elem::Int(cubecl::ir::IntKind::I16),\n FusePrecision::I8 => Elem::Int(cubecl::ir::IntKind::I8),\n FusePrecision::U64 => Elem::UInt(cubecl::ir::UIntKind::U64),\n FusePrecision::U32 => Elem::UInt(cubecl::ir::UIntKind::U32),\n FusePrecision::U16 => Elem::UInt(cubecl::ir::UIntKind::U16),\n FusePrecision::U8 => Elem::UInt(cubecl::ir::UIntKind::U8),\n FusePrecision::Bool => Elem::Bool,\n }\n }\n}\n\nimpl From<DType> for FusePrecision {\n fn from(value: DType) -> Self {\n match value {\n DType::F32 => Self::F32,\n DType::Flex32 => Self::Flex32,\n DType::F16 => Self::F16,\n DType::BF16 => Self::BF16,\n DType::I64 => Self::I64,\n DType::I32 => Self::I32,\n DType::I16 => Self::I16,\n DType::I8 => Self::I8,\n DType::U64 => Self::U64,\n DType::U32 => Self::U32,\n DType::U16 => Self::U16,\n DType::U8 => Self::U8,\n DType::Bool => Self::Bool,\n _ => panic!(\"Unsupported\"),\n }\n }\n}\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// Configuration that encapsulates all comptime information necessary for element wise fusion.\npub struct FuseBlockConfig {\n pub rank: u32,\n pub ref_layout: RefLayout,\n pub ops: Sequence<FuseOp>,\n pub width: u8,\n}\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// A reference layout determines how a fuse execution will access elements in tensors.\n///\n/// It can either follow the same layout as a concrete tensor, or follow a virtual layout.\npub enum RefLayout {\n Concrete(Arg),\n Virtual(VirtualLayout),\n}\n\n#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]\n/// A virtual layout is always contiguous and retrieve its shape from either a reshape tensor or a\n/// tensor with swap dimensions.\npub enum VirtualLayout {\n Reshaped(u32),\n SwapDims(Arg, (u32, u32)),\n}\n\nimpl Arg {\n /// Add layout information; it's going to impact how the input or output is read\n /// and written to.\n pub fn add_layout_info(&mut self, layout: LayoutInfo) {\n match self {\n Arg::Input(_, _, old) => {\n *old = layout;\n }\n Arg::Output(_, _, old) => {\n *old = layout;\n }\n _ => {}\n }\n }\n}\n\nimpl RegistryQuery<Self> for Arg {}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 380,\n \"name\": \"from\",\n \"signature\": \"fn from(value: Elem) -> Self\",\n \"start_line\": 356\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl From<Elem> for FusePrecision {\\n fn from(value: Elem) -> Self {\\n match value {\\n Elem::Float(kind) => match kind {\\n cubecl::ir::FloatKind::F16 => Self::F16,\\n cubecl::ir::FloatKind::BF16 => Self::BF16,\\n cubecl::ir::FloatKind::F32 => Self::F32,\\n cubecl::ir::FloatKind::Flex32 => Self::Flex32,\\n _ => panic!(\\\"Unsupported precision for fusion: {value}\\\"),\\n },\\n Elem::Int(kind) => match kind {\\n cubecl::ir::IntKind::I64 => Self::I64,\\n cubecl::ir::IntKind::I32 => Self::I32,\\n cubecl::ir::IntKind::I16 => Self::I16,\\n cubecl::ir::IntKind::I8 => Self::I8,\\n },\\n Elem::UInt(kind) => match kind {\\n cubecl::ir::UIntKind::U64 => Self::U64,\\n cubecl::ir::UIntKind::U32 => Self::U32,\\n cubecl::ir::UIntKind::U16 => Self::U16,\\n cubecl::ir::UIntKind::U8 => Self::U8,\\n },\\n Elem::Bool => Self::Bool,\\n _ => panic!(\\\"Unsupported precision for fusion: {value}\\\"),\\n }\\n }\\n}\",\n \"class_signature\": \"impl From<Elem> for FusePrecision\"\n}"}}},{"rowIdx":166,"cells":{"function_name":{"kind":"string","value":"build"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/trace/builder.rs"},"focal_code":{"kind":"string","value":"pub fn build(&self, shape_ref: Vec<usize>) -> FuseTrace {\n let mut resources = self.resources.clone();\n let mut outputs = RegisteredTensors::default();\n let mut blocks = Vec::new();\n\n let mut register_block =\n |block: &FuseBlockBuilder, shape_ref: &Vec<usize>, offset: usize| {\n let (block, block_tensor_writes) =\n block.build(&self.resources, shape_ref.clone(), offset);\n blocks.push(block);\n\n let num_outputs = block_tensor_writes.len();\n for (ir, precision) in block_tensor_writes.into_iter() {\n outputs.insert(precision, ir);\n }\n\n num_outputs\n };\n\n let mut offset = 0;\n\n for (block, shape_ref) in self.blocks_previous.iter() {\n offset += register_block(block, shape_ref, offset);\n }\n register_block(&self.block_current, &shape_ref, offset);\n\n // We update the output tensors registered to be the ones that are written to in global\n // memory.\n resources.outputs = outputs;\n\n FuseTrace { blocks, resources }\n }"},"file_content":{"kind":"string","value":"use super::{\n super::{\n ir::{Arg, FuseOp, FusePrecision, LayoutInfo},\n settings::FuseSettings,\n },\n FuseResources,\n block::FuseBlockBuilder,\n};\nuse super::{FuseTrace, RegisteredTensors};\nuse burn_ir::TensorIr;\nuse burn_tensor::{DType, Element};\n\n#[derive(Clone, Debug)]\n/// It is responsible to create a [trace](FuseTrace) composed of multiple [blocks](super::block::FuseBlock).\n///\n/// It mostly handles the [resources](KernelResources) needed by the generated fused kernel, and\n/// delegates most of the work to the [block builder](FuseBlockBuilder).\npub struct FuseTraceBuilder {\n settings: FuseSettings,\n pub bool_precision: FusePrecision,\n // The tensors returned by the block that don't need to be written to global memory.\n block_current: FuseBlockBuilder,\n blocks_previous: Vec<(FuseBlockBuilder, Vec<usize>)>,\n resources: FuseResources,\n}\n\nimpl FuseTraceBuilder {\n pub fn new(bool_precision: FusePrecision, settings: FuseSettings) -> Self {\n Self {\n settings,\n bool_precision,\n block_current: FuseBlockBuilder::new(bool_precision, settings),\n blocks_previous: Default::default(),\n resources: Default::default(),\n }\n }\n\n /// Register an operation.\n pub fn register_operation(&mut self, op: FuseOp) {\n self.block_current.ops.push(op);\n }\n\n /// The number of operations fused.\n pub fn num_ops_fused(&self) -> u32 {\n let mut num_ops_fused = 0;\n\n for (block, _) in self.blocks_previous.iter() {\n num_ops_fused += block.ops.len();\n }\n\n num_ops_fused += self.block_current.ops.len();\n num_ops_fused as u32\n }\n\n pub fn next_block(&mut self, shape_ref: Vec<usize>, settings: FuseSettings) {\n let mut block_new = FuseBlockBuilder::new(self.bool_precision, settings);\n core::mem::swap(&mut self.block_current, &mut block_new);\n self.blocks_previous.push((block_new, shape_ref));\n self.settings = settings;\n }\n\n // Estimate how many bindings are in use right now. This can return more than the actual number\n // but should never return less.\n pub fn estimate_bindings(&self) -> u32 {\n let mut estimation = 1; // Metadata takes one.\n for b in self.blocks_previous.iter() {\n estimation += b.0.estimate_num_outputs(&self.resources);\n }\n estimation += self.block_current.estimate_num_outputs(&self.resources);\n estimation += self.resources.inputs.len() as u32;\n // One buffer per scalar type for now.\n estimation += self.resources.scalars.len() as u32;\n\n estimation\n }\n\n /// Tag the [tensor](TensorIr) to be the logical returned value of the current block.\n ///\n /// This will avoid the output to be written in global memory when not necessary.\n pub fn block_local_output(&mut self, tensor: &TensorIr) {\n self.block_current.local_outputs.push(tensor.id);\n }\n\n /// Register an output tensor that won't be automatically synced into global memory.\n ///\n /// It is therefore the responsibility of the operation to write the result to given tensor.\n pub fn output_unhandled(&mut self, tensor: &TensorIr) -> Arg {\n let arg = self\n .output(tensor)\n .expect(\"Can't add a new output that is already used in an index operation\");\n self.resources.outputs_unhandled.push(arg.clone());\n self.block_current.outputs_unhandled.push(arg.clone());\n arg\n }\n\n /// Register an input tensor that won't be automatically read into a local variable.\n ///\n /// It is therefore the responsibility of the operation to read the given tensor.\n pub fn input_unhandled(&mut self, tensor: &TensorIr) -> Arg {\n if self.resources.indexed.contains_key(&tensor.id) {\n panic!(\"Can't add a new input that is already used in an index operation\");\n }\n\n let precision = tensor.dtype.into();\n\n // Bool tensors are encoded as bool_precision.\n let precision_input = match precision {\n FusePrecision::Bool => self.bool_precision,\n _ => precision,\n };\n let new_input = self\n .resources\n .inputs\n .insert(precision_input, tensor.clone());\n let arg = Arg::Input(new_input, precision_input, LayoutInfo::Unknown);\n\n self.resources.inputs_unhandled.push(tensor.id);\n arg\n }\n\n /// Register an input tensor.\n pub fn input(&mut self, tensor: &TensorIr) -> Option<Arg> {\n self.block_current.input(tensor, &mut self.resources)\n }\n\n /// Register an output tensor.\n pub fn output(&mut self, tensor: &TensorIr) -> Option<Arg> {\n self.block_current.output(tensor, &mut self.resources)\n }\n\n /// Register an input that will be accessed using custom indexing with no vectorization.\n pub fn input_indexed(&mut self, tensor: &TensorIr) -> Option<Arg> {\n if let Some(val) = self.resources.indexed.get(&tensor.id) {\n return Some(val.clone());\n };\n\n if self.resources.inputs.get(tensor.id).is_some() {\n return None;\n }\n\n if self.resources.outputs.get(tensor.id).is_some() {\n return None;\n }\n\n let input = self.input_unhandled(tensor);\n self.resources.indexed.insert(tensor.id, input.clone());\n\n Some(input)\n }\n\n /// Register an input with swapped dims.\n pub fn input_swap_dims(\n &mut self,\n tensor: &TensorIr,\n output: &TensorIr,\n dims: (u32, u32),\n ) -> Option<Arg> {\n self.block_current\n .input_swap_dims(tensor, output, dims, &mut self.resources)\n }\n\n /// Register an input that is reshaped.\n pub fn input_reshaped(&mut self, tensor: &TensorIr, output: &TensorIr) -> Option<Arg> {\n self.block_current\n .input_reshaped(tensor, output, &mut self.resources)\n }\n\n /// Register a scalar value.\n pub fn scalar<E: Element>(&mut self, _: &E, dtype: DType) -> Arg {\n let precision = dtype.into();\n\n // Bool scalars are encoded as bool_precision.\n let precision = match precision {\n FusePrecision::Bool => self.bool_precision,\n _ => precision,\n };\n let new_index = self.resources.scalars.len() as u32;\n\n self.resources.scalars.push((precision, new_index));\n Arg::Scalar(new_index, precision)\n }\n\n /// Build into a trace.\n pub fn build(&self, shape_ref: Vec<usize>) -> FuseTrace {\n let mut resources = self.resources.clone();\n let mut outputs = RegisteredTensors::default();\n let mut blocks = Vec::new();\n\n let mut register_block =\n |block: &FuseBlockBuilder, shape_ref: &Vec<usize>, offset: usize| {\n let (block, block_tensor_writes) =\n block.build(&self.resources, shape_ref.clone(), offset);\n blocks.push(block);\n\n let num_outputs = block_tensor_writes.len();\n for (ir, precision) in block_tensor_writes.into_iter() {\n outputs.insert(precision, ir);\n }\n\n num_outputs\n };\n\n let mut offset = 0;\n\n for (block, shape_ref) in self.blocks_previous.iter() {\n offset += register_block(block, shape_ref, offset);\n }\n register_block(&self.block_current, &shape_ref, offset);\n\n // We update the output tensors registered to be the ones that are written to in global\n // memory.\n resources.outputs = outputs;\n\n FuseTrace { blocks, resources }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct Vec<T, #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")] A: Allocator = Global> {\\n buf: RawVec<T, A>,\\n len: usize,\\n}\"\n ],\n \"name\": \"shape_ref\",\n \"type\": \"Vec<usize>\"\n }\n ],\n \"end_line\": 215,\n \"name\": \"build\",\n \"signature\": \"pub fn build(&self, shape_ref: Vec<usize>) -> FuseTrace\",\n \"start_line\": 184\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl FuseTraceBuilder {\\n pub fn new(bool_precision: FusePrecision, settings: FuseSettings) -> Self {\\n Self {\\n settings,\\n bool_precision,\\n block_current: FuseBlockBuilder::new(bool_precision, settings),\\n blocks_previous: Default::default(),\\n resources: Default::default(),\\n }\\n }\\n\\n /// Register an operation.\\n pub fn register_operation(&mut self, op: FuseOp) {\\n self.block_current.ops.push(op);\\n }\\n\\n /// The number of operations fused.\\n pub fn num_ops_fused(&self) -> u32 {\\n let mut num_ops_fused = 0;\\n\\n for (block, _) in self.blocks_previous.iter() {\\n num_ops_fused += block.ops.len();\\n }\\n\\n num_ops_fused += self.block_current.ops.len();\\n num_ops_fused as u32\\n }\\n\\n pub fn next_block(&mut self, shape_ref: Vec<usize>, settings: FuseSettings) {\\n let mut block_new = FuseBlockBuilder::new(self.bool_precision, settings);\\n core::mem::swap(&mut self.block_current, &mut block_new);\\n self.blocks_previous.push((block_new, shape_ref));\\n self.settings = settings;\\n }\\n\\n // Estimate how many bindings are in use right now. This can return more than the actual number\\n // but should never return less.\\n pub fn estimate_bindings(&self) -> u32 {\\n let mut estimation = 1; // Metadata takes one.\\n for b in self.blocks_previous.iter() {\\n estimation += b.0.estimate_num_outputs(&self.resources);\\n }\\n estimation += self.block_current.estimate_num_outputs(&self.resources);\\n estimation += self.resources.inputs.len() as u32;\\n // One buffer per scalar type for now.\\n estimation += self.resources.scalars.len() as u32;\\n\\n estimation\\n }\\n\\n /// Tag the [tensor](TensorIr) to be the logical returned value of the current block.\\n ///\\n /// This will avoid the output to be written in global memory when not necessary.\\n pub fn block_local_output(&mut self, tensor: &TensorIr) {\\n self.block_current.local_outputs.push(tensor.id);\\n }\\n\\n /// Register an output tensor that won't be automatically synced into global memory.\\n ///\\n /// It is therefore the responsibility of the operation to write the result to given tensor.\\n pub fn output_unhandled(&mut self, tensor: &TensorIr) -> Arg {\\n let arg = self\\n .output(tensor)\\n .expect(\\\"Can't add a new output that is already used in an index operation\\\");\\n self.resources.outputs_unhandled.push(arg.clone());\\n self.block_current.outputs_unhandled.push(arg.clone());\\n arg\\n }\\n\\n /// Register an input tensor that won't be automatically read into a local variable.\\n ///\\n /// It is therefore the responsibility of the operation to read the given tensor.\\n pub fn input_unhandled(&mut self, tensor: &TensorIr) -> Arg {\\n if self.resources.indexed.contains_key(&tensor.id) {\\n panic!(\\\"Can't add a new input that is already used in an index operation\\\");\\n }\\n\\n let precision = tensor.dtype.into();\\n\\n // Bool tensors are encoded as bool_precision.\\n let precision_input = match precision {\\n FusePrecision::Bool => self.bool_precision,\\n _ => precision,\\n };\\n let new_input = self\\n .resources\\n .inputs\\n .insert(precision_input, tensor.clone());\\n let arg = Arg::Input(new_input, precision_input, LayoutInfo::Unknown);\\n\\n self.resources.inputs_unhandled.push(tensor.id);\\n arg\\n }\\n\\n /// Register an input tensor.\\n pub fn input(&mut self, tensor: &TensorIr) -> Option<Arg> {\\n self.block_current.input(tensor, &mut self.resources)\\n }\\n\\n /// Register an output tensor.\\n pub fn output(&mut self, tensor: &TensorIr) -> Option<Arg> {\\n self.block_current.output(tensor, &mut self.resources)\\n }\\n\\n /// Register an input that will be accessed using custom indexing with no vectorization.\\n pub fn input_indexed(&mut self, tensor: &TensorIr) -> Option<Arg> {\\n if let Some(val) = self.resources.indexed.get(&tensor.id) {\\n return Some(val.clone());\\n };\\n\\n if self.resources.inputs.get(tensor.id).is_some() {\\n return None;\\n }\\n\\n if self.resources.outputs.get(tensor.id).is_some() {\\n return None;\\n }\\n\\n let input = self.input_unhandled(tensor);\\n self.resources.indexed.insert(tensor.id, input.clone());\\n\\n Some(input)\\n }\\n\\n /// Register an input with swapped dims.\\n pub fn input_swap_dims(\\n &mut self,\\n tensor: &TensorIr,\\n output: &TensorIr,\\n dims: (u32, u32),\\n ) -> Option<Arg> {\\n self.block_current\\n .input_swap_dims(tensor, output, dims, &mut self.resources)\\n }\\n\\n /// Register an input that is reshaped.\\n pub fn input_reshaped(&mut self, tensor: &TensorIr, output: &TensorIr) -> Option<Arg> {\\n self.block_current\\n .input_reshaped(tensor, output, &mut self.resources)\\n }\\n\\n /// Register a scalar value.\\n pub fn scalar<E: Element>(&mut self, _: &E, dtype: DType) -> Arg {\\n let precision = dtype.into();\\n\\n // Bool scalars are encoded as bool_precision.\\n let precision = match precision {\\n FusePrecision::Bool => self.bool_precision,\\n _ => precision,\\n };\\n let new_index = self.resources.scalars.len() as u32;\\n\\n self.resources.scalars.push((precision, new_index));\\n Arg::Scalar(new_index, precision)\\n }\\n\\n /// Build into a trace.\\n pub fn build(&self, shape_ref: Vec<usize>) -> FuseTrace {\\n let mut resources = self.resources.clone();\\n let mut outputs = RegisteredTensors::default();\\n let mut blocks = Vec::new();\\n\\n let mut register_block =\\n |block: &FuseBlockBuilder, shape_ref: &Vec<usize>, offset: usize| {\\n let (block, block_tensor_writes) =\\n block.build(&self.resources, shape_ref.clone(), offset);\\n blocks.push(block);\\n\\n let num_outputs = block_tensor_writes.len();\\n for (ir, precision) in block_tensor_writes.into_iter() {\\n outputs.insert(precision, ir);\\n }\\n\\n num_outputs\\n };\\n\\n let mut offset = 0;\\n\\n for (block, shape_ref) in self.blocks_previous.iter() {\\n offset += register_block(block, shape_ref, offset);\\n }\\n register_block(&self.block_current, &shape_ref, offset);\\n\\n // We update the output tensors registered to be the ones that are written to in global\\n // memory.\\n resources.outputs = outputs;\\n\\n FuseTrace { blocks, resources }\\n }\\n}\",\n \"class_signature\": \"impl FuseTraceBuilder\"\n}"}}},{"rowIdx":167,"cells":{"function_name":{"kind":"string","value":"analyze_view"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl-fusion/src/shared/trace/input.rs"},"focal_code":{"kind":"string","value":"fn analyze_view(\n pos: usize,\n tensor_relative: &'a TensorIr,\n block: &FuseBlock,\n block_plan: &mut BlockPlan<'a>,\n view: &TensorView,\n ) -> bool {\n match view {\n TensorView::Reshape {\n reshaped,\n original,\n reshape_pos,\n shape_relative,\n } => {\n if original == &tensor_relative.id || reshaped == &tensor_relative.id {\n if block_plan.potential_reference_input.is_none()\n && shape_relative == &block.shape_ref\n {\n block_plan.potential_reference_input = Some(InputReference::Reshaped {\n reshape_pos: *reshape_pos as usize,\n });\n }\n return true;\n }\n }\n TensorView::SwapDims {\n swapped,\n original,\n dims,\n ..\n } => {\n if swapped == &tensor_relative.id {\n return true;\n }\n\n if original == &tensor_relative.id {\n let mut shape = tensor_relative.shape.clone();\n shape.swap(dims.0 as usize, dims.1 as usize);\n\n if block_plan.potential_reference_input.is_none() && shape == block.shape_ref {\n block_plan.potential_reference_input = Some(InputReference::SwapDims {\n original_pos: pos,\n dims: *dims,\n });\n }\n return true;\n }\n }\n };\n\n false\n }"},"file_content":{"kind":"string","value":"use super::{BlockPlan, FuseResources, InputReference, TensorView, block::FuseBlock};\nuse crate::CubeFusionHandle;\nuse burn_fusion::stream::Context;\nuse burn_ir::{TensorIr, TensorStatus};\nuse cubecl::Runtime;\nuse std::marker::PhantomData;\n\nuse super::{HandleInput, LaunchPlan, PotentialInplace};\n\n/// Fetch and register [input handles](HandleInput). Also identifies potential inputs that\n/// can be used inplace and/or as the [reference layout](super::super::ir::RefLayout).\npub struct InputPlanner<'a, R: Runtime> {\n resources: &'a FuseResources,\n blocks: &'a Vec<FuseBlock>,\n _r: PhantomData<R>,\n}\n\nimpl<'a, R: Runtime> InputPlanner<'a, R> {\n pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> Self {\n Self {\n resources,\n blocks,\n _r: PhantomData,\n }\n }\n\n pub fn run(self, context: &mut Context<'_, CubeFusionHandle<R>>, plan: &mut LaunchPlan<'a, R>) {\n for (pos, (tensor_relative, precision)) in self.resources.inputs.iter().enumerate() {\n let mut tensor_global = context.tensors.get(&tensor_relative.id).unwrap().clone();\n // Important to take the status of the relative graph and not\n // the global graph, since the status of the global graph\n // might be of a later operation on the same tensor id.\n let status = &tensor_relative.status;\n let mut handle = context.handles.get_handle(&tensor_global.id, status);\n\n self.analyze(plan, pos, tensor_relative, &handle);\n\n if tensor_global.shape.len() < plan.rank {\n let num_elem: usize = tensor_global.shape.iter().product();\n for _ in 0..(plan.rank - tensor_global.shape.len()) {\n tensor_global.shape.insert(0, 1);\n handle.strides.insert(0, num_elem);\n }\n }\n\n plan.handle_inputs.push(HandleInput {\n precision: *precision,\n handle,\n relative_id: tensor_relative.id,\n global_id: tensor_global.id,\n global_shape: tensor_global.shape.clone(),\n vectorization: 1,\n broadcated: false,\n });\n plan.global_inputs.push(tensor_global);\n }\n }\n\n fn analyze(\n &self,\n plan: &mut LaunchPlan<'a, R>,\n pos: usize,\n tensor_relative: &'a TensorIr,\n handle: &CubeFusionHandle<R>,\n ) {\n if !self\n .resources\n .inputs_unhandled\n .contains(&tensor_relative.id)\n {\n let mut is_a_view = false;\n // For each view we try to see if it's not possible to set it as a reference input.\n for view in self.resources.views.iter() {\n for (block_plan, block) in plan.blocks.iter_mut().zip(self.blocks) {\n is_a_view = is_a_view\n || Self::analyze_view(pos, tensor_relative, block, block_plan, view);\n }\n }\n\n // Views can't be used inplace.\n if is_a_view {\n return;\n }\n\n self.analyze_potential_inplace(plan, pos, tensor_relative, handle);\n }\n }\n\n /// Analyzes if the given tensor can be used inplace in one of the block.\n fn analyze_potential_inplace(\n &self,\n plan: &mut LaunchPlan<'a, R>,\n pos: usize,\n tensor_relative: &'a TensorIr,\n handle: &CubeFusionHandle<R>,\n ) {\n enum BlockInplaceSelection {\n Notinit,\n /// The block reads the input, and therefore can use it for inplace.\n Selected(usize),\n /// The same input is used in multiple blocks.\n Unavailable,\n }\n\n let mut block_inplace_selection = BlockInplaceSelection::Notinit;\n\n for (idx, block) in plan.blocks.iter().enumerate() {\n if block.reads.contains_key(&tensor_relative.id) {\n match block_inplace_selection {\n BlockInplaceSelection::Notinit => {\n block_inplace_selection = BlockInplaceSelection::Selected(idx);\n }\n BlockInplaceSelection::Selected(_) => {\n block_inplace_selection = BlockInplaceSelection::Unavailable;\n }\n BlockInplaceSelection::Unavailable => {}\n }\n }\n }\n\n if let BlockInplaceSelection::Selected(idx) = block_inplace_selection {\n if self.blocks[idx].shape_ref != tensor_relative.shape {\n return;\n }\n\n let block_plan = &mut plan.blocks[idx];\n if tensor_relative.status == TensorStatus::ReadWrite\n && handle.handle.can_mut()\n && self.blocks[idx].settings.inplace\n {\n block_plan.potential_inplaces.push(PotentialInplace {\n input_pos: pos,\n tensor_relative,\n strides: handle.strides.clone(),\n });\n // Inplace tensors are normally really good as the reference layout, since\n // it's normally better to be based on writes rather than on reads.\n block_plan.potential_reference_input =\n Some(InputReference::Normal { input_pos: pos });\n } else {\n block_plan.potential_reference_input =\n Some(InputReference::Normal { input_pos: pos });\n }\n }\n }\n\n /// Analyzes if the given tensor is also the view provided, and check if it can be used as the reference layout\n /// for the given block.\n fn analyze_view(\n pos: usize,\n tensor_relative: &'a TensorIr,\n block: &FuseBlock,\n block_plan: &mut BlockPlan<'a>,\n view: &TensorView,\n ) -> bool {\n match view {\n TensorView::Reshape {\n reshaped,\n original,\n reshape_pos,\n shape_relative,\n } => {\n if original == &tensor_relative.id || reshaped == &tensor_relative.id {\n if block_plan.potential_reference_input.is_none()\n && shape_relative == &block.shape_ref\n {\n block_plan.potential_reference_input = Some(InputReference::Reshaped {\n reshape_pos: *reshape_pos as usize,\n });\n }\n return true;\n }\n }\n TensorView::SwapDims {\n swapped,\n original,\n dims,\n ..\n } => {\n if swapped == &tensor_relative.id {\n return true;\n }\n\n if original == &tensor_relative.id {\n let mut shape = tensor_relative.shape.clone();\n shape.swap(dims.0 as usize, dims.1 as usize);\n\n if block_plan.potential_reference_input.is_none() && shape == block.shape_ref {\n block_plan.potential_reference_input = Some(InputReference::SwapDims {\n original_pos: pos,\n dims: *dims,\n });\n }\n return true;\n }\n }\n };\n\n false\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct FuseBlock {\\n pub settings: FuseSettings,\\n pub ops: Vec<FuseOp>,\\n pub shape_ref: Vec<usize>,\\n pub reads: BTreeMap<TensorId, Vec<FuseOp>>,\\n pub writes: BTreeMap<TensorId, FuseOp>,\\n}\"\n ],\n \"name\": \"block\",\n \"type\": \"&FuseBlock\"\n },\n {\n \"definitions\": [\n \"pub(crate) struct BlockPlan<'a> {\\n pub potential_inplaces: Vec<PotentialInplace<'a>>,\\n pub potential_reference_input: Option<InputReference>,\\n pub reference: ReferenceSelection,\\n pub reads: BTreeMap<TensorId, Vec<FuseOp>>,\\n pub writes: BTreeMap<TensorId, FuseOp>,\\n pub width: u8,\\n}\"\n ],\n \"name\": \"block_plan\",\n \"type\": \"&mut BlockPlan<'a>\"\n },\n {\n \"definitions\": [\n \"pub enum TensorView {\\n Reshape {\\n reshaped: TensorId,\\n original: TensorId,\\n reshape_pos: u32,\\n shape_relative: Vec<usize>,\\n },\\n SwapDims {\\n swapped: TensorId,\\n original: TensorId,\\n dims: (u32, u32),\\n },\\n}\"\n ],\n \"name\": \"view\",\n \"type\": \"&TensorView\"\n }\n ],\n \"end_line\": 200,\n \"name\": \"analyze_view\",\n \"signature\": \"fn analyze_view(\\n pos: usize,\\n tensor_relative: &'a TensorIr,\\n block: &FuseBlock,\\n block_plan: &mut BlockPlan<'a>,\\n view: &TensorView,\\n ) -> bool\",\n \"start_line\": 149\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<'a, R: Runtime> InputPlanner<'a, R> {\\n pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> Self {\\n Self {\\n resources,\\n blocks,\\n _r: PhantomData,\\n }\\n }\\n\\n pub fn run(self, context: &mut Context<'_, CubeFusionHandle<R>>, plan: &mut LaunchPlan<'a, R>) {\\n for (pos, (tensor_relative, precision)) in self.resources.inputs.iter().enumerate() {\\n let mut tensor_global = context.tensors.get(&tensor_relative.id).unwrap().clone();\\n // Important to take the status of the relative graph and not\\n // the global graph, since the status of the global graph\\n // might be of a later operation on the same tensor id.\\n let status = &tensor_relative.status;\\n let mut handle = context.handles.get_handle(&tensor_global.id, status);\\n\\n self.analyze(plan, pos, tensor_relative, &handle);\\n\\n if tensor_global.shape.len() < plan.rank {\\n let num_elem: usize = tensor_global.shape.iter().product();\\n for _ in 0..(plan.rank - tensor_global.shape.len()) {\\n tensor_global.shape.insert(0, 1);\\n handle.strides.insert(0, num_elem);\\n }\\n }\\n\\n plan.handle_inputs.push(HandleInput {\\n precision: *precision,\\n handle,\\n relative_id: tensor_relative.id,\\n global_id: tensor_global.id,\\n global_shape: tensor_global.shape.clone(),\\n vectorization: 1,\\n broadcated: false,\\n });\\n plan.global_inputs.push(tensor_global);\\n }\\n }\\n\\n fn analyze(\\n &self,\\n plan: &mut LaunchPlan<'a, R>,\\n pos: usize,\\n tensor_relative: &'a TensorIr,\\n handle: &CubeFusionHandle<R>,\\n ) {\\n if !self\\n .resources\\n .inputs_unhandled\\n .contains(&tensor_relative.id)\\n {\\n let mut is_a_view = false;\\n // For each view we try to see if it's not possible to set it as a reference input.\\n for view in self.resources.views.iter() {\\n for (block_plan, block) in plan.blocks.iter_mut().zip(self.blocks) {\\n is_a_view = is_a_view\\n || Self::analyze_view(pos, tensor_relative, block, block_plan, view);\\n }\\n }\\n\\n // Views can't be used inplace.\\n if is_a_view {\\n return;\\n }\\n\\n self.analyze_potential_inplace(plan, pos, tensor_relative, handle);\\n }\\n }\\n\\n /// Analyzes if the given tensor can be used inplace in one of the block.\\n fn analyze_potential_inplace(\\n &self,\\n plan: &mut LaunchPlan<'a, R>,\\n pos: usize,\\n tensor_relative: &'a TensorIr,\\n handle: &CubeFusionHandle<R>,\\n ) {\\n enum BlockInplaceSelection {\\n Notinit,\\n /// The block reads the input, and therefore can use it for inplace.\\n Selected(usize),\\n /// The same input is used in multiple blocks.\\n Unavailable,\\n }\\n\\n let mut block_inplace_selection = BlockInplaceSelection::Notinit;\\n\\n for (idx, block) in plan.blocks.iter().enumerate() {\\n if block.reads.contains_key(&tensor_relative.id) {\\n match block_inplace_selection {\\n BlockInplaceSelection::Notinit => {\\n block_inplace_selection = BlockInplaceSelection::Selected(idx);\\n }\\n BlockInplaceSelection::Selected(_) => {\\n block_inplace_selection = BlockInplaceSelection::Unavailable;\\n }\\n BlockInplaceSelection::Unavailable => {}\\n }\\n }\\n }\\n\\n if let BlockInplaceSelection::Selected(idx) = block_inplace_selection {\\n if self.blocks[idx].shape_ref != tensor_relative.shape {\\n return;\\n }\\n\\n let block_plan = &mut plan.blocks[idx];\\n if tensor_relative.status == TensorStatus::ReadWrite\\n && handle.handle.can_mut()\\n && self.blocks[idx].settings.inplace\\n {\\n block_plan.potential_inplaces.push(PotentialInplace {\\n input_pos: pos,\\n tensor_relative,\\n strides: handle.strides.clone(),\\n });\\n // Inplace tensors are normally really good as the reference layout, since\\n // it's normally better to be based on writes rather than on reads.\\n block_plan.potential_reference_input =\\n Some(InputReference::Normal { input_pos: pos });\\n } else {\\n block_plan.potential_reference_input =\\n Some(InputReference::Normal { input_pos: pos });\\n }\\n }\\n }\\n\\n /// Analyzes if the given tensor is also the view provided, and check if it can be used as the reference layout\\n /// for the given block.\\n fn analyze_view(\\n pos: usize,\\n tensor_relative: &'a TensorIr,\\n block: &FuseBlock,\\n block_plan: &mut BlockPlan<'a>,\\n view: &TensorView,\\n ) -> bool {\\n match view {\\n TensorView::Reshape {\\n reshaped,\\n original,\\n reshape_pos,\\n shape_relative,\\n } => {\\n if original == &tensor_relative.id || reshaped == &tensor_relative.id {\\n if block_plan.potential_reference_input.is_none()\\n && shape_relative == &block.shape_ref\\n {\\n block_plan.potential_reference_input = Some(InputReference::Reshaped {\\n reshape_pos: *reshape_pos as usize,\\n });\\n }\\n return true;\\n }\\n }\\n TensorView::SwapDims {\\n swapped,\\n original,\\n dims,\\n ..\\n } => {\\n if swapped == &tensor_relative.id {\\n return true;\\n }\\n\\n if original == &tensor_relative.id {\\n let mut shape = tensor_relative.shape.clone();\\n shape.swap(dims.0 as usize, dims.1 as usize);\\n\\n if block_plan.potential_reference_input.is_none() && shape == block.shape_ref {\\n block_plan.potential_reference_input = Some(InputReference::SwapDims {\\n original_pos: pos,\\n dims: *dims,\\n });\\n }\\n return true;\\n }\\n }\\n };\\n\\n false\\n }\\n}\",\n \"class_signature\": \"impl<'a, R: Runtime> InputPlanner<'a, R>\"\n}"}}},{"rowIdx":168,"cells":{"function_name":{"kind":"string","value":"format_eta"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/renderer/tui/progress.rs"},"focal_code":{"kind":"string","value":"fn format_eta(eta_secs: u64) -> String {\n let seconds = eta_secs % 60;\n let minutes = eta_secs / MINUTE % 60;\n let hours = eta_secs / HOUR % 24;\n let days = eta_secs / DAY;\n\n if days > 1 {\n format!(\"{days} days\")\n } else if days == 1 {\n \"1 day\".to_string()\n } else if hours > 1 {\n format!(\"{hours} hours\")\n } else if hours == 1 {\n \"1 hour\".to_string()\n } else if minutes > 1 {\n format!(\"{minutes} mins\")\n } else if minutes == 1 {\n \"1 min\".to_string()\n } else if seconds > 1 {\n format!(\"{seconds} secs\")\n } else {\n \"1 sec\".to_string()\n }\n}"},"file_content":{"kind":"string","value":"use super::TerminalFrame;\nuse crate::renderer::TrainingProgress;\nuse ratatui::{\n prelude::{Alignment, Constraint, Direction, Layout, Rect},\n style::{Color, Style, Stylize},\n text::{Line, Span},\n widgets::{Block, Borders, Gauge, Paragraph},\n};\nuse std::time::{Duration, Instant};\n\n/// Simple progress bar for the training.\n///\n/// We currently ignore the time taken for the validation part.\npub(crate) struct ProgressBarState {\n progress_train: f64, // Progress for total training.\n starting_epoch: usize,\n estimate: ProgressEstimate,\n}\n\nconst MINUTE: u64 = 60;\nconst HOUR: u64 = 60 * 60;\nconst DAY: u64 = 24 * 60 * 60;\n\nimpl ProgressBarState {\n pub fn new(checkpoint: Option<usize>) -> Self {\n Self {\n progress_train: 0.0,\n estimate: ProgressEstimate::new(),\n starting_epoch: checkpoint.unwrap_or(0),\n }\n }\n /// Update the training progress.\n pub(crate) fn update_train(&mut self, progress: &TrainingProgress) {\n self.progress_train = calculate_progress(progress, 0, 0);\n self.estimate.update(progress, self.starting_epoch);\n }\n\n /// Update the validation progress.\n pub(crate) fn update_valid(&mut self, _progress: &TrainingProgress) {\n // We don't use the validation for the progress yet.\n }\n\n /// Create a view for the current progress.\n pub(crate) fn view(&self) -> ProgressBarView {\n const NO_ETA: &str = \"---\";\n\n let eta = match self.estimate.secs() {\n Some(eta) => format_eta(eta),\n None => NO_ETA.to_string(),\n };\n ProgressBarView::new(self.progress_train, eta)\n }\n}\n\n#[derive(new)]\npub(crate) struct ProgressBarView {\n progress: f64,\n eta: String,\n}\n\nimpl ProgressBarView {\n /// Render the view.\n pub(crate) fn render(self, frame: &mut TerminalFrame<'_>, size: Rect) {\n let block = Block::default()\n .borders(Borders::ALL)\n .title(\"Progress\")\n .title_alignment(Alignment::Left);\n let size_new = block.inner(size);\n frame.render_widget(block, size);\n let size = size_new;\n\n let chunks = Layout::default()\n .direction(Direction::Horizontal)\n .constraints(\n [\n Constraint::Length(1), // Empty space\n Constraint::Min(0),\n Constraint::Length(self.eta.len() as u16 + 4),\n ]\n .as_ref(),\n )\n .split(size);\n\n let size_gauge = chunks[1];\n let size_eta = chunks[2];\n\n let iteration = Gauge::default()\n .gauge_style(Style::default().fg(Color::Yellow))\n .ratio(self.progress.min(1.0));\n let eta = Paragraph::new(Line::from(vec![\n Span::from(\" (\"),\n Span::from(self.eta).italic(),\n Span::from(\") \"),\n ]));\n\n frame.render_widget(iteration, size_gauge);\n frame.render_widget(eta, size_eta);\n }\n}\n\nstruct ProgressEstimate {\n started: Instant,\n started_after_warmup: Option<Instant>,\n warmup_num_items: usize,\n progress: f64,\n}\n\nimpl ProgressEstimate {\n fn new() -> Self {\n Self {\n started: Instant::now(),\n started_after_warmup: None,\n warmup_num_items: 0,\n progress: 0.0,\n }\n }\n\n fn secs(&self) -> Option<u64> {\n let eta = self.started_after_warmup?.elapsed();\n\n let total_estimated = (eta.as_secs() as f64) / self.progress;\n\n if total_estimated.is_normal() {\n let remaining = 1.0 - self.progress;\n let eta = (total_estimated * remaining) as u64;\n Some(eta)\n } else {\n None\n }\n }\n\n fn update(&mut self, progress: &TrainingProgress, starting_epoch: usize) {\n if self.started_after_warmup.is_some() {\n self.progress = calculate_progress(progress, starting_epoch, self.warmup_num_items);\n return;\n }\n\n const WARMUP_NUM_ITERATION: usize = 10;\n\n // When the training has started since 30 seconds.\n if self.started.elapsed() > Duration::from_secs(30) {\n self.init(progress, starting_epoch);\n return;\n }\n\n // When the training has started since at least 10 seconds and completed 10 iterations.\n if progress.iteration >= WARMUP_NUM_ITERATION\n && self.started.elapsed() > Duration::from_secs(10)\n {\n self.init(progress, starting_epoch);\n }\n }\n\n fn init(&mut self, progress: &TrainingProgress, starting_epoch: usize) {\n let epoch = progress.epoch - starting_epoch;\n let epoch_items = (epoch - 1) * progress.progress.items_total;\n let iteration_items = progress.progress.items_processed;\n\n self.warmup_num_items = epoch_items + iteration_items;\n self.started_after_warmup = Some(Instant::now());\n self.progress = calculate_progress(progress, starting_epoch, self.warmup_num_items);\n }\n}\n\nfn calculate_progress(\n progress: &TrainingProgress,\n starting_epoch: usize,\n ignore_num_items: usize,\n) -> f64 {\n let epoch_total = progress.epoch_total - starting_epoch;\n let epoch = progress.epoch - starting_epoch;\n\n let total_items = progress.progress.items_total * epoch_total;\n let epoch_items = (epoch - 1) * progress.progress.items_total;\n let iteration_items = progress.progress.items_processed;\n let num_items = epoch_items + iteration_items - ignore_num_items;\n\n num_items as f64 / total_items as f64\n}\n\nfn format_eta(eta_secs: u64) -> String {\n let seconds = eta_secs % 60;\n let minutes = eta_secs / MINUTE % 60;\n let hours = eta_secs / HOUR % 24;\n let days = eta_secs / DAY;\n\n if days > 1 {\n format!(\"{days} days\")\n } else if days == 1 {\n \"1 day\".to_string()\n } else if hours > 1 {\n format!(\"{hours} hours\")\n } else if hours == 1 {\n \"1 hour\".to_string()\n } else if minutes > 1 {\n format!(\"{minutes} mins\")\n } else if minutes == 1 {\n \"1 min\".to_string()\n } else if seconds > 1 {\n format!(\"{seconds} secs\")\n } else {\n \"1 sec\".to_string()\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use burn_core::data::dataloader::Progress;\n\n #[test]\n fn test_format_eta() {\n assert_eq!(\"55 secs\", format_eta(55), \"Less than 1 minutes\");\n assert_eq!(\"1 min\", format_eta(61), \"More than 1 minutes\");\n assert_eq!(\"2 mins\", format_eta(2 * 61), \"More than 2 minutes\");\n assert_eq!(\"1 hour\", format_eta(3601), \"More than 1 hour\");\n assert_eq!(\"2 hours\", format_eta(2 * 3601), \"More than 2 hour\");\n assert_eq!(\"1 day\", format_eta(24 * 3601), \"More than 1 day\");\n assert_eq!(\"2 days\", format_eta(48 * 3601), \"More than 2 day\");\n }\n\n #[test]\n fn calculate_progress_for_eta() {\n let half = Progress {\n items_processed: 5,\n items_total: 10,\n };\n let progress = TrainingProgress {\n progress: half,\n epoch: 9,\n epoch_total: 10,\n iteration: 500,\n };\n\n let starting_epoch = 8;\n let progress = calculate_progress(&progress, starting_epoch, 0);\n\n // Two epochs remaining while the first is half done.\n assert_eq!(0.25, progress);\n }\n\n #[test]\n fn calculate_progress_for_eta_with_warmup() {\n let half = Progress {\n items_processed: 110,\n items_total: 1000,\n };\n let progress = TrainingProgress {\n progress: half,\n epoch: 9,\n epoch_total: 10,\n iteration: 500,\n };\n\n let starting_epoch = 8;\n let progress = calculate_progress(&progress, starting_epoch, 10);\n\n // Two epochs remaining while the first is half done.\n assert_eq!(0.05, progress);\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 204,\n \"name\": \"format_eta\",\n \"signature\": \"fn format_eta(eta_secs: u64) -> String\",\n \"start_line\": 181\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":169,"cells":{"function_name":{"kind":"string","value":"new"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/renderer/tui/renderer.rs"},"focal_code":{"kind":"string","value":"pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self {\n let mut stdout = io::stdout();\n execute!(stdout, EnterAlternateScreen).unwrap();\n enable_raw_mode().unwrap();\n let terminal = Terminal::new(CrosstermBackend::new(stdout)).unwrap();\n\n // Reset the terminal to raw mode on panic before running the panic handler\n // This prevents that the panic message is not visible for the user.\n let previous_panic_hook = Arc::new(take_hook());\n set_hook(Box::new({\n let previous_panic_hook = previous_panic_hook.clone();\n move |panic_info| {\n let _ = disable_raw_mode();\n let _ = execute!(io::stdout(), LeaveAlternateScreen);\n previous_panic_hook(panic_info);\n }\n }));\n\n Self {\n terminal,\n last_update: Instant::now(),\n progress: ProgressBarState::new(checkpoint),\n metrics_numeric: NumericMetricsState::default(),\n metrics_text: TextMetricsState::default(),\n status: StatusState::default(),\n interuptor,\n popup: PopupState::Empty,\n previous_panic_hook: Some(previous_panic_hook),\n persistent: false,\n }\n }"},"file_content":{"kind":"string","value":"use crate::TrainingInterrupter;\nuse crate::renderer::{MetricState, TrainingProgress};\nuse crate::renderer::{MetricsRenderer, tui::NumericMetricsState};\nuse ratatui::{\n Terminal,\n crossterm::{\n event::{self, Event, KeyCode},\n execute,\n terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},\n },\n prelude::*,\n};\nuse std::panic::{set_hook, take_hook};\nuse std::sync::Arc;\nuse std::{\n error::Error,\n io::{self, Stdout},\n time::{Duration, Instant},\n};\n\nuse super::{\n Callback, CallbackFn, ControlsView, MetricsView, PopupState, ProgressBarState, StatusState,\n TextMetricsState,\n};\n\n/// The current terminal backend.\npub(crate) type TerminalBackend = CrosstermBackend<Stdout>;\n/// The current terminal frame.\npub(crate) type TerminalFrame<'a> = ratatui::Frame<'a>;\n\ntype PanicHook = Box<dyn Fn(&std::panic::PanicHookInfo<'_>) + 'static + Sync + Send>;\n\nconst MAX_REFRESH_RATE_MILLIS: u64 = 100;\n\n/// The terminal UI metrics renderer.\npub struct TuiMetricsRenderer {\n terminal: Terminal<TerminalBackend>,\n last_update: std::time::Instant,\n progress: ProgressBarState,\n metrics_numeric: NumericMetricsState,\n metrics_text: TextMetricsState,\n status: StatusState,\n interuptor: TrainingInterrupter,\n popup: PopupState,\n previous_panic_hook: Option<Arc<PanicHook>>,\n persistent: bool,\n}\n\nimpl MetricsRenderer for TuiMetricsRenderer {\n fn update_train(&mut self, state: MetricState) {\n match state {\n MetricState::Generic(entry) => {\n self.metrics_text.update_train(entry);\n }\n MetricState::Numeric(entry, value) => {\n self.metrics_numeric.push_train(entry.name.clone(), value);\n self.metrics_text.update_train(entry);\n }\n };\n }\n\n fn update_valid(&mut self, state: MetricState) {\n match state {\n MetricState::Generic(entry) => {\n self.metrics_text.update_valid(entry);\n }\n MetricState::Numeric(entry, value) => {\n self.metrics_numeric.push_valid(entry.name.clone(), value);\n self.metrics_text.update_valid(entry);\n }\n };\n }\n\n fn render_train(&mut self, item: TrainingProgress) {\n self.progress.update_train(&item);\n self.metrics_numeric.update_progress_train(&item);\n self.status.update_train(item);\n self.render().unwrap();\n }\n\n fn render_valid(&mut self, item: TrainingProgress) {\n self.progress.update_valid(&item);\n self.metrics_numeric.update_progress_valid(&item);\n self.status.update_valid(item);\n self.render().unwrap();\n }\n\n fn on_train_end(&mut self) -> Result<(), Box<dyn Error>> {\n self.reset()\n }\n}\n\nimpl TuiMetricsRenderer {\n /// Create a new terminal UI renderer.\n pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self {\n let mut stdout = io::stdout();\n execute!(stdout, EnterAlternateScreen).unwrap();\n enable_raw_mode().unwrap();\n let terminal = Terminal::new(CrosstermBackend::new(stdout)).unwrap();\n\n // Reset the terminal to raw mode on panic before running the panic handler\n // This prevents that the panic message is not visible for the user.\n let previous_panic_hook = Arc::new(take_hook());\n set_hook(Box::new({\n let previous_panic_hook = previous_panic_hook.clone();\n move |panic_info| {\n let _ = disable_raw_mode();\n let _ = execute!(io::stdout(), LeaveAlternateScreen);\n previous_panic_hook(panic_info);\n }\n }));\n\n Self {\n terminal,\n last_update: Instant::now(),\n progress: ProgressBarState::new(checkpoint),\n metrics_numeric: NumericMetricsState::default(),\n metrics_text: TextMetricsState::default(),\n status: StatusState::default(),\n interuptor,\n popup: PopupState::Empty,\n previous_panic_hook: Some(previous_panic_hook),\n persistent: false,\n }\n }\n\n /// Set the renderer to persistent mode.\n pub fn persistent(mut self) -> Self {\n self.persistent = true;\n self\n }\n\n fn render(&mut self) -> Result<(), Box<dyn Error>> {\n let tick_rate = Duration::from_millis(MAX_REFRESH_RATE_MILLIS);\n if self.last_update.elapsed() < tick_rate {\n return Ok(());\n }\n\n self.draw()?;\n self.handle_events()?;\n\n self.last_update = Instant::now();\n\n Ok(())\n }\n\n fn draw(&mut self) -> Result<(), Box<dyn Error>> {\n self.terminal.draw(|frame| {\n let size = frame.area();\n\n match self.popup.view() {\n Some(view) => view.render(frame, size),\n None => {\n let view = MetricsView::new(\n self.metrics_numeric.view(),\n self.metrics_text.view(),\n self.progress.view(),\n ControlsView,\n self.status.view(),\n );\n\n view.render(frame, size);\n }\n };\n })?;\n\n Ok(())\n }\n\n fn handle_events(&mut self) -> Result<(), Box<dyn Error>> {\n while event::poll(Duration::from_secs(0))? {\n let event = event::read()?;\n self.popup.on_event(&event);\n\n if self.popup.is_empty() {\n self.metrics_numeric.on_event(&event);\n\n if let Event::Key(key) = event {\n if let KeyCode::Char('q') = key.code {\n self.popup = PopupState::Full(\n \"Quit\".to_string(),\n vec![\n Callback::new(\n \"Stop the training.\",\n \"Stop the training immediately. This will break from the \\\n training loop, but any remaining code after the loop will be \\\n executed.\",\n 's',\n QuitPopupAccept(self.interuptor.clone()),\n ),\n Callback::new(\n \"Stop the training immediately.\",\n \"Kill the program. This will create a panic! which will make \\\n the current training fails. Any code following the training \\\n won't be executed.\",\n 'k',\n KillPopupAccept,\n ),\n Callback::new(\n \"Cancel\",\n \"Cancel the action, continue the training.\",\n 'c',\n PopupCancel,\n ),\n ],\n );\n }\n }\n }\n }\n\n Ok(())\n }\n\n fn handle_post_training(&mut self) -> Result<(), Box<dyn Error>> {\n self.popup = PopupState::Full(\n \"Training is done\".to_string(),\n vec![Callback::new(\n \"Training Done\",\n \"Press 'x' to close this popup. Press 'q' to exit the application after the \\\n popup is closed.\",\n 'x',\n PopupCancel,\n )],\n );\n\n self.draw().ok();\n\n loop {\n if let Ok(true) = event::poll(Duration::from_millis(MAX_REFRESH_RATE_MILLIS)) {\n match event::read() {\n Ok(event @ Event::Key(key)) => {\n if self.popup.is_empty() {\n self.metrics_numeric.on_event(&event);\n if let KeyCode::Char('q') = key.code {\n break;\n }\n } else {\n self.popup.on_event(&event);\n }\n self.draw().ok();\n }\n\n Ok(Event::Resize(..)) => {\n self.draw().ok();\n }\n Err(err) => {\n eprintln!(\"Error reading event: {}\", err);\n break;\n }\n _ => continue,\n }\n }\n }\n Ok(())\n }\n\n // Reset the terminal back to raw mode.\n fn reset(&mut self) -> Result<(), Box<dyn Error>> {\n // If previous panic hook has already been re-instated, then the terminal was already reset.\n if self.previous_panic_hook.is_some() {\n if self.persistent {\n if let Err(err) = self.handle_post_training() {\n eprintln!(\"Error in post-training handling: {}\", err);\n }\n }\n\n disable_raw_mode()?;\n execute!(self.terminal.backend_mut(), LeaveAlternateScreen)?;\n self.terminal.show_cursor()?;\n\n // Reinstall the previous panic hook\n let _ = take_hook();\n if let Some(previous_panic_hook) =\n Arc::into_inner(self.previous_panic_hook.take().unwrap())\n {\n set_hook(previous_panic_hook);\n }\n }\n Ok(())\n }\n}\n\nstruct QuitPopupAccept(TrainingInterrupter);\nstruct KillPopupAccept;\nstruct PopupCancel;\n\nimpl CallbackFn for KillPopupAccept {\n fn call(&self) -> bool {\n panic!(\"Killing training from user input.\");\n }\n}\n\nimpl CallbackFn for QuitPopupAccept {\n fn call(&self) -> bool {\n self.0.stop();\n true\n }\n}\n\nimpl CallbackFn for PopupCancel {\n fn call(&self) -> bool {\n true\n }\n}\n\nimpl Drop for TuiMetricsRenderer {\n fn drop(&mut self) {\n // Reset the terminal back to raw mode. This can be skipped during\n // panicking because the panic hook has already reset the terminal\n if !std::thread::panicking() {\n self.reset().unwrap();\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 125,\n \"name\": \"new\",\n \"signature\": \"pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self\",\n \"start_line\": 95\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl TuiMetricsRenderer {\\n /// Create a new terminal UI renderer.\\n pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self {\\n let mut stdout = io::stdout();\\n execute!(stdout, EnterAlternateScreen).unwrap();\\n enable_raw_mode().unwrap();\\n let terminal = Terminal::new(CrosstermBackend::new(stdout)).unwrap();\\n\\n // Reset the terminal to raw mode on panic before running the panic handler\\n // This prevents that the panic message is not visible for the user.\\n let previous_panic_hook = Arc::new(take_hook());\\n set_hook(Box::new({\\n let previous_panic_hook = previous_panic_hook.clone();\\n move |panic_info| {\\n let _ = disable_raw_mode();\\n let _ = execute!(io::stdout(), LeaveAlternateScreen);\\n previous_panic_hook(panic_info);\\n }\\n }));\\n\\n Self {\\n terminal,\\n last_update: Instant::now(),\\n progress: ProgressBarState::new(checkpoint),\\n metrics_numeric: NumericMetricsState::default(),\\n metrics_text: TextMetricsState::default(),\\n status: StatusState::default(),\\n interuptor,\\n popup: PopupState::Empty,\\n previous_panic_hook: Some(previous_panic_hook),\\n persistent: false,\\n }\\n }\\n\\n /// Set the renderer to persistent mode.\\n pub fn persistent(mut self) -> Self {\\n self.persistent = true;\\n self\\n }\\n\\n fn render(&mut self) -> Result<(), Box<dyn Error>> {\\n let tick_rate = Duration::from_millis(MAX_REFRESH_RATE_MILLIS);\\n if self.last_update.elapsed() < tick_rate {\\n return Ok(());\\n }\\n\\n self.draw()?;\\n self.handle_events()?;\\n\\n self.last_update = Instant::now();\\n\\n Ok(())\\n }\\n\\n fn draw(&mut self) -> Result<(), Box<dyn Error>> {\\n self.terminal.draw(|frame| {\\n let size = frame.area();\\n\\n match self.popup.view() {\\n Some(view) => view.render(frame, size),\\n None => {\\n let view = MetricsView::new(\\n self.metrics_numeric.view(),\\n self.metrics_text.view(),\\n self.progress.view(),\\n ControlsView,\\n self.status.view(),\\n );\\n\\n view.render(frame, size);\\n }\\n };\\n })?;\\n\\n Ok(())\\n }\\n\\n fn handle_events(&mut self) -> Result<(), Box<dyn Error>> {\\n while event::poll(Duration::from_secs(0))? {\\n let event = event::read()?;\\n self.popup.on_event(&event);\\n\\n if self.popup.is_empty() {\\n self.metrics_numeric.on_event(&event);\\n\\n if let Event::Key(key) = event {\\n if let KeyCode::Char('q') = key.code {\\n self.popup = PopupState::Full(\\n \\\"Quit\\\".to_string(),\\n vec![\\n Callback::new(\\n \\\"Stop the training.\\\",\\n \\\"Stop the training immediately. This will break from the \\\\\\n training loop, but any remaining code after the loop will be \\\\\\n executed.\\\",\\n 's',\\n QuitPopupAccept(self.interuptor.clone()),\\n ),\\n Callback::new(\\n \\\"Stop the training immediately.\\\",\\n \\\"Kill the program. This will create a panic! which will make \\\\\\n the current training fails. Any code following the training \\\\\\n won't be executed.\\\",\\n 'k',\\n KillPopupAccept,\\n ),\\n Callback::new(\\n \\\"Cancel\\\",\\n \\\"Cancel the action, continue the training.\\\",\\n 'c',\\n PopupCancel,\\n ),\\n ],\\n );\\n }\\n }\\n }\\n }\\n\\n Ok(())\\n }\\n\\n fn handle_post_training(&mut self) -> Result<(), Box<dyn Error>> {\\n self.popup = PopupState::Full(\\n \\\"Training is done\\\".to_string(),\\n vec![Callback::new(\\n \\\"Training Done\\\",\\n \\\"Press 'x' to close this popup. Press 'q' to exit the application after the \\\\\\n popup is closed.\\\",\\n 'x',\\n PopupCancel,\\n )],\\n );\\n\\n self.draw().ok();\\n\\n loop {\\n if let Ok(true) = event::poll(Duration::from_millis(MAX_REFRESH_RATE_MILLIS)) {\\n match event::read() {\\n Ok(event @ Event::Key(key)) => {\\n if self.popup.is_empty() {\\n self.metrics_numeric.on_event(&event);\\n if let KeyCode::Char('q') = key.code {\\n break;\\n }\\n } else {\\n self.popup.on_event(&event);\\n }\\n self.draw().ok();\\n }\\n\\n Ok(Event::Resize(..)) => {\\n self.draw().ok();\\n }\\n Err(err) => {\\n eprintln!(\\\"Error reading event: {}\\\", err);\\n break;\\n }\\n _ => continue,\\n }\\n }\\n }\\n Ok(())\\n }\\n\\n // Reset the terminal back to raw mode.\\n fn reset(&mut self) -> Result<(), Box<dyn Error>> {\\n // If previous panic hook has already been re-instated, then the terminal was already reset.\\n if self.previous_panic_hook.is_some() {\\n if self.persistent {\\n if let Err(err) = self.handle_post_training() {\\n eprintln!(\\\"Error in post-training handling: {}\\\", err);\\n }\\n }\\n\\n disable_raw_mode()?;\\n execute!(self.terminal.backend_mut(), LeaveAlternateScreen)?;\\n self.terminal.show_cursor()?;\\n\\n // Reinstall the previous panic hook\\n let _ = take_hook();\\n if let Some(previous_panic_hook) =\\n Arc::into_inner(self.previous_panic_hook.take().unwrap())\\n {\\n set_hook(previous_panic_hook);\\n }\\n }\\n Ok(())\\n }\\n}\",\n \"class_signature\": \"impl TuiMetricsRenderer\"\n}"}}},{"rowIdx":170,"cells":{"function_name":{"kind":"string","value":"should_stop"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/learner/early_stopping.rs"},"focal_code":{"kind":"string","value":"fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool {\n let current_value =\n match store.find_metric(&self.metric_name, epoch, self.aggregate, self.split) {\n Some(value) => value,\n None => {\n log::warn!(\"Can't find metric for early stopping.\");\n return false;\n }\n };\n\n let is_best = match self.direction {\n Direction::Lowest => current_value < self.best_value,\n Direction::Highest => current_value > self.best_value,\n };\n\n if is_best {\n log::info!(\n \"New best epoch found {} {}: {}\",\n epoch,\n self.metric_name,\n current_value\n );\n self.best_value = current_value;\n self.best_epoch = epoch;\n return false;\n }\n\n match self.condition {\n StoppingCondition::NoImprovementSince { n_epochs } => {\n let should_stop = epoch - self.best_epoch >= n_epochs;\n\n if should_stop {\n log::info!(\n \"Stopping training loop, no improvement since epoch {}, {}: {}, current \\\n epoch {}, {}: {}\",\n self.best_epoch,\n self.metric_name,\n self.best_value,\n epoch,\n self.metric_name,\n current_value\n );\n }\n\n should_stop\n }\n }\n }"},"file_content":{"kind":"string","value":"use crate::metric::{\n Metric,\n store::{Aggregate, Direction, EventStoreClient, Split},\n};\n\n/// The condition that [early stopping strategies](EarlyStoppingStrategy) should follow.\npub enum StoppingCondition {\n /// When no improvement has happened since the given number of epochs.\n NoImprovementSince {\n /// The number of epochs allowed to worsen before it gets better.\n n_epochs: usize,\n },\n}\n\n/// A strategy that checks if the training should be stopped.\npub trait EarlyStoppingStrategy {\n /// Update its current state and returns if the training should be stopped.\n fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool;\n}\n\n/// An [early stopping strategy](EarlyStoppingStrategy) based on a metrics collected\n/// during training or validation.\npub struct MetricEarlyStoppingStrategy {\n condition: StoppingCondition,\n metric_name: String,\n aggregate: Aggregate,\n direction: Direction,\n split: Split,\n best_epoch: usize,\n best_value: f64,\n}\n\nimpl EarlyStoppingStrategy for MetricEarlyStoppingStrategy {\n fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool {\n let current_value =\n match store.find_metric(&self.metric_name, epoch, self.aggregate, self.split) {\n Some(value) => value,\n None => {\n log::warn!(\"Can't find metric for early stopping.\");\n return false;\n }\n };\n\n let is_best = match self.direction {\n Direction::Lowest => current_value < self.best_value,\n Direction::Highest => current_value > self.best_value,\n };\n\n if is_best {\n log::info!(\n \"New best epoch found {} {}: {}\",\n epoch,\n self.metric_name,\n current_value\n );\n self.best_value = current_value;\n self.best_epoch = epoch;\n return false;\n }\n\n match self.condition {\n StoppingCondition::NoImprovementSince { n_epochs } => {\n let should_stop = epoch - self.best_epoch >= n_epochs;\n\n if should_stop {\n log::info!(\n \"Stopping training loop, no improvement since epoch {}, {}: {}, current \\\n epoch {}, {}: {}\",\n self.best_epoch,\n self.metric_name,\n self.best_value,\n epoch,\n self.metric_name,\n current_value\n );\n }\n\n should_stop\n }\n }\n }\n}\n\nimpl MetricEarlyStoppingStrategy {\n /// Create a new [early stopping strategy](EarlyStoppingStrategy) based on a metrics collected\n /// during training or validation.\n ///\n /// # Notes\n ///\n /// The metric should be registered for early stopping to work, otherwise no data is collected.\n pub fn new<Me: Metric>(\n metric: &Me,\n aggregate: Aggregate,\n direction: Direction,\n split: Split,\n condition: StoppingCondition,\n ) -> Self {\n let init_value = match direction {\n Direction::Lowest => f64::MAX,\n Direction::Highest => f64::MIN,\n };\n\n Self {\n metric_name: metric.name(),\n condition,\n aggregate,\n direction,\n split,\n best_epoch: 1,\n best_value: init_value,\n }\n }\n}\n\n#[cfg(test)]\nmod tests {\n use std::sync::Arc;\n\n use crate::{\n TestBackend,\n logger::InMemoryMetricLogger,\n metric::{\n LossMetric,\n processor::{\n Metrics, MinimalEventProcessor,\n test_utils::{end_epoch, process_train},\n },\n store::LogEventStore,\n },\n };\n\n use super::*;\n\n #[test]\n fn never_early_stop_while_it_is_improving() {\n test_early_stopping(\n 1,\n &[\n (&[0.5, 0.3], false, \"Should not stop first epoch\"),\n (&[0.4, 0.3], false, \"Should not stop when improving\"),\n (&[0.3, 0.3], false, \"Should not stop when improving\"),\n (&[0.2, 0.3], false, \"Should not stop when improving\"),\n ],\n );\n }\n\n #[test]\n fn early_stop_when_no_improvement_since_two_epochs() {\n test_early_stopping(\n 2,\n &[\n (&[1.0, 0.5], false, \"Should not stop first epoch\"),\n (&[0.5, 0.3], false, \"Should not stop when improving\"),\n (\n &[1.0, 3.0],\n false,\n \"Should not stop first time it gets worse\",\n ),\n (\n &[1.0, 2.0],\n true,\n \"Should stop since two following epochs didn't improve\",\n ),\n ],\n );\n }\n\n #[test]\n fn early_stop_when_stays_equal() {\n test_early_stopping(\n 2,\n &[\n (&[0.5, 0.3], false, \"Should not stop first epoch\"),\n (\n &[0.5, 0.3],\n false,\n \"Should not stop first time it stars the same\",\n ),\n (\n &[0.5, 0.3],\n true,\n \"Should stop since two following epochs didn't improve\",\n ),\n ],\n );\n }\n\n fn test_early_stopping(n_epochs: usize, data: &[(&[f64], bool, &str)]) {\n let loss = LossMetric::<TestBackend>::new();\n let mut early_stopping = MetricEarlyStoppingStrategy::new(\n &loss,\n Aggregate::Mean,\n Direction::Lowest,\n Split::Train,\n StoppingCondition::NoImprovementSince { n_epochs },\n );\n let mut store = LogEventStore::default();\n let mut metrics = Metrics::<f64, f64>::default();\n\n store.register_logger_train(InMemoryMetricLogger::default());\n metrics.register_train_metric_numeric(loss);\n\n let store = Arc::new(EventStoreClient::new(store));\n let mut processor = MinimalEventProcessor::new(metrics, store.clone());\n\n let mut epoch = 1;\n for (points, should_start, comment) in data {\n for point in points.iter() {\n process_train(&mut processor, *point, epoch);\n }\n end_epoch(&mut processor, epoch);\n\n assert_eq!(\n *should_start,\n early_stopping.should_stop(epoch, &store),\n \"{comment}\"\n );\n epoch += 1;\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct EventStoreClient {\\n sender: mpsc::Sender<Message>,\\n handler: Option<JoinHandle<()>>,\\n}\"\n ],\n \"name\": \"store\",\n \"type\": \"&EventStoreClient\"\n }\n ],\n \"end_line\": 81,\n \"name\": \"should_stop\",\n \"signature\": \"fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool\",\n \"start_line\": 34\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl EarlyStoppingStrategy for MetricEarlyStoppingStrategy {\\n fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool {\\n let current_value =\\n match store.find_metric(&self.metric_name, epoch, self.aggregate, self.split) {\\n Some(value) => value,\\n None => {\\n log::warn!(\\\"Can't find metric for early stopping.\\\");\\n return false;\\n }\\n };\\n\\n let is_best = match self.direction {\\n Direction::Lowest => current_value < self.best_value,\\n Direction::Highest => current_value > self.best_value,\\n };\\n\\n if is_best {\\n log::info!(\\n \\\"New best epoch found {} {}: {}\\\",\\n epoch,\\n self.metric_name,\\n current_value\\n );\\n self.best_value = current_value;\\n self.best_epoch = epoch;\\n return false;\\n }\\n\\n match self.condition {\\n StoppingCondition::NoImprovementSince { n_epochs } => {\\n let should_stop = epoch - self.best_epoch >= n_epochs;\\n\\n if should_stop {\\n log::info!(\\n \\\"Stopping training loop, no improvement since epoch {}, {}: {}, current \\\\\\n epoch {}, {}: {}\\\",\\n self.best_epoch,\\n self.metric_name,\\n self.best_value,\\n epoch,\\n self.metric_name,\\n current_value\\n );\\n }\\n\\n should_stop\\n }\\n }\\n }\\n}\",\n \"class_signature\": \"impl EarlyStoppingStrategy for MetricEarlyStoppingStrategy\"\n}"}}},{"rowIdx":171,"cells":{"function_name":{"kind":"string","value":"build"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/learner/builder.rs"},"focal_code":{"kind":"string","value":"pub fn build(\n mut self,\n model: M,\n optim: O,\n lr_scheduler: S,\n ) -> Learner<\n LearnerComponentsMarker<\n B,\n S,\n M,\n O,\n AsyncCheckpointer<M::Record, B>,\n AsyncCheckpointer<O::Record, B>,\n AsyncCheckpointer<S::Record<B>, B>,\n AsyncProcessor<FullEventProcessor<T, V>>,\n Box<dyn CheckpointingStrategy>,\n >,\n > {\n if self.tracing_logger.is_some() {\n if let Err(e) = self.tracing_logger.as_ref().unwrap().install() {\n log::warn!(\"Failed to install the experiment logger: {}\", e);\n }\n }\n let renderer = self\n .renderer\n .unwrap_or_else(|| default_renderer(self.interrupter.clone(), self.checkpoint));\n\n if self.num_loggers == 0 {\n self.event_store\n .register_logger_train(FileMetricLogger::new(self.directory.join(\"train\")));\n self.event_store\n .register_logger_valid(FileMetricLogger::new(self.directory.join(\"valid\")));\n }\n\n let event_store = Arc::new(EventStoreClient::new(self.event_store));\n let event_processor = AsyncProcessor::new(FullEventProcessor::new(\n self.metrics,\n renderer,\n event_store.clone(),\n ));\n\n let checkpointer = self.checkpointers.map(|(model, optim, scheduler)| {\n LearnerCheckpointer::new(model, optim, scheduler, self.checkpointer_strategy)\n });\n\n let summary = if self.summary {\n Some(LearnerSummaryConfig {\n directory: self.directory,\n metrics: self.summary_metrics.into_iter().collect::<Vec<_>>(),\n })\n } else {\n None\n };\n\n Learner {\n model,\n optim,\n lr_scheduler,\n checkpointer,\n num_epochs: self.num_epochs,\n event_processor,\n event_store,\n checkpoint: self.checkpoint,\n grad_accumulation: self.grad_accumulation,\n devices: self.devices,\n interrupter: self.interrupter,\n early_stopping: self.early_stopping,\n summary,\n }\n }"},"file_content":{"kind":"string","value":"use std::collections::HashSet;\nuse std::path::{Path, PathBuf};\nuse std::sync::Arc;\n\nuse super::Learner;\nuse crate::checkpoint::{\n AsyncCheckpointer, CheckpointingStrategy, ComposedCheckpointingStrategy, FileCheckpointer,\n KeepLastNCheckpoints, MetricCheckpointingStrategy,\n};\nuse crate::components::LearnerComponentsMarker;\nuse crate::learner::EarlyStoppingStrategy;\nuse crate::learner::base::TrainingInterrupter;\nuse crate::logger::{FileMetricLogger, MetricLogger};\nuse crate::metric::processor::{AsyncProcessor, FullEventProcessor, ItemLazy, Metrics};\nuse crate::metric::store::{Aggregate, Direction, EventStoreClient, LogEventStore, Split};\nuse crate::metric::{Adaptor, LossMetric, Metric};\nuse crate::renderer::{MetricsRenderer, default_renderer};\nuse crate::{\n ApplicationLoggerInstaller, FileApplicationLoggerInstaller, LearnerCheckpointer,\n LearnerSummaryConfig,\n};\nuse burn_core::lr_scheduler::LrScheduler;\nuse burn_core::module::AutodiffModule;\nuse burn_core::optim::Optimizer;\nuse burn_core::record::FileRecorder;\nuse burn_core::tensor::backend::AutodiffBackend;\n\n/// Struct to configure and create a [learner](Learner).\npub struct LearnerBuilder<B, T, V, M, O, S>\nwhere\n T: ItemLazy + 'static,\n V: ItemLazy + 'static,\n B: AutodiffBackend,\n M: AutodiffModule<B>,\n O: Optimizer<M, B>,\n S: LrScheduler,\n{\n // Not that complex and very convenient when the traits are\n // already constrained correctly. Extracting in another type\n // would be more complex.\n #[allow(clippy::type_complexity)]\n checkpointers: Option<(\n AsyncCheckpointer<M::Record, B>,\n AsyncCheckpointer<O::Record, B>,\n AsyncCheckpointer<S::Record<B>, B>,\n )>,\n num_epochs: usize,\n checkpoint: Option<usize>,\n directory: PathBuf,\n grad_accumulation: Option<usize>,\n devices: Vec<B::Device>,\n renderer: Option<Box<dyn MetricsRenderer + 'static>>,\n metrics: Metrics<T, V>,\n event_store: LogEventStore,\n interrupter: TrainingInterrupter,\n tracing_logger: Option<Box<dyn ApplicationLoggerInstaller>>,\n num_loggers: usize,\n checkpointer_strategy: Box<dyn CheckpointingStrategy>,\n early_stopping: Option<Box<dyn EarlyStoppingStrategy>>,\n summary_metrics: HashSet<String>,\n summary: bool,\n}\n\nimpl<B, T, V, M, O, S> LearnerBuilder<B, T, V, M, O, S>\nwhere\n B: AutodiffBackend,\n T: ItemLazy + 'static,\n V: ItemLazy + 'static,\n M: AutodiffModule<B> + core::fmt::Display + 'static,\n O: Optimizer<M, B>,\n S: LrScheduler,\n{\n /// Creates a new learner builder.\n ///\n /// # Arguments\n ///\n /// * `directory` - The directory to save the checkpoints.\n pub fn new(directory: impl AsRef<Path>) -> Self {\n let directory = directory.as_ref().to_path_buf();\n let experiment_log_file = directory.join(\"experiment.log\");\n Self {\n num_epochs: 1,\n checkpoint: None,\n checkpointers: None,\n directory,\n grad_accumulation: None,\n devices: vec![B::Device::default()],\n metrics: Metrics::default(),\n event_store: LogEventStore::default(),\n renderer: None,\n interrupter: TrainingInterrupter::new(),\n tracing_logger: Some(Box::new(FileApplicationLoggerInstaller::new(\n experiment_log_file,\n ))),\n num_loggers: 0,\n checkpointer_strategy: Box::new(\n ComposedCheckpointingStrategy::builder()\n .add(KeepLastNCheckpoints::new(2))\n .add(MetricCheckpointingStrategy::new(\n &LossMetric::<B>::new(), // default to valid loss\n Aggregate::Mean,\n Direction::Lowest,\n Split::Valid,\n ))\n .build(),\n ),\n early_stopping: None,\n summary_metrics: HashSet::new(),\n summary: false,\n }\n }\n\n /// Replace the default metric loggers with the provided ones.\n ///\n /// # Arguments\n ///\n /// * `logger_train` - The training logger.\n /// * `logger_valid` - The validation logger.\n pub fn metric_loggers<MT, MV>(mut self, logger_train: MT, logger_valid: MV) -> Self\n where\n MT: MetricLogger + 'static,\n MV: MetricLogger + 'static,\n {\n self.event_store.register_logger_train(logger_train);\n self.event_store.register_logger_valid(logger_valid);\n self.num_loggers += 1;\n self\n }\n\n /// Update the checkpointing_strategy.\n pub fn with_checkpointing_strategy<CS>(mut self, strategy: CS) -> Self\n where\n CS: CheckpointingStrategy + 'static,\n {\n self.checkpointer_strategy = Box::new(strategy);\n self\n }\n\n /// Replace the default CLI renderer with a custom one.\n ///\n /// # Arguments\n ///\n /// * `renderer` - The custom renderer.\n pub fn renderer<MR>(mut self, renderer: MR) -> Self\n where\n MR: MetricsRenderer + 'static,\n {\n self.renderer = Some(Box::new(renderer));\n self\n }\n\n /// Register a training metric.\n pub fn metric_train<Me: Metric + 'static>(mut self, metric: Me) -> Self\n where\n T::ItemSync: Adaptor<Me::Input>,\n {\n self.metrics.register_train_metric(metric);\n self\n }\n\n /// Register a validation metric.\n pub fn metric_valid<Me: Metric + 'static>(mut self, metric: Me) -> Self\n where\n V::ItemSync: Adaptor<Me::Input>,\n {\n self.metrics.register_valid_metric(metric);\n self\n }\n\n /// Enable gradients accumulation.\n ///\n /// # Notes\n ///\n /// When you enable gradients accumulation, the gradients object used by the optimizer will be\n /// the sum of all gradients generated by each backward pass. It might be a good idea to\n /// reduce the learning to compensate.\n ///\n /// The effect is similar to increasing the `batch size` and the `learning rate` by the `accumulation`\n /// amount.\n pub fn grads_accumulation(mut self, accumulation: usize) -> Self {\n self.grad_accumulation = Some(accumulation);\n self\n }\n\n /// Register a [numeric](crate::metric::Numeric) training [metric](Metric).\n pub fn metric_train_numeric<Me>(mut self, metric: Me) -> Self\n where\n Me: Metric + crate::metric::Numeric + 'static,\n T::ItemSync: Adaptor<Me::Input>,\n {\n self.summary_metrics.insert(metric.name());\n self.metrics.register_train_metric_numeric(metric);\n self\n }\n\n /// Register a [numeric](crate::metric::Numeric) validation [metric](Metric).\n pub fn metric_valid_numeric<Me: Metric + crate::metric::Numeric + 'static>(\n mut self,\n metric: Me,\n ) -> Self\n where\n V::ItemSync: Adaptor<Me::Input>,\n {\n self.summary_metrics.insert(metric.name());\n self.metrics.register_valid_metric_numeric(metric);\n self\n }\n\n /// The number of epochs the training should last.\n pub fn num_epochs(mut self, num_epochs: usize) -> Self {\n self.num_epochs = num_epochs;\n self\n }\n\n /// Run the training loop on multiple devices.\n pub fn devices(mut self, devices: Vec<B::Device>) -> Self {\n self.devices = devices;\n self\n }\n\n /// The epoch from which the training must resume.\n pub fn checkpoint(mut self, checkpoint: usize) -> Self {\n self.checkpoint = Some(checkpoint);\n self\n }\n\n /// Provides a handle that can be used to interrupt training.\n pub fn interrupter(&self) -> TrainingInterrupter {\n self.interrupter.clone()\n }\n\n /// Register an [early stopping strategy](EarlyStoppingStrategy) to stop the training when the\n /// conditions are meet.\n pub fn early_stopping<Strategy>(mut self, strategy: Strategy) -> Self\n where\n Strategy: EarlyStoppingStrategy + 'static,\n {\n self.early_stopping = Some(Box::new(strategy));\n self\n }\n\n /// By default, Rust logs are captured and written into\n /// `experiment.log`. If disabled, standard Rust log handling\n /// will apply.\n pub fn with_application_logger(\n mut self,\n logger: Option<Box<dyn ApplicationLoggerInstaller>>,\n ) -> Self {\n self.tracing_logger = logger;\n self\n }\n\n /// Register a checkpointer that will save the [optimizer](Optimizer), the\n /// [model](AutodiffModule) and the [scheduler](LrScheduler) to different files.\n pub fn with_file_checkpointer<FR>(mut self, recorder: FR) -> Self\n where\n FR: FileRecorder<B> + 'static,\n FR: FileRecorder<B::InnerBackend> + 'static,\n O::Record: 'static,\n M::Record: 'static,\n S::Record<B>: 'static,\n {\n let checkpoint_dir = self.directory.join(\"checkpoint\");\n let checkpointer_model = FileCheckpointer::new(recorder.clone(), &checkpoint_dir, \"model\");\n let checkpointer_optimizer =\n FileCheckpointer::new(recorder.clone(), &checkpoint_dir, \"optim\");\n let checkpointer_scheduler: FileCheckpointer<FR> =\n FileCheckpointer::new(recorder, &checkpoint_dir, \"scheduler\");\n\n self.checkpointers = Some((\n AsyncCheckpointer::new(checkpointer_model),\n AsyncCheckpointer::new(checkpointer_optimizer),\n AsyncCheckpointer::new(checkpointer_scheduler),\n ));\n\n self\n }\n\n /// Enable the training summary report.\n ///\n /// The summary will be displayed at the end of `.fit()`.\n pub fn summary(mut self) -> Self {\n self.summary = true;\n self\n }\n\n /// Create the [learner](Learner) from a [model](AutodiffModule) and an [optimizer](Optimizer).\n /// The [learning rate scheduler](LrScheduler) can also be a simple\n /// [learning rate](burn_core::LearningRate).\n #[allow(clippy::type_complexity)] // The goal for the builder is to handle all types and\n // creates a clean learner.\n pub fn build(\n mut self,\n model: M,\n optim: O,\n lr_scheduler: S,\n ) -> Learner<\n LearnerComponentsMarker<\n B,\n S,\n M,\n O,\n AsyncCheckpointer<M::Record, B>,\n AsyncCheckpointer<O::Record, B>,\n AsyncCheckpointer<S::Record<B>, B>,\n AsyncProcessor<FullEventProcessor<T, V>>,\n Box<dyn CheckpointingStrategy>,\n >,\n >\n where\n M::Record: 'static,\n O::Record: 'static,\n S::Record<B>: 'static,\n {\n if self.tracing_logger.is_some() {\n if let Err(e) = self.tracing_logger.as_ref().unwrap().install() {\n log::warn!(\"Failed to install the experiment logger: {}\", e);\n }\n }\n let renderer = self\n .renderer\n .unwrap_or_else(|| default_renderer(self.interrupter.clone(), self.checkpoint));\n\n if self.num_loggers == 0 {\n self.event_store\n .register_logger_train(FileMetricLogger::new(self.directory.join(\"train\")));\n self.event_store\n .register_logger_valid(FileMetricLogger::new(self.directory.join(\"valid\")));\n }\n\n let event_store = Arc::new(EventStoreClient::new(self.event_store));\n let event_processor = AsyncProcessor::new(FullEventProcessor::new(\n self.metrics,\n renderer,\n event_store.clone(),\n ));\n\n let checkpointer = self.checkpointers.map(|(model, optim, scheduler)| {\n LearnerCheckpointer::new(model, optim, scheduler, self.checkpointer_strategy)\n });\n\n let summary = if self.summary {\n Some(LearnerSummaryConfig {\n directory: self.directory,\n metrics: self.summary_metrics.into_iter().collect::<Vec<_>>(),\n })\n } else {\n None\n };\n\n Learner {\n model,\n optim,\n lr_scheduler,\n checkpointer,\n num_epochs: self.num_epochs,\n event_processor,\n event_store,\n checkpoint: self.checkpoint,\n grad_accumulation: self.grad_accumulation,\n devices: self.devices,\n interrupter: self.interrupter,\n early_stopping: self.early_stopping,\n summary,\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 366,\n \"name\": \"build\",\n \"signature\": \"pub fn build(\\n mut self,\\n model: M,\\n optim: O,\\n lr_scheduler: S,\\n ) -> Learner<\\n LearnerComponentsMarker<\\n B,\\n S,\\n M,\\n O,\\n AsyncCheckpointer<M::Record, B>,\\n AsyncCheckpointer<O::Record, B>,\\n AsyncCheckpointer<S::Record<B>, B>,\\n AsyncProcessor<FullEventProcessor<T, V>>,\\n Box<dyn CheckpointingStrategy>,\\n >,\\n >\",\n \"start_line\": 292\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<B, T, V, M, O, S> LearnerBuilder<B, T, V, M, O, S>\\nwhere\\n B: AutodiffBackend,\\n T: ItemLazy + 'static,\\n V: ItemLazy + 'static,\\n M: AutodiffModule<B> + core::fmt::Display + 'static,\\n O: Optimizer<M, B>,\\n S: LrScheduler,\\n{\\n /// Creates a new learner builder.\\n ///\\n /// # Arguments\\n ///\\n /// * `directory` - The directory to save the checkpoints.\\n pub fn new(directory: impl AsRef<Path>) -> Self {\\n let directory = directory.as_ref().to_path_buf();\\n let experiment_log_file = directory.join(\\\"experiment.log\\\");\\n Self {\\n num_epochs: 1,\\n checkpoint: None,\\n checkpointers: None,\\n directory,\\n grad_accumulation: None,\\n devices: vec![B::Device::default()],\\n metrics: Metrics::default(),\\n event_store: LogEventStore::default(),\\n renderer: None,\\n interrupter: TrainingInterrupter::new(),\\n tracing_logger: Some(Box::new(FileApplicationLoggerInstaller::new(\\n experiment_log_file,\\n ))),\\n num_loggers: 0,\\n checkpointer_strategy: Box::new(\\n ComposedCheckpointingStrategy::builder()\\n .add(KeepLastNCheckpoints::new(2))\\n .add(MetricCheckpointingStrategy::new(\\n &LossMetric::<B>::new(), // default to valid loss\\n Aggregate::Mean,\\n Direction::Lowest,\\n Split::Valid,\\n ))\\n .build(),\\n ),\\n early_stopping: None,\\n summary_metrics: HashSet::new(),\\n summary: false,\\n }\\n }\\n\\n /// Replace the default metric loggers with the provided ones.\\n ///\\n /// # Arguments\\n ///\\n /// * `logger_train` - The training logger.\\n /// * `logger_valid` - The validation logger.\\n pub fn metric_loggers<MT, MV>(mut self, logger_train: MT, logger_valid: MV) -> Self\\n where\\n MT: MetricLogger + 'static,\\n MV: MetricLogger + 'static,\\n {\\n self.event_store.register_logger_train(logger_train);\\n self.event_store.register_logger_valid(logger_valid);\\n self.num_loggers += 1;\\n self\\n }\\n\\n /// Update the checkpointing_strategy.\\n pub fn with_checkpointing_strategy<CS>(mut self, strategy: CS) -> Self\\n where\\n CS: CheckpointingStrategy + 'static,\\n {\\n self.checkpointer_strategy = Box::new(strategy);\\n self\\n }\\n\\n /// Replace the default CLI renderer with a custom one.\\n ///\\n /// # Arguments\\n ///\\n /// * `renderer` - The custom renderer.\\n pub fn renderer<MR>(mut self, renderer: MR) -> Self\\n where\\n MR: MetricsRenderer + 'static,\\n {\\n self.renderer = Some(Box::new(renderer));\\n self\\n }\\n\\n /// Register a training metric.\\n pub fn metric_train<Me: Metric + 'static>(mut self, metric: Me) -> Self\\n where\\n T::ItemSync: Adaptor<Me::Input>,\\n {\\n self.metrics.register_train_metric(metric);\\n self\\n }\\n\\n /// Register a validation metric.\\n pub fn metric_valid<Me: Metric + 'static>(mut self, metric: Me) -> Self\\n where\\n V::ItemSync: Adaptor<Me::Input>,\\n {\\n self.metrics.register_valid_metric(metric);\\n self\\n }\\n\\n /// Enable gradients accumulation.\\n ///\\n /// # Notes\\n ///\\n /// When you enable gradients accumulation, the gradients object used by the optimizer will be\\n /// the sum of all gradients generated by each backward pass. It might be a good idea to\\n /// reduce the learning to compensate.\\n ///\\n /// The effect is similar to increasing the `batch size` and the `learning rate` by the `accumulation`\\n /// amount.\\n pub fn grads_accumulation(mut self, accumulation: usize) -> Self {\\n self.grad_accumulation = Some(accumulation);\\n self\\n }\\n\\n /// Register a [numeric](crate::metric::Numeric) training [metric](Metric).\\n pub fn metric_train_numeric<Me>(mut self, metric: Me) -> Self\\n where\\n Me: Metric + crate::metric::Numeric + 'static,\\n T::ItemSync: Adaptor<Me::Input>,\\n {\\n self.summary_metrics.insert(metric.name());\\n self.metrics.register_train_metric_numeric(metric);\\n self\\n }\\n\\n /// Register a [numeric](crate::metric::Numeric) validation [metric](Metric).\\n pub fn metric_valid_numeric<Me: Metric + crate::metric::Numeric + 'static>(\\n mut self,\\n metric: Me,\\n ) -> Self\\n where\\n V::ItemSync: Adaptor<Me::Input>,\\n {\\n self.summary_metrics.insert(metric.name());\\n self.metrics.register_valid_metric_numeric(metric);\\n self\\n }\\n\\n /// The number of epochs the training should last.\\n pub fn num_epochs(mut self, num_epochs: usize) -> Self {\\n self.num_epochs = num_epochs;\\n self\\n }\\n\\n /// Run the training loop on multiple devices.\\n pub fn devices(mut self, devices: Vec<B::Device>) -> Self {\\n self.devices = devices;\\n self\\n }\\n\\n /// The epoch from which the training must resume.\\n pub fn checkpoint(mut self, checkpoint: usize) -> Self {\\n self.checkpoint = Some(checkpoint);\\n self\\n }\\n\\n /// Provides a handle that can be used to interrupt training.\\n pub fn interrupter(&self) -> TrainingInterrupter {\\n self.interrupter.clone()\\n }\\n\\n /// Register an [early stopping strategy](EarlyStoppingStrategy) to stop the training when the\\n /// conditions are meet.\\n pub fn early_stopping<Strategy>(mut self, strategy: Strategy) -> Self\\n where\\n Strategy: EarlyStoppingStrategy + 'static,\\n {\\n self.early_stopping = Some(Box::new(strategy));\\n self\\n }\\n\\n /// By default, Rust logs are captured and written into\\n /// `experiment.log`. If disabled, standard Rust log handling\\n /// will apply.\\n pub fn with_application_logger(\\n mut self,\\n logger: Option<Box<dyn ApplicationLoggerInstaller>>,\\n ) -> Self {\\n self.tracing_logger = logger;\\n self\\n }\\n\\n /// Register a checkpointer that will save the [optimizer](Optimizer), the\\n /// [model](AutodiffModule) and the [scheduler](LrScheduler) to different files.\\n pub fn with_file_checkpointer<FR>(mut self, recorder: FR) -> Self\\n where\\n FR: FileRecorder<B> + 'static,\\n FR: FileRecorder<B::InnerBackend> + 'static,\\n O::Record: 'static,\\n M::Record: 'static,\\n S::Record<B>: 'static,\\n {\\n let checkpoint_dir = self.directory.join(\\\"checkpoint\\\");\\n let checkpointer_model = FileCheckpointer::new(recorder.clone(), &checkpoint_dir, \\\"model\\\");\\n let checkpointer_optimizer =\\n FileCheckpointer::new(recorder.clone(), &checkpoint_dir, \\\"optim\\\");\\n let checkpointer_scheduler: FileCheckpointer<FR> =\\n FileCheckpointer::new(recorder, &checkpoint_dir, \\\"scheduler\\\");\\n\\n self.checkpointers = Some((\\n AsyncCheckpointer::new(checkpointer_model),\\n AsyncCheckpointer::new(checkpointer_optimizer),\\n AsyncCheckpointer::new(checkpointer_scheduler),\\n ));\\n\\n self\\n }\\n\\n /// Enable the training summary report.\\n ///\\n /// The summary will be displayed at the end of `.fit()`.\\n pub fn summary(mut self) -> Self {\\n self.summary = true;\\n self\\n }\\n\\n /// Create the [learner](Learner) from a [model](AutodiffModule) and an [optimizer](Optimizer).\\n /// The [learning rate scheduler](LrScheduler) can also be a simple\\n /// [learning rate](burn_core::LearningRate).\\n #[allow(clippy::type_complexity)] // The goal for the builder is to handle all types and\\n // creates a clean learner.\\n pub fn build(\\n mut self,\\n model: M,\\n optim: O,\\n lr_scheduler: S,\\n ) -> Learner<\\n LearnerComponentsMarker<\\n B,\\n S,\\n M,\\n O,\\n AsyncCheckpointer<M::Record, B>,\\n AsyncCheckpointer<O::Record, B>,\\n AsyncCheckpointer<S::Record<B>, B>,\\n AsyncProcessor<FullEventProcessor<T, V>>,\\n Box<dyn CheckpointingStrategy>,\\n >,\\n >\\n where\\n M::Record: 'static,\\n O::Record: 'static,\\n S::Record<B>: 'static,\\n {\\n if self.tracing_logger.is_some() {\\n if let Err(e) = self.tracing_logger.as_ref().unwrap().install() {\\n log::warn!(\\\"Failed to install the experiment logger: {}\\\", e);\\n }\\n }\\n let renderer = self\\n .renderer\\n .unwrap_or_else(|| default_renderer(self.interrupter.clone(), self.checkpoint));\\n\\n if self.num_loggers == 0 {\\n self.event_store\\n .register_logger_train(FileMetricLogger::new(self.directory.join(\\\"train\\\")));\\n self.event_store\\n .register_logger_valid(FileMetricLogger::new(self.directory.join(\\\"valid\\\")));\\n }\\n\\n let event_store = Arc::new(EventStoreClient::new(self.event_store));\\n let event_processor = AsyncProcessor::new(FullEventProcessor::new(\\n self.metrics,\\n renderer,\\n event_store.clone(),\\n ));\\n\\n let checkpointer = self.checkpointers.map(|(model, optim, scheduler)| {\\n LearnerCheckpointer::new(model, optim, scheduler, self.checkpointer_strategy)\\n });\\n\\n let summary = if self.summary {\\n Some(LearnerSummaryConfig {\\n directory: self.directory,\\n metrics: self.summary_metrics.into_iter().collect::<Vec<_>>(),\\n })\\n } else {\\n None\\n };\\n\\n Learner {\\n model,\\n optim,\\n lr_scheduler,\\n checkpointer,\\n num_epochs: self.num_epochs,\\n event_processor,\\n event_store,\\n checkpoint: self.checkpoint,\\n grad_accumulation: self.grad_accumulation,\\n devices: self.devices,\\n interrupter: self.interrupter,\\n early_stopping: self.early_stopping,\\n summary,\\n }\\n }\\n}\",\n \"class_signature\": \"impl<B, T, V, M, O, S> LearnerBuilder<B, T, V, M, O, S>\\nwhere\\n B: AutodiffBackend,\\n T: ItemLazy + 'static,\\n V: ItemLazy + 'static,\\n M: AutodiffModule<B> + core::fmt::Display + 'static,\\n O: Optimizer<M, B>,\\n S: LrScheduler,\"\n}"}}},{"rowIdx":172,"cells":{"function_name":{"kind":"string","value":"checkpointing"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/checkpoint/strategy/metric.rs"},"focal_code":{"kind":"string","value":"fn checkpointing(\n &mut self,\n epoch: usize,\n store: &EventStoreClient,\n ) -> Vec<CheckpointingAction> {\n let best_epoch =\n match store.find_epoch(&self.name, self.aggregate, self.direction, self.split) {\n Some(epoch_best) => epoch_best,\n None => epoch,\n };\n\n let mut actions = Vec::new();\n\n if let Some(current) = self.current {\n if current != best_epoch {\n actions.push(CheckpointingAction::Delete(current));\n }\n }\n\n if best_epoch == epoch {\n actions.push(CheckpointingAction::Save);\n }\n\n self.current = Some(best_epoch);\n\n actions\n }"},"file_content":{"kind":"string","value":"use super::CheckpointingStrategy;\nuse crate::{\n checkpoint::CheckpointingAction,\n metric::{\n Metric,\n store::{Aggregate, Direction, EventStoreClient, Split},\n },\n};\n\n/// Keep the best checkpoint based on a metric.\npub struct MetricCheckpointingStrategy {\n current: Option<usize>,\n aggregate: Aggregate,\n direction: Direction,\n split: Split,\n name: String,\n}\n\nimpl MetricCheckpointingStrategy {\n /// Create a new metric checkpointing strategy.\n pub fn new<M>(metric: &M, aggregate: Aggregate, direction: Direction, split: Split) -> Self\n where\n M: Metric,\n {\n Self {\n current: None,\n name: metric.name(),\n aggregate,\n direction,\n split,\n }\n }\n}\n\nimpl CheckpointingStrategy for MetricCheckpointingStrategy {\n fn checkpointing(\n &mut self,\n epoch: usize,\n store: &EventStoreClient,\n ) -> Vec<CheckpointingAction> {\n let best_epoch =\n match store.find_epoch(&self.name, self.aggregate, self.direction, self.split) {\n Some(epoch_best) => epoch_best,\n None => epoch,\n };\n\n let mut actions = Vec::new();\n\n if let Some(current) = self.current {\n if current != best_epoch {\n actions.push(CheckpointingAction::Delete(current));\n }\n }\n\n if best_epoch == epoch {\n actions.push(CheckpointingAction::Save);\n }\n\n self.current = Some(best_epoch);\n\n actions\n }\n}\n\n#[cfg(test)]\nmod tests {\n use crate::{\n TestBackend,\n logger::InMemoryMetricLogger,\n metric::{\n LossMetric,\n processor::{\n Metrics, MinimalEventProcessor,\n test_utils::{end_epoch, process_train},\n },\n store::LogEventStore,\n },\n };\n\n use super::*;\n use std::sync::Arc;\n\n #[test]\n fn always_keep_the_best_epoch() {\n let loss = LossMetric::<TestBackend>::new();\n let mut store = LogEventStore::default();\n let mut strategy = MetricCheckpointingStrategy::new(\n &loss,\n Aggregate::Mean,\n Direction::Lowest,\n Split::Train,\n );\n let mut metrics = Metrics::<f64, f64>::default();\n // Register an in memory logger.\n store.register_logger_train(InMemoryMetricLogger::default());\n // Register the loss metric.\n metrics.register_train_metric_numeric(loss);\n let store = Arc::new(EventStoreClient::new(store));\n let mut processor = MinimalEventProcessor::new(metrics, store.clone());\n\n // Two points for the first epoch. Mean 0.75\n let mut epoch = 1;\n process_train(&mut processor, 1.0, epoch);\n process_train(&mut processor, 0.5, epoch);\n end_epoch(&mut processor, epoch);\n\n // Should save the current record.\n assert_eq!(\n vec![CheckpointingAction::Save],\n strategy.checkpointing(epoch, &store)\n );\n\n // Two points for the second epoch. Mean 0.4\n epoch += 1;\n process_train(&mut processor, 0.5, epoch);\n process_train(&mut processor, 0.3, epoch);\n end_epoch(&mut processor, epoch);\n\n // Should save the current record and delete the previous one.\n assert_eq!(\n vec![CheckpointingAction::Delete(1), CheckpointingAction::Save],\n strategy.checkpointing(epoch, &store)\n );\n\n // Two points for the last epoch. Mean 2.0\n epoch += 1;\n process_train(&mut processor, 1.0, epoch);\n process_train(&mut processor, 3.0, epoch);\n end_epoch(&mut processor, epoch);\n\n // Should not delete the previous record, since it's the best one, and should not save a\n // new one.\n assert!(strategy.checkpointing(epoch, &store).is_empty());\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct EventStoreClient {\\n sender: mpsc::Sender<Message>,\\n handler: Option<JoinHandle<()>>,\\n}\"\n ],\n \"name\": \"store\",\n \"type\": \"&EventStoreClient\"\n }\n ],\n \"end_line\": 62,\n \"name\": \"checkpointing\",\n \"signature\": \"fn checkpointing(\\n &mut self,\\n epoch: usize,\\n store: &EventStoreClient,\\n ) -> Vec<CheckpointingAction>\",\n \"start_line\": 36\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl CheckpointingStrategy for MetricCheckpointingStrategy {\\n fn checkpointing(\\n &mut self,\\n epoch: usize,\\n store: &EventStoreClient,\\n ) -> Vec<CheckpointingAction> {\\n let best_epoch =\\n match store.find_epoch(&self.name, self.aggregate, self.direction, self.split) {\\n Some(epoch_best) => epoch_best,\\n None => epoch,\\n };\\n\\n let mut actions = Vec::new();\\n\\n if let Some(current) = self.current {\\n if current != best_epoch {\\n actions.push(CheckpointingAction::Delete(current));\\n }\\n }\\n\\n if best_epoch == epoch {\\n actions.push(CheckpointingAction::Save);\\n }\\n\\n self.current = Some(best_epoch);\\n\\n actions\\n }\\n}\",\n \"class_signature\": \"impl CheckpointingStrategy for MetricCheckpointingStrategy\"\n}"}}},{"rowIdx":173,"cells":{"function_name":{"kind":"string","value":"checkpointing"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/checkpoint/strategy/composed.rs"},"focal_code":{"kind":"string","value":"fn checkpointing(\n &mut self,\n epoch: usize,\n collector: &EventStoreClient,\n ) -> Vec<CheckpointingAction> {\n let mut saved = false;\n let mut actions = Vec::new();\n let mut epochs_to_check = Vec::new();\n\n for (i, strategy) in self.strategies.iter_mut().enumerate() {\n let actions = strategy.checkpointing(epoch, collector);\n // We assume that the strategy would not want the current epoch to be saved.\n // So we flag it as deleted.\n if actions.is_empty() {\n self.deleted\n .get_mut(i)\n .expect(\"As many 'deleted' as 'strategies'.\")\n .insert(epoch);\n }\n\n for action in actions {\n match action {\n CheckpointingAction::Delete(epoch) => {\n self.deleted\n .get_mut(i)\n .expect(\"As many 'deleted' as 'strategies'.\")\n .insert(epoch);\n epochs_to_check.push(epoch);\n }\n CheckpointingAction::Save => saved = true,\n }\n }\n }\n\n if saved {\n actions.push(CheckpointingAction::Save);\n }\n\n for epoch in epochs_to_check.into_iter() {\n let mut num_true = 0;\n for i in 0..self.strategies.len() {\n if self\n .deleted\n .get(i)\n .expect(\"Ad many 'deleted' as 'strategies'.\")\n .contains(&epoch)\n {\n num_true += 1;\n }\n }\n\n if num_true == self.strategies.len() {\n actions.push(CheckpointingAction::Delete(epoch));\n\n for i in 0..self.strategies.len() {\n self.deleted\n .get_mut(i)\n .expect(\"As many 'deleted' as 'strategies'.\")\n .remove(&epoch);\n }\n }\n }\n\n actions\n }"},"file_content":{"kind":"string","value":"use crate::metric::store::EventStoreClient;\n\nuse super::{CheckpointingAction, CheckpointingStrategy};\nuse std::collections::HashSet;\n\n/// Compose multiple checkpointing strategy and only delete checkpoints when both strategy flag an\n/// epoch to be deleted.\npub struct ComposedCheckpointingStrategy {\n strategies: Vec<Box<dyn CheckpointingStrategy>>,\n deleted: Vec<HashSet<usize>>,\n}\n\n/// Help building a [checkpointing strategy](CheckpointingStrategy) by combining multiple ones.\n#[derive(Default)]\npub struct ComposedCheckpointingStrategyBuilder {\n strategies: Vec<Box<dyn CheckpointingStrategy>>,\n}\n\nimpl ComposedCheckpointingStrategyBuilder {\n /// Add a new [checkpointing strategy](CheckpointingStrategy).\n #[allow(clippy::should_implement_trait)]\n pub fn add<S>(mut self, strategy: S) -> Self\n where\n S: CheckpointingStrategy + 'static,\n {\n self.strategies.push(Box::new(strategy));\n self\n }\n\n /// Create a new [composed checkpointing strategy](ComposedCheckpointingStrategy).\n pub fn build(self) -> ComposedCheckpointingStrategy {\n ComposedCheckpointingStrategy::new(self.strategies)\n }\n}\n\nimpl ComposedCheckpointingStrategy {\n fn new(strategies: Vec<Box<dyn CheckpointingStrategy>>) -> Self {\n Self {\n deleted: strategies.iter().map(|_| HashSet::new()).collect(),\n strategies,\n }\n }\n /// Create a new builder which help compose multiple\n /// [checkpointing strategies](CheckpointingStrategy).\n pub fn builder() -> ComposedCheckpointingStrategyBuilder {\n ComposedCheckpointingStrategyBuilder::default()\n }\n}\n\nimpl CheckpointingStrategy for ComposedCheckpointingStrategy {\n fn checkpointing(\n &mut self,\n epoch: usize,\n collector: &EventStoreClient,\n ) -> Vec<CheckpointingAction> {\n let mut saved = false;\n let mut actions = Vec::new();\n let mut epochs_to_check = Vec::new();\n\n for (i, strategy) in self.strategies.iter_mut().enumerate() {\n let actions = strategy.checkpointing(epoch, collector);\n // We assume that the strategy would not want the current epoch to be saved.\n // So we flag it as deleted.\n if actions.is_empty() {\n self.deleted\n .get_mut(i)\n .expect(\"As many 'deleted' as 'strategies'.\")\n .insert(epoch);\n }\n\n for action in actions {\n match action {\n CheckpointingAction::Delete(epoch) => {\n self.deleted\n .get_mut(i)\n .expect(\"As many 'deleted' as 'strategies'.\")\n .insert(epoch);\n epochs_to_check.push(epoch);\n }\n CheckpointingAction::Save => saved = true,\n }\n }\n }\n\n if saved {\n actions.push(CheckpointingAction::Save);\n }\n\n for epoch in epochs_to_check.into_iter() {\n let mut num_true = 0;\n for i in 0..self.strategies.len() {\n if self\n .deleted\n .get(i)\n .expect(\"Ad many 'deleted' as 'strategies'.\")\n .contains(&epoch)\n {\n num_true += 1;\n }\n }\n\n if num_true == self.strategies.len() {\n actions.push(CheckpointingAction::Delete(epoch));\n\n for i in 0..self.strategies.len() {\n self.deleted\n .get_mut(i)\n .expect(\"As many 'deleted' as 'strategies'.\")\n .remove(&epoch);\n }\n }\n }\n\n actions\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use crate::{checkpoint::KeepLastNCheckpoints, metric::store::LogEventStore};\n\n #[test]\n fn should_delete_when_both_deletes() {\n let store = EventStoreClient::new(LogEventStore::default());\n let mut strategy = ComposedCheckpointingStrategy::builder()\n .add(KeepLastNCheckpoints::new(1))\n .add(KeepLastNCheckpoints::new(2))\n .build();\n\n assert_eq!(\n vec![CheckpointingAction::Save],\n strategy.checkpointing(1, &store)\n );\n\n assert_eq!(\n vec![CheckpointingAction::Save],\n strategy.checkpointing(2, &store)\n );\n\n assert_eq!(\n vec![CheckpointingAction::Save, CheckpointingAction::Delete(1)],\n strategy.checkpointing(3, &store)\n );\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct EventStoreClient {\\n sender: mpsc::Sender<Message>,\\n handler: Option<JoinHandle<()>>,\\n}\"\n ],\n \"name\": \"collector\",\n \"type\": \"&EventStoreClient\"\n }\n ],\n \"end_line\": 115,\n \"name\": \"checkpointing\",\n \"signature\": \"fn checkpointing(\\n &mut self,\\n epoch: usize,\\n collector: &EventStoreClient,\\n ) -> Vec<CheckpointingAction>\",\n \"start_line\": 51\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl CheckpointingStrategy for ComposedCheckpointingStrategy {\\n fn checkpointing(\\n &mut self,\\n epoch: usize,\\n collector: &EventStoreClient,\\n ) -> Vec<CheckpointingAction> {\\n let mut saved = false;\\n let mut actions = Vec::new();\\n let mut epochs_to_check = Vec::new();\\n\\n for (i, strategy) in self.strategies.iter_mut().enumerate() {\\n let actions = strategy.checkpointing(epoch, collector);\\n // We assume that the strategy would not want the current epoch to be saved.\\n // So we flag it as deleted.\\n if actions.is_empty() {\\n self.deleted\\n .get_mut(i)\\n .expect(\\\"As many 'deleted' as 'strategies'.\\\")\\n .insert(epoch);\\n }\\n\\n for action in actions {\\n match action {\\n CheckpointingAction::Delete(epoch) => {\\n self.deleted\\n .get_mut(i)\\n .expect(\\\"As many 'deleted' as 'strategies'.\\\")\\n .insert(epoch);\\n epochs_to_check.push(epoch);\\n }\\n CheckpointingAction::Save => saved = true,\\n }\\n }\\n }\\n\\n if saved {\\n actions.push(CheckpointingAction::Save);\\n }\\n\\n for epoch in epochs_to_check.into_iter() {\\n let mut num_true = 0;\\n for i in 0..self.strategies.len() {\\n if self\\n .deleted\\n .get(i)\\n .expect(\\\"Ad many 'deleted' as 'strategies'.\\\")\\n .contains(&epoch)\\n {\\n num_true += 1;\\n }\\n }\\n\\n if num_true == self.strategies.len() {\\n actions.push(CheckpointingAction::Delete(epoch));\\n\\n for i in 0..self.strategies.len() {\\n self.deleted\\n .get_mut(i)\\n .expect(\\\"As many 'deleted' as 'strategies'.\\\")\\n .remove(&epoch);\\n }\\n }\\n }\\n\\n actions\\n }\\n}\",\n \"class_signature\": \"impl CheckpointingStrategy for ComposedCheckpointingStrategy\"\n}"}}},{"rowIdx":174,"cells":{"function_name":{"kind":"string","value":"aggregate"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/metric/store/aggregate.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn aggregate(\n &mut self,\n name: &str,\n epoch: usize,\n aggregate: Aggregate,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<f64> {\n let key = Key::new(name.to_string(), epoch, aggregate);\n\n if let Some(value) = self.value_for_each_epoch.get(&key) {\n return Some(*value);\n }\n\n let points = || {\n let mut errors = Vec::new();\n for logger in loggers {\n match logger.read_numeric(name, epoch) {\n Ok(points) => return Ok(points),\n Err(err) => errors.push(err),\n };\n }\n\n Err(errors.join(\" \"))\n };\n\n let points = points().expect(\"Can read values\");\n\n if points.is_empty() {\n return None;\n }\n\n // Accurately compute the aggregated value based on the *actual* number of points\n // since not all mini-batches are guaranteed to have the specified batch size\n let (sum, num_points) = points\n .into_iter()\n .map(|entry| match entry {\n NumericEntry::Value(v) => (v, 1),\n // Right now the mean is the only aggregate available, so we can assume that the sum\n // of an entry corresponds to (value * number of elements)\n NumericEntry::Aggregated(v, n) => (v * n as f64, n),\n })\n .reduce(|(acc_v, acc_n), (v, n)| (acc_v + v, acc_n + n))\n .unwrap();\n let value = match aggregate {\n Aggregate::Mean => sum / num_points as f64,\n };\n\n self.value_for_each_epoch.insert(key, value);\n Some(value)\n }"},"file_content":{"kind":"string","value":"use crate::{logger::MetricLogger, metric::NumericEntry};\nuse std::collections::HashMap;\n\nuse super::{Aggregate, Direction};\n\n/// Type that can be used to fetch and use numeric metric aggregates.\n#[derive(Default, Debug)]\npub(crate) struct NumericMetricsAggregate {\n value_for_each_epoch: HashMap<Key, f64>,\n}\n\n#[derive(new, Hash, PartialEq, Eq, Debug)]\nstruct Key {\n name: String,\n epoch: usize,\n aggregate: Aggregate,\n}\n\nimpl NumericMetricsAggregate {\n pub(crate) fn aggregate(\n &mut self,\n name: &str,\n epoch: usize,\n aggregate: Aggregate,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<f64> {\n let key = Key::new(name.to_string(), epoch, aggregate);\n\n if let Some(value) = self.value_for_each_epoch.get(&key) {\n return Some(*value);\n }\n\n let points = || {\n let mut errors = Vec::new();\n for logger in loggers {\n match logger.read_numeric(name, epoch) {\n Ok(points) => return Ok(points),\n Err(err) => errors.push(err),\n };\n }\n\n Err(errors.join(\" \"))\n };\n\n let points = points().expect(\"Can read values\");\n\n if points.is_empty() {\n return None;\n }\n\n // Accurately compute the aggregated value based on the *actual* number of points\n // since not all mini-batches are guaranteed to have the specified batch size\n let (sum, num_points) = points\n .into_iter()\n .map(|entry| match entry {\n NumericEntry::Value(v) => (v, 1),\n // Right now the mean is the only aggregate available, so we can assume that the sum\n // of an entry corresponds to (value * number of elements)\n NumericEntry::Aggregated(v, n) => (v * n as f64, n),\n })\n .reduce(|(acc_v, acc_n), (v, n)| (acc_v + v, acc_n + n))\n .unwrap();\n let value = match aggregate {\n Aggregate::Mean => sum / num_points as f64,\n };\n\n self.value_for_each_epoch.insert(key, value);\n Some(value)\n }\n\n pub(crate) fn find_epoch(\n &mut self,\n name: &str,\n aggregate: Aggregate,\n direction: Direction,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<usize> {\n let mut data = Vec::new();\n let mut current_epoch = 1;\n\n while let Some(value) = self.aggregate(name, current_epoch, aggregate, loggers) {\n data.push(value);\n current_epoch += 1;\n }\n\n if data.is_empty() {\n return None;\n }\n\n let mut current_value = match &direction {\n Direction::Lowest => f64::MAX,\n Direction::Highest => f64::MIN,\n };\n\n for (i, value) in data.into_iter().enumerate() {\n match &direction {\n Direction::Lowest => {\n if value < current_value {\n current_value = value;\n current_epoch = i + 1;\n }\n }\n Direction::Highest => {\n if value > current_value {\n current_value = value;\n current_epoch = i + 1;\n }\n }\n }\n }\n\n Some(current_epoch)\n }\n}\n\n#[cfg(test)]\nmod tests {\n use crate::{\n logger::{FileMetricLogger, InMemoryMetricLogger},\n metric::MetricEntry,\n };\n\n use super::*;\n\n struct TestLogger {\n logger: FileMetricLogger,\n epoch: usize,\n }\n const NAME: &str = \"test-logger\";\n\n impl TestLogger {\n fn new() -> Self {\n Self {\n logger: FileMetricLogger::new(\"/tmp\"),\n epoch: 1,\n }\n }\n fn log(&mut self, num: f64) {\n self.logger.log(&MetricEntry::new(\n NAME.into(),\n num.to_string(),\n num.to_string(),\n ));\n }\n fn new_epoch(&mut self) {\n self.logger.end_epoch(self.epoch);\n self.epoch += 1;\n }\n }\n\n #[test]\n fn should_find_epoch() {\n let mut logger = TestLogger::new();\n let mut aggregate = NumericMetricsAggregate::default();\n\n logger.log(500.); // Epoch 1\n logger.log(1000.); // Epoch 1\n logger.new_epoch();\n logger.log(200.); // Epoch 2\n logger.log(1000.); // Epoch 2\n logger.new_epoch();\n logger.log(10000.); // Epoch 3\n\n let value = aggregate\n .find_epoch(\n NAME,\n Aggregate::Mean,\n Direction::Lowest,\n &mut [Box::new(logger.logger)],\n )\n .unwrap();\n\n assert_eq!(value, 2);\n }\n\n #[test]\n fn should_aggregate_numeric_entry() {\n let mut logger = InMemoryMetricLogger::default();\n let mut aggregate = NumericMetricsAggregate::default();\n let metric_name = \"Loss\";\n\n // Epoch 1\n let loss_1 = 0.5;\n let loss_2 = 1.25; // (1.5 + 1.0) / 2 = 2.5 / 2\n let entry = MetricEntry::new(\n metric_name.to_string(),\n loss_1.to_string(),\n NumericEntry::Value(loss_1).serialize(),\n );\n logger.log(&entry);\n let entry = MetricEntry::new(\n metric_name.to_string(),\n loss_2.to_string(),\n NumericEntry::Aggregated(loss_2, 2).serialize(),\n );\n logger.log(&entry);\n\n let value = aggregate\n .aggregate(metric_name, 1, Aggregate::Mean, &mut [Box::new(logger)])\n .unwrap();\n\n // Average should be (0.5 + 1.25 * 2) / 3 = 1.0, not (0.5 + 1.25) / 2 = 0.875\n assert_eq!(value, 1.0);\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub enum Aggregate {\\n /// Compute the average.\\n Mean,\\n}\"\n ],\n \"name\": \"aggregate\",\n \"type\": \"Aggregate\"\n },\n {\n \"definitions\": [\n \"impl<T> Box<T> {\\n /// Allocates memory on the heap and then places `x` into it.\\n ///\\n /// This doesn't actually allocate if `T` is zero-sized.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// let five = Box::new(5);\\n /// ```\\n #[cfg(not(no_global_oom_handling))]\\n #[inline(always)]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n #[must_use]\\n #[rustc_diagnostic_item = \\\"box_new\\\"]\\n #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces\\n pub fn new(x: T) -> Self {\\n return box_new(x);\\n }\\n\\n /// Constructs a new box with uninitialized contents.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// let mut five = Box::<u32>::new_uninit();\\n /// // Deferred initialization:\\n /// five.write(5);\\n /// let five = unsafe { five.assume_init() };\\n ///\\n /// assert_eq!(*five, 5)\\n /// ```\\n #[cfg(not(no_global_oom_handling))]\\n #[stable(feature = \\\"new_uninit\\\", since = \\\"1.82.0\\\")]\\n #[must_use]\\n #[inline]\\n pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {\\n Self::new_uninit_in(Global)\\n }\\n\\n /// Constructs a new `Box` with uninitialized contents, with the memory\\n /// being filled with `0` bytes.\\n ///\\n /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage\\n /// of this method.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(new_zeroed_alloc)]\\n ///\\n /// let zero = Box::<u32>::new_zeroed();\\n /// let zero = unsafe { zero.assume_init() };\\n ///\\n /// assert_eq!(*zero, 0)\\n /// ```\\n ///\\n /// [zeroed]: mem::MaybeUninit::zeroed\\n #[cfg(not(no_global_oom_handling))]\\n #[inline]\\n #[unstable(feature = \\\"new_zeroed_alloc\\\", issue = \\\"129396\\\")]\\n #[must_use]\\n pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {\\n Self::new_zeroed_in(Global)\\n }\\n\\n /// Constructs a new `Pin<Box<T>>`. If `T` does not implement [`Unpin`], then\\n /// `x` will be pinned in memory and unable to be moved.\\n ///\\n /// Constructing and pinning of the `Box` can also be done in two steps: `Box::pin(x)`\\n /// does the same as <code>[Box::into_pin]\\\\([Box::new]\\\\(x))</code>. Consider using\\n /// [`into_pin`](Box::into_pin) if you already have a `Box<T>`, or if you want to\\n /// construct a (pinned) `Box` in a different way than with [`Box::new`].\\n #[cfg(not(no_global_oom_handling))]\\n #[stable(feature = \\\"pin\\\", since = \\\"1.33.0\\\")]\\n #[must_use]\\n #[inline(always)]\\n pub fn pin(x: T) -> Pin<Box<T>> {\\n Box::new(x).into()\\n }\\n\\n /// Allocates memory on the heap then places `x` into it,\\n /// returning an error if the allocation fails\\n ///\\n /// This doesn't actually allocate if `T` is zero-sized.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(allocator_api)]\\n ///\\n /// let five = Box::try_new(5)?;\\n /// # Ok::<(), std::alloc::AllocError>(())\\n /// ```\\n #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")]\\n #[inline]\\n pub fn try_new(x: T) -> Result<Self, AllocError> {\\n Self::try_new_in(x, Global)\\n }\\n\\n /// Constructs a new box with uninitialized contents on the heap,\\n /// returning an error if the allocation fails\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(allocator_api)]\\n ///\\n /// let mut five = Box::<u32>::try_new_uninit()?;\\n /// // Deferred initialization:\\n /// five.write(5);\\n /// let five = unsafe { five.assume_init() };\\n ///\\n /// assert_eq!(*five, 5);\\n /// # Ok::<(), std::alloc::AllocError>(())\\n /// ```\\n #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")]\\n // #[unstable(feature = \\\"new_uninit\\\", issue = \\\"63291\\\")]\\n #[inline]\\n pub fn try_new_uninit() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {\\n Box::try_new_uninit_in(Global)\\n }\\n\\n /// Constructs a new `Box` with uninitialized contents, with the memory\\n /// being filled with `0` bytes on the heap\\n ///\\n /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage\\n /// of this method.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(allocator_api)]\\n ///\\n /// let zero = Box::<u32>::try_new_zeroed()?;\\n /// let zero = unsafe { zero.assume_init() };\\n ///\\n /// assert_eq!(*zero, 0);\\n /// # Ok::<(), std::alloc::AllocError>(())\\n /// ```\\n ///\\n /// [zeroed]: mem::MaybeUninit::zeroed\\n #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")]\\n // #[unstable(feature = \\\"new_uninit\\\", issue = \\\"63291\\\")]\\n #[inline]\\n pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {\\n Box::try_new_zeroed_in(Global)\\n }\\n}\"\n ],\n \"name\": \"loggers\",\n \"type\": \"&mut [Box<dyn MetricLogger>]\"\n }\n ],\n \"end_line\": 69,\n \"name\": \"aggregate\",\n \"signature\": \"pub(crate) fn aggregate(\\n &mut self,\\n name: &str,\\n epoch: usize,\\n aggregate: Aggregate,\\n loggers: &mut [Box<dyn MetricLogger>],\\n ) -> Option<f64>\",\n \"start_line\": 20\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl NumericMetricsAggregate {\\n pub(crate) fn aggregate(\\n &mut self,\\n name: &str,\\n epoch: usize,\\n aggregate: Aggregate,\\n loggers: &mut [Box<dyn MetricLogger>],\\n ) -> Option<f64> {\\n let key = Key::new(name.to_string(), epoch, aggregate);\\n\\n if let Some(value) = self.value_for_each_epoch.get(&key) {\\n return Some(*value);\\n }\\n\\n let points = || {\\n let mut errors = Vec::new();\\n for logger in loggers {\\n match logger.read_numeric(name, epoch) {\\n Ok(points) => return Ok(points),\\n Err(err) => errors.push(err),\\n };\\n }\\n\\n Err(errors.join(\\\" \\\"))\\n };\\n\\n let points = points().expect(\\\"Can read values\\\");\\n\\n if points.is_empty() {\\n return None;\\n }\\n\\n // Accurately compute the aggregated value based on the *actual* number of points\\n // since not all mini-batches are guaranteed to have the specified batch size\\n let (sum, num_points) = points\\n .into_iter()\\n .map(|entry| match entry {\\n NumericEntry::Value(v) => (v, 1),\\n // Right now the mean is the only aggregate available, so we can assume that the sum\\n // of an entry corresponds to (value * number of elements)\\n NumericEntry::Aggregated(v, n) => (v * n as f64, n),\\n })\\n .reduce(|(acc_v, acc_n), (v, n)| (acc_v + v, acc_n + n))\\n .unwrap();\\n let value = match aggregate {\\n Aggregate::Mean => sum / num_points as f64,\\n };\\n\\n self.value_for_each_epoch.insert(key, value);\\n Some(value)\\n }\\n\\n pub(crate) fn find_epoch(\\n &mut self,\\n name: &str,\\n aggregate: Aggregate,\\n direction: Direction,\\n loggers: &mut [Box<dyn MetricLogger>],\\n ) -> Option<usize> {\\n let mut data = Vec::new();\\n let mut current_epoch = 1;\\n\\n while let Some(value) = self.aggregate(name, current_epoch, aggregate, loggers) {\\n data.push(value);\\n current_epoch += 1;\\n }\\n\\n if data.is_empty() {\\n return None;\\n }\\n\\n let mut current_value = match &direction {\\n Direction::Lowest => f64::MAX,\\n Direction::Highest => f64::MIN,\\n };\\n\\n for (i, value) in data.into_iter().enumerate() {\\n match &direction {\\n Direction::Lowest => {\\n if value < current_value {\\n current_value = value;\\n current_epoch = i + 1;\\n }\\n }\\n Direction::Highest => {\\n if value > current_value {\\n current_value = value;\\n current_epoch = i + 1;\\n }\\n }\\n }\\n }\\n\\n Some(current_epoch)\\n }\\n}\",\n \"class_signature\": \"impl NumericMetricsAggregate\"\n}"}}},{"rowIdx":175,"cells":{"function_name":{"kind":"string","value":"find_epoch"},"file_path":{"kind":"string","value":"burn-main/crates/burn-train/src/metric/store/aggregate.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn find_epoch(\n &mut self,\n name: &str,\n aggregate: Aggregate,\n direction: Direction,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<usize> {\n let mut data = Vec::new();\n let mut current_epoch = 1;\n\n while let Some(value) = self.aggregate(name, current_epoch, aggregate, loggers) {\n data.push(value);\n current_epoch += 1;\n }\n\n if data.is_empty() {\n return None;\n }\n\n let mut current_value = match &direction {\n Direction::Lowest => f64::MAX,\n Direction::Highest => f64::MIN,\n };\n\n for (i, value) in data.into_iter().enumerate() {\n match &direction {\n Direction::Lowest => {\n if value < current_value {\n current_value = value;\n current_epoch = i + 1;\n }\n }\n Direction::Highest => {\n if value > current_value {\n current_value = value;\n current_epoch = i + 1;\n }\n }\n }\n }\n\n Some(current_epoch)\n }"},"file_content":{"kind":"string","value":"use crate::{logger::MetricLogger, metric::NumericEntry};\nuse std::collections::HashMap;\n\nuse super::{Aggregate, Direction};\n\n/// Type that can be used to fetch and use numeric metric aggregates.\n#[derive(Default, Debug)]\npub(crate) struct NumericMetricsAggregate {\n value_for_each_epoch: HashMap<Key, f64>,\n}\n\n#[derive(new, Hash, PartialEq, Eq, Debug)]\nstruct Key {\n name: String,\n epoch: usize,\n aggregate: Aggregate,\n}\n\nimpl NumericMetricsAggregate {\n pub(crate) fn aggregate(\n &mut self,\n name: &str,\n epoch: usize,\n aggregate: Aggregate,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<f64> {\n let key = Key::new(name.to_string(), epoch, aggregate);\n\n if let Some(value) = self.value_for_each_epoch.get(&key) {\n return Some(*value);\n }\n\n let points = || {\n let mut errors = Vec::new();\n for logger in loggers {\n match logger.read_numeric(name, epoch) {\n Ok(points) => return Ok(points),\n Err(err) => errors.push(err),\n };\n }\n\n Err(errors.join(\" \"))\n };\n\n let points = points().expect(\"Can read values\");\n\n if points.is_empty() {\n return None;\n }\n\n // Accurately compute the aggregated value based on the *actual* number of points\n // since not all mini-batches are guaranteed to have the specified batch size\n let (sum, num_points) = points\n .into_iter()\n .map(|entry| match entry {\n NumericEntry::Value(v) => (v, 1),\n // Right now the mean is the only aggregate available, so we can assume that the sum\n // of an entry corresponds to (value * number of elements)\n NumericEntry::Aggregated(v, n) => (v * n as f64, n),\n })\n .reduce(|(acc_v, acc_n), (v, n)| (acc_v + v, acc_n + n))\n .unwrap();\n let value = match aggregate {\n Aggregate::Mean => sum / num_points as f64,\n };\n\n self.value_for_each_epoch.insert(key, value);\n Some(value)\n }\n\n pub(crate) fn find_epoch(\n &mut self,\n name: &str,\n aggregate: Aggregate,\n direction: Direction,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<usize> {\n let mut data = Vec::new();\n let mut current_epoch = 1;\n\n while let Some(value) = self.aggregate(name, current_epoch, aggregate, loggers) {\n data.push(value);\n current_epoch += 1;\n }\n\n if data.is_empty() {\n return None;\n }\n\n let mut current_value = match &direction {\n Direction::Lowest => f64::MAX,\n Direction::Highest => f64::MIN,\n };\n\n for (i, value) in data.into_iter().enumerate() {\n match &direction {\n Direction::Lowest => {\n if value < current_value {\n current_value = value;\n current_epoch = i + 1;\n }\n }\n Direction::Highest => {\n if value > current_value {\n current_value = value;\n current_epoch = i + 1;\n }\n }\n }\n }\n\n Some(current_epoch)\n }\n}\n\n#[cfg(test)]\nmod tests {\n use crate::{\n logger::{FileMetricLogger, InMemoryMetricLogger},\n metric::MetricEntry,\n };\n\n use super::*;\n\n struct TestLogger {\n logger: FileMetricLogger,\n epoch: usize,\n }\n const NAME: &str = \"test-logger\";\n\n impl TestLogger {\n fn new() -> Self {\n Self {\n logger: FileMetricLogger::new(\"/tmp\"),\n epoch: 1,\n }\n }\n fn log(&mut self, num: f64) {\n self.logger.log(&MetricEntry::new(\n NAME.into(),\n num.to_string(),\n num.to_string(),\n ));\n }\n fn new_epoch(&mut self) {\n self.logger.end_epoch(self.epoch);\n self.epoch += 1;\n }\n }\n\n #[test]\n fn should_find_epoch() {\n let mut logger = TestLogger::new();\n let mut aggregate = NumericMetricsAggregate::default();\n\n logger.log(500.); // Epoch 1\n logger.log(1000.); // Epoch 1\n logger.new_epoch();\n logger.log(200.); // Epoch 2\n logger.log(1000.); // Epoch 2\n logger.new_epoch();\n logger.log(10000.); // Epoch 3\n\n let value = aggregate\n .find_epoch(\n NAME,\n Aggregate::Mean,\n Direction::Lowest,\n &mut [Box::new(logger.logger)],\n )\n .unwrap();\n\n assert_eq!(value, 2);\n }\n\n #[test]\n fn should_aggregate_numeric_entry() {\n let mut logger = InMemoryMetricLogger::default();\n let mut aggregate = NumericMetricsAggregate::default();\n let metric_name = \"Loss\";\n\n // Epoch 1\n let loss_1 = 0.5;\n let loss_2 = 1.25; // (1.5 + 1.0) / 2 = 2.5 / 2\n let entry = MetricEntry::new(\n metric_name.to_string(),\n loss_1.to_string(),\n NumericEntry::Value(loss_1).serialize(),\n );\n logger.log(&entry);\n let entry = MetricEntry::new(\n metric_name.to_string(),\n loss_2.to_string(),\n NumericEntry::Aggregated(loss_2, 2).serialize(),\n );\n logger.log(&entry);\n\n let value = aggregate\n .aggregate(metric_name, 1, Aggregate::Mean, &mut [Box::new(logger)])\n .unwrap();\n\n // Average should be (0.5 + 1.25 * 2) / 3 = 1.0, not (0.5 + 1.25) / 2 = 0.875\n assert_eq!(value, 1.0);\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub enum Aggregate {\\n /// Compute the average.\\n Mean,\\n}\"\n ],\n \"name\": \"aggregate\",\n \"type\": \"Aggregate\"\n },\n {\n \"definitions\": [\n \"pub enum Direction {\\n /// Lower is better.\\n Lowest,\\n /// Higher is better.\\n Highest,\\n}\"\n ],\n \"name\": \"direction\",\n \"type\": \"Direction\"\n },\n {\n \"definitions\": [\n \"impl<T> Box<T> {\\n /// Allocates memory on the heap and then places `x` into it.\\n ///\\n /// This doesn't actually allocate if `T` is zero-sized.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// let five = Box::new(5);\\n /// ```\\n #[cfg(not(no_global_oom_handling))]\\n #[inline(always)]\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n #[must_use]\\n #[rustc_diagnostic_item = \\\"box_new\\\"]\\n #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces\\n pub fn new(x: T) -> Self {\\n return box_new(x);\\n }\\n\\n /// Constructs a new box with uninitialized contents.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// let mut five = Box::<u32>::new_uninit();\\n /// // Deferred initialization:\\n /// five.write(5);\\n /// let five = unsafe { five.assume_init() };\\n ///\\n /// assert_eq!(*five, 5)\\n /// ```\\n #[cfg(not(no_global_oom_handling))]\\n #[stable(feature = \\\"new_uninit\\\", since = \\\"1.82.0\\\")]\\n #[must_use]\\n #[inline]\\n pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {\\n Self::new_uninit_in(Global)\\n }\\n\\n /// Constructs a new `Box` with uninitialized contents, with the memory\\n /// being filled with `0` bytes.\\n ///\\n /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage\\n /// of this method.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(new_zeroed_alloc)]\\n ///\\n /// let zero = Box::<u32>::new_zeroed();\\n /// let zero = unsafe { zero.assume_init() };\\n ///\\n /// assert_eq!(*zero, 0)\\n /// ```\\n ///\\n /// [zeroed]: mem::MaybeUninit::zeroed\\n #[cfg(not(no_global_oom_handling))]\\n #[inline]\\n #[unstable(feature = \\\"new_zeroed_alloc\\\", issue = \\\"129396\\\")]\\n #[must_use]\\n pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {\\n Self::new_zeroed_in(Global)\\n }\\n\\n /// Constructs a new `Pin<Box<T>>`. If `T` does not implement [`Unpin`], then\\n /// `x` will be pinned in memory and unable to be moved.\\n ///\\n /// Constructing and pinning of the `Box` can also be done in two steps: `Box::pin(x)`\\n /// does the same as <code>[Box::into_pin]\\\\([Box::new]\\\\(x))</code>. Consider using\\n /// [`into_pin`](Box::into_pin) if you already have a `Box<T>`, or if you want to\\n /// construct a (pinned) `Box` in a different way than with [`Box::new`].\\n #[cfg(not(no_global_oom_handling))]\\n #[stable(feature = \\\"pin\\\", since = \\\"1.33.0\\\")]\\n #[must_use]\\n #[inline(always)]\\n pub fn pin(x: T) -> Pin<Box<T>> {\\n Box::new(x).into()\\n }\\n\\n /// Allocates memory on the heap then places `x` into it,\\n /// returning an error if the allocation fails\\n ///\\n /// This doesn't actually allocate if `T` is zero-sized.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(allocator_api)]\\n ///\\n /// let five = Box::try_new(5)?;\\n /// # Ok::<(), std::alloc::AllocError>(())\\n /// ```\\n #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")]\\n #[inline]\\n pub fn try_new(x: T) -> Result<Self, AllocError> {\\n Self::try_new_in(x, Global)\\n }\\n\\n /// Constructs a new box with uninitialized contents on the heap,\\n /// returning an error if the allocation fails\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(allocator_api)]\\n ///\\n /// let mut five = Box::<u32>::try_new_uninit()?;\\n /// // Deferred initialization:\\n /// five.write(5);\\n /// let five = unsafe { five.assume_init() };\\n ///\\n /// assert_eq!(*five, 5);\\n /// # Ok::<(), std::alloc::AllocError>(())\\n /// ```\\n #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")]\\n // #[unstable(feature = \\\"new_uninit\\\", issue = \\\"63291\\\")]\\n #[inline]\\n pub fn try_new_uninit() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {\\n Box::try_new_uninit_in(Global)\\n }\\n\\n /// Constructs a new `Box` with uninitialized contents, with the memory\\n /// being filled with `0` bytes on the heap\\n ///\\n /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage\\n /// of this method.\\n ///\\n /// # Examples\\n ///\\n /// ```\\n /// #![feature(allocator_api)]\\n ///\\n /// let zero = Box::<u32>::try_new_zeroed()?;\\n /// let zero = unsafe { zero.assume_init() };\\n ///\\n /// assert_eq!(*zero, 0);\\n /// # Ok::<(), std::alloc::AllocError>(())\\n /// ```\\n ///\\n /// [zeroed]: mem::MaybeUninit::zeroed\\n #[unstable(feature = \\\"allocator_api\\\", issue = \\\"32838\\\")]\\n // #[unstable(feature = \\\"new_uninit\\\", issue = \\\"63291\\\")]\\n #[inline]\\n pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {\\n Box::try_new_zeroed_in(Global)\\n }\\n}\"\n ],\n \"name\": \"loggers\",\n \"type\": \"&mut [Box<dyn MetricLogger>]\"\n }\n ],\n \"end_line\": 113,\n \"name\": \"find_epoch\",\n \"signature\": \"pub(crate) fn find_epoch(\\n &mut self,\\n name: &str,\\n aggregate: Aggregate,\\n direction: Direction,\\n loggers: &mut [Box<dyn MetricLogger>],\\n ) -> Option<usize>\",\n \"start_line\": 71\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl NumericMetricsAggregate {\\n pub(crate) fn aggregate(\\n &mut self,\\n name: &str,\\n epoch: usize,\\n aggregate: Aggregate,\\n loggers: &mut [Box<dyn MetricLogger>],\\n ) -> Option<f64> {\\n let key = Key::new(name.to_string(), epoch, aggregate);\\n\\n if let Some(value) = self.value_for_each_epoch.get(&key) {\\n return Some(*value);\\n }\\n\\n let points = || {\\n let mut errors = Vec::new();\\n for logger in loggers {\\n match logger.read_numeric(name, epoch) {\\n Ok(points) => return Ok(points),\\n Err(err) => errors.push(err),\\n };\\n }\\n\\n Err(errors.join(\\\" \\\"))\\n };\\n\\n let points = points().expect(\\\"Can read values\\\");\\n\\n if points.is_empty() {\\n return None;\\n }\\n\\n // Accurately compute the aggregated value based on the *actual* number of points\\n // since not all mini-batches are guaranteed to have the specified batch size\\n let (sum, num_points) = points\\n .into_iter()\\n .map(|entry| match entry {\\n NumericEntry::Value(v) => (v, 1),\\n // Right now the mean is the only aggregate available, so we can assume that the sum\\n // of an entry corresponds to (value * number of elements)\\n NumericEntry::Aggregated(v, n) => (v * n as f64, n),\\n })\\n .reduce(|(acc_v, acc_n), (v, n)| (acc_v + v, acc_n + n))\\n .unwrap();\\n let value = match aggregate {\\n Aggregate::Mean => sum / num_points as f64,\\n };\\n\\n self.value_for_each_epoch.insert(key, value);\\n Some(value)\\n }\\n\\n pub(crate) fn find_epoch(\\n &mut self,\\n name: &str,\\n aggregate: Aggregate,\\n direction: Direction,\\n loggers: &mut [Box<dyn MetricLogger>],\\n ) -> Option<usize> {\\n let mut data = Vec::new();\\n let mut current_epoch = 1;\\n\\n while let Some(value) = self.aggregate(name, current_epoch, aggregate, loggers) {\\n data.push(value);\\n current_epoch += 1;\\n }\\n\\n if data.is_empty() {\\n return None;\\n }\\n\\n let mut current_value = match &direction {\\n Direction::Lowest => f64::MAX,\\n Direction::Highest => f64::MIN,\\n };\\n\\n for (i, value) in data.into_iter().enumerate() {\\n match &direction {\\n Direction::Lowest => {\\n if value < current_value {\\n current_value = value;\\n current_epoch = i + 1;\\n }\\n }\\n Direction::Highest => {\\n if value > current_value {\\n current_value = value;\\n current_epoch = i + 1;\\n }\\n }\\n }\\n }\\n\\n Some(current_epoch)\\n }\\n}\",\n \"class_signature\": \"impl NumericMetricsAggregate\"\n}"}}},{"rowIdx":176,"cells":{"function_name":{"kind":"string","value":"run"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/fusion.rs"},"focal_code":{"kind":"string","value":"fn run(\n &self,\n input: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n d_o: &DType,\n d_a: &DType,\n ) -> CubeFusionHandle<R> {\n let d_i = input.dtype;\n\n let config = match inst {\n ReduceInstruction::ArgMax => ReduceFnConfig::ArgMax,\n ReduceInstruction::ArgMin => ReduceFnConfig::ArgMin,\n ReduceInstruction::Mean => ReduceFnConfig::Mean,\n ReduceInstruction::Prod => ReduceFnConfig::Prod,\n ReduceInstruction::Sum => ReduceFnConfig::Sum,\n ReduceInstruction::Max => ReduceFnConfig::Max,\n ReduceInstruction::Min => ReduceFnConfig::Min,\n ReduceInstruction::MaxAbs => ReduceFnConfig::MaxAbs,\n };\n\n match d_a {\n DType::F64 => reduce_dtype::<R, f64>(input, shape, axis, &d_i, d_o, config),\n DType::F32 => reduce_dtype::<R, f32>(input, shape, axis, &d_i, d_o, config),\n DType::F16 => reduce_dtype::<R, f16>(input, shape, axis, &d_i, d_o, config),\n DType::I64 => reduce_dtype::<R, i64>(input, shape, axis, &d_i, d_o, config),\n DType::I32 => reduce_dtype::<R, i32>(input, shape, axis, &d_i, d_o, config),\n DType::I16 => reduce_dtype::<R, i16>(input, shape, axis, &d_i, d_o, config),\n DType::I8 => reduce_dtype::<R, i8>(input, shape, axis, &d_i, d_o, config),\n DType::U64 => reduce_dtype::<R, u64>(input, shape, axis, &d_i, d_o, config),\n DType::U32 => reduce_dtype::<R, u32>(input, shape, axis, &d_i, d_o, config),\n DType::U16 => reduce_dtype::<R, u16>(input, shape, axis, &d_i, d_o, config),\n DType::U8 => reduce_dtype::<R, u8>(input, shape, axis, &d_i, d_o, config),\n _ => todo!(\"Not yet supported\"),\n }\n }"},"file_content":{"kind":"string","value":"use crate::BoolElement;\nuse crate::element::CubeElement;\nuse crate::{CubeBackend, CubeRuntime, FloatElement, IntElement, kernel, tensor::CubeTensor};\n\nuse burn_cubecl_fusion::CubeFusionHandle;\nuse burn_cubecl_fusion::elemwise::optimization::ElemwiseOptimization;\nuse burn_cubecl_fusion::matmul::MatmulFallbackFn;\nuse burn_cubecl_fusion::matmul::builder::MatmulBuilder;\nuse burn_cubecl_fusion::matmul::optimization::MatmulOptimization;\nuse burn_cubecl_fusion::reduce::builder::ReduceBuilder;\nuse burn_cubecl_fusion::reduce::optimization::{\n ReduceFallbackFn, ReduceInstruction, ReduceOptimization,\n};\nuse burn_cubecl_fusion::{\n CubeOptimization, CubeOptimizationState, elemwise::builder::ElementWiseBuilder,\n};\nuse burn_fusion::{FusionBackend, FusionRuntime, client::MutexFusionClient};\nuse burn_ir::{BackendIr, TensorHandle};\nuse burn_tensor::{DType, Shape};\nuse core::marker::PhantomData;\nuse cubecl::flex32;\nuse cubecl::reduce::instructions::ReduceFnConfig;\nuse half::{bf16, f16};\nuse std::sync::Arc;\n\nimpl<R, BT> burn_fusion::Optimization<FusionCubeRuntime<R, BT>> for CubeOptimization<R>\nwhere\n R: CubeRuntime,\n BT: BoolElement,\n{\n fn execute(&mut self, context: &mut burn_fusion::stream::Context<'_, CubeFusionHandle<R>>) {\n match self {\n Self::ElementWise(op) => op.execute::<BT>(context),\n Self::Matmul(op) => op.execute::<BT>(context),\n Self::Reduce(op) => op.execute::<BT>(context),\n }\n }\n\n fn len(&self) -> usize {\n match self {\n Self::ElementWise(op) => op.num_ops_fused(),\n Self::Matmul(op) => op.num_ops_fused(),\n Self::Reduce(op) => op.num_ops_fused(),\n }\n }\n\n fn to_state(&self) -> CubeOptimizationState {\n match self {\n Self::ElementWise(value) => CubeOptimizationState::ElementWise(value.to_state()),\n Self::Matmul(value) => CubeOptimizationState::Matmul(value.to_state()),\n Self::Reduce(value) => CubeOptimizationState::Reduce(value.to_state()),\n }\n }\n\n fn from_state(device: &R::Device, state: CubeOptimizationState) -> Self {\n match state {\n CubeOptimizationState::ElementWise(state) => {\n Self::ElementWise(ElemwiseOptimization::from_state(device, state))\n }\n CubeOptimizationState::Matmul(state) => Self::Matmul(MatmulOptimization::from_state(\n device,\n state,\n Arc::new(FallbackMatmul),\n )),\n CubeOptimizationState::Reduce(state) => Self::Reduce(ReduceOptimization::from_state(\n device,\n state,\n Arc::new(FallbackReduce),\n )),\n }\n }\n}\n\nstruct FallbackMatmul;\nstruct FallbackReduce;\n\nimpl<R: CubeRuntime> MatmulFallbackFn<R> for FallbackMatmul {\n fn run(\n &self,\n lhs: (CubeFusionHandle<R>, &[usize]),\n rhs: (CubeFusionHandle<R>, &[usize]),\n ) -> CubeFusionHandle<R> {\n match lhs.0.dtype {\n DType::F64 => run_fallback_matmul::<R, f64>(lhs, rhs),\n DType::F32 => run_fallback_matmul::<R, f32>(lhs, rhs),\n DType::Flex32 => run_fallback_matmul::<R, flex32>(lhs, rhs),\n DType::F16 => run_fallback_matmul::<R, f16>(lhs, rhs),\n DType::BF16 => run_fallback_matmul::<R, bf16>(lhs, rhs),\n _ => todo!(\"Not yet supported\"),\n }\n }\n}\n\nimpl<R: CubeRuntime> ReduceFallbackFn<R> for FallbackReduce {\n fn run(\n &self,\n input: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n d_o: &DType,\n d_a: &DType,\n ) -> CubeFusionHandle<R> {\n let d_i = input.dtype;\n\n let config = match inst {\n ReduceInstruction::ArgMax => ReduceFnConfig::ArgMax,\n ReduceInstruction::ArgMin => ReduceFnConfig::ArgMin,\n ReduceInstruction::Mean => ReduceFnConfig::Mean,\n ReduceInstruction::Prod => ReduceFnConfig::Prod,\n ReduceInstruction::Sum => ReduceFnConfig::Sum,\n ReduceInstruction::Max => ReduceFnConfig::Max,\n ReduceInstruction::Min => ReduceFnConfig::Min,\n ReduceInstruction::MaxAbs => ReduceFnConfig::MaxAbs,\n };\n\n match d_a {\n DType::F64 => reduce_dtype::<R, f64>(input, shape, axis, &d_i, d_o, config),\n DType::F32 => reduce_dtype::<R, f32>(input, shape, axis, &d_i, d_o, config),\n DType::F16 => reduce_dtype::<R, f16>(input, shape, axis, &d_i, d_o, config),\n DType::I64 => reduce_dtype::<R, i64>(input, shape, axis, &d_i, d_o, config),\n DType::I32 => reduce_dtype::<R, i32>(input, shape, axis, &d_i, d_o, config),\n DType::I16 => reduce_dtype::<R, i16>(input, shape, axis, &d_i, d_o, config),\n DType::I8 => reduce_dtype::<R, i8>(input, shape, axis, &d_i, d_o, config),\n DType::U64 => reduce_dtype::<R, u64>(input, shape, axis, &d_i, d_o, config),\n DType::U32 => reduce_dtype::<R, u32>(input, shape, axis, &d_i, d_o, config),\n DType::U16 => reduce_dtype::<R, u16>(input, shape, axis, &d_i, d_o, config),\n DType::U8 => reduce_dtype::<R, u8>(input, shape, axis, &d_i, d_o, config),\n _ => todo!(\"Not yet supported\"),\n }\n }\n}\n\nfn run_fallback_matmul<R: CubeRuntime, EG: FloatElement>(\n lhs: (CubeFusionHandle<R>, &[usize]),\n rhs: (CubeFusionHandle<R>, &[usize]),\n) -> CubeFusionHandle<R> {\n let lhs_tensor = into_tensor(\n lhs.0,\n Shape {\n dims: lhs.1.to_vec(),\n },\n );\n let rhs_tensor = into_tensor(\n rhs.0,\n Shape {\n dims: rhs.1.to_vec(),\n },\n );\n let out_tensor = crate::kernel::matmul::matmul::<R, EG>(\n lhs_tensor,\n rhs_tensor,\n None,\n crate::kernel::matmul::MatmulStrategy::default(),\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}\n\nfn reduce_dtype<R: CubeRuntime, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_input: &DType,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_input {\n DType::F64 => {\n reduce_dtype_output::<R, f64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F32 | DType::Flex32 => {\n reduce_dtype_output::<R, f32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F16 => {\n reduce_dtype_output::<R, f16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::BF16 => {\n reduce_dtype_output::<R, bf16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I64 => {\n reduce_dtype_output::<R, i64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I32 => {\n reduce_dtype_output::<R, i32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I16 => {\n reduce_dtype_output::<R, i16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I8 => {\n reduce_dtype_output::<R, i8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U64 => {\n reduce_dtype_output::<R, u64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U32 => {\n reduce_dtype_output::<R, u32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U16 => {\n reduce_dtype_output::<R, u16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U8 => {\n reduce_dtype_output::<R, u8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n _ => todo!(\"Not yet supported\"),\n }\n}\n\nfn reduce_dtype_output<R: CubeRuntime, In: CubeElement, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_output {\n DType::F64 => reduce::<R, In, f64, Acc>(input_handle, shape, axis, config),\n DType::F32 | DType::Flex32 => reduce::<R, In, f32, Acc>(input_handle, shape, axis, config),\n DType::F16 => reduce::<R, In, f16, Acc>(input_handle, shape, axis, config),\n DType::BF16 => reduce::<R, In, bf16, Acc>(input_handle, shape, axis, config),\n DType::I64 => reduce::<R, In, i64, Acc>(input_handle, shape, axis, config),\n DType::I32 => reduce::<R, In, i32, Acc>(input_handle, shape, axis, config),\n DType::I16 => reduce::<R, In, i16, Acc>(input_handle, shape, axis, config),\n DType::U64 => reduce::<R, In, u64, Acc>(input_handle, shape, axis, config),\n DType::U32 => reduce::<R, In, u32, Acc>(input_handle, shape, axis, config),\n DType::U16 => reduce::<R, In, u16, Acc>(input_handle, shape, axis, config),\n _ => todo!(\"Not yet supported\"),\n }\n}\n\nfn reduce<R: CubeRuntime, In: CubeElement, Out: CubeElement, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n let input_tensor = into_tensor(\n input_handle,\n Shape {\n dims: shape.to_vec(),\n },\n );\n let out_tensor = crate::kernel::reduce::reduce_dim::<R, In, Out, Acc>(\n input_tensor,\n axis,\n crate::kernel::reduce::ReduceStrategy::default(),\n config,\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}\n\nimpl<R: CubeRuntime, F: FloatElement, I: IntElement, BT: BoolElement> BackendIr\n for CubeBackend<R, F, I, BT>\n{\n type Handle = CubeFusionHandle<R>;\n\n fn float_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::FloatTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn int_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::IntTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn bool_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::BoolTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn quantized_tensor(\n handle: TensorHandle<Self::Handle>,\n ) -> burn_tensor::ops::QuantizedTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn float_tensor_handle(tensor: burn_tensor::ops::FloatTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn int_tensor_handle(tensor: burn_tensor::ops::IntTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn bool_tensor_handle(tensor: burn_tensor::ops::BoolTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn quantized_tensor_handle(tensor: burn_tensor::ops::QuantizedTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n}\n\nimpl<R: CubeRuntime, BT: BoolElement> FusionRuntime for FusionCubeRuntime<R, BT> {\n type OptimizationState = CubeOptimizationState;\n type Optimization = CubeOptimization<R>;\n type FusionHandle = CubeFusionHandle<R>;\n type FusionDevice = R::CubeDevice;\n type FusionClient = MutexFusionClient<Self>;\n type BoolRepr = BT;\n\n fn optimizations(\n device: R::Device,\n ) -> Vec<Box<dyn burn_fusion::OptimizationBuilder<Self::Optimization>>> {\n vec![\n Box::new(ElementWiseBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n )),\n Box::new(MatmulBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n Arc::new(FallbackMatmul),\n )),\n Box::new(ReduceBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n Arc::new(FallbackReduce),\n )),\n ]\n }\n}\n\n/// Fusion runtime for JIT runtimes.\n#[derive(Debug)]\npub struct FusionCubeRuntime<R: CubeRuntime, BT: BoolElement> {\n _b: PhantomData<R>,\n _bool: PhantomData<BT>,\n}\n\nimpl<R: CubeRuntime, F: FloatElement, I: IntElement, BT: BoolElement> FusionBackend\n for CubeBackend<R, F, I, BT>\n{\n type FusionRuntime = FusionCubeRuntime<R, BT>;\n\n type FullPrecisionBackend = CubeBackend<R, f32, i32, BT>;\n\n fn cast_float(tensor: burn_tensor::ops::FloatTensor<Self>, dtype: DType) -> Self::Handle {\n fn cast<R: CubeRuntime, F: FloatElement, FTarget: FloatElement>(\n tensor: CubeTensor<R>,\n ) -> CubeFusionHandle<R> {\n CubeFusionHandle::from(kernel::cast::<R, F, FTarget>(tensor))\n }\n\n match dtype {\n DType::F32 | DType::Flex32 => cast::<R, F, f32>(tensor),\n DType::F16 => cast::<R, F, f16>(tensor),\n DType::BF16 => cast::<R, F, bf16>(tensor),\n _ => panic!(\"Casting error: {dtype:?} unsupported.\"),\n }\n }\n}\n\nfn into_tensor<R: CubeRuntime>(handle: CubeFusionHandle<R>, shape: Shape) -> CubeTensor<R> {\n CubeTensor {\n client: handle.client,\n handle: handle.handle,\n device: handle.device,\n shape,\n strides: handle.strides,\n dtype: handle.dtype,\n }\n}\n\nimpl<R: CubeRuntime> From<CubeTensor<R>> for CubeFusionHandle<R> {\n fn from(value: CubeTensor<R>) -> Self {\n Self {\n client: value.client,\n handle: value.handle,\n device: value.device,\n strides: value.strides,\n dtype: value.dtype,\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 131,\n \"name\": \"run\",\n \"signature\": \"fn run(\\n &self,\\n input: CubeFusionHandle<R>,\\n shape: &[usize],\\n axis: usize,\\n inst: &ReduceInstruction,\\n d_o: &DType,\\n d_a: &DType,\\n ) -> CubeFusionHandle<R>\",\n \"start_line\": 95\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R: CubeRuntime> ReduceFallbackFn<R> for FallbackReduce {\\n fn run(\\n &self,\\n input: CubeFusionHandle<R>,\\n shape: &[usize],\\n axis: usize,\\n inst: &ReduceInstruction,\\n d_o: &DType,\\n d_a: &DType,\\n ) -> CubeFusionHandle<R> {\\n let d_i = input.dtype;\\n\\n let config = match inst {\\n ReduceInstruction::ArgMax => ReduceFnConfig::ArgMax,\\n ReduceInstruction::ArgMin => ReduceFnConfig::ArgMin,\\n ReduceInstruction::Mean => ReduceFnConfig::Mean,\\n ReduceInstruction::Prod => ReduceFnConfig::Prod,\\n ReduceInstruction::Sum => ReduceFnConfig::Sum,\\n ReduceInstruction::Max => ReduceFnConfig::Max,\\n ReduceInstruction::Min => ReduceFnConfig::Min,\\n ReduceInstruction::MaxAbs => ReduceFnConfig::MaxAbs,\\n };\\n\\n match d_a {\\n DType::F64 => reduce_dtype::<R, f64>(input, shape, axis, &d_i, d_o, config),\\n DType::F32 => reduce_dtype::<R, f32>(input, shape, axis, &d_i, d_o, config),\\n DType::F16 => reduce_dtype::<R, f16>(input, shape, axis, &d_i, d_o, config),\\n DType::I64 => reduce_dtype::<R, i64>(input, shape, axis, &d_i, d_o, config),\\n DType::I32 => reduce_dtype::<R, i32>(input, shape, axis, &d_i, d_o, config),\\n DType::I16 => reduce_dtype::<R, i16>(input, shape, axis, &d_i, d_o, config),\\n DType::I8 => reduce_dtype::<R, i8>(input, shape, axis, &d_i, d_o, config),\\n DType::U64 => reduce_dtype::<R, u64>(input, shape, axis, &d_i, d_o, config),\\n DType::U32 => reduce_dtype::<R, u32>(input, shape, axis, &d_i, d_o, config),\\n DType::U16 => reduce_dtype::<R, u16>(input, shape, axis, &d_i, d_o, config),\\n DType::U8 => reduce_dtype::<R, u8>(input, shape, axis, &d_i, d_o, config),\\n _ => todo!(\\\"Not yet supported\\\"),\\n }\\n }\\n}\",\n \"class_signature\": \"impl<R: CubeRuntime> ReduceFallbackFn<R> for FallbackReduce\"\n}"}}},{"rowIdx":177,"cells":{"function_name":{"kind":"string","value":"reduce_dtype"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/fusion.rs"},"focal_code":{"kind":"string","value":"fn reduce_dtype(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_input: &DType,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_input {\n DType::F64 => {\n reduce_dtype_output::<R, f64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F32 | DType::Flex32 => {\n reduce_dtype_output::<R, f32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F16 => {\n reduce_dtype_output::<R, f16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::BF16 => {\n reduce_dtype_output::<R, bf16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I64 => {\n reduce_dtype_output::<R, i64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I32 => {\n reduce_dtype_output::<R, i32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I16 => {\n reduce_dtype_output::<R, i16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I8 => {\n reduce_dtype_output::<R, i8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U64 => {\n reduce_dtype_output::<R, u64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U32 => {\n reduce_dtype_output::<R, u32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U16 => {\n reduce_dtype_output::<R, u16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U8 => {\n reduce_dtype_output::<R, u8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n _ => todo!(\"Not yet supported\"),\n }\n}"},"file_content":{"kind":"string","value":"use crate::BoolElement;\nuse crate::element::CubeElement;\nuse crate::{CubeBackend, CubeRuntime, FloatElement, IntElement, kernel, tensor::CubeTensor};\n\nuse burn_cubecl_fusion::CubeFusionHandle;\nuse burn_cubecl_fusion::elemwise::optimization::ElemwiseOptimization;\nuse burn_cubecl_fusion::matmul::MatmulFallbackFn;\nuse burn_cubecl_fusion::matmul::builder::MatmulBuilder;\nuse burn_cubecl_fusion::matmul::optimization::MatmulOptimization;\nuse burn_cubecl_fusion::reduce::builder::ReduceBuilder;\nuse burn_cubecl_fusion::reduce::optimization::{\n ReduceFallbackFn, ReduceInstruction, ReduceOptimization,\n};\nuse burn_cubecl_fusion::{\n CubeOptimization, CubeOptimizationState, elemwise::builder::ElementWiseBuilder,\n};\nuse burn_fusion::{FusionBackend, FusionRuntime, client::MutexFusionClient};\nuse burn_ir::{BackendIr, TensorHandle};\nuse burn_tensor::{DType, Shape};\nuse core::marker::PhantomData;\nuse cubecl::flex32;\nuse cubecl::reduce::instructions::ReduceFnConfig;\nuse half::{bf16, f16};\nuse std::sync::Arc;\n\nimpl<R, BT> burn_fusion::Optimization<FusionCubeRuntime<R, BT>> for CubeOptimization<R>\nwhere\n R: CubeRuntime,\n BT: BoolElement,\n{\n fn execute(&mut self, context: &mut burn_fusion::stream::Context<'_, CubeFusionHandle<R>>) {\n match self {\n Self::ElementWise(op) => op.execute::<BT>(context),\n Self::Matmul(op) => op.execute::<BT>(context),\n Self::Reduce(op) => op.execute::<BT>(context),\n }\n }\n\n fn len(&self) -> usize {\n match self {\n Self::ElementWise(op) => op.num_ops_fused(),\n Self::Matmul(op) => op.num_ops_fused(),\n Self::Reduce(op) => op.num_ops_fused(),\n }\n }\n\n fn to_state(&self) -> CubeOptimizationState {\n match self {\n Self::ElementWise(value) => CubeOptimizationState::ElementWise(value.to_state()),\n Self::Matmul(value) => CubeOptimizationState::Matmul(value.to_state()),\n Self::Reduce(value) => CubeOptimizationState::Reduce(value.to_state()),\n }\n }\n\n fn from_state(device: &R::Device, state: CubeOptimizationState) -> Self {\n match state {\n CubeOptimizationState::ElementWise(state) => {\n Self::ElementWise(ElemwiseOptimization::from_state(device, state))\n }\n CubeOptimizationState::Matmul(state) => Self::Matmul(MatmulOptimization::from_state(\n device,\n state,\n Arc::new(FallbackMatmul),\n )),\n CubeOptimizationState::Reduce(state) => Self::Reduce(ReduceOptimization::from_state(\n device,\n state,\n Arc::new(FallbackReduce),\n )),\n }\n }\n}\n\nstruct FallbackMatmul;\nstruct FallbackReduce;\n\nimpl<R: CubeRuntime> MatmulFallbackFn<R> for FallbackMatmul {\n fn run(\n &self,\n lhs: (CubeFusionHandle<R>, &[usize]),\n rhs: (CubeFusionHandle<R>, &[usize]),\n ) -> CubeFusionHandle<R> {\n match lhs.0.dtype {\n DType::F64 => run_fallback_matmul::<R, f64>(lhs, rhs),\n DType::F32 => run_fallback_matmul::<R, f32>(lhs, rhs),\n DType::Flex32 => run_fallback_matmul::<R, flex32>(lhs, rhs),\n DType::F16 => run_fallback_matmul::<R, f16>(lhs, rhs),\n DType::BF16 => run_fallback_matmul::<R, bf16>(lhs, rhs),\n _ => todo!(\"Not yet supported\"),\n }\n }\n}\n\nimpl<R: CubeRuntime> ReduceFallbackFn<R> for FallbackReduce {\n fn run(\n &self,\n input: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n d_o: &DType,\n d_a: &DType,\n ) -> CubeFusionHandle<R> {\n let d_i = input.dtype;\n\n let config = match inst {\n ReduceInstruction::ArgMax => ReduceFnConfig::ArgMax,\n ReduceInstruction::ArgMin => ReduceFnConfig::ArgMin,\n ReduceInstruction::Mean => ReduceFnConfig::Mean,\n ReduceInstruction::Prod => ReduceFnConfig::Prod,\n ReduceInstruction::Sum => ReduceFnConfig::Sum,\n ReduceInstruction::Max => ReduceFnConfig::Max,\n ReduceInstruction::Min => ReduceFnConfig::Min,\n ReduceInstruction::MaxAbs => ReduceFnConfig::MaxAbs,\n };\n\n match d_a {\n DType::F64 => reduce_dtype::<R, f64>(input, shape, axis, &d_i, d_o, config),\n DType::F32 => reduce_dtype::<R, f32>(input, shape, axis, &d_i, d_o, config),\n DType::F16 => reduce_dtype::<R, f16>(input, shape, axis, &d_i, d_o, config),\n DType::I64 => reduce_dtype::<R, i64>(input, shape, axis, &d_i, d_o, config),\n DType::I32 => reduce_dtype::<R, i32>(input, shape, axis, &d_i, d_o, config),\n DType::I16 => reduce_dtype::<R, i16>(input, shape, axis, &d_i, d_o, config),\n DType::I8 => reduce_dtype::<R, i8>(input, shape, axis, &d_i, d_o, config),\n DType::U64 => reduce_dtype::<R, u64>(input, shape, axis, &d_i, d_o, config),\n DType::U32 => reduce_dtype::<R, u32>(input, shape, axis, &d_i, d_o, config),\n DType::U16 => reduce_dtype::<R, u16>(input, shape, axis, &d_i, d_o, config),\n DType::U8 => reduce_dtype::<R, u8>(input, shape, axis, &d_i, d_o, config),\n _ => todo!(\"Not yet supported\"),\n }\n }\n}\n\nfn run_fallback_matmul<R: CubeRuntime, EG: FloatElement>(\n lhs: (CubeFusionHandle<R>, &[usize]),\n rhs: (CubeFusionHandle<R>, &[usize]),\n) -> CubeFusionHandle<R> {\n let lhs_tensor = into_tensor(\n lhs.0,\n Shape {\n dims: lhs.1.to_vec(),\n },\n );\n let rhs_tensor = into_tensor(\n rhs.0,\n Shape {\n dims: rhs.1.to_vec(),\n },\n );\n let out_tensor = crate::kernel::matmul::matmul::<R, EG>(\n lhs_tensor,\n rhs_tensor,\n None,\n crate::kernel::matmul::MatmulStrategy::default(),\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}\n\nfn reduce_dtype<R: CubeRuntime, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_input: &DType,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_input {\n DType::F64 => {\n reduce_dtype_output::<R, f64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F32 | DType::Flex32 => {\n reduce_dtype_output::<R, f32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F16 => {\n reduce_dtype_output::<R, f16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::BF16 => {\n reduce_dtype_output::<R, bf16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I64 => {\n reduce_dtype_output::<R, i64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I32 => {\n reduce_dtype_output::<R, i32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I16 => {\n reduce_dtype_output::<R, i16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I8 => {\n reduce_dtype_output::<R, i8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U64 => {\n reduce_dtype_output::<R, u64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U32 => {\n reduce_dtype_output::<R, u32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U16 => {\n reduce_dtype_output::<R, u16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U8 => {\n reduce_dtype_output::<R, u8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n _ => todo!(\"Not yet supported\"),\n }\n}\n\nfn reduce_dtype_output<R: CubeRuntime, In: CubeElement, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_output {\n DType::F64 => reduce::<R, In, f64, Acc>(input_handle, shape, axis, config),\n DType::F32 | DType::Flex32 => reduce::<R, In, f32, Acc>(input_handle, shape, axis, config),\n DType::F16 => reduce::<R, In, f16, Acc>(input_handle, shape, axis, config),\n DType::BF16 => reduce::<R, In, bf16, Acc>(input_handle, shape, axis, config),\n DType::I64 => reduce::<R, In, i64, Acc>(input_handle, shape, axis, config),\n DType::I32 => reduce::<R, In, i32, Acc>(input_handle, shape, axis, config),\n DType::I16 => reduce::<R, In, i16, Acc>(input_handle, shape, axis, config),\n DType::U64 => reduce::<R, In, u64, Acc>(input_handle, shape, axis, config),\n DType::U32 => reduce::<R, In, u32, Acc>(input_handle, shape, axis, config),\n DType::U16 => reduce::<R, In, u16, Acc>(input_handle, shape, axis, config),\n _ => todo!(\"Not yet supported\"),\n }\n}\n\nfn reduce<R: CubeRuntime, In: CubeElement, Out: CubeElement, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n let input_tensor = into_tensor(\n input_handle,\n Shape {\n dims: shape.to_vec(),\n },\n );\n let out_tensor = crate::kernel::reduce::reduce_dim::<R, In, Out, Acc>(\n input_tensor,\n axis,\n crate::kernel::reduce::ReduceStrategy::default(),\n config,\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}\n\nimpl<R: CubeRuntime, F: FloatElement, I: IntElement, BT: BoolElement> BackendIr\n for CubeBackend<R, F, I, BT>\n{\n type Handle = CubeFusionHandle<R>;\n\n fn float_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::FloatTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn int_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::IntTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn bool_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::BoolTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn quantized_tensor(\n handle: TensorHandle<Self::Handle>,\n ) -> burn_tensor::ops::QuantizedTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn float_tensor_handle(tensor: burn_tensor::ops::FloatTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn int_tensor_handle(tensor: burn_tensor::ops::IntTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn bool_tensor_handle(tensor: burn_tensor::ops::BoolTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn quantized_tensor_handle(tensor: burn_tensor::ops::QuantizedTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n}\n\nimpl<R: CubeRuntime, BT: BoolElement> FusionRuntime for FusionCubeRuntime<R, BT> {\n type OptimizationState = CubeOptimizationState;\n type Optimization = CubeOptimization<R>;\n type FusionHandle = CubeFusionHandle<R>;\n type FusionDevice = R::CubeDevice;\n type FusionClient = MutexFusionClient<Self>;\n type BoolRepr = BT;\n\n fn optimizations(\n device: R::Device,\n ) -> Vec<Box<dyn burn_fusion::OptimizationBuilder<Self::Optimization>>> {\n vec![\n Box::new(ElementWiseBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n )),\n Box::new(MatmulBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n Arc::new(FallbackMatmul),\n )),\n Box::new(ReduceBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n Arc::new(FallbackReduce),\n )),\n ]\n }\n}\n\n/// Fusion runtime for JIT runtimes.\n#[derive(Debug)]\npub struct FusionCubeRuntime<R: CubeRuntime, BT: BoolElement> {\n _b: PhantomData<R>,\n _bool: PhantomData<BT>,\n}\n\nimpl<R: CubeRuntime, F: FloatElement, I: IntElement, BT: BoolElement> FusionBackend\n for CubeBackend<R, F, I, BT>\n{\n type FusionRuntime = FusionCubeRuntime<R, BT>;\n\n type FullPrecisionBackend = CubeBackend<R, f32, i32, BT>;\n\n fn cast_float(tensor: burn_tensor::ops::FloatTensor<Self>, dtype: DType) -> Self::Handle {\n fn cast<R: CubeRuntime, F: FloatElement, FTarget: FloatElement>(\n tensor: CubeTensor<R>,\n ) -> CubeFusionHandle<R> {\n CubeFusionHandle::from(kernel::cast::<R, F, FTarget>(tensor))\n }\n\n match dtype {\n DType::F32 | DType::Flex32 => cast::<R, F, f32>(tensor),\n DType::F16 => cast::<R, F, f16>(tensor),\n DType::BF16 => cast::<R, F, bf16>(tensor),\n _ => panic!(\"Casting error: {dtype:?} unsupported.\"),\n }\n }\n}\n\nfn into_tensor<R: CubeRuntime>(handle: CubeFusionHandle<R>, shape: Shape) -> CubeTensor<R> {\n CubeTensor {\n client: handle.client,\n handle: handle.handle,\n device: handle.device,\n shape,\n strides: handle.strides,\n dtype: handle.dtype,\n }\n}\n\nimpl<R: CubeRuntime> From<CubeTensor<R>> for CubeFusionHandle<R> {\n fn from(value: CubeTensor<R>) -> Self {\n Self {\n client: value.client,\n handle: value.handle,\n device: value.device,\n strides: value.strides,\n dtype: value.dtype,\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 214,\n \"name\": \"reduce_dtype\",\n \"signature\": \"fn reduce_dtype(\\n input_handle: CubeFusionHandle<R>,\\n shape: &[usize],\\n axis: usize,\\n dtype_input: &DType,\\n dtype_output: &DType,\\n config: ReduceFnConfig,\\n) -> CubeFusionHandle<R>\",\n \"start_line\": 167\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":178,"cells":{"function_name":{"kind":"string","value":"reduce"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/fusion.rs"},"focal_code":{"kind":"string","value":"fn reduce(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n let input_tensor = into_tensor(\n input_handle,\n Shape {\n dims: shape.to_vec(),\n },\n );\n let out_tensor = crate::kernel::reduce::reduce_dim::<R, In, Out, Acc>(\n input_tensor,\n axis,\n crate::kernel::reduce::ReduceStrategy::default(),\n config,\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}"},"file_content":{"kind":"string","value":"use crate::BoolElement;\nuse crate::element::CubeElement;\nuse crate::{CubeBackend, CubeRuntime, FloatElement, IntElement, kernel, tensor::CubeTensor};\n\nuse burn_cubecl_fusion::CubeFusionHandle;\nuse burn_cubecl_fusion::elemwise::optimization::ElemwiseOptimization;\nuse burn_cubecl_fusion::matmul::MatmulFallbackFn;\nuse burn_cubecl_fusion::matmul::builder::MatmulBuilder;\nuse burn_cubecl_fusion::matmul::optimization::MatmulOptimization;\nuse burn_cubecl_fusion::reduce::builder::ReduceBuilder;\nuse burn_cubecl_fusion::reduce::optimization::{\n ReduceFallbackFn, ReduceInstruction, ReduceOptimization,\n};\nuse burn_cubecl_fusion::{\n CubeOptimization, CubeOptimizationState, elemwise::builder::ElementWiseBuilder,\n};\nuse burn_fusion::{FusionBackend, FusionRuntime, client::MutexFusionClient};\nuse burn_ir::{BackendIr, TensorHandle};\nuse burn_tensor::{DType, Shape};\nuse core::marker::PhantomData;\nuse cubecl::flex32;\nuse cubecl::reduce::instructions::ReduceFnConfig;\nuse half::{bf16, f16};\nuse std::sync::Arc;\n\nimpl<R, BT> burn_fusion::Optimization<FusionCubeRuntime<R, BT>> for CubeOptimization<R>\nwhere\n R: CubeRuntime,\n BT: BoolElement,\n{\n fn execute(&mut self, context: &mut burn_fusion::stream::Context<'_, CubeFusionHandle<R>>) {\n match self {\n Self::ElementWise(op) => op.execute::<BT>(context),\n Self::Matmul(op) => op.execute::<BT>(context),\n Self::Reduce(op) => op.execute::<BT>(context),\n }\n }\n\n fn len(&self) -> usize {\n match self {\n Self::ElementWise(op) => op.num_ops_fused(),\n Self::Matmul(op) => op.num_ops_fused(),\n Self::Reduce(op) => op.num_ops_fused(),\n }\n }\n\n fn to_state(&self) -> CubeOptimizationState {\n match self {\n Self::ElementWise(value) => CubeOptimizationState::ElementWise(value.to_state()),\n Self::Matmul(value) => CubeOptimizationState::Matmul(value.to_state()),\n Self::Reduce(value) => CubeOptimizationState::Reduce(value.to_state()),\n }\n }\n\n fn from_state(device: &R::Device, state: CubeOptimizationState) -> Self {\n match state {\n CubeOptimizationState::ElementWise(state) => {\n Self::ElementWise(ElemwiseOptimization::from_state(device, state))\n }\n CubeOptimizationState::Matmul(state) => Self::Matmul(MatmulOptimization::from_state(\n device,\n state,\n Arc::new(FallbackMatmul),\n )),\n CubeOptimizationState::Reduce(state) => Self::Reduce(ReduceOptimization::from_state(\n device,\n state,\n Arc::new(FallbackReduce),\n )),\n }\n }\n}\n\nstruct FallbackMatmul;\nstruct FallbackReduce;\n\nimpl<R: CubeRuntime> MatmulFallbackFn<R> for FallbackMatmul {\n fn run(\n &self,\n lhs: (CubeFusionHandle<R>, &[usize]),\n rhs: (CubeFusionHandle<R>, &[usize]),\n ) -> CubeFusionHandle<R> {\n match lhs.0.dtype {\n DType::F64 => run_fallback_matmul::<R, f64>(lhs, rhs),\n DType::F32 => run_fallback_matmul::<R, f32>(lhs, rhs),\n DType::Flex32 => run_fallback_matmul::<R, flex32>(lhs, rhs),\n DType::F16 => run_fallback_matmul::<R, f16>(lhs, rhs),\n DType::BF16 => run_fallback_matmul::<R, bf16>(lhs, rhs),\n _ => todo!(\"Not yet supported\"),\n }\n }\n}\n\nimpl<R: CubeRuntime> ReduceFallbackFn<R> for FallbackReduce {\n fn run(\n &self,\n input: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n d_o: &DType,\n d_a: &DType,\n ) -> CubeFusionHandle<R> {\n let d_i = input.dtype;\n\n let config = match inst {\n ReduceInstruction::ArgMax => ReduceFnConfig::ArgMax,\n ReduceInstruction::ArgMin => ReduceFnConfig::ArgMin,\n ReduceInstruction::Mean => ReduceFnConfig::Mean,\n ReduceInstruction::Prod => ReduceFnConfig::Prod,\n ReduceInstruction::Sum => ReduceFnConfig::Sum,\n ReduceInstruction::Max => ReduceFnConfig::Max,\n ReduceInstruction::Min => ReduceFnConfig::Min,\n ReduceInstruction::MaxAbs => ReduceFnConfig::MaxAbs,\n };\n\n match d_a {\n DType::F64 => reduce_dtype::<R, f64>(input, shape, axis, &d_i, d_o, config),\n DType::F32 => reduce_dtype::<R, f32>(input, shape, axis, &d_i, d_o, config),\n DType::F16 => reduce_dtype::<R, f16>(input, shape, axis, &d_i, d_o, config),\n DType::I64 => reduce_dtype::<R, i64>(input, shape, axis, &d_i, d_o, config),\n DType::I32 => reduce_dtype::<R, i32>(input, shape, axis, &d_i, d_o, config),\n DType::I16 => reduce_dtype::<R, i16>(input, shape, axis, &d_i, d_o, config),\n DType::I8 => reduce_dtype::<R, i8>(input, shape, axis, &d_i, d_o, config),\n DType::U64 => reduce_dtype::<R, u64>(input, shape, axis, &d_i, d_o, config),\n DType::U32 => reduce_dtype::<R, u32>(input, shape, axis, &d_i, d_o, config),\n DType::U16 => reduce_dtype::<R, u16>(input, shape, axis, &d_i, d_o, config),\n DType::U8 => reduce_dtype::<R, u8>(input, shape, axis, &d_i, d_o, config),\n _ => todo!(\"Not yet supported\"),\n }\n }\n}\n\nfn run_fallback_matmul<R: CubeRuntime, EG: FloatElement>(\n lhs: (CubeFusionHandle<R>, &[usize]),\n rhs: (CubeFusionHandle<R>, &[usize]),\n) -> CubeFusionHandle<R> {\n let lhs_tensor = into_tensor(\n lhs.0,\n Shape {\n dims: lhs.1.to_vec(),\n },\n );\n let rhs_tensor = into_tensor(\n rhs.0,\n Shape {\n dims: rhs.1.to_vec(),\n },\n );\n let out_tensor = crate::kernel::matmul::matmul::<R, EG>(\n lhs_tensor,\n rhs_tensor,\n None,\n crate::kernel::matmul::MatmulStrategy::default(),\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}\n\nfn reduce_dtype<R: CubeRuntime, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_input: &DType,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_input {\n DType::F64 => {\n reduce_dtype_output::<R, f64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F32 | DType::Flex32 => {\n reduce_dtype_output::<R, f32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::F16 => {\n reduce_dtype_output::<R, f16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::BF16 => {\n reduce_dtype_output::<R, bf16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I64 => {\n reduce_dtype_output::<R, i64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I32 => {\n reduce_dtype_output::<R, i32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I16 => {\n reduce_dtype_output::<R, i16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::I8 => {\n reduce_dtype_output::<R, i8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U64 => {\n reduce_dtype_output::<R, u64, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U32 => {\n reduce_dtype_output::<R, u32, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U16 => {\n reduce_dtype_output::<R, u16, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n DType::U8 => {\n reduce_dtype_output::<R, u8, Acc>(input_handle, shape, axis, dtype_output, config)\n }\n _ => todo!(\"Not yet supported\"),\n }\n}\n\nfn reduce_dtype_output<R: CubeRuntime, In: CubeElement, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n match dtype_output {\n DType::F64 => reduce::<R, In, f64, Acc>(input_handle, shape, axis, config),\n DType::F32 | DType::Flex32 => reduce::<R, In, f32, Acc>(input_handle, shape, axis, config),\n DType::F16 => reduce::<R, In, f16, Acc>(input_handle, shape, axis, config),\n DType::BF16 => reduce::<R, In, bf16, Acc>(input_handle, shape, axis, config),\n DType::I64 => reduce::<R, In, i64, Acc>(input_handle, shape, axis, config),\n DType::I32 => reduce::<R, In, i32, Acc>(input_handle, shape, axis, config),\n DType::I16 => reduce::<R, In, i16, Acc>(input_handle, shape, axis, config),\n DType::U64 => reduce::<R, In, u64, Acc>(input_handle, shape, axis, config),\n DType::U32 => reduce::<R, In, u32, Acc>(input_handle, shape, axis, config),\n DType::U16 => reduce::<R, In, u16, Acc>(input_handle, shape, axis, config),\n _ => todo!(\"Not yet supported\"),\n }\n}\n\nfn reduce<R: CubeRuntime, In: CubeElement, Out: CubeElement, Acc: CubeElement>(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R> {\n let input_tensor = into_tensor(\n input_handle,\n Shape {\n dims: shape.to_vec(),\n },\n );\n let out_tensor = crate::kernel::reduce::reduce_dim::<R, In, Out, Acc>(\n input_tensor,\n axis,\n crate::kernel::reduce::ReduceStrategy::default(),\n config,\n )\n .unwrap();\n\n CubeFusionHandle {\n client: out_tensor.client,\n handle: out_tensor.handle,\n device: out_tensor.device,\n dtype: out_tensor.dtype,\n strides: out_tensor.strides,\n }\n}\n\nimpl<R: CubeRuntime, F: FloatElement, I: IntElement, BT: BoolElement> BackendIr\n for CubeBackend<R, F, I, BT>\n{\n type Handle = CubeFusionHandle<R>;\n\n fn float_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::FloatTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn int_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::IntTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn bool_tensor(handle: TensorHandle<Self::Handle>) -> burn_tensor::ops::BoolTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn quantized_tensor(\n handle: TensorHandle<Self::Handle>,\n ) -> burn_tensor::ops::QuantizedTensor<Self> {\n into_tensor(handle.handle, handle.shape)\n }\n\n fn float_tensor_handle(tensor: burn_tensor::ops::FloatTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn int_tensor_handle(tensor: burn_tensor::ops::IntTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn bool_tensor_handle(tensor: burn_tensor::ops::BoolTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n\n fn quantized_tensor_handle(tensor: burn_tensor::ops::QuantizedTensor<Self>) -> Self::Handle {\n tensor.into()\n }\n}\n\nimpl<R: CubeRuntime, BT: BoolElement> FusionRuntime for FusionCubeRuntime<R, BT> {\n type OptimizationState = CubeOptimizationState;\n type Optimization = CubeOptimization<R>;\n type FusionHandle = CubeFusionHandle<R>;\n type FusionDevice = R::CubeDevice;\n type FusionClient = MutexFusionClient<Self>;\n type BoolRepr = BT;\n\n fn optimizations(\n device: R::Device,\n ) -> Vec<Box<dyn burn_fusion::OptimizationBuilder<Self::Optimization>>> {\n vec![\n Box::new(ElementWiseBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n )),\n Box::new(MatmulBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n Arc::new(FallbackMatmul),\n )),\n Box::new(ReduceBuilder::<R>::new(\n device.clone(),\n BT::as_elem_native_unchecked().into(),\n Arc::new(FallbackReduce),\n )),\n ]\n }\n}\n\n/// Fusion runtime for JIT runtimes.\n#[derive(Debug)]\npub struct FusionCubeRuntime<R: CubeRuntime, BT: BoolElement> {\n _b: PhantomData<R>,\n _bool: PhantomData<BT>,\n}\n\nimpl<R: CubeRuntime, F: FloatElement, I: IntElement, BT: BoolElement> FusionBackend\n for CubeBackend<R, F, I, BT>\n{\n type FusionRuntime = FusionCubeRuntime<R, BT>;\n\n type FullPrecisionBackend = CubeBackend<R, f32, i32, BT>;\n\n fn cast_float(tensor: burn_tensor::ops::FloatTensor<Self>, dtype: DType) -> Self::Handle {\n fn cast<R: CubeRuntime, F: FloatElement, FTarget: FloatElement>(\n tensor: CubeTensor<R>,\n ) -> CubeFusionHandle<R> {\n CubeFusionHandle::from(kernel::cast::<R, F, FTarget>(tensor))\n }\n\n match dtype {\n DType::F32 | DType::Flex32 => cast::<R, F, f32>(tensor),\n DType::F16 => cast::<R, F, f16>(tensor),\n DType::BF16 => cast::<R, F, bf16>(tensor),\n _ => panic!(\"Casting error: {dtype:?} unsupported.\"),\n }\n }\n}\n\nfn into_tensor<R: CubeRuntime>(handle: CubeFusionHandle<R>, shape: Shape) -> CubeTensor<R> {\n CubeTensor {\n client: handle.client,\n handle: handle.handle,\n device: handle.device,\n shape,\n strides: handle.strides,\n dtype: handle.dtype,\n }\n}\n\nimpl<R: CubeRuntime> From<CubeTensor<R>> for CubeFusionHandle<R> {\n fn from(value: CubeTensor<R>) -> Self {\n Self {\n client: value.client,\n handle: value.handle,\n device: value.device,\n strides: value.strides,\n dtype: value.dtype,\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 265,\n \"name\": \"reduce\",\n \"signature\": \"fn reduce(\\n input_handle: CubeFusionHandle<R>,\\n shape: &[usize],\\n axis: usize,\\n config: ReduceFnConfig,\\n) -> CubeFusionHandle<R>\",\n \"start_line\": 238\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":179,"cells":{"function_name":{"kind":"string","value":"expand"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/ops/base.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn expand(tensor: CubeTensor<R>, target_shape: Shape) -> CubeTensor<R> {\n let ndims_in = tensor.shape.num_dims();\n let ndims_out = target_shape.num_dims();\n\n // Initialize new strides with zeros\n let mut new_strides = vec![0usize; ndims_out];\n\n // Calculate the difference in dimensions\n let dim_diff = ndims_out.saturating_sub(ndims_in);\n\n // Compare dimensions from the end, setting strides for matching dimensions or broadcasted ones\n let mut tensor_dim_iter = tensor.shape.dims.iter().rev();\n for i in (0..ndims_out).rev() {\n if i >= dim_diff {\n if let Some(&tensor_dim) = tensor_dim_iter.next() {\n if tensor_dim == target_shape.dims[i] || tensor_dim == 1 {\n // Copy stride for non-broadcast dimensions or set to 0 for broadcast ones\n new_strides[i] = if tensor_dim == target_shape.dims[i] {\n tensor.strides[i - dim_diff]\n } else {\n 0\n };\n } else {\n // Error handling: Dimension mismatch for broadcasting\n panic!(\n \"Dimension mismatch: cannot broadcast dimension {} of tensor to target shape\",\n tensor_dim\n );\n }\n } else {\n // If the input tensor has fewer dimensions, treat missing dimensions as 1\n // and set stride to 0 (broadcasting)\n new_strides[i] = 0;\n }\n } else {\n // For extra dimensions in the target shape, set stride to 0 (broadcasting)\n new_strides[i] = 0;\n }\n }\n\n CubeTensor {\n client: tensor.client,\n device: tensor.device,\n shape: target_shape,\n strides: new_strides,\n handle: tensor.handle,\n dtype: tensor.dtype,\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, element::CubeElement, kernel, tensor::CubeTensor};\nuse burn_tensor::{Shape, TensorData};\nuse cubecl::tensor_vectorization_factor;\n\npub(crate) fn from_data<R: CubeRuntime>(data: TensorData, device: &R::Device) -> CubeTensor<R> {\n let shape: Shape = (&data.shape).into();\n let client = R::client(device);\n let buffer = client.create(data.as_bytes());\n\n CubeTensor::new_contiguous(client, device.clone(), shape, buffer, data.dtype)\n}\n\npub(crate) async fn into_data<R: CubeRuntime, E: CubeElement>(tensor: CubeTensor<R>) -> TensorData {\n let tensor = kernel::into_contiguous(tensor);\n let bytes = tensor\n .client\n .read_async(vec![tensor.handle.binding()])\n .await;\n let bytes = &bytes[0];\n let actual_len = tensor.shape.num_elements() * size_of::<E>();\n TensorData::new(E::from_bytes(&bytes[..actual_len]).to_vec(), tensor.shape)\n}\n\n/// Read data from a `CubeTensor` synchronously\n#[allow(unused, reason = \"useful for debugging kernels\")]\npub fn into_data_sync<R: CubeRuntime, E: CubeElement>(tensor: CubeTensor<R>) -> TensorData {\n let tensor = kernel::into_contiguous(tensor);\n\n let bytes = tensor.client.read_one(tensor.handle.binding());\n let actual_len = tensor.shape.num_elements() * size_of::<E>();\n TensorData::new(E::from_bytes(&bytes[..actual_len]).to_vec(), tensor.shape)\n}\n\npub(crate) fn to_device<R: CubeRuntime>(\n tensor: CubeTensor<R>,\n device: &R::Device,\n) -> CubeTensor<R> {\n if &tensor.device == device {\n return tensor;\n }\n\n let client = R::client(device);\n tensor.to_client(client, device.clone())\n}\n\npub(crate) fn empty<R: CubeRuntime, E: CubeElement>(\n shape: Shape,\n device: &R::Device,\n) -> CubeTensor<R> {\n let client = R::client(device);\n let buffer = client.empty(shape.num_elements() * core::mem::size_of::<E>());\n\n CubeTensor::new_contiguous(client, device.clone(), shape, buffer, E::dtype())\n}\n\npub(crate) fn swap_dims<R: CubeRuntime>(\n mut tensor: CubeTensor<R>,\n dim1: usize,\n dim2: usize,\n) -> CubeTensor<R> {\n tensor.strides.swap(dim1, dim2);\n tensor.shape.dims.swap(dim1, dim2);\n\n tensor\n}\n\n/// Permute a tensor's dimensions\npub fn permute<R: CubeRuntime>(mut tensor: CubeTensor<R>, axes: &[usize]) -> CubeTensor<R> {\n // remap strides\n tensor.strides = axes.iter().map(|i| tensor.strides[*i]).collect();\n\n // remap shape\n tensor.shape.dims = axes.iter().map(|i| tensor.shape.dims[*i]).collect();\n\n tensor\n}\n\n/// Permute a tensor's dimensions from NCHW to NHWC, or the N-dimensional equivalent\npub fn permute_nchw_to_nhwc<R: CubeRuntime>(tensor: CubeTensor<R>) -> CubeTensor<R> {\n let rank = tensor.shape.num_dims();\n let c_dim = 1;\n\n let mut dims = vec![0];\n dims.extend(2..rank);\n dims.push(c_dim);\n\n permute(tensor, &dims)\n}\n\n/// Permute a tensor's dimensions from NHWC to NCHW, or the N-dimensional equivalent\npub fn permute_nhwc_to_nchw<R: CubeRuntime>(tensor: CubeTensor<R>) -> CubeTensor<R> {\n let rank = tensor.shape.num_dims();\n let c_dim = rank - 1;\n\n let mut dims = vec![0];\n dims.push(c_dim);\n dims.extend(1..c_dim);\n\n permute(tensor, &dims)\n}\n\npub(crate) fn expand<R: CubeRuntime>(tensor: CubeTensor<R>, target_shape: Shape) -> CubeTensor<R> {\n let ndims_in = tensor.shape.num_dims();\n let ndims_out = target_shape.num_dims();\n\n // Initialize new strides with zeros\n let mut new_strides = vec![0usize; ndims_out];\n\n // Calculate the difference in dimensions\n let dim_diff = ndims_out.saturating_sub(ndims_in);\n\n // Compare dimensions from the end, setting strides for matching dimensions or broadcasted ones\n let mut tensor_dim_iter = tensor.shape.dims.iter().rev();\n for i in (0..ndims_out).rev() {\n if i >= dim_diff {\n if let Some(&tensor_dim) = tensor_dim_iter.next() {\n if tensor_dim == target_shape.dims[i] || tensor_dim == 1 {\n // Copy stride for non-broadcast dimensions or set to 0 for broadcast ones\n new_strides[i] = if tensor_dim == target_shape.dims[i] {\n tensor.strides[i - dim_diff]\n } else {\n 0\n };\n } else {\n // Error handling: Dimension mismatch for broadcasting\n panic!(\n \"Dimension mismatch: cannot broadcast dimension {} of tensor to target shape\",\n tensor_dim\n );\n }\n } else {\n // If the input tensor has fewer dimensions, treat missing dimensions as 1\n // and set stride to 0 (broadcasting)\n new_strides[i] = 0;\n }\n } else {\n // For extra dimensions in the target shape, set stride to 0 (broadcasting)\n new_strides[i] = 0;\n }\n }\n\n CubeTensor {\n client: tensor.client,\n device: tensor.device,\n shape: target_shape,\n strides: new_strides,\n handle: tensor.handle,\n dtype: tensor.dtype,\n }\n}\n\n/// Reshape a jit tensor to a new shape\npub fn reshape<R: CubeRuntime>(tensor: CubeTensor<R>, shape: Shape) -> CubeTensor<R> {\n // TODO: Not force standard layout all the time (improve performance).\n let tensor = kernel::into_contiguous(tensor);\n\n CubeTensor::new_contiguous(\n tensor.client,\n tensor.device,\n shape,\n tensor.handle,\n tensor.dtype,\n )\n}\n\npub(crate) fn max_line_size<R: CubeRuntime>(tensor: &CubeTensor<R>) -> u8 {\n tensor_vectorization_factor(\n R::supported_line_sizes(),\n &tensor.shape.dims,\n &tensor.strides,\n tensor.shape.num_dims() - 1,\n )\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 150,\n \"name\": \"expand\",\n \"signature\": \"pub(crate) fn expand(tensor: CubeTensor<R>, target_shape: Shape) -> CubeTensor<R>\",\n \"start_line\": 102\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":180,"cells":{"function_name":{"kind":"string","value":"float_powf_scalar"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/ops/float_ops.rs"},"focal_code":{"kind":"string","value":"fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\n struct Powf;\n\n #[cube]\n impl<F: Float> FloatUnaryOp<F> for Powf {\n type Options = F;\n\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\n Line::powf(input, Line::new(*options))\n }\n }\n\n impl FloatUnaryOpFamily for Powf {\n type Options<F: Float> = F;\n type Unary<F: Float> = Self;\n }\n\n execute_with_dtype!(\n float(lhs.dtype),\n F,\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\n )\n }"},"file_content":{"kind":"string","value":"use super::{expand, numeric, permute};\nuse crate::kernel::prng::{random_bernoulli, random_normal, random_uniform};\nuse crate::kernel::unary_basic::BasicFloatUnaryKind;\nuse crate::kernel::{\n self, FloatUnaryOp, FloatUnaryOpFamily, launch_unary_float, reduce, unary_basic,\n};\nuse crate::{CubeBackend, execute_with_dtype};\nuse crate::{CubeRuntime, FloatElement, IntElement};\nuse crate::{\n element::BoolElement,\n kernel::matmul::{MatmulStrategy, matmul},\n};\nuse burn_tensor::ops::{BoolTensor, Device, FloatElem, FloatTensor, IntTensor};\nuse burn_tensor::{DType, ElementConversion, FloatDType};\nuse burn_tensor::{Distribution, Shape, TensorData, ops::FloatTensorOps};\nuse cubecl::prelude::*;\nuse cubecl::reduce::ReducePrecision;\nuse cubecl::reduce::instructions::ReduceFnConfig;\nuse half::{bf16, f16};\nuse std::ops::Range;\n\nimpl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\nwhere\n R: CubeRuntime,\n F: FloatElement,\n I: IntElement,\n BT: BoolElement,\n{\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n match data.dtype {\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\n super::from_data::<R>(data, device)\n }\n _ => unimplemented!(\"Unsupported dtype for `float_from_data`\"),\n }\n }\n\n fn float_random(\n shape: Shape,\n distribution: Distribution,\n device: &Device<Self>,\n ) -> FloatTensor<Self> {\n match distribution {\n Distribution::Default => random_uniform(shape, device, 0.elem::<F>(), 1.elem()),\n Distribution::Uniform(low, high) => {\n random_uniform(shape, device, low.elem::<F>(), high.elem())\n }\n Distribution::Bernoulli(prob) => random_bernoulli(shape, device, prob.elem::<F>()),\n Distribution::Normal(mean, std) => {\n random_normal(shape, device, mean.elem::<F>(), std.elem())\n }\n }\n }\n\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n super::into_data::<R, E>(tensor).await\n )\n }\n\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\n tensor.device.clone()\n }\n\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\n super::to_device(tensor, device)\n }\n\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n super::empty::<R, F>(shape, device)\n }\n\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::add::<R, E>(lhs, rhs)\n )\n }\n\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::add_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n numeric::zeros::<R, F>(shape, device)\n }\n\n fn float_full(\n shape: Shape,\n fill_value: FloatElem<Self>,\n device: &R::Device,\n ) -> FloatTensor<Self> {\n numeric::full::<R, F>(shape, device, fill_value)\n }\n\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n numeric::ones::<R, F>(shape, device)\n }\n\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::sub::<R, E>(lhs, rhs)\n )\n }\n\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::sub_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::mul::<R, E>(lhs, rhs)\n )\n }\n\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::mul_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::div::<R, E>(lhs, rhs)\n )\n }\n\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::div_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::remainder::<R, E>(lhs, rhs)\n )\n }\n\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::remainder_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n matmul::<R, E>(lhs, rhs, None, MatmulStrategy::default()).unwrap()\n )\n }\n\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\n super::swap_dims(tensor, dim1, dim2)\n }\n\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n super::reshape(tensor, shape)\n }\n\n fn float_gather(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::gather::<R, E, I>(dim, tensor, indices)\n )\n }\n\n fn float_scatter(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<Self>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::scatter::<R, E, I>(dim, tensor, indices, value)\n )\n }\n\n fn float_select(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::select::<R, E, I>(tensor, dim, indices)\n )\n }\n\n fn float_select_assign(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<Self>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::select_assign::<R, E, I>(tensor, dim, indices, value)\n )\n }\n\n fn float_slice(tensor: FloatTensor<Self>, ranges: &[Range<usize>]) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::slice::<R, E>(tensor, ranges)\n )\n }\n\n fn float_slice_assign(\n tensor: FloatTensor<Self>,\n ranges: &[Range<usize>],\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::slice_assign::<R, E>(tensor, ranges, value)\n )\n }\n\n fn float_mask_where(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<Self>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::mask_where_auto::<R, E, BT>(tensor, mask, value)\n )\n }\n\n fn float_mask_fill(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<Self>,\n value: FloatElem<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::mask_fill_auto::<R, E, BT>(tensor, mask, value.elem())\n )\n }\n\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::equal::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::equal_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::greater::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::greater_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::greater_equal::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::greater_equal_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::lower::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::lower_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::lower_equal::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::lower_equal_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::sum::<R, E>(tensor, Default::default()).unwrap()\n )\n }\n\n fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Max).unwrap()\n )\n }\n\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Max)\n .unwrap()\n )\n }\n\n fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Min).unwrap()\n )\n }\n\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Min)\n .unwrap()\n )\n }\n\n fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::MaxAbs)\n .unwrap()\n )\n }\n\n fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, E>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::MaxAbs\n )\n .unwrap()\n )\n }\n\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::Sum\n )\n .unwrap()\n )\n }\n\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::Mean\n )\n .unwrap()\n )\n }\n\n fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n Default::default(),\n ReduceFnConfig::Prod\n )\n .unwrap()\n )\n }\n\n fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::Prod\n )\n .unwrap()\n )\n }\n\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Exp)\n }\n\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log)\n }\n\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log1p)\n }\n\n fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\n struct Powf;\n\n #[cube]\n impl<F: Float> FloatUnaryOp<F> for Powf {\n type Options = F;\n\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\n Line::powf(input, Line::new(*options))\n }\n }\n\n impl FloatUnaryOpFamily for Powf {\n type Options<F: Float> = F;\n type Unary<F: Float> = Self;\n }\n\n execute_with_dtype!(\n float(lhs.dtype),\n F,\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\n )\n }\n\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sqrt)\n }\n\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Abs)\n }\n\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Cos)\n }\n\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sin)\n }\n\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Tanh)\n }\n\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Round)\n }\n\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Floor)\n }\n\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Ceil)\n }\n\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Erf)\n }\n\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, I, E>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::ArgMax\n )\n .unwrap()\n )\n }\n\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, I, E>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::ArgMin\n )\n .unwrap()\n )\n }\n\n fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {\n execute_with_dtype!(float(tensor.dtype), E, kernel::cast::<R, E, I>(tensor))\n }\n\n fn float_clamp(\n tensor: FloatTensor<Self>,\n min: FloatElem<Self>,\n max: FloatElem<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::clamp::<R, E>(tensor, min.elem(), max.elem())\n )\n }\n\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Recip)\n }\n\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::repeat_dim::<R, E>(tensor, dim, times)\n )\n }\n\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(float(lhs.dtype), E, numeric::pow::<R, E>(lhs, rhs))\n }\n\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n permute(tensor, axes)\n }\n\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n expand(tensor, shape)\n }\n\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::flip::<R, E, BT>(tensor, axes)\n )\n }\n\n fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\n match (tensor.dtype, dtype) {\n (DType::F64, FloatDType::F64)\n | (DType::F32, FloatDType::F32)\n | (DType::BF16, FloatDType::BF16)\n | (DType::F16, FloatDType::F16) => tensor,\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\n _ => unimplemented!(\"Unsupported floating point type cast\"),\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"{\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n match data.dtype {\\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\\n super::from_data::<R>(data, device)\\n }\\n _ => unimplemented!(\\\"Unsupported dtype for `float_from_data`\\\"),\\n }\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n match distribution {\\n Distribution::Default => random_uniform(shape, device, 0.elem::<F>(), 1.elem()),\\n Distribution::Uniform(low, high) => {\\n random_uniform(shape, device, low.elem::<F>(), high.elem())\\n }\\n Distribution::Bernoulli(prob) => random_bernoulli(shape, device, prob.elem::<F>()),\\n Distribution::Normal(mean, std) => {\\n random_normal(shape, device, mean.elem::<F>(), std.elem())\\n }\\n }\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n super::into_data::<R, E>(tensor).await\\n )\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n tensor.device.clone()\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n super::to_device(tensor, device)\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n super::empty::<R, F>(shape, device)\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::add::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::add_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::zeros::<R, F>(shape, device)\\n }\\n\\n fn float_full(\\n shape: Shape,\\n fill_value: FloatElem<Self>,\\n device: &R::Device,\\n ) -> FloatTensor<Self> {\\n numeric::full::<R, F>(shape, device, fill_value)\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::ones::<R, F>(shape, device)\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::sub::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::sub_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::mul::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::mul_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::div::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::div_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::remainder::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::remainder_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n matmul::<R, E>(lhs, rhs, None, MatmulStrategy::default()).unwrap()\\n )\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n super::swap_dims(tensor, dim1, dim2)\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n super::reshape(tensor, shape)\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::gather::<R, E, I>(dim, tensor, indices)\\n )\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::scatter::<R, E, I>(dim, tensor, indices, value)\\n )\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::select::<R, E, I>(tensor, dim, indices)\\n )\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::select_assign::<R, E, I>(tensor, dim, indices, value)\\n )\\n }\\n\\n fn float_slice(tensor: FloatTensor<Self>, ranges: &[Range<usize>]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::slice::<R, E>(tensor, ranges)\\n )\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::slice_assign::<R, E>(tensor, ranges, value)\\n )\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::mask_where_auto::<R, E, BT>(tensor, mask, value)\\n )\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::mask_fill_auto::<R, E, BT>(tensor, mask, value.elem())\\n )\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::sum::<R, E>(tensor, Default::default()).unwrap()\\n )\\n }\\n\\n fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Max).unwrap()\\n )\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Max)\\n .unwrap()\\n )\\n }\\n\\n fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Min).unwrap()\\n )\\n }\\n\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Min)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::MaxAbs)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::MaxAbs\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Sum\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Mean\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Exp)\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log)\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log1p)\\n }\\n\\n fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\\n struct Powf;\\n\\n #[cube]\\n impl<F: Float> FloatUnaryOp<F> for Powf {\\n type Options = F;\\n\\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\\n Line::powf(input, Line::new(*options))\\n }\\n }\\n\\n impl FloatUnaryOpFamily for Powf {\\n type Options<F: Float> = F;\\n type Unary<F: Float> = Self;\\n }\\n\\n execute_with_dtype!(\\n float(lhs.dtype),\\n F,\\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\\n )\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sqrt)\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Abs)\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Cos)\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sin)\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Tanh)\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Round)\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Floor)\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Ceil)\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Erf)\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMax\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMin\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {\\n execute_with_dtype!(float(tensor.dtype), E, kernel::cast::<R, E, I>(tensor))\\n }\\n\\n fn float_clamp(\\n tensor: FloatTensor<Self>,\\n min: FloatElem<Self>,\\n max: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::clamp::<R, E>(tensor, min.elem(), max.elem())\\n )\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Recip)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::repeat_dim::<R, E>(tensor, dim, times)\\n )\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(float(lhs.dtype), E, numeric::pow::<R, E>(lhs, rhs))\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n permute(tensor, axes)\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n expand(tensor, shape)\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::flip::<R, E, BT>(tensor, axes)\\n )\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\\n match (tensor.dtype, dtype) {\\n (DType::F64, FloatDType::F64)\\n | (DType::F32, FloatDType::F32)\\n | (DType::BF16, FloatDType::BF16)\\n | (DType::F16, FloatDType::F16) => tensor,\\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\\n _ => unimplemented!(\\\"Unsupported floating point type cast\\\"),\\n }\\n }\\n}\"\n ],\n \"name\": \"lhs\",\n \"type\": \"FloatTensor<Self>\"\n }\n ],\n \"end_line\": 515,\n \"name\": \"float_powf_scalar\",\n \"signature\": \"fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self>\",\n \"start_line\": 493\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\\nwhere\\n R: CubeRuntime,\\n F: FloatElement,\\n I: IntElement,\\n BT: BoolElement,\\n{\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n match data.dtype {\\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\\n super::from_data::<R>(data, device)\\n }\\n _ => unimplemented!(\\\"Unsupported dtype for `float_from_data`\\\"),\\n }\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n match distribution {\\n Distribution::Default => random_uniform(shape, device, 0.elem::<F>(), 1.elem()),\\n Distribution::Uniform(low, high) => {\\n random_uniform(shape, device, low.elem::<F>(), high.elem())\\n }\\n Distribution::Bernoulli(prob) => random_bernoulli(shape, device, prob.elem::<F>()),\\n Distribution::Normal(mean, std) => {\\n random_normal(shape, device, mean.elem::<F>(), std.elem())\\n }\\n }\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n super::into_data::<R, E>(tensor).await\\n )\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n tensor.device.clone()\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n super::to_device(tensor, device)\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n super::empty::<R, F>(shape, device)\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::add::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::add_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::zeros::<R, F>(shape, device)\\n }\\n\\n fn float_full(\\n shape: Shape,\\n fill_value: FloatElem<Self>,\\n device: &R::Device,\\n ) -> FloatTensor<Self> {\\n numeric::full::<R, F>(shape, device, fill_value)\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::ones::<R, F>(shape, device)\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::sub::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::sub_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::mul::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::mul_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::div::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::div_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::remainder::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::remainder_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n matmul::<R, E>(lhs, rhs, None, MatmulStrategy::default()).unwrap()\\n )\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n super::swap_dims(tensor, dim1, dim2)\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n super::reshape(tensor, shape)\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::gather::<R, E, I>(dim, tensor, indices)\\n )\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::scatter::<R, E, I>(dim, tensor, indices, value)\\n )\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::select::<R, E, I>(tensor, dim, indices)\\n )\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::select_assign::<R, E, I>(tensor, dim, indices, value)\\n )\\n }\\n\\n fn float_slice(tensor: FloatTensor<Self>, ranges: &[Range<usize>]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::slice::<R, E>(tensor, ranges)\\n )\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::slice_assign::<R, E>(tensor, ranges, value)\\n )\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::mask_where_auto::<R, E, BT>(tensor, mask, value)\\n )\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::mask_fill_auto::<R, E, BT>(tensor, mask, value.elem())\\n )\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::sum::<R, E>(tensor, Default::default()).unwrap()\\n )\\n }\\n\\n fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Max).unwrap()\\n )\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Max)\\n .unwrap()\\n )\\n }\\n\\n fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Min).unwrap()\\n )\\n }\\n\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Min)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::MaxAbs)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::MaxAbs\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Sum\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Mean\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Exp)\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log)\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log1p)\\n }\\n\\n fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\\n struct Powf;\\n\\n #[cube]\\n impl<F: Float> FloatUnaryOp<F> for Powf {\\n type Options = F;\\n\\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\\n Line::powf(input, Line::new(*options))\\n }\\n }\\n\\n impl FloatUnaryOpFamily for Powf {\\n type Options<F: Float> = F;\\n type Unary<F: Float> = Self;\\n }\\n\\n execute_with_dtype!(\\n float(lhs.dtype),\\n F,\\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\\n )\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sqrt)\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Abs)\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Cos)\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sin)\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Tanh)\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Round)\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Floor)\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Ceil)\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Erf)\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMax\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMin\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {\\n execute_with_dtype!(float(tensor.dtype), E, kernel::cast::<R, E, I>(tensor))\\n }\\n\\n fn float_clamp(\\n tensor: FloatTensor<Self>,\\n min: FloatElem<Self>,\\n max: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::clamp::<R, E>(tensor, min.elem(), max.elem())\\n )\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Recip)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::repeat_dim::<R, E>(tensor, dim, times)\\n )\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(float(lhs.dtype), E, numeric::pow::<R, E>(lhs, rhs))\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n permute(tensor, axes)\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n expand(tensor, shape)\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::flip::<R, E, BT>(tensor, axes)\\n )\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\\n match (tensor.dtype, dtype) {\\n (DType::F64, FloatDType::F64)\\n | (DType::F32, FloatDType::F32)\\n | (DType::BF16, FloatDType::BF16)\\n | (DType::F16, FloatDType::F16) => tensor,\\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\\n _ => unimplemented!(\\\"Unsupported floating point type cast\\\"),\\n }\\n }\\n}\",\n \"class_signature\": \"impl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\\nwhere\\n R: CubeRuntime,\\n F: FloatElement,\\n I: IntElement,\\n BT: BoolElement,\"\n}"}}},{"rowIdx":181,"cells":{"function_name":{"kind":"string","value":"float_cast"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/ops/float_ops.rs"},"focal_code":{"kind":"string","value":"fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\n match (tensor.dtype, dtype) {\n (DType::F64, FloatDType::F64)\n | (DType::F32, FloatDType::F32)\n | (DType::BF16, FloatDType::BF16)\n | (DType::F16, FloatDType::F16) => tensor,\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\n _ => unimplemented!(\"Unsupported floating point type cast\"),\n }\n }"},"file_content":{"kind":"string","value":"use super::{expand, numeric, permute};\nuse crate::kernel::prng::{random_bernoulli, random_normal, random_uniform};\nuse crate::kernel::unary_basic::BasicFloatUnaryKind;\nuse crate::kernel::{\n self, FloatUnaryOp, FloatUnaryOpFamily, launch_unary_float, reduce, unary_basic,\n};\nuse crate::{CubeBackend, execute_with_dtype};\nuse crate::{CubeRuntime, FloatElement, IntElement};\nuse crate::{\n element::BoolElement,\n kernel::matmul::{MatmulStrategy, matmul},\n};\nuse burn_tensor::ops::{BoolTensor, Device, FloatElem, FloatTensor, IntTensor};\nuse burn_tensor::{DType, ElementConversion, FloatDType};\nuse burn_tensor::{Distribution, Shape, TensorData, ops::FloatTensorOps};\nuse cubecl::prelude::*;\nuse cubecl::reduce::ReducePrecision;\nuse cubecl::reduce::instructions::ReduceFnConfig;\nuse half::{bf16, f16};\nuse std::ops::Range;\n\nimpl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\nwhere\n R: CubeRuntime,\n F: FloatElement,\n I: IntElement,\n BT: BoolElement,\n{\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n match data.dtype {\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\n super::from_data::<R>(data, device)\n }\n _ => unimplemented!(\"Unsupported dtype for `float_from_data`\"),\n }\n }\n\n fn float_random(\n shape: Shape,\n distribution: Distribution,\n device: &Device<Self>,\n ) -> FloatTensor<Self> {\n match distribution {\n Distribution::Default => random_uniform(shape, device, 0.elem::<F>(), 1.elem()),\n Distribution::Uniform(low, high) => {\n random_uniform(shape, device, low.elem::<F>(), high.elem())\n }\n Distribution::Bernoulli(prob) => random_bernoulli(shape, device, prob.elem::<F>()),\n Distribution::Normal(mean, std) => {\n random_normal(shape, device, mean.elem::<F>(), std.elem())\n }\n }\n }\n\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n super::into_data::<R, E>(tensor).await\n )\n }\n\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\n tensor.device.clone()\n }\n\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\n super::to_device(tensor, device)\n }\n\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n super::empty::<R, F>(shape, device)\n }\n\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::add::<R, E>(lhs, rhs)\n )\n }\n\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::add_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n numeric::zeros::<R, F>(shape, device)\n }\n\n fn float_full(\n shape: Shape,\n fill_value: FloatElem<Self>,\n device: &R::Device,\n ) -> FloatTensor<Self> {\n numeric::full::<R, F>(shape, device, fill_value)\n }\n\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\n numeric::ones::<R, F>(shape, device)\n }\n\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::sub::<R, E>(lhs, rhs)\n )\n }\n\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::sub_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::mul::<R, E>(lhs, rhs)\n )\n }\n\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::mul_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::div::<R, E>(lhs, rhs)\n )\n }\n\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::div_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n numeric::remainder::<R, E>(lhs, rhs)\n )\n }\n\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n numeric::remainder_scalar::<R, E>(lhs, rhs.elem())\n )\n }\n\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n matmul::<R, E>(lhs, rhs, None, MatmulStrategy::default()).unwrap()\n )\n }\n\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\n super::swap_dims(tensor, dim1, dim2)\n }\n\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n super::reshape(tensor, shape)\n }\n\n fn float_gather(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::gather::<R, E, I>(dim, tensor, indices)\n )\n }\n\n fn float_scatter(\n dim: usize,\n tensor: FloatTensor<Self>,\n indices: IntTensor<Self>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::scatter::<R, E, I>(dim, tensor, indices, value)\n )\n }\n\n fn float_select(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::select::<R, E, I>(tensor, dim, indices)\n )\n }\n\n fn float_select_assign(\n tensor: FloatTensor<Self>,\n dim: usize,\n indices: IntTensor<Self>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::select_assign::<R, E, I>(tensor, dim, indices, value)\n )\n }\n\n fn float_slice(tensor: FloatTensor<Self>, ranges: &[Range<usize>]) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::slice::<R, E>(tensor, ranges)\n )\n }\n\n fn float_slice_assign(\n tensor: FloatTensor<Self>,\n ranges: &[Range<usize>],\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::slice_assign::<R, E>(tensor, ranges, value)\n )\n }\n\n fn float_mask_where(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<Self>,\n value: FloatTensor<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype, value.dtype),\n E,\n kernel::mask_where_auto::<R, E, BT>(tensor, mask, value)\n )\n }\n\n fn float_mask_fill(\n tensor: FloatTensor<Self>,\n mask: BoolTensor<Self>,\n value: FloatElem<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::mask_fill_auto::<R, E, BT>(tensor, mask, value.elem())\n )\n }\n\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::equal::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::equal_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::greater::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::greater_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::greater_equal::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::greater_equal_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::lower::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::lower_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype, rhs.dtype),\n E,\n kernel::lower_equal::<R, E, BT>(lhs, rhs)\n )\n }\n\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\n execute_with_dtype!(\n float(lhs.dtype),\n E,\n kernel::lower_equal_elem::<R, E, BT>(lhs, rhs.elem())\n )\n }\n\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::sum::<R, E>(tensor, Default::default()).unwrap()\n )\n }\n\n fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Max).unwrap()\n )\n }\n\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Max)\n .unwrap()\n )\n }\n\n fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Min).unwrap()\n )\n }\n\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Min)\n .unwrap()\n )\n }\n\n fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::MaxAbs)\n .unwrap()\n )\n }\n\n fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, E>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::MaxAbs\n )\n .unwrap()\n )\n }\n\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::Sum\n )\n .unwrap()\n )\n }\n\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::Mean\n )\n .unwrap()\n )\n }\n\n fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n Default::default(),\n ReduceFnConfig::Prod\n )\n .unwrap()\n )\n }\n\n fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::Prod\n )\n .unwrap()\n )\n }\n\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Exp)\n }\n\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log)\n }\n\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log1p)\n }\n\n fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\n struct Powf;\n\n #[cube]\n impl<F: Float> FloatUnaryOp<F> for Powf {\n type Options = F;\n\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\n Line::powf(input, Line::new(*options))\n }\n }\n\n impl FloatUnaryOpFamily for Powf {\n type Options<F: Float> = F;\n type Unary<F: Float> = Self;\n }\n\n execute_with_dtype!(\n float(lhs.dtype),\n F,\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\n )\n }\n\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sqrt)\n }\n\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Abs)\n }\n\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Cos)\n }\n\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sin)\n }\n\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Tanh)\n }\n\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Round)\n }\n\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Floor)\n }\n\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Ceil)\n }\n\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Erf)\n }\n\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, I, E>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::ArgMax\n )\n .unwrap()\n )\n }\n\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n reduce::reduce_dim::<R, E, I, E>(\n tensor,\n dim,\n Default::default(),\n ReduceFnConfig::ArgMin\n )\n .unwrap()\n )\n }\n\n fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {\n execute_with_dtype!(float(tensor.dtype), E, kernel::cast::<R, E, I>(tensor))\n }\n\n fn float_clamp(\n tensor: FloatTensor<Self>,\n min: FloatElem<Self>,\n max: FloatElem<Self>,\n ) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::clamp::<R, E>(tensor, min.elem(), max.elem())\n )\n }\n\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Recip)\n }\n\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::repeat_dim::<R, E>(tensor, dim, times)\n )\n }\n\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\n execute_with_dtype!(float(lhs.dtype), E, numeric::pow::<R, E>(lhs, rhs))\n }\n\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n permute(tensor, axes)\n }\n\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\n expand(tensor, shape)\n }\n\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\n execute_with_dtype!(\n float(tensor.dtype),\n E,\n kernel::flip::<R, E, BT>(tensor, axes)\n )\n }\n\n fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\n match (tensor.dtype, dtype) {\n (DType::F64, FloatDType::F64)\n | (DType::F32, FloatDType::F32)\n | (DType::BF16, FloatDType::BF16)\n | (DType::F16, FloatDType::F16) => tensor,\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\n _ => unimplemented!(\"Unsupported floating point type cast\"),\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"{\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n match data.dtype {\\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\\n super::from_data::<R>(data, device)\\n }\\n _ => unimplemented!(\\\"Unsupported dtype for `float_from_data`\\\"),\\n }\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n match distribution {\\n Distribution::Default => random_uniform(shape, device, 0.elem::<F>(), 1.elem()),\\n Distribution::Uniform(low, high) => {\\n random_uniform(shape, device, low.elem::<F>(), high.elem())\\n }\\n Distribution::Bernoulli(prob) => random_bernoulli(shape, device, prob.elem::<F>()),\\n Distribution::Normal(mean, std) => {\\n random_normal(shape, device, mean.elem::<F>(), std.elem())\\n }\\n }\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n super::into_data::<R, E>(tensor).await\\n )\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n tensor.device.clone()\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n super::to_device(tensor, device)\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n super::empty::<R, F>(shape, device)\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::add::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::add_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::zeros::<R, F>(shape, device)\\n }\\n\\n fn float_full(\\n shape: Shape,\\n fill_value: FloatElem<Self>,\\n device: &R::Device,\\n ) -> FloatTensor<Self> {\\n numeric::full::<R, F>(shape, device, fill_value)\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::ones::<R, F>(shape, device)\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::sub::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::sub_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::mul::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::mul_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::div::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::div_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::remainder::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::remainder_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n matmul::<R, E>(lhs, rhs, None, MatmulStrategy::default()).unwrap()\\n )\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n super::swap_dims(tensor, dim1, dim2)\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n super::reshape(tensor, shape)\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::gather::<R, E, I>(dim, tensor, indices)\\n )\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::scatter::<R, E, I>(dim, tensor, indices, value)\\n )\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::select::<R, E, I>(tensor, dim, indices)\\n )\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::select_assign::<R, E, I>(tensor, dim, indices, value)\\n )\\n }\\n\\n fn float_slice(tensor: FloatTensor<Self>, ranges: &[Range<usize>]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::slice::<R, E>(tensor, ranges)\\n )\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::slice_assign::<R, E>(tensor, ranges, value)\\n )\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::mask_where_auto::<R, E, BT>(tensor, mask, value)\\n )\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::mask_fill_auto::<R, E, BT>(tensor, mask, value.elem())\\n )\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::sum::<R, E>(tensor, Default::default()).unwrap()\\n )\\n }\\n\\n fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Max).unwrap()\\n )\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Max)\\n .unwrap()\\n )\\n }\\n\\n fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Min).unwrap()\\n )\\n }\\n\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Min)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::MaxAbs)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::MaxAbs\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Sum\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Mean\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Exp)\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log)\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log1p)\\n }\\n\\n fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\\n struct Powf;\\n\\n #[cube]\\n impl<F: Float> FloatUnaryOp<F> for Powf {\\n type Options = F;\\n\\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\\n Line::powf(input, Line::new(*options))\\n }\\n }\\n\\n impl FloatUnaryOpFamily for Powf {\\n type Options<F: Float> = F;\\n type Unary<F: Float> = Self;\\n }\\n\\n execute_with_dtype!(\\n float(lhs.dtype),\\n F,\\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\\n )\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sqrt)\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Abs)\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Cos)\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sin)\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Tanh)\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Round)\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Floor)\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Ceil)\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Erf)\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMax\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMin\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {\\n execute_with_dtype!(float(tensor.dtype), E, kernel::cast::<R, E, I>(tensor))\\n }\\n\\n fn float_clamp(\\n tensor: FloatTensor<Self>,\\n min: FloatElem<Self>,\\n max: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::clamp::<R, E>(tensor, min.elem(), max.elem())\\n )\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Recip)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::repeat_dim::<R, E>(tensor, dim, times)\\n )\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(float(lhs.dtype), E, numeric::pow::<R, E>(lhs, rhs))\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n permute(tensor, axes)\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n expand(tensor, shape)\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::flip::<R, E, BT>(tensor, axes)\\n )\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\\n match (tensor.dtype, dtype) {\\n (DType::F64, FloatDType::F64)\\n | (DType::F32, FloatDType::F32)\\n | (DType::BF16, FloatDType::BF16)\\n | (DType::F16, FloatDType::F16) => tensor,\\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\\n _ => unimplemented!(\\\"Unsupported floating point type cast\\\"),\\n }\\n }\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"FloatTensor<Self>\"\n }\n ],\n \"end_line\": 649,\n \"name\": \"float_cast\",\n \"signature\": \"fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self>\",\n \"start_line\": 629\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\\nwhere\\n R: CubeRuntime,\\n F: FloatElement,\\n I: IntElement,\\n BT: BoolElement,\\n{\\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\\n match data.dtype {\\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\\n super::from_data::<R>(data, device)\\n }\\n _ => unimplemented!(\\\"Unsupported dtype for `float_from_data`\\\"),\\n }\\n }\\n\\n fn float_random(\\n shape: Shape,\\n distribution: Distribution,\\n device: &Device<Self>,\\n ) -> FloatTensor<Self> {\\n match distribution {\\n Distribution::Default => random_uniform(shape, device, 0.elem::<F>(), 1.elem()),\\n Distribution::Uniform(low, high) => {\\n random_uniform(shape, device, low.elem::<F>(), high.elem())\\n }\\n Distribution::Bernoulli(prob) => random_bernoulli(shape, device, prob.elem::<F>()),\\n Distribution::Normal(mean, std) => {\\n random_normal(shape, device, mean.elem::<F>(), std.elem())\\n }\\n }\\n }\\n\\n async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n super::into_data::<R, E>(tensor).await\\n )\\n }\\n\\n fn float_device(tensor: &FloatTensor<Self>) -> Device<Self> {\\n tensor.device.clone()\\n }\\n\\n fn float_to_device(tensor: FloatTensor<Self>, device: &Device<Self>) -> FloatTensor<Self> {\\n super::to_device(tensor, device)\\n }\\n\\n fn float_empty(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n super::empty::<R, F>(shape, device)\\n }\\n\\n fn float_add(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::add::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_add_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::add_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_zeros(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::zeros::<R, F>(shape, device)\\n }\\n\\n fn float_full(\\n shape: Shape,\\n fill_value: FloatElem<Self>,\\n device: &R::Device,\\n ) -> FloatTensor<Self> {\\n numeric::full::<R, F>(shape, device, fill_value)\\n }\\n\\n fn float_ones(shape: Shape, device: &Device<Self>) -> FloatTensor<Self> {\\n numeric::ones::<R, F>(shape, device)\\n }\\n\\n fn float_sub(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::sub::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::sub_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_mul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::mul::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::mul_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_div(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::div::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_div_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::div_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_remainder(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n numeric::remainder::<R, E>(lhs, rhs)\\n )\\n }\\n\\n fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n numeric::remainder_scalar::<R, E>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_matmul(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n matmul::<R, E>(lhs, rhs, None, MatmulStrategy::default()).unwrap()\\n )\\n }\\n\\n fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {\\n super::swap_dims(tensor, dim1, dim2)\\n }\\n\\n fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n super::reshape(tensor, shape)\\n }\\n\\n fn float_gather(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::gather::<R, E, I>(dim, tensor, indices)\\n )\\n }\\n\\n fn float_scatter(\\n dim: usize,\\n tensor: FloatTensor<Self>,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::scatter::<R, E, I>(dim, tensor, indices, value)\\n )\\n }\\n\\n fn float_select(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::select::<R, E, I>(tensor, dim, indices)\\n )\\n }\\n\\n fn float_select_assign(\\n tensor: FloatTensor<Self>,\\n dim: usize,\\n indices: IntTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::select_assign::<R, E, I>(tensor, dim, indices, value)\\n )\\n }\\n\\n fn float_slice(tensor: FloatTensor<Self>, ranges: &[Range<usize>]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::slice::<R, E>(tensor, ranges)\\n )\\n }\\n\\n fn float_slice_assign(\\n tensor: FloatTensor<Self>,\\n ranges: &[Range<usize>],\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::slice_assign::<R, E>(tensor, ranges, value)\\n )\\n }\\n\\n fn float_mask_where(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatTensor<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype, value.dtype),\\n E,\\n kernel::mask_where_auto::<R, E, BT>(tensor, mask, value)\\n )\\n }\\n\\n fn float_mask_fill(\\n tensor: FloatTensor<Self>,\\n mask: BoolTensor<Self>,\\n value: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::mask_fill_auto::<R, E, BT>(tensor, mask, value.elem())\\n )\\n }\\n\\n fn float_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_greater_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::greater_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_greater_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::greater_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_lower_equal(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype, rhs.dtype),\\n E,\\n kernel::lower_equal::<R, E, BT>(lhs, rhs)\\n )\\n }\\n\\n fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: FloatElem<Self>) -> BoolTensor<Self> {\\n execute_with_dtype!(\\n float(lhs.dtype),\\n E,\\n kernel::lower_equal_elem::<R, E, BT>(lhs, rhs.elem())\\n )\\n }\\n\\n fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::sum::<R, E>(tensor, Default::default()).unwrap()\\n )\\n }\\n\\n fn float_max(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Max).unwrap()\\n )\\n }\\n\\n fn float_max_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Max)\\n .unwrap()\\n )\\n }\\n\\n fn float_min(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::Min).unwrap()\\n )\\n }\\n\\n fn float_min_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(tensor, dim, Default::default(), ReduceFnConfig::Min)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, E>(tensor, Default::default(), ReduceFnConfig::MaxAbs)\\n .unwrap()\\n )\\n }\\n\\n fn float_max_abs_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::MaxAbs\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Sum\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Mean\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_prod_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, E, <E as ReducePrecision>::EA>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::Prod\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Exp)\\n }\\n\\n fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log)\\n }\\n\\n fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Log1p)\\n }\\n\\n fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {\\n struct Powf;\\n\\n #[cube]\\n impl<F: Float> FloatUnaryOp<F> for Powf {\\n type Options = F;\\n\\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\\n Line::powf(input, Line::new(*options))\\n }\\n }\\n\\n impl FloatUnaryOpFamily for Powf {\\n type Options<F: Float> = F;\\n type Unary<F: Float> = Self;\\n }\\n\\n execute_with_dtype!(\\n float(lhs.dtype),\\n F,\\n launch_unary_float::<R, F, Powf, _>(lhs, |_| ScalarArg::new(rhs.elem::<F>()))\\n )\\n }\\n\\n fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sqrt)\\n }\\n\\n fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Abs)\\n }\\n\\n fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Cos)\\n }\\n\\n fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Sin)\\n }\\n\\n fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Tanh)\\n }\\n\\n fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Round)\\n }\\n\\n fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Floor)\\n }\\n\\n fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Ceil)\\n }\\n\\n fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Erf)\\n }\\n\\n fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMax\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> IntTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n reduce::reduce_dim::<R, E, I, E>(\\n tensor,\\n dim,\\n Default::default(),\\n ReduceFnConfig::ArgMin\\n )\\n .unwrap()\\n )\\n }\\n\\n fn float_into_int(tensor: FloatTensor<Self>) -> IntTensor<Self> {\\n execute_with_dtype!(float(tensor.dtype), E, kernel::cast::<R, E, I>(tensor))\\n }\\n\\n fn float_clamp(\\n tensor: FloatTensor<Self>,\\n min: FloatElem<Self>,\\n max: FloatElem<Self>,\\n ) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::clamp::<R, E>(tensor, min.elem(), max.elem())\\n )\\n }\\n\\n fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {\\n unary_basic::launch::<R, _>(tensor, |_| &BasicFloatUnaryKind::Recip)\\n }\\n\\n fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::repeat_dim::<R, E>(tensor, dim, times)\\n )\\n }\\n\\n fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {\\n execute_with_dtype!(float(lhs.dtype), E, numeric::pow::<R, E>(lhs, rhs))\\n }\\n\\n fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n permute(tensor, axes)\\n }\\n\\n fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {\\n expand(tensor, shape)\\n }\\n\\n fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {\\n execute_with_dtype!(\\n float(tensor.dtype),\\n E,\\n kernel::flip::<R, E, BT>(tensor, axes)\\n )\\n }\\n\\n fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {\\n match (tensor.dtype, dtype) {\\n (DType::F64, FloatDType::F64)\\n | (DType::F32, FloatDType::F32)\\n | (DType::BF16, FloatDType::BF16)\\n | (DType::F16, FloatDType::F16) => tensor,\\n (DType::F64, FloatDType::F32) => kernel::cast::<R, f64, f32>(tensor),\\n (DType::F64, FloatDType::F16) => kernel::cast::<R, f64, f16>(tensor),\\n (DType::F64, FloatDType::BF16) => kernel::cast::<R, f64, bf16>(tensor),\\n (DType::F32, FloatDType::F64) => kernel::cast::<R, f32, f64>(tensor),\\n (DType::F32, FloatDType::F16) => kernel::cast::<R, f32, f16>(tensor),\\n (DType::F32, FloatDType::BF16) => kernel::cast::<R, f32, bf16>(tensor),\\n (DType::F16, FloatDType::F64) => kernel::cast::<R, f16, f64>(tensor),\\n (DType::F16, FloatDType::F32) => kernel::cast::<R, f16, f32>(tensor),\\n (DType::F16, FloatDType::BF16) => kernel::cast::<R, f16, bf16>(tensor),\\n (DType::BF16, FloatDType::F64) => kernel::cast::<R, bf16, f64>(tensor),\\n (DType::BF16, FloatDType::F32) => kernel::cast::<R, bf16, f32>(tensor),\\n (DType::BF16, FloatDType::F16) => kernel::cast::<R, bf16, f16>(tensor),\\n _ => unimplemented!(\\\"Unsupported floating point type cast\\\"),\\n }\\n }\\n}\",\n \"class_signature\": \"impl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\\nwhere\\n R: CubeRuntime,\\n F: FloatElement,\\n I: IntElement,\\n BT: BoolElement,\"\n}"}}},{"rowIdx":182,"cells":{"function_name":{"kind":"string","value":"new_contiguous"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/tensor/base.rs"},"focal_code":{"kind":"string","value":"pub fn new_contiguous(\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n shape: Shape,\n handle: Handle,\n dtype: DType,\n ) -> Self {\n let ndims = shape.num_dims();\n let mut strides = vec![0; ndims];\n let mut current = 1;\n\n shape\n .dims\n .iter()\n .enumerate()\n .rev()\n .for_each(|(index, val)| {\n strides[index] = current;\n current *= val;\n });\n\n Self {\n client,\n handle,\n shape,\n strides,\n device,\n dtype,\n }\n }"},"file_content":{"kind":"string","value":"use crate::CubeRuntime;\nuse crate::element::CubeElement;\nuse crate::kernel::{NumericUnaryOp, NumericUnaryOpFamily, launch_unary_numeric};\nuse burn_common::tensor::is_contiguous;\nuse burn_tensor::quantization::QTensorPrimitive;\nuse burn_tensor::{DType, Shape, TensorMetadata};\nuse cubecl::client::ComputeClient;\nuse cubecl::frontend::Numeric;\nuse cubecl::linalg::tensor::TensorHandle;\nuse cubecl::prelude::{TensorHandleRef, *};\nuse cubecl::server::Handle;\nuse std::marker::PhantomData;\n\n/// The basic tensor primitive struct.\n#[derive(new)]\npub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the tensor.\n pub shape: Shape,\n /// The device of the tensor.\n pub device: R::Device,\n /// The strides of the tensor.\n pub strides: Vec<usize>,\n /// The datatype of the tensor.\n pub dtype: DType,\n}\n\nimpl<R: CubeRuntime, E: CubeElement> From<CubeTensor<R>> for TensorHandle<R, E> {\n fn from(val: CubeTensor<R>) -> Self {\n TensorHandle::new(val.handle, val.shape.dims.to_vec(), val.strides.to_vec())\n }\n}\n\nimpl<R: CubeRuntime> cubecl::tune::AutotuneOutput for CubeTensor<R> {\n #[cfg(feature = \"export_tests\")]\n fn check_equivalence(&self, other: Self) {\n use burn_tensor::Tolerance;\n\n use crate::ops::into_data_sync;\n\n match self.dtype {\n DType::F64 => {\n let expected = into_data_sync::<R, f64>(self.clone());\n let actual = into_data_sync::<R, f64>(other);\n expected.assert_approx_eq::<f64>(&actual, Tolerance::rel_abs(1e-2, 1e-3));\n }\n DType::F32 | DType::Flex32 => {\n let expected = into_data_sync::<R, f32>(self.clone());\n let actual = into_data_sync::<R, f32>(other);\n expected.assert_approx_eq::<f32>(&actual, Tolerance::rel_abs(1e-2, 1e-3));\n }\n DType::F16 => {\n let expected = into_data_sync::<R, half::f16>(self.clone());\n let actual = into_data_sync::<R, half::f16>(other);\n expected.assert_approx_eq::<half::f16>(&actual, Tolerance::rel_abs(1e-2, 4e-3));\n }\n DType::BF16 => {\n let expected = into_data_sync::<R, half::bf16>(self.clone());\n let actual = into_data_sync::<R, half::bf16>(other);\n expected.assert_approx_eq::<half::bf16>(&actual, Tolerance::rel_abs(1e-2, 1e-3));\n }\n DType::I64 => {\n let expected = into_data_sync::<R, i64>(self.clone());\n let actual = into_data_sync::<R, i64>(other);\n expected.assert_eq(&actual, true);\n }\n DType::I32 => {\n let expected = into_data_sync::<R, i32>(self.clone());\n let actual = into_data_sync::<R, i32>(other);\n expected.assert_eq(&actual, true);\n }\n DType::I16 => {\n let expected = into_data_sync::<R, i16>(self.clone());\n let actual = into_data_sync::<R, i16>(other);\n expected.assert_eq(&actual, true);\n }\n DType::I8 => {\n let expected = into_data_sync::<R, i8>(self.clone());\n let actual = into_data_sync::<R, i8>(other);\n expected.assert_eq(&actual, true);\n }\n DType::U64 => {\n let expected = into_data_sync::<R, u64>(self.clone());\n let actual = into_data_sync::<R, u64>(other);\n expected.assert_eq(&actual, true);\n }\n DType::U32 => {\n let expected = into_data_sync::<R, u32>(self.clone());\n let actual = into_data_sync::<R, u32>(other);\n expected.assert_eq(&actual, true);\n }\n DType::U16 => {\n let expected = into_data_sync::<R, u16>(self.clone());\n let actual = into_data_sync::<R, u16>(other);\n expected.assert_eq(&actual, true);\n }\n DType::U8 => {\n let expected = into_data_sync::<R, u8>(self.clone());\n let actual = into_data_sync::<R, u8>(other);\n expected.assert_eq(&actual, true);\n }\n DType::Bool => (),\n DType::QFloat(..) => (),\n }\n }\n}\n\nimpl<R> core::fmt::Debug for CubeTensor<R>\nwhere\n R: CubeRuntime,\n{\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.write_fmt(format_args!(\n \"CubeTensor {{ shape: {:?}, device: {:?}, strides: {:?}, elem: {}, runtime: {}}}\",\n self.shape,\n self.device,\n self.strides,\n self.dtype.name(),\n R::name(&self.client),\n ))\n }\n}\n\nimpl<R> Clone for CubeTensor<R>\nwhere\n R: CubeRuntime,\n{\n fn clone(&self) -> Self {\n Self {\n client: self.client.clone(),\n handle: self.handle.clone(),\n shape: self.shape.clone(),\n device: self.device.clone(),\n strides: self.strides.clone(),\n dtype: self.dtype,\n }\n }\n}\n\nimpl<R: CubeRuntime> TensorMetadata for CubeTensor<R> {\n fn dtype(&self) -> DType {\n self.dtype\n }\n\n fn shape(&self) -> Shape {\n self.shape.clone()\n }\n}\n\nimpl<R: CubeRuntime> QTensorPrimitive for CubeTensor<R> {\n fn scheme(&self) -> &burn_tensor::quantization::QuantizationScheme {\n if let DType::QFloat(scheme) = &self.dtype {\n scheme\n } else {\n panic!(\n \"Quantization scheme is not valid for dtype {:?}\",\n self.dtype,\n )\n }\n }\n}\n\n/// Macro to execute a kernel/operation for a given element type.\n///\n/// # Panics\n/// Since there is no automatic type cast at this time, binary operations for different\n/// floating point precision data types will panic with a data type mismatch.\n#[macro_export]\nmacro_rules! execute_with_dtype {\n (float($dtype:expr), $element:ident, $op:expr) => {{\n match $dtype {\n burn_tensor::DType::F64 => {\n type $element = f64;\n $op\n }\n burn_tensor::DType::F32 => {\n type $element = f32;\n $op\n }\n burn_tensor::DType::Flex32 => {\n type $element = cubecl::flex32;\n $op\n }\n\n burn_tensor::DType::F16 => {\n type $element = half::f16;\n $op\n }\n burn_tensor::DType::BF16 => {\n type $element = half::bf16;\n $op\n }\n _ => unimplemented!(\"Unsupported dtype {:?}\", $dtype),\n }\n }};\n\n (float($lhs_dtype:expr, $rhs_dtype:expr), $element:ident, $op:expr) => {{\n // NOTE: might be better for floating point binary operations to return a Result instead?\n if $lhs_dtype != $rhs_dtype {\n panic!(\n \"Data type mismatch (lhs: {:?}, rhs: {:?})\",\n $lhs_dtype, $rhs_dtype\n );\n }\n execute_with_dtype!(float($lhs_dtype), $element, $op)\n }};\n ($dtype:expr, $element:ident, $op:expr) => {{\n match $dtype {\n burn_tensor::DType::F64 => {\n type $element = f64;\n $op\n }\n burn_tensor::DType::F32 => {\n type $element = f32;\n $op\n }\n burn_tensor::DType::Flex32 => {\n type $element = cubecl::flex32;\n $op\n }\n burn_tensor::DType::F16 => {\n type $element = half::f16;\n $op\n }\n burn_tensor::DType::BF16 => {\n type $element = half::bf16;\n $op\n }\n burn_tensor::DType::U64 => {\n type $element = u64;\n $op\n }\n burn_tensor::DType::U32 => {\n type $element = u32;\n $op\n }\n burn_tensor::DType::U16 => {\n type $element = u16;\n $op\n }\n burn_tensor::DType::U8 => {\n type $element = u8;\n $op\n }\n burn_tensor::DType::I64 => {\n type $element = i64;\n $op\n }\n burn_tensor::DType::I32 => {\n type $element = i32;\n $op\n }\n burn_tensor::DType::I16 => {\n type $element = i16;\n $op\n }\n burn_tensor::DType::I8 => {\n type $element = i8;\n $op\n }\n // NOTE: bool and qfloat dtypes are actually represented as u32/u8\n // burn_tensor::DType::Bool => {\n // type $element = u32/u8;\n // $op\n // }\n burn_tensor::DType::QFloat(_) => {\n type $element = u32;\n $op\n }\n _ => unimplemented!(\"Unsupported dtype {:?}\", $dtype),\n }\n }};\n}\n\nimpl<R> CubeTensor<R>\nwhere\n R: CubeRuntime,\n{\n /// Create a new tensor with a contiguous memory layout.\n pub fn new_contiguous(\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n shape: Shape,\n handle: Handle,\n dtype: DType,\n ) -> Self {\n let ndims = shape.num_dims();\n let mut strides = vec![0; ndims];\n let mut current = 1;\n\n shape\n .dims\n .iter()\n .enumerate()\n .rev()\n .for_each(|(index, val)| {\n strides[index] = current;\n current *= val;\n });\n\n Self {\n client,\n handle,\n shape,\n strides,\n device,\n dtype,\n }\n }\n\n /// Change the context of the current tensor and return the newly transferred tensor.\n pub fn to_client(\n &self,\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n ) -> Self {\n let bytes = self.client.read_one(self.handle.clone().binding());\n let handle = client.create(&bytes);\n\n Self {\n client,\n handle,\n shape: self.shape.clone(),\n strides: self.strides.clone(),\n device,\n dtype: self.dtype,\n }\n }\n\n /// Return the reference to a tensor handle.\n pub fn as_handle_ref(&self) -> TensorHandleRef<'_, R> {\n TensorHandleRef {\n handle: &self.handle,\n strides: &self.strides,\n shape: &self.shape.dims,\n runtime: PhantomData,\n elem_size: self.elem_size(),\n }\n }\n\n fn elem_size(&self) -> usize {\n if let DType::QFloat(_) = self.dtype {\n // Encoded as u32\n core::mem::size_of::<u32>()\n } else {\n self.dtype.size()\n }\n }\n\n /// Return the reference to a tensor argument.\n pub fn as_tensor_arg<'a, E: CubeElement>(&'a self, line_size: u8) -> TensorArg<'a, R> {\n let handle: TensorHandleRef<'a, R> = self.as_handle_ref();\n\n unsafe {\n TensorArg::from_raw_parts::<E>(handle.handle, handle.strides, handle.shape, line_size)\n }\n }\n\n /// Return the reference to an array argument.\n pub fn as_array_arg<E: CubeElement>(&self, vectorisation: u8) -> ArrayArg<'_, R> {\n unsafe {\n ArrayArg::from_raw_parts::<E>(\n &self.handle,\n self.handle.size() as usize / core::mem::size_of::<E>(),\n vectorisation,\n )\n }\n }\n\n pub(crate) fn can_mut_broadcast(&self, rhs: &Self) -> bool {\n if !self.handle.can_mut() || !self.is_contiguous_buffer() {\n return false;\n }\n let ndims = self.shape.num_dims();\n\n for i in 0..ndims {\n let shape_lhs = self.shape.dims[i];\n let shape_rhs = rhs.shape.dims[i];\n\n // Output tensor will be different from the mutable tensor.\n if shape_lhs < shape_rhs {\n return false;\n }\n }\n\n true\n }\n\n /// Copy the current tensor.\n pub fn copy(&self) -> Self {\n struct Copy;\n\n #[cube]\n impl<N: Numeric> NumericUnaryOp<N> for Copy {\n type Options = ();\n\n fn execute(input: Line<N>, _options: &Self::Options) -> Line<N> {\n input\n }\n }\n\n impl NumericUnaryOpFamily for Copy {\n type Options<N: Numeric> = ();\n type Unary<N: Numeric> = Self;\n }\n\n let tensor = self.clone();\n\n execute_with_dtype!(\n tensor.dtype,\n E,\n launch_unary_numeric::<R, E, Copy, _>(tensor, |_| ())\n )\n }\n\n /// Check if the tensor is safe to mutate.\n pub fn can_mut(&self) -> bool {\n self.handle.can_mut()\n }\n\n /// Assert that both tensors are on the same device.\n pub fn assert_is_on_same_device(&self, other: &Self) {\n if self.device != other.device {\n panic!(\n \"Both tensors should be on the same device {:?} != {:?}\",\n self.device, other.device\n );\n }\n }\n\n /// Check if the current tensor is contiguous.\n ///\n /// A tensor is contiguous if the elements are stored in memory\n /// if the strides in non-increasing order and the\n /// strides at position k is equal to the product of the shapes\n /// at all positions greater than k. However, all axes with a shape of 1 are ignored.\n pub fn is_contiguous(&self) -> bool {\n is_contiguous(&self.shape.dims, &self.strides)\n }\n\n /// Check if the current tensor has a contiguous backing buffer (no overlap and no empty memory\n /// regions within the shape).\n pub fn is_contiguous_buffer(&self) -> bool {\n self.shape.num_elements() * self.dtype.size() == self.handle.size() as usize\n }\n}\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn is_contiguous_non_increasing() {\n assert!(is_contiguous(&[3, 1], &[1, 1]));\n }\n\n #[test]\n fn is_contiguous_basic() {\n assert!(is_contiguous(&[32, 32], &[32, 1]));\n }\n\n #[test]\n fn is_contiguous_permuted() {\n assert!(!is_contiguous(&[32, 32], &[1, 32]));\n }\n\n #[test]\n fn is_contiguous_slice() {\n assert!(!is_contiguous(&[32, 1, 64], &[32, 64, 1]));\n }\n\n #[test]\n fn is_contiguous_4d_positive() {\n assert!(is_contiguous(&[8, 256, 32, 32], &[262144, 1024, 32, 1]));\n }\n\n #[test]\n fn is_contiguous_4d_negative() {\n assert!(!is_contiguous(&[256, 8, 32, 32], &[1024, 262144, 32, 1]));\n }\n\n /// Based on a bug encountered in interpolate_1d\n #[test]\n fn is_contiguous_4d_unit_shape() {\n assert!(!is_contiguous(&[1, 1, 1, 9], &[72, 1, 72, 8]));\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 312,\n \"name\": \"new_contiguous\",\n \"signature\": \"pub fn new_contiguous(\\n client: ComputeClient<R::Server, R::Channel>,\\n device: R::Device,\\n shape: Shape,\\n handle: Handle,\\n dtype: DType,\\n ) -> Self\",\n \"start_line\": 283\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"impl<R> CubeTensor<R>\\nwhere\\n R: CubeRuntime,\\n{\\n /// Create a new tensor with a contiguous memory layout.\\n pub fn new_contiguous(\\n client: ComputeClient<R::Server, R::Channel>,\\n device: R::Device,\\n shape: Shape,\\n handle: Handle,\\n dtype: DType,\\n ) -> Self {\\n let ndims = shape.num_dims();\\n let mut strides = vec![0; ndims];\\n let mut current = 1;\\n\\n shape\\n .dims\\n .iter()\\n .enumerate()\\n .rev()\\n .for_each(|(index, val)| {\\n strides[index] = current;\\n current *= val;\\n });\\n\\n Self {\\n client,\\n handle,\\n shape,\\n strides,\\n device,\\n dtype,\\n }\\n }\\n\\n /// Change the context of the current tensor and return the newly transferred tensor.\\n pub fn to_client(\\n &self,\\n client: ComputeClient<R::Server, R::Channel>,\\n device: R::Device,\\n ) -> Self {\\n let bytes = self.client.read_one(self.handle.clone().binding());\\n let handle = client.create(&bytes);\\n\\n Self {\\n client,\\n handle,\\n shape: self.shape.clone(),\\n strides: self.strides.clone(),\\n device,\\n dtype: self.dtype,\\n }\\n }\\n\\n /// Return the reference to a tensor handle.\\n pub fn as_handle_ref(&self) -> TensorHandleRef<'_, R> {\\n TensorHandleRef {\\n handle: &self.handle,\\n strides: &self.strides,\\n shape: &self.shape.dims,\\n runtime: PhantomData,\\n elem_size: self.elem_size(),\\n }\\n }\\n\\n fn elem_size(&self) -> usize {\\n if let DType::QFloat(_) = self.dtype {\\n // Encoded as u32\\n core::mem::size_of::<u32>()\\n } else {\\n self.dtype.size()\\n }\\n }\\n\\n /// Return the reference to a tensor argument.\\n pub fn as_tensor_arg<'a, E: CubeElement>(&'a self, line_size: u8) -> TensorArg<'a, R> {\\n let handle: TensorHandleRef<'a, R> = self.as_handle_ref();\\n\\n unsafe {\\n TensorArg::from_raw_parts::<E>(handle.handle, handle.strides, handle.shape, line_size)\\n }\\n }\\n\\n /// Return the reference to an array argument.\\n pub fn as_array_arg<E: CubeElement>(&self, vectorisation: u8) -> ArrayArg<'_, R> {\\n unsafe {\\n ArrayArg::from_raw_parts::<E>(\\n &self.handle,\\n self.handle.size() as usize / core::mem::size_of::<E>(),\\n vectorisation,\\n )\\n }\\n }\\n\\n pub(crate) fn can_mut_broadcast(&self, rhs: &Self) -> bool {\\n if !self.handle.can_mut() || !self.is_contiguous_buffer() {\\n return false;\\n }\\n let ndims = self.shape.num_dims();\\n\\n for i in 0..ndims {\\n let shape_lhs = self.shape.dims[i];\\n let shape_rhs = rhs.shape.dims[i];\\n\\n // Output tensor will be different from the mutable tensor.\\n if shape_lhs < shape_rhs {\\n return false;\\n }\\n }\\n\\n true\\n }\\n\\n /// Copy the current tensor.\\n pub fn copy(&self) -> Self {\\n struct Copy;\\n\\n #[cube]\\n impl<N: Numeric> NumericUnaryOp<N> for Copy {\\n type Options = ();\\n\\n fn execute(input: Line<N>, _options: &Self::Options) -> Line<N> {\\n input\\n }\\n }\\n\\n impl NumericUnaryOpFamily for Copy {\\n type Options<N: Numeric> = ();\\n type Unary<N: Numeric> = Self;\\n }\\n\\n let tensor = self.clone();\\n\\n execute_with_dtype!(\\n tensor.dtype,\\n E,\\n launch_unary_numeric::<R, E, Copy, _>(tensor, |_| ())\\n )\\n }\\n\\n /// Check if the tensor is safe to mutate.\\n pub fn can_mut(&self) -> bool {\\n self.handle.can_mut()\\n }\\n\\n /// Assert that both tensors are on the same device.\\n pub fn assert_is_on_same_device(&self, other: &Self) {\\n if self.device != other.device {\\n panic!(\\n \\\"Both tensors should be on the same device {:?} != {:?}\\\",\\n self.device, other.device\\n );\\n }\\n }\\n\\n /// Check if the current tensor is contiguous.\\n ///\\n /// A tensor is contiguous if the elements are stored in memory\\n /// if the strides in non-increasing order and the\\n /// strides at position k is equal to the product of the shapes\\n /// at all positions greater than k. However, all axes with a shape of 1 are ignored.\\n pub fn is_contiguous(&self) -> bool {\\n is_contiguous(&self.shape.dims, &self.strides)\\n }\\n\\n /// Check if the current tensor has a contiguous backing buffer (no overlap and no empty memory\\n /// regions within the shape).\\n pub fn is_contiguous_buffer(&self) -> bool {\\n self.shape.num_elements() * self.dtype.size() == self.handle.size() as usize\\n }\\n}\",\n \"class_signature\": \"impl<R> CubeTensor<R>\\nwhere\\n R: CubeRuntime,\"\n}"}}},{"rowIdx":183,"cells":{"function_name":{"kind":"string","value":"launch_binop"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/binary.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_binop(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let line_size_lhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &lhs.shape.dims,\n &lhs.strides,\n ndims - 1,\n );\n let line_size_rhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &rhs.shape.dims,\n &rhs.strides,\n ndims - 1,\n );\n let line_size = Ord::min(line_size_lhs, line_size_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if lhs.can_mut_broadcast(&rhs) {\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n lhs\n } else if rhs.can_mut_broadcast(&lhs) {\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n rhs\n } else {\n let output = empty_device::<R, E>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use std::marker::PhantomData;\n\nuse crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse burn_tensor::Shape;\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\nuse super::into_contiguous;\n\npub(crate) trait BinaryOpFamily: Send + Sync + 'static {\n type BinaryOp<C: Numeric>: BinaryOp<C>;\n}\n\n#[cube]\npub(crate) trait BinaryOp<C: Numeric>: 'static + Send + Sync {\n /// Execute a binary operation.\n fn execute(lhs: Line<C>, rhs: Line<C>) -> Line<C>;\n}\n\npub(crate) struct AddOp;\npub(crate) struct SubOp;\npub(crate) struct MulOp;\npub(crate) struct DivOp;\npub(crate) struct RemainderOp;\npub(crate) struct AndOp;\npub(crate) struct OrOp;\n\n/// Since Powf only works on float, but we still want to implement the numeric binary op family, we\n/// set another precision in the family type to cast, when necessary, the input value to a valid\n/// float.\n///\n/// Because of this we won't benefit from the cubecl rust compilation speed improvement from using\n/// the family pattern for [PowOp], but at least we don't duplicate code.\npub(crate) struct PowOp<F: Float> {\n _f: PhantomData<F>,\n}\n\nimpl BinaryOpFamily for AddOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for SubOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for MulOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for DivOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for RemainderOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl<F: Float> BinaryOpFamily for PowOp<F> {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for AndOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for OrOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for AddOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs + rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for SubOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs - rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for MulOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs * rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for DivOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs / rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for RemainderOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n Line::rem(lhs, rhs)\n }\n}\n\n#[cube]\nimpl<N: Numeric, F: Float> BinaryOp<N> for PowOp<F> {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n let lhs = Line::<F>::cast_from(lhs);\n let rhs = Line::<F>::cast_from(rhs);\n let out = Line::powf(lhs, rhs);\n\n Line::cast_from(out)\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for AndOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n Line::cast_from(Line::<bool>::cast_from(lhs).and(Line::<bool>::cast_from(rhs)))\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for OrOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n Line::cast_from(Line::<bool>::cast_from(lhs).or(Line::<bool>::cast_from(rhs)))\n }\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_scalar_binop<C: Numeric, O: BinaryOpFamily>(\n input: &Tensor<Line<C>>,\n scalar: C,\n output: &mut Tensor<Line<C>>,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n output[ABSOLUTE_POS] = O::BinaryOp::<C>::execute(input[ABSOLUTE_POS], Line::new(scalar));\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_binop<C: Numeric, O: BinaryOpFamily>(\n lhs: &Tensor<Line<C>>,\n rhs: &Tensor<Line<C>>,\n out: &mut Tensor<Line<C>>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous_lhs: bool,\n #[comptime] to_contiguous_rhs: bool,\n) {\n let offset_out = ABSOLUTE_POS;\n let mut offset_lhs = ABSOLUTE_POS;\n let mut offset_rhs = ABSOLUTE_POS;\n\n if offset_out >= out.len() {\n terminate!();\n }\n\n if to_contiguous_lhs {\n offset_lhs = index_offset_with_layout::<C, C>(\n lhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n if to_contiguous_rhs {\n offset_rhs = index_offset_with_layout::<C, C>(\n rhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n out[offset_out] = O::BinaryOp::<C>::execute(lhs[offset_lhs], rhs[offset_rhs]);\n}\n\npub(crate) fn launch_binop<R: CubeRuntime, E: CubeElement, O: BinaryOpFamily>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let line_size_lhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &lhs.shape.dims,\n &lhs.strides,\n ndims - 1,\n );\n let line_size_rhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &rhs.shape.dims,\n &rhs.strides,\n ndims - 1,\n );\n let line_size = Ord::min(line_size_lhs, line_size_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if lhs.can_mut_broadcast(&rhs) {\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n lhs\n } else if rhs.can_mut_broadcast(&lhs) {\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n rhs\n } else {\n let output = empty_device::<R, E>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n }\n}\n\npub(crate) fn launch_scalar_binop<R: CubeRuntime, E: CubeElement, O: BinaryOpFamily>(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n // Vectorization is only enabled when the last dimension is contiguous.\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if tensor.can_mut() {\n kernel_scalar_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<E>(line_size),\n );\n\n output\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"lhs\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"rhs\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 272,\n \"name\": \"launch_binop\",\n \"signature\": \"pub(crate) fn launch_binop(\\n lhs: CubeTensor<R>,\\n rhs: CubeTensor<R>,\\n) -> CubeTensor<R>\",\n \"start_line\": 187\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":184,"cells":{"function_name":{"kind":"string","value":"launch_scalar_binop"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/binary.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_scalar_binop(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n // Vectorization is only enabled when the last dimension is contiguous.\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if tensor.can_mut() {\n kernel_scalar_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<E>(line_size),\n );\n\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use std::marker::PhantomData;\n\nuse crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse burn_tensor::Shape;\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\nuse super::into_contiguous;\n\npub(crate) trait BinaryOpFamily: Send + Sync + 'static {\n type BinaryOp<C: Numeric>: BinaryOp<C>;\n}\n\n#[cube]\npub(crate) trait BinaryOp<C: Numeric>: 'static + Send + Sync {\n /// Execute a binary operation.\n fn execute(lhs: Line<C>, rhs: Line<C>) -> Line<C>;\n}\n\npub(crate) struct AddOp;\npub(crate) struct SubOp;\npub(crate) struct MulOp;\npub(crate) struct DivOp;\npub(crate) struct RemainderOp;\npub(crate) struct AndOp;\npub(crate) struct OrOp;\n\n/// Since Powf only works on float, but we still want to implement the numeric binary op family, we\n/// set another precision in the family type to cast, when necessary, the input value to a valid\n/// float.\n///\n/// Because of this we won't benefit from the cubecl rust compilation speed improvement from using\n/// the family pattern for [PowOp], but at least we don't duplicate code.\npub(crate) struct PowOp<F: Float> {\n _f: PhantomData<F>,\n}\n\nimpl BinaryOpFamily for AddOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for SubOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for MulOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for DivOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for RemainderOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl<F: Float> BinaryOpFamily for PowOp<F> {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for AndOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\nimpl BinaryOpFamily for OrOp {\n type BinaryOp<C: Numeric> = Self;\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for AddOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs + rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for SubOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs - rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for MulOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs * rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for DivOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs / rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for RemainderOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n Line::rem(lhs, rhs)\n }\n}\n\n#[cube]\nimpl<N: Numeric, F: Float> BinaryOp<N> for PowOp<F> {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n let lhs = Line::<F>::cast_from(lhs);\n let rhs = Line::<F>::cast_from(rhs);\n let out = Line::powf(lhs, rhs);\n\n Line::cast_from(out)\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for AndOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n Line::cast_from(Line::<bool>::cast_from(lhs).and(Line::<bool>::cast_from(rhs)))\n }\n}\n\n#[cube]\nimpl<N: Numeric> BinaryOp<N> for OrOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n Line::cast_from(Line::<bool>::cast_from(lhs).or(Line::<bool>::cast_from(rhs)))\n }\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_scalar_binop<C: Numeric, O: BinaryOpFamily>(\n input: &Tensor<Line<C>>,\n scalar: C,\n output: &mut Tensor<Line<C>>,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n output[ABSOLUTE_POS] = O::BinaryOp::<C>::execute(input[ABSOLUTE_POS], Line::new(scalar));\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_binop<C: Numeric, O: BinaryOpFamily>(\n lhs: &Tensor<Line<C>>,\n rhs: &Tensor<Line<C>>,\n out: &mut Tensor<Line<C>>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous_lhs: bool,\n #[comptime] to_contiguous_rhs: bool,\n) {\n let offset_out = ABSOLUTE_POS;\n let mut offset_lhs = ABSOLUTE_POS;\n let mut offset_rhs = ABSOLUTE_POS;\n\n if offset_out >= out.len() {\n terminate!();\n }\n\n if to_contiguous_lhs {\n offset_lhs = index_offset_with_layout::<C, C>(\n lhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n if to_contiguous_rhs {\n offset_rhs = index_offset_with_layout::<C, C>(\n rhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n out[offset_out] = O::BinaryOp::<C>::execute(lhs[offset_lhs], rhs[offset_rhs]);\n}\n\npub(crate) fn launch_binop<R: CubeRuntime, E: CubeElement, O: BinaryOpFamily>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let line_size_lhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &lhs.shape.dims,\n &lhs.strides,\n ndims - 1,\n );\n let line_size_rhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &rhs.shape.dims,\n &rhs.strides,\n ndims - 1,\n );\n let line_size = Ord::min(line_size_lhs, line_size_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if lhs.can_mut_broadcast(&rhs) {\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n lhs\n } else if rhs.can_mut_broadcast(&lhs) {\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n rhs\n } else {\n let output = empty_device::<R, E>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n }\n}\n\npub(crate) fn launch_scalar_binop<R: CubeRuntime, E: CubeElement, O: BinaryOpFamily>(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n // Vectorization is only enabled when the last dimension is contiguous.\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if tensor.can_mut() {\n kernel_scalar_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_binop::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<E>(line_size),\n );\n\n output\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 327,\n \"name\": \"launch_scalar_binop\",\n \"signature\": \"pub(crate) fn launch_scalar_binop(\\n mut tensor: CubeTensor<R>,\\n scalar: E,\\n) -> CubeTensor<R>\",\n \"start_line\": 274\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":185,"cells":{"function_name":{"kind":"string","value":"launch_cmp"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/comparison.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_cmp(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let vectorization_factor_lhs =\n tensor_vectorization_factor(&[4, 2], &lhs.shape.dims, &lhs.strides, ndims - 1);\n let vectorization_factor_rhs =\n tensor_vectorization_factor(&[4, 2], &rhs.shape.dims, &rhs.strides, ndims - 1);\n\n let vectorization_factor = Ord::min(vectorization_factor_lhs, vectorization_factor_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems / vectorization_factor as usize, cube_dim);\n\n let same_tensor_type = core::any::TypeId::of::<E>() == core::any::TypeId::of::<BT>();\n if same_tensor_type && lhs.can_mut_broadcast(&rhs) {\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n CubeTensor::new(\n lhs.client,\n lhs.handle,\n lhs.shape,\n lhs.device,\n lhs.strides,\n BT::dtype(),\n )\n } else if same_tensor_type && rhs.can_mut_broadcast(&lhs) {\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n CubeTensor::new(\n rhs.client,\n rhs.handle,\n rhs.shape,\n rhs.device,\n rhs.strides,\n BT::dtype(),\n )\n } else {\n let output = empty_device::<R, BT>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n output.as_tensor_arg::<BT>(vectorization_factor),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n}"},"file_content":{"kind":"string","value":"use std::marker::PhantomData;\n\nuse crate::{\n BoolElement, CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor,\n};\nuse burn_tensor::Shape;\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_vectorization_factor,\n};\n\nuse super::into_contiguous;\n\n#[cube]\npub(crate) trait ComparisonOp<C: Numeric>: 'static + Send + Sync {\n /// Execute a comparison operation.\n fn execute(lhs: Line<C>, rhs: Line<C>) -> bool;\n}\n\nstruct EqualOp;\nstruct GreaterEqualOp;\nstruct LowerEqualOp;\nstruct GreaterOp;\nstruct LowerOp;\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for EqualOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs == rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for GreaterEqualOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs >= rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for LowerEqualOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs <= rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for GreaterOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs > rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for LowerOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs < rhs\n }\n}\n\npub(crate) trait ScalarOpSpec: Send + Sync + 'static {\n type C: Numeric;\n type B: Numeric;\n}\n\npub(crate) struct Spec<C, B> {\n _c: PhantomData<C>,\n _b: PhantomData<B>,\n}\n\nimpl<C: Numeric, B: Numeric> ScalarOpSpec for Spec<C, B> {\n type C = C;\n type B = B;\n}\n\n#[cube(launch)]\npub(crate) fn kernel_scalar_cmp<SS: ScalarOpSpec, O: ComparisonOp<SS::C>>(\n input: &Tensor<Line<SS::C>>,\n scalar: SS::C,\n output: &mut Tensor<Line<SS::B>>,\n) {\n let offset_output = ABSOLUTE_POS;\n\n if offset_output >= output.len() {\n terminate!();\n }\n\n output[ABSOLUTE_POS] = Line::cast_from(O::execute(input[ABSOLUTE_POS], Line::new(scalar)));\n}\n\n#[cube(launch)]\npub(crate) fn kernel_cmp<SS: ScalarOpSpec, O: ComparisonOp<SS::C>>(\n lhs: &Tensor<Line<SS::C>>,\n rhs: &Tensor<Line<SS::C>>,\n out: &mut Tensor<Line<SS::B>>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous_lhs: bool,\n #[comptime] to_contiguous_rhs: bool,\n) {\n let offset_out = ABSOLUTE_POS;\n let mut offset_lhs = ABSOLUTE_POS;\n let mut offset_rhs = ABSOLUTE_POS;\n\n if offset_out >= out.len() {\n terminate!();\n }\n\n if to_contiguous_lhs {\n offset_lhs = index_offset_with_layout::<SS::C, SS::B>(\n lhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n if to_contiguous_rhs {\n offset_rhs = index_offset_with_layout::<SS::C, SS::B>(\n rhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n out[offset_out] = Line::cast_from(O::execute(lhs[offset_lhs], rhs[offset_rhs]));\n}\n\npub(crate) fn launch_cmp<R: CubeRuntime, E: CubeElement, BT: BoolElement, O: ComparisonOp<E>>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let vectorization_factor_lhs =\n tensor_vectorization_factor(&[4, 2], &lhs.shape.dims, &lhs.strides, ndims - 1);\n let vectorization_factor_rhs =\n tensor_vectorization_factor(&[4, 2], &rhs.shape.dims, &rhs.strides, ndims - 1);\n\n let vectorization_factor = Ord::min(vectorization_factor_lhs, vectorization_factor_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems / vectorization_factor as usize, cube_dim);\n\n let same_tensor_type = core::any::TypeId::of::<E>() == core::any::TypeId::of::<BT>();\n if same_tensor_type && lhs.can_mut_broadcast(&rhs) {\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n CubeTensor::new(\n lhs.client,\n lhs.handle,\n lhs.shape,\n lhs.device,\n lhs.strides,\n BT::dtype(),\n )\n } else if same_tensor_type && rhs.can_mut_broadcast(&lhs) {\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n CubeTensor::new(\n rhs.client,\n rhs.handle,\n rhs.shape,\n rhs.device,\n rhs.strides,\n BT::dtype(),\n )\n } else {\n let output = empty_device::<R, BT>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n output.as_tensor_arg::<BT>(vectorization_factor),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n}\n\npub(crate) fn launch_scalar_cmp<\n R: CubeRuntime,\n E: CubeElement,\n BT: BoolElement,\n O: ComparisonOp<E>,\n>(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n let ndims = tensor.shape.num_dims();\n // Vectorization is only enabled when the last dimension is contiguous.\n let vectorization_factor =\n tensor_vectorization_factor(&[4, 2], &tensor.shape.dims, &tensor.strides, ndims - 1);\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems / vectorization_factor as usize, cube_dim);\n\n let same_tensor_type = core::any::TypeId::of::<E>() == core::any::TypeId::of::<BT>();\n if same_tensor_type && tensor.can_mut() {\n kernel_scalar_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(vectorization_factor),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n CubeTensor::new(\n tensor.client,\n tensor.handle,\n tensor.shape,\n tensor.device,\n tensor.strides,\n BT::dtype(),\n )\n } else {\n let output = empty_device::<R, BT>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(vectorization_factor),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<BT>(vectorization_factor),\n );\n\n output\n }\n}\n\npub fn equal<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, EqualOp>(lhs, rhs)\n}\n\npub fn greater<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, GreaterOp>(lhs, rhs)\n}\n\npub fn greater_equal<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, GreaterEqualOp>(lhs, rhs)\n}\n\npub fn lower<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, LowerOp>(lhs, rhs)\n}\n\npub fn lower_equal<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, LowerEqualOp>(lhs, rhs)\n}\n\npub fn equal_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, EqualOp>(lhs, rhs)\n}\n\npub fn greater_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, GreaterOp>(lhs, rhs)\n}\n\npub fn lower_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, LowerOp>(lhs, rhs)\n}\n\npub fn greater_equal_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, GreaterEqualOp>(lhs, rhs)\n}\n\npub fn lower_equal_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, LowerEqualOp>(lhs, rhs)\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"lhs\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"rhs\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 225,\n \"name\": \"launch_cmp\",\n \"signature\": \"pub(crate) fn launch_cmp(\\n lhs: CubeTensor<R>,\\n rhs: CubeTensor<R>,\\n) -> CubeTensor<R>\",\n \"start_line\": 133\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":186,"cells":{"function_name":{"kind":"string","value":"launch_scalar_cmp"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/comparison.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_scalar_cmp(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n let ndims = tensor.shape.num_dims();\n // Vectorization is only enabled when the last dimension is contiguous.\n let vectorization_factor =\n tensor_vectorization_factor(&[4, 2], &tensor.shape.dims, &tensor.strides, ndims - 1);\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems / vectorization_factor as usize, cube_dim);\n\n let same_tensor_type = core::any::TypeId::of::<E>() == core::any::TypeId::of::<BT>();\n if same_tensor_type && tensor.can_mut() {\n kernel_scalar_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(vectorization_factor),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n CubeTensor::new(\n tensor.client,\n tensor.handle,\n tensor.shape,\n tensor.device,\n tensor.strides,\n BT::dtype(),\n )\n } else {\n let output = empty_device::<R, BT>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(vectorization_factor),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<BT>(vectorization_factor),\n );\n\n output\n }\n}"},"file_content":{"kind":"string","value":"use std::marker::PhantomData;\n\nuse crate::{\n BoolElement, CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor,\n};\nuse burn_tensor::Shape;\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_vectorization_factor,\n};\n\nuse super::into_contiguous;\n\n#[cube]\npub(crate) trait ComparisonOp<C: Numeric>: 'static + Send + Sync {\n /// Execute a comparison operation.\n fn execute(lhs: Line<C>, rhs: Line<C>) -> bool;\n}\n\nstruct EqualOp;\nstruct GreaterEqualOp;\nstruct LowerEqualOp;\nstruct GreaterOp;\nstruct LowerOp;\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for EqualOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs == rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for GreaterEqualOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs >= rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for LowerEqualOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs <= rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for GreaterOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs > rhs\n }\n}\n\n#[cube]\nimpl<N: Numeric> ComparisonOp<N> for LowerOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> bool {\n lhs < rhs\n }\n}\n\npub(crate) trait ScalarOpSpec: Send + Sync + 'static {\n type C: Numeric;\n type B: Numeric;\n}\n\npub(crate) struct Spec<C, B> {\n _c: PhantomData<C>,\n _b: PhantomData<B>,\n}\n\nimpl<C: Numeric, B: Numeric> ScalarOpSpec for Spec<C, B> {\n type C = C;\n type B = B;\n}\n\n#[cube(launch)]\npub(crate) fn kernel_scalar_cmp<SS: ScalarOpSpec, O: ComparisonOp<SS::C>>(\n input: &Tensor<Line<SS::C>>,\n scalar: SS::C,\n output: &mut Tensor<Line<SS::B>>,\n) {\n let offset_output = ABSOLUTE_POS;\n\n if offset_output >= output.len() {\n terminate!();\n }\n\n output[ABSOLUTE_POS] = Line::cast_from(O::execute(input[ABSOLUTE_POS], Line::new(scalar)));\n}\n\n#[cube(launch)]\npub(crate) fn kernel_cmp<SS: ScalarOpSpec, O: ComparisonOp<SS::C>>(\n lhs: &Tensor<Line<SS::C>>,\n rhs: &Tensor<Line<SS::C>>,\n out: &mut Tensor<Line<SS::B>>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous_lhs: bool,\n #[comptime] to_contiguous_rhs: bool,\n) {\n let offset_out = ABSOLUTE_POS;\n let mut offset_lhs = ABSOLUTE_POS;\n let mut offset_rhs = ABSOLUTE_POS;\n\n if offset_out >= out.len() {\n terminate!();\n }\n\n if to_contiguous_lhs {\n offset_lhs = index_offset_with_layout::<SS::C, SS::B>(\n lhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n if to_contiguous_rhs {\n offset_rhs = index_offset_with_layout::<SS::C, SS::B>(\n rhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n out[offset_out] = Line::cast_from(O::execute(lhs[offset_lhs], rhs[offset_rhs]));\n}\n\npub(crate) fn launch_cmp<R: CubeRuntime, E: CubeElement, BT: BoolElement, O: ComparisonOp<E>>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let vectorization_factor_lhs =\n tensor_vectorization_factor(&[4, 2], &lhs.shape.dims, &lhs.strides, ndims - 1);\n let vectorization_factor_rhs =\n tensor_vectorization_factor(&[4, 2], &rhs.shape.dims, &rhs.strides, ndims - 1);\n\n let vectorization_factor = Ord::min(vectorization_factor_lhs, vectorization_factor_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems / vectorization_factor as usize, cube_dim);\n\n let same_tensor_type = core::any::TypeId::of::<E>() == core::any::TypeId::of::<BT>();\n if same_tensor_type && lhs.can_mut_broadcast(&rhs) {\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n CubeTensor::new(\n lhs.client,\n lhs.handle,\n lhs.shape,\n lhs.device,\n lhs.strides,\n BT::dtype(),\n )\n } else if same_tensor_type && rhs.can_mut_broadcast(&lhs) {\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n CubeTensor::new(\n rhs.client,\n rhs.handle,\n rhs.shape,\n rhs.device,\n rhs.strides,\n BT::dtype(),\n )\n } else {\n let output = empty_device::<R, BT>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n lhs.as_tensor_arg::<E>(vectorization_factor),\n rhs.as_tensor_arg::<E>(vectorization_factor),\n output.as_tensor_arg::<BT>(vectorization_factor),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n}\n\npub(crate) fn launch_scalar_cmp<\n R: CubeRuntime,\n E: CubeElement,\n BT: BoolElement,\n O: ComparisonOp<E>,\n>(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n let ndims = tensor.shape.num_dims();\n // Vectorization is only enabled when the last dimension is contiguous.\n let vectorization_factor =\n tensor_vectorization_factor(&[4, 2], &tensor.shape.dims, &tensor.strides, ndims - 1);\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems / vectorization_factor as usize, cube_dim);\n\n let same_tensor_type = core::any::TypeId::of::<E>() == core::any::TypeId::of::<BT>();\n if same_tensor_type && tensor.can_mut() {\n kernel_scalar_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(vectorization_factor),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n CubeTensor::new(\n tensor.client,\n tensor.handle,\n tensor.shape,\n tensor.device,\n tensor.strides,\n BT::dtype(),\n )\n } else {\n let output = empty_device::<R, BT>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_cmp::launch::<Spec<E, BT>, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(vectorization_factor),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<BT>(vectorization_factor),\n );\n\n output\n }\n}\n\npub fn equal<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, EqualOp>(lhs, rhs)\n}\n\npub fn greater<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, GreaterOp>(lhs, rhs)\n}\n\npub fn greater_equal<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, GreaterEqualOp>(lhs, rhs)\n}\n\npub fn lower<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, LowerOp>(lhs, rhs)\n}\n\npub fn lower_equal<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n launch_cmp::<R, E, BT, LowerEqualOp>(lhs, rhs)\n}\n\npub fn equal_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, EqualOp>(lhs, rhs)\n}\n\npub fn greater_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, GreaterOp>(lhs, rhs)\n}\n\npub fn lower_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, LowerOp>(lhs, rhs)\n}\n\npub fn greater_equal_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, GreaterEqualOp>(lhs, rhs)\n}\n\npub fn lower_equal_elem<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n lhs: CubeTensor<R>,\n rhs: E,\n) -> CubeTensor<R> {\n launch_scalar_cmp::<R, E, BT, LowerEqualOp>(lhs, rhs)\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 288,\n \"name\": \"launch_scalar_cmp\",\n \"signature\": \"pub(crate) fn launch_scalar_cmp(\\n mut tensor: CubeTensor<R>,\\n scalar: E,\\n) -> CubeTensor<R>\",\n \"start_line\": 227\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":187,"cells":{"function_name":{"kind":"string","value":"launch_unary_float"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/unary_float.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_unary_float(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R> {\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n let is_contiguous = tensor.is_contiguous();\n\n unsafe {\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\n unary_float::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n args(&()),\n None,\n false,\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n unary_float::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n args(&()),\n Some(ndims as u32),\n !is_contiguous,\n );\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\npub(crate) trait FloatUnaryOpFamily: 'static + Send + Sync {\n type Options<F: Float>: LaunchArg;\n type Unary<F: Float>: FloatUnaryOp<F, Options = Self::Options<F>>;\n}\n\n#[cube]\npub(crate) trait FloatUnaryOp<F: Float>: 'static + Send + Sync {\n type Options: LaunchArg;\n\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F>;\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn unary_float<F: Float, O: FloatUnaryOpFamily>(\n input: &Tensor<Line<F>>,\n output: &mut Tensor<Line<F>>,\n options: &O::Options<F>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous: bool,\n) {\n let offset_output = ABSOLUTE_POS;\n\n if offset_output >= output.len() {\n terminate!();\n }\n\n if comptime![to_contiguous] {\n let offset_input = index_offset_with_layout::<F, F>(\n input,\n output,\n offset_output,\n 0,\n rank.unwrap_or_else(|| output.rank()),\n rank.is_some(),\n );\n\n output[offset_output] = O::Unary::<F>::execute(input[offset_input], options);\n } else {\n output[offset_output] = O::Unary::<F>::execute(input[offset_output], options);\n }\n}\n\npub(crate) fn launch_unary_float<R, E, O, Args>(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R>\nwhere\n // Magic fix for lifetime, the closure is supposed to capture everything required to create the\n // argument.\n for<'a> Args: FnOnce(&'a ()) -> RuntimeArg<'a, O::Options<E>, R>,\n R: CubeRuntime,\n E: CubeElement + Float,\n O: FloatUnaryOpFamily,\n{\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n let is_contiguous = tensor.is_contiguous();\n\n unsafe {\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\n unary_float::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n args(&()),\n None,\n false,\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n unary_float::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n args(&()),\n Some(ndims as u32),\n !is_contiguous,\n );\n output\n }\n }\n}\n\n/// Use comptime enum to implement all unary operations that don't have any input argument in the\n/// kernel definition.\npub(crate) mod unary_basic {\n use crate::execute_with_dtype;\n\n use super::*;\n\n pub(crate) fn launch<R, Args>(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R>\n where\n R: CubeRuntime,\n for<'a> Args: FnOnce(&'a ()) -> &'a BasicFloatUnaryKind,\n {\n execute_with_dtype!(\n float(tensor.dtype),\n F,\n launch_unary_float::<R, F, BasicFloatUnary, _>(tensor, |input| {\n BasicFloatUnaryOptionsLaunch::new(args(input))\n })\n )\n }\n\n #[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, serde::Serialize, serde::Deserialize)]\n pub enum BasicFloatUnaryKind {\n Exp,\n Log,\n Log1p,\n Sqrt,\n Abs,\n Cos,\n Sin,\n Tanh,\n Round,\n Floor,\n Ceil,\n Erf,\n Recip,\n }\n\n #[derive(CubeLaunch, CubeType)]\n struct BasicFloatUnaryOptions {\n #[cube(comptime)]\n kind: BasicFloatUnaryKind,\n }\n struct BasicFloatUnary;\n\n #[cube]\n impl<F: Float> FloatUnaryOp<F> for BasicFloatUnary {\n type Options = BasicFloatUnaryOptions;\n\n fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {\n match comptime![options.kind] {\n BasicFloatUnaryKind::Exp => Line::exp(input),\n BasicFloatUnaryKind::Log => Line::log(input),\n BasicFloatUnaryKind::Log1p => Line::log1p(input),\n BasicFloatUnaryKind::Sqrt => Line::sqrt(input),\n BasicFloatUnaryKind::Abs => Line::abs(input),\n BasicFloatUnaryKind::Cos => Line::cos(input),\n BasicFloatUnaryKind::Sin => Line::sin(input),\n BasicFloatUnaryKind::Tanh => Line::tanh(input),\n BasicFloatUnaryKind::Round => Line::round(input),\n BasicFloatUnaryKind::Floor => Line::floor(input),\n BasicFloatUnaryKind::Ceil => Line::ceil(input),\n BasicFloatUnaryKind::Erf => Line::erf(input),\n BasicFloatUnaryKind::Recip => Line::recip(input),\n }\n }\n }\n\n impl FloatUnaryOpFamily for BasicFloatUnary {\n type Options<F: Float> = BasicFloatUnaryOptions;\n type Unary<F: Float> = Self;\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"{\\n let ndims = tensor.shape.num_dims();\\n let line_size = tensor_line_size_parallel(\\n R::line_size_elem(&E::as_elem_native_unchecked()),\\n &tensor.shape.dims,\\n &tensor.strides,\\n ndims - 1,\\n );\\n\\n let client = tensor.client.clone();\\n let num_elems = tensor.shape.num_elements();\\n\\n let cube_dim = CubeDim::default();\\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\\n let is_contiguous = tensor.is_contiguous();\\n\\n unsafe {\\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\\n unary_float::launch_unchecked::<E, O, R>(\\n &client,\\n cube_count,\\n cube_dim,\\n tensor.as_tensor_arg::<E>(line_size),\\n TensorArg::alias(0),\\n args(&()),\\n None,\\n false,\\n );\\n\\n tensor\\n } else {\\n let output = empty_device::<R, E>(\\n tensor.client.clone(),\\n tensor.device.clone(),\\n tensor.shape.clone(),\\n );\\n\\n unary_float::launch_unchecked::<E, O, R>(\\n &client,\\n cube_count,\\n CubeDim::default(),\\n tensor.as_tensor_arg::<E>(line_size),\\n output.as_tensor_arg::<E>(line_size),\\n args(&()),\\n Some(ndims as u32),\\n !is_contiguous,\\n );\\n output\\n }\\n }\\n}\"\n ],\n \"name\": \"args\",\n \"type\": \"Args\"\n }\n ],\n \"end_line\": 107,\n \"name\": \"launch_unary_float\",\n \"signature\": \"pub(crate) fn launch_unary_float(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R>\",\n \"start_line\": 49\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":188,"cells":{"function_name":{"kind":"string","value":"launch_unary_int"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/unary_int.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_unary_int(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R> {\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n let is_contiguous = tensor.is_contiguous();\n\n unsafe {\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\n unary_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n args(&()),\n None,\n false,\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n unary_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n args(&()),\n Some(ndims as u32),\n !is_contiguous,\n );\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, IntElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\npub(crate) trait IntUnaryOpFamily: 'static + Send + Sync {\n type Options<I: Int>: LaunchArg;\n type Unary<I: Int>: IntUnaryOp<I, Options = Self::Options<I>>;\n}\n\n#[cube]\npub(crate) trait IntUnaryOp<I: CubePrimitive>: 'static + Send + Sync {\n type Options: LaunchArg;\n\n fn execute(input: Line<I>, options: &Self::Options) -> Line<I>;\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn unary_int<I: Int, O: IntUnaryOpFamily>(\n input: &Tensor<Line<I>>,\n output: &mut Tensor<Line<I>>,\n options: &O::Options<I>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous: bool,\n) {\n let offset_output = ABSOLUTE_POS;\n\n if offset_output >= output.len() {\n terminate!();\n }\n\n if comptime![to_contiguous] {\n let offset_input = index_offset_with_layout::<I, I>(\n input,\n output,\n offset_output,\n 0,\n rank.unwrap_or_else(|| output.rank()),\n rank.is_some(),\n );\n\n output[offset_output] = O::Unary::<I>::execute(input[offset_input], options);\n } else {\n output[offset_output] = O::Unary::<I>::execute(input[offset_output], options);\n }\n}\n\npub(crate) fn launch_unary_int<R, E, O, Args>(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R>\nwhere\n for<'a> Args: FnOnce(&'a ()) -> RuntimeArg<'a, O::Options<E>, R>,\n R: CubeRuntime,\n E: IntElement + Int,\n O: IntUnaryOpFamily,\n{\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n let is_contiguous = tensor.is_contiguous();\n\n unsafe {\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\n unary_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n args(&()),\n None,\n false,\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n unary_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n args(&()),\n Some(ndims as u32),\n !is_contiguous,\n );\n output\n }\n }\n}\n\npub(crate) mod unary_basic_int {\n\n use super::*;\n\n pub(crate) fn launch<R, Args, I>(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R>\n where\n R: CubeRuntime,\n for<'a> Args: FnOnce(&'a ()) -> &'a BasicIntUnaryKind,\n I: IntElement,\n {\n launch_unary_int::<R, I, BasicIntUnary, _>(tensor, |input| {\n BasicIntUnaryOptionsLaunch::new(args(input))\n })\n }\n\n #[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, serde::Serialize, serde::Deserialize)]\n pub enum BasicIntUnaryKind {\n BitwiseNot,\n }\n\n #[derive(CubeLaunch, CubeType)]\n struct BasicIntUnaryOptions {\n #[cube(comptime)]\n kind: BasicIntUnaryKind,\n }\n struct BasicIntUnary;\n\n #[cube]\n impl<I: Int> IntUnaryOp<I> for BasicIntUnary {\n type Options = BasicIntUnaryOptions;\n\n fn execute(input: Line<I>, options: &Self::Options) -> Line<I> {\n match comptime![options.kind] {\n BasicIntUnaryKind::BitwiseNot => Line::bitwise_not(input),\n }\n }\n }\n\n impl IntUnaryOpFamily for BasicIntUnary {\n type Options<I: Int> = BasicIntUnaryOptions;\n type Unary<I: Int> = Self;\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"{\\n let ndims = tensor.shape.num_dims();\\n let line_size = tensor_line_size_parallel(\\n R::line_size_elem(&E::as_elem_native_unchecked()),\\n &tensor.shape.dims,\\n &tensor.strides,\\n ndims - 1,\\n );\\n let client = tensor.client.clone();\\n let num_elems = tensor.shape.num_elements();\\n\\n let cube_dim = CubeDim::default();\\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\\n let is_contiguous = tensor.is_contiguous();\\n\\n unsafe {\\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\\n unary_int::launch_unchecked::<E, O, R>(\\n &client,\\n cube_count,\\n cube_dim,\\n tensor.as_tensor_arg::<E>(line_size),\\n TensorArg::alias(0),\\n args(&()),\\n None,\\n false,\\n );\\n\\n tensor\\n } else {\\n let output = empty_device::<R, E>(\\n tensor.client.clone(),\\n tensor.device.clone(),\\n tensor.shape.clone(),\\n );\\n\\n unary_int::launch_unchecked::<E, O, R>(\\n &client,\\n cube_count,\\n CubeDim::default(),\\n tensor.as_tensor_arg::<E>(line_size),\\n output.as_tensor_arg::<E>(line_size),\\n args(&()),\\n Some(ndims as u32),\\n !is_contiguous,\\n );\\n output\\n }\\n }\\n}\"\n ],\n \"name\": \"args\",\n \"type\": \"Args\"\n }\n ],\n \"end_line\": 104,\n \"name\": \"launch_unary_int\",\n \"signature\": \"pub(crate) fn launch_unary_int(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R>\",\n \"start_line\": 49\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":189,"cells":{"function_name":{"kind":"string","value":"launch_unary_numeric"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/unary_numeric.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_unary_numeric(\n tensor: CubeTensor<R>,\n args: Args,\n) -> CubeTensor<R> {\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n let is_contiguous = tensor.is_contiguous();\n\n unsafe {\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\n unary_numeric::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n args(&()),\n None,\n false,\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n unary_numeric::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n args(&()),\n Some(ndims as u32),\n !is_contiguous,\n );\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\npub(crate) trait NumericUnaryOpFamily: 'static + Send + Sync {\n type Options<N: Numeric>: LaunchArg;\n type Unary<N: Numeric>: NumericUnaryOp<N, Options = Self::Options<N>>;\n}\n\n#[cube]\npub(crate) trait NumericUnaryOp<N: CubePrimitive>: 'static + Send + Sync {\n type Options: LaunchArg;\n\n fn execute(input: Line<N>, options: &Self::Options) -> Line<N>;\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn unary_numeric<N: Numeric, O: NumericUnaryOpFamily>(\n input: &Tensor<Line<N>>,\n output: &mut Tensor<Line<N>>,\n options: &O::Options<N>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous: bool,\n) {\n let offset_output = ABSOLUTE_POS;\n\n if offset_output >= output.len() {\n terminate!();\n }\n\n if comptime![to_contiguous] {\n let offset_input = index_offset_with_layout::<N, N>(\n input,\n output,\n offset_output,\n 0,\n rank.unwrap_or_else(|| output.rank()),\n rank.is_some(),\n );\n\n output[offset_output] = O::Unary::<N>::execute(input[offset_input], options);\n } else {\n output[offset_output] = O::Unary::<N>::execute(input[offset_output], options);\n }\n}\n\npub(crate) fn launch_unary_numeric<R, E, O, Args>(\n tensor: CubeTensor<R>,\n args: Args,\n) -> CubeTensor<R>\nwhere\n // Magic fix for lifetime, the closure is supposed to capture everything required to create the\n // argument.\n for<'a> Args: FnOnce(&'a ()) -> RuntimeArg<'a, O::Options<E>, R>,\n R: CubeRuntime,\n E: CubeElement + Numeric,\n O: NumericUnaryOpFamily,\n{\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n let is_contiguous = tensor.is_contiguous();\n\n unsafe {\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\n unary_numeric::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n args(&()),\n None,\n false,\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n unary_numeric::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n args(&()),\n Some(ndims as u32),\n !is_contiguous,\n );\n output\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"{\\n let ndims = tensor.shape.num_dims();\\n let line_size = tensor_line_size_parallel(\\n R::line_size_elem(&E::as_elem_native_unchecked()),\\n &tensor.shape.dims,\\n &tensor.strides,\\n ndims - 1,\\n );\\n let client = tensor.client.clone();\\n let num_elems = tensor.shape.num_elements();\\n\\n let cube_dim = CubeDim::default();\\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\\n let is_contiguous = tensor.is_contiguous();\\n\\n unsafe {\\n if tensor.can_mut() && tensor.is_contiguous_buffer() {\\n unary_numeric::launch_unchecked::<E, O, R>(\\n &client,\\n cube_count,\\n cube_dim,\\n tensor.as_tensor_arg::<E>(line_size),\\n TensorArg::alias(0),\\n args(&()),\\n None,\\n false,\\n );\\n\\n tensor\\n } else {\\n let output = empty_device::<R, E>(\\n tensor.client.clone(),\\n tensor.device.clone(),\\n tensor.shape.clone(),\\n );\\n\\n unary_numeric::launch_unchecked::<E, O, R>(\\n &client,\\n cube_count,\\n CubeDim::default(),\\n tensor.as_tensor_arg::<E>(line_size),\\n output.as_tensor_arg::<E>(line_size),\\n args(&()),\\n Some(ndims as u32),\\n !is_contiguous,\\n );\\n output\\n }\\n }\\n}\"\n ],\n \"name\": \"args\",\n \"type\": \"Args\"\n }\n ],\n \"end_line\": 109,\n \"name\": \"launch_unary_numeric\",\n \"signature\": \"pub(crate) fn launch_unary_numeric(\\n tensor: CubeTensor<R>,\\n args: Args,\\n) -> CubeTensor<R>\",\n \"start_line\": 49\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":190,"cells":{"function_name":{"kind":"string","value":"launch_binop_int"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/binary_int.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_binop_int(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let line_size_lhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &lhs.shape.dims,\n &lhs.strides,\n ndims - 1,\n );\n let line_size_rhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &rhs.shape.dims,\n &rhs.strides,\n ndims - 1,\n );\n let line_size = Ord::min(line_size_lhs, line_size_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if lhs.can_mut_broadcast(&rhs) {\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n lhs\n } else if rhs.can_mut_broadcast(&lhs) {\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n rhs\n } else {\n let output = empty_device::<R, E>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, IntElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse burn_tensor::Shape;\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\nuse super::into_contiguous;\n\npub(crate) trait BinaryOpIntFamily: Send + Sync + 'static {\n type BinaryOp<C: Int>: BinaryOpInt<C>;\n}\n\n#[cube]\npub(crate) trait BinaryOpInt<C: Int>: 'static + Send + Sync {\n /// Execute a binary operation.\n fn execute(lhs: Line<C>, rhs: Line<C>) -> Line<C>;\n}\n\npub(crate) struct BitwiseAndOp;\npub(crate) struct BitwiseOrOp;\npub(crate) struct BitwiseXorOp;\npub(crate) struct BitwiseShrOp;\npub(crate) struct BitwiseShlOp;\n\nimpl BinaryOpIntFamily for BitwiseAndOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseOrOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseXorOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseShrOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseShlOp {\n type BinaryOp<C: Int> = Self;\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseAndOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs & rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseOrOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs | rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseXorOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs ^ rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseShrOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs >> rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseShlOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs << rhs\n }\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_scalar_binop_int<C: Int, O: BinaryOpIntFamily>(\n input: &Tensor<Line<C>>,\n scalar: C,\n output: &mut Tensor<Line<C>>,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n output[ABSOLUTE_POS] = O::BinaryOp::<C>::execute(input[ABSOLUTE_POS], Line::new(scalar));\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_binop_int<C: Int, O: BinaryOpIntFamily>(\n lhs: &Tensor<Line<C>>,\n rhs: &Tensor<Line<C>>,\n out: &mut Tensor<Line<C>>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous_lhs: bool,\n #[comptime] to_contiguous_rhs: bool,\n) {\n let offset_out = ABSOLUTE_POS;\n let mut offset_lhs = ABSOLUTE_POS;\n let mut offset_rhs = ABSOLUTE_POS;\n\n if offset_out >= out.len() {\n terminate!();\n }\n\n if to_contiguous_lhs {\n offset_lhs = index_offset_with_layout::<C, C>(\n lhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n if to_contiguous_rhs {\n offset_rhs = index_offset_with_layout::<C, C>(\n rhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n out[offset_out] = O::BinaryOp::<C>::execute(lhs[offset_lhs], rhs[offset_rhs]);\n}\n\npub(crate) fn launch_binop_int<R: CubeRuntime, E: IntElement, O: BinaryOpIntFamily>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let line_size_lhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &lhs.shape.dims,\n &lhs.strides,\n ndims - 1,\n );\n let line_size_rhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &rhs.shape.dims,\n &rhs.strides,\n ndims - 1,\n );\n let line_size = Ord::min(line_size_lhs, line_size_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if lhs.can_mut_broadcast(&rhs) {\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n lhs\n } else if rhs.can_mut_broadcast(&lhs) {\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n rhs\n } else {\n let output = empty_device::<R, E>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n }\n}\n\npub(crate) fn launch_scalar_binop_int<R: CubeRuntime, E: IntElement, O: BinaryOpIntFamily>(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n // Vectorization is only enabled when the last dimension is contiguous.\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if tensor.can_mut() {\n kernel_scalar_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<E>(line_size),\n );\n\n output\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"lhs\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"rhs\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 221,\n \"name\": \"launch_binop_int\",\n \"signature\": \"pub(crate) fn launch_binop_int(\\n lhs: CubeTensor<R>,\\n rhs: CubeTensor<R>,\\n) -> CubeTensor<R>\",\n \"start_line\": 136\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":191,"cells":{"function_name":{"kind":"string","value":"launch_scalar_binop_int"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/binary_int.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn launch_scalar_binop_int(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n // Vectorization is only enabled when the last dimension is contiguous.\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if tensor.can_mut() {\n kernel_scalar_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<E>(line_size),\n );\n\n output\n }\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, IntElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse burn_tensor::Shape;\nuse cubecl::{\n calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,\n tensor_line_size_parallel,\n};\n\nuse super::into_contiguous;\n\npub(crate) trait BinaryOpIntFamily: Send + Sync + 'static {\n type BinaryOp<C: Int>: BinaryOpInt<C>;\n}\n\n#[cube]\npub(crate) trait BinaryOpInt<C: Int>: 'static + Send + Sync {\n /// Execute a binary operation.\n fn execute(lhs: Line<C>, rhs: Line<C>) -> Line<C>;\n}\n\npub(crate) struct BitwiseAndOp;\npub(crate) struct BitwiseOrOp;\npub(crate) struct BitwiseXorOp;\npub(crate) struct BitwiseShrOp;\npub(crate) struct BitwiseShlOp;\n\nimpl BinaryOpIntFamily for BitwiseAndOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseOrOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseXorOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseShrOp {\n type BinaryOp<C: Int> = Self;\n}\n\nimpl BinaryOpIntFamily for BitwiseShlOp {\n type BinaryOp<C: Int> = Self;\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseAndOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs & rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseOrOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs | rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseXorOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs ^ rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseShrOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs >> rhs\n }\n}\n\n#[cube]\nimpl<N: Int> BinaryOpInt<N> for BitwiseShlOp {\n fn execute(lhs: Line<N>, rhs: Line<N>) -> Line<N> {\n lhs << rhs\n }\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_scalar_binop_int<C: Int, O: BinaryOpIntFamily>(\n input: &Tensor<Line<C>>,\n scalar: C,\n output: &mut Tensor<Line<C>>,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n output[ABSOLUTE_POS] = O::BinaryOp::<C>::execute(input[ABSOLUTE_POS], Line::new(scalar));\n}\n\n#[cube(launch_unchecked)]\npub(crate) fn kernel_binop_int<C: Int, O: BinaryOpIntFamily>(\n lhs: &Tensor<Line<C>>,\n rhs: &Tensor<Line<C>>,\n out: &mut Tensor<Line<C>>,\n #[comptime] rank: Option<u32>,\n #[comptime] to_contiguous_lhs: bool,\n #[comptime] to_contiguous_rhs: bool,\n) {\n let offset_out = ABSOLUTE_POS;\n let mut offset_lhs = ABSOLUTE_POS;\n let mut offset_rhs = ABSOLUTE_POS;\n\n if offset_out >= out.len() {\n terminate!();\n }\n\n if to_contiguous_lhs {\n offset_lhs = index_offset_with_layout::<C, C>(\n lhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n if to_contiguous_rhs {\n offset_rhs = index_offset_with_layout::<C, C>(\n rhs,\n out,\n offset_out,\n 0,\n rank.unwrap_or_else(|| out.rank()),\n rank.is_some(),\n );\n }\n\n out[offset_out] = O::BinaryOp::<C>::execute(lhs[offset_lhs], rhs[offset_rhs]);\n}\n\npub(crate) fn launch_binop_int<R: CubeRuntime, E: IntElement, O: BinaryOpIntFamily>(\n lhs: CubeTensor<R>,\n rhs: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = lhs.shape.num_dims();\n let line_size_lhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &lhs.shape.dims,\n &lhs.strides,\n ndims - 1,\n );\n let line_size_rhs = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &rhs.shape.dims,\n &rhs.strides,\n ndims - 1,\n );\n let line_size = Ord::min(line_size_lhs, line_size_rhs);\n\n let mut shape_out = vec![0; ndims];\n lhs.shape\n .dims\n .iter()\n .zip(rhs.shape.dims.iter())\n .enumerate()\n .for_each(|(index, (dim_lhs, dim_rhs))| {\n shape_out[index] = usize::max(*dim_lhs, *dim_rhs);\n });\n\n let shape_out = Shape::from(shape_out);\n let client = lhs.client.clone();\n let num_elems = shape_out.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if lhs.can_mut_broadcast(&rhs) {\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(0),\n None,\n false,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n );\n\n lhs\n } else if rhs.can_mut_broadcast(&lhs) {\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n TensorArg::alias(1),\n None,\n rhs.strides != lhs.strides || rhs.shape != lhs.shape,\n false,\n );\n\n rhs\n } else {\n let output = empty_device::<R, E>(lhs.client.clone(), lhs.device.clone(), shape_out);\n let to_contiguous_lhs = lhs.strides != output.strides || lhs.shape != output.shape;\n let to_contiguous_rhs = rhs.strides != output.strides || rhs.shape != output.shape;\n\n kernel_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n lhs.as_tensor_arg::<E>(line_size),\n rhs.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n None,\n to_contiguous_lhs,\n to_contiguous_rhs,\n );\n\n output\n }\n }\n}\n\npub(crate) fn launch_scalar_binop_int<R: CubeRuntime, E: IntElement, O: BinaryOpIntFamily>(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R> {\n if !tensor.is_contiguous_buffer() {\n tensor = into_contiguous(tensor);\n }\n\n // Vectorization is only enabled when the last dimension is contiguous.\n let ndims = tensor.shape.num_dims();\n let line_size = tensor_line_size_parallel(\n R::line_size_elem(&E::as_elem_native_unchecked()),\n &tensor.shape.dims,\n &tensor.strides,\n ndims - 1,\n );\n let client = tensor.client.clone();\n let num_elems = tensor.shape.num_elements();\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size as usize, cube_dim);\n\n unsafe {\n if tensor.can_mut() {\n kernel_scalar_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n TensorArg::alias(0),\n );\n\n tensor\n } else {\n let output = empty_device::<R, E>(\n tensor.client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n );\n\n kernel_scalar_binop_int::launch_unchecked::<E, O, R>(\n &client,\n cube_count,\n CubeDim::default(),\n tensor.as_tensor_arg::<E>(line_size),\n ScalarArg::new(scalar),\n output.as_tensor_arg::<E>(line_size),\n );\n\n output\n }\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 276,\n \"name\": \"launch_scalar_binop_int\",\n \"signature\": \"pub(crate) fn launch_scalar_binop_int(\\n mut tensor: CubeTensor<R>,\\n scalar: E,\\n) -> CubeTensor<R>\",\n \"start_line\": 223\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":192,"cells":{"function_name":{"kind":"string","value":"random"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/prng/base.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn random(\n shape: Shape,\n device: &R::Device,\n prng: P,\n) -> CubeTensor<R> {\n let client = R::client(device);\n let output = empty_device::<R, E>(client.clone(), device.clone(), shape);\n let seeds = get_seeds();\n let args = prng.args();\n\n let cube_dim = CubeDim::default();\n let cube_count = prng_cube_count(output.shape.num_elements(), cube_dim, N_VALUES_PER_THREAD);\n\n prng_kernel::launch::<P, E, R>(\n &client,\n cube_count,\n cube_dim,\n output.as_tensor_arg::<E>(1),\n ScalarArg::new(seeds[0]),\n ScalarArg::new(seeds[1]),\n ScalarArg::new(seeds[2]),\n ScalarArg::new(seeds[3]),\n args,\n N_VALUES_PER_THREAD as u32,\n );\n\n output\n}"},"file_content":{"kind":"string","value":"use cubecl::prelude::*;\n\nuse crate::{CubeElement, CubeRuntime, SEED, ops::numeric::empty_device, tensor::CubeTensor};\nuse burn_common::rand::get_seeded_rng;\nuse burn_tensor::Shape;\nuse rand::Rng;\n\npub(crate) const N_VALUES_PER_THREAD: usize = 128;\n\n/// Pseudo-random generator\npub(crate) fn random<P: PrngRuntime<E>, R: CubeRuntime, E: CubeElement>(\n shape: Shape,\n device: &R::Device,\n prng: P,\n) -> CubeTensor<R> {\n let client = R::client(device);\n let output = empty_device::<R, E>(client.clone(), device.clone(), shape);\n let seeds = get_seeds();\n let args = prng.args();\n\n let cube_dim = CubeDim::default();\n let cube_count = prng_cube_count(output.shape.num_elements(), cube_dim, N_VALUES_PER_THREAD);\n\n prng_kernel::launch::<P, E, R>(\n &client,\n cube_count,\n cube_dim,\n output.as_tensor_arg::<E>(1),\n ScalarArg::new(seeds[0]),\n ScalarArg::new(seeds[1]),\n ScalarArg::new(seeds[2]),\n ScalarArg::new(seeds[3]),\n args,\n N_VALUES_PER_THREAD as u32,\n );\n\n output\n}\n\nfn prng_cube_count(num_elems: usize, cube_dim: CubeDim, n_values_per_thread: usize) -> CubeCount {\n let num_threads = f32::ceil(num_elems as f32 / n_values_per_thread as f32);\n let num_invocations = f32::ceil(num_threads / cube_dim.num_elems() as f32);\n let cubes_x = f32::ceil(f32::sqrt(num_invocations));\n let cubes_y = f32::ceil(num_invocations / cubes_x);\n\n CubeCount::Static(cubes_x as u32, cubes_y as u32, 1)\n}\n\npub(crate) fn get_seeds() -> [u32; 4] {\n let mut seed = SEED.lock().unwrap();\n let mut rng = match seed.as_ref() {\n Some(rng_seeded) => rng_seeded.clone(),\n None => get_seeded_rng(),\n };\n let mut seeds: Vec<u32> = Vec::with_capacity(4);\n for _ in 0..4 {\n seeds.push(rng.random());\n }\n *seed = Some(rng);\n\n seeds.try_into().unwrap()\n}\n\npub(crate) trait PrngArgs<E: CubeElement>: Send + Sync + 'static {\n type Args: LaunchArg;\n\n fn args<'a, R: Runtime>(self) -> <Self::Args as LaunchArg>::RuntimeArg<'a, R>;\n}\n\n#[cube]\npub(crate) trait PrngRuntime<E: CubeElement>: Send + Sync + 'static + PrngArgs<E> {\n #[allow(clippy::too_many_arguments)]\n fn inner_loop(\n args: Self::Args,\n write_index_base: u32,\n n_invocations: u32,\n #[comptime] n_values_per_thread: u32,\n state_0: &mut u32,\n state_1: &mut u32,\n state_2: &mut u32,\n state_3: &mut u32,\n output: &mut Tensor<E>,\n );\n}\n\n#[cube(launch)]\nfn prng_kernel<P: PrngRuntime<E>, E: CubeElement>(\n output: &mut Tensor<E>,\n seed_0: u32,\n seed_1: u32,\n seed_2: u32,\n seed_3: u32,\n args: P::Args,\n #[comptime] n_values_per_thread: u32,\n) {\n let cube_offset = CUBE_POS * CUBE_DIM;\n\n let write_index_base = cube_offset * n_values_per_thread + UNIT_POS;\n\n #[allow(arithmetic_overflow)]\n let thread_seed = 1000000007u32 * ABSOLUTE_POS;\n\n let mut state_0 = thread_seed + seed_0;\n let mut state_1 = thread_seed + seed_1;\n let mut state_2 = thread_seed + seed_2;\n let mut state_3 = thread_seed + seed_3;\n\n // Creation of n_values_per_thread values, specific to the distribution\n P::inner_loop(\n args,\n write_index_base,\n CUBE_DIM,\n n_values_per_thread,\n &mut state_0,\n &mut state_1,\n &mut state_2,\n &mut state_3,\n output,\n );\n}\n\n#[cube]\npub(crate) fn taus_step_0(z: u32) -> u32 {\n taus_step(z, 13u32, 19u32, 12u32, 4294967294u32)\n}\n\n#[cube]\npub(crate) fn taus_step_1(z: u32) -> u32 {\n taus_step(z, 2u32, 25u32, 4u32, 4294967288u32)\n}\n\n#[cube]\npub(crate) fn taus_step_2(z: u32) -> u32 {\n taus_step(z, 3u32, 11u32, 17u32, 4294967280u32)\n}\n\n#[cube]\nfn taus_step(z: u32, s1: u32, s2: u32, s3: u32, m: u32) -> u32 {\n let b = z << s1;\n let b = b ^ z;\n let b = b >> s2;\n let z = (z & m) << s3;\n z ^ b\n}\n\n#[cube]\npub(crate) fn lcg_step(z: u32) -> u32 {\n let a = 1664525u32;\n let b = 1013904223u32;\n\n z * a + b\n}\n\n#[cube]\npub(crate) fn cast_uint_to_float(int_random: u32) -> f32 {\n let tmp = 2.328_306_4e-10f32;\n f32::cast_from(int_random) * tmp\n}\n\n#[allow(missing_docs)]\npub mod tests_utils {\n use burn_tensor::Element;\n\n #[derive(Default, Copy, Clone)]\n pub struct BinStats {\n pub count: usize,\n pub n_runs: usize, // Number of sequences of same bin\n }\n\n #[allow(unused)]\n pub fn calculate_bin_stats<E: Element>(\n numbers: &[E],\n number_of_bins: usize,\n low: f32,\n high: f32,\n ) -> Vec<BinStats> {\n let range = (high - low) / number_of_bins as f32;\n let mut output: Vec<BinStats> = (0..number_of_bins).map(|_| Default::default()).collect();\n let mut initialized = false;\n let mut current_runs = number_of_bins; // impossible value for starting point\n for number in numbers {\n let num = number.elem::<f32>();\n if num < low || num > high {\n continue;\n }\n let index = f32::floor((num - low) / range) as usize;\n output[index].count += 1;\n if initialized && index != current_runs {\n output[current_runs].n_runs += 1;\n }\n initialized = true;\n current_runs = index;\n }\n output[current_runs].n_runs += 1;\n output\n }\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 38,\n \"name\": \"random\",\n \"signature\": \"pub(crate) fn random(\\n shape: Shape,\\n device: &R::Device,\\n prng: P,\\n) -> CubeTensor<R>\",\n \"start_line\": 11\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":193,"cells":{"function_name":{"kind":"string","value":"mask_fill_readonly"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/mask/mask_fill.rs"},"focal_code":{"kind":"string","value":"fn mask_fill_readonly(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: EI,\n) -> CubeTensor<R> {\n let ndims = input.shape.num_dims();\n let output = empty_device::<R, EI>(\n input.client.clone(),\n input.device.clone(),\n input.shape.clone(),\n );\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\n let vectorization = max_line_size(&input);\n\n mask_fill_readonly_kernel::launch::<EI, EM, R>(\n &input.client,\n cube_count,\n cube_dim,\n input.as_tensor_arg::<EI>(vectorization),\n mask.as_tensor_arg::<EM>(vectorization),\n output.as_tensor_arg::<EI>(vectorization),\n ScalarArg::new(value),\n ndims as u32,\n );\n\n output\n}"},"file_content":{"kind":"string","value":"use cubecl::{calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*};\n\nuse crate::{\n BoolElement, CubeRuntime,\n element::CubeElement,\n ops::{max_line_size, numeric::empty_device},\n tensor::CubeTensor,\n};\n\n#[cube(launch)]\nfn mask_fill_readonly_kernel<T: Numeric, B: Int>(\n input: &Tensor<Line<T>>,\n mask: &Tensor<Line<B>>,\n output: &mut Tensor<Line<T>>,\n value: T,\n #[comptime] rank: u32,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n let index_input = index_offset_with_layout(input, output, ABSOLUTE_POS, 0, rank, true);\n let index_mask = index_offset_with_layout(mask, output, ABSOLUTE_POS, 0, rank, true);\n\n let mask = Line::cast_from(mask[index_mask]);\n\n output[ABSOLUTE_POS] = select_many(mask, Line::new(value), input[index_input]);\n}\n\n#[cube(launch)]\nfn mask_fill_inplace_kernel<T: Numeric, B: Int>(\n input: &mut Tensor<Line<T>>,\n mask: &Tensor<Line<B>>,\n value: T,\n #[comptime] rank: u32,\n) {\n if ABSOLUTE_POS >= input.len() {\n terminate!();\n }\n\n let index_mask = index_offset_with_layout(mask, input, ABSOLUTE_POS, 0, rank, true);\n let mask = Line::cast_from(mask[index_mask]);\n\n input[ABSOLUTE_POS] = select_many(mask, Line::new(value), input[ABSOLUTE_POS]);\n}\n\n#[derive(Clone, Copy, Debug)]\n/// Define how to run the mask fill kernel.\n///\n/// # Notes\n///\n/// All assertions should be done before choosing the strategy.\npub enum MaskFillStrategy {\n /// Don't mutate any input.\n Readonly,\n /// Reuse the input tensor inplace.\n Inplace,\n}\n\n/// Execute the mask fill kernel with the given strategy.\npub fn mask_fill<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: E,\n strategy: MaskFillStrategy,\n) -> CubeTensor<R> {\n match strategy {\n MaskFillStrategy::Readonly => mask_fill_readonly::<R, E, BT>(input, mask, value),\n MaskFillStrategy::Inplace => mask_fill_inplace::<R, E, BT>(input, mask, value),\n }\n}\n\nfn mask_fill_readonly<R: CubeRuntime, EI: CubeElement, EM: BoolElement>(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: EI,\n) -> CubeTensor<R> {\n let ndims = input.shape.num_dims();\n let output = empty_device::<R, EI>(\n input.client.clone(),\n input.device.clone(),\n input.shape.clone(),\n );\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\n let vectorization = max_line_size(&input);\n\n mask_fill_readonly_kernel::launch::<EI, EM, R>(\n &input.client,\n cube_count,\n cube_dim,\n input.as_tensor_arg::<EI>(vectorization),\n mask.as_tensor_arg::<EM>(vectorization),\n output.as_tensor_arg::<EI>(vectorization),\n ScalarArg::new(value),\n ndims as u32,\n );\n\n output\n}\n\nfn mask_fill_inplace<R: CubeRuntime, EI: CubeElement, EM: BoolElement>(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: EI,\n) -> CubeTensor<R> {\n let ndims = input.shape.num_dims();\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\n let vectorization = max_line_size(&input);\n\n mask_fill_inplace_kernel::launch::<EI, EM, R>(\n &input.client,\n cube_count,\n cube_dim,\n input.as_tensor_arg::<EI>(vectorization),\n mask.as_tensor_arg::<EM>(vectorization),\n ScalarArg::new(value),\n ndims as u32,\n );\n\n input\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"input\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"mask\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \") -> CubeTensor<R> {\\n let ndims = input.shape.num_dims();\\n let output = empty_device::<R, EI>(\\n input.client.clone(),\\n input.device.clone(),\\n input.shape.clone(),\\n );\\n\\n let cube_dim = CubeDim::default();\\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\\n let vectorization = max_line_size(&input);\\n\\n mask_fill_readonly_kernel::launch::<EI, EM, R>(\\n &input.client,\\n cube_count,\\n cube_dim,\\n input.as_tensor_arg::<EI>(vectorization),\\n mask.as_tensor_arg::<EM>(vectorization),\\n output.as_tensor_arg::<EI>(vectorization),\\n ScalarArg::new(value),\\n ndims as u32,\\n );\\n\\n output\\n}\"\n ],\n \"name\": \"value\",\n \"type\": \"EI\"\n }\n ],\n \"end_line\": 101,\n \"name\": \"mask_fill_readonly\",\n \"signature\": \"fn mask_fill_readonly(\\n input: CubeTensor<R>,\\n mask: CubeTensor<R>,\\n value: EI,\\n) -> CubeTensor<R>\",\n \"start_line\": 73\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":194,"cells":{"function_name":{"kind":"string","value":"mask_where_readonly"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/mask/mask_where.rs"},"focal_code":{"kind":"string","value":"fn mask_where_readonly(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = input.shape.num_dims();\n let output = empty_device::<R, EI>(\n input.client.clone(),\n input.device.clone(),\n input.shape.clone(),\n );\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\n let vectorization = max_line_size(&input);\n\n mask_where_readonly_kernel::launch::<EI, EM, R>(\n &input.client,\n cube_count,\n cube_dim,\n input.as_tensor_arg::<EI>(vectorization),\n mask.as_tensor_arg::<EM>(vectorization),\n value.as_tensor_arg::<EI>(vectorization),\n output.as_tensor_arg::<EI>(vectorization),\n ndims as u32,\n );\n\n output\n}"},"file_content":{"kind":"string","value":"use cubecl::{calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*};\n\nuse crate::{\n BoolElement, CubeRuntime,\n element::CubeElement,\n ops::{max_line_size, numeric::empty_device},\n tensor::CubeTensor,\n};\n\n#[cube(launch)]\nfn mask_where_readonly_kernel<T: CubePrimitive, B: Int>(\n input: &Tensor<Line<T>>,\n mask: &Tensor<Line<B>>,\n value: &Tensor<Line<T>>,\n output: &mut Tensor<Line<T>>,\n #[comptime] rank: u32,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n let index_input = index_offset_with_layout(input, output, ABSOLUTE_POS, 0, rank, true);\n let index_mask = index_offset_with_layout(mask, output, ABSOLUTE_POS, 0, rank, true);\n let index_value = index_offset_with_layout(value, output, ABSOLUTE_POS, 0, rank, true);\n let mask = Line::cast_from(mask[index_mask]);\n\n output[ABSOLUTE_POS] = select_many(mask, value[index_value], input[index_input]);\n}\n\n#[cube(launch)]\nfn mask_where_inplace_kernel<T: CubePrimitive, B: Int>(\n input: &mut Tensor<Line<T>>,\n mask: &Tensor<Line<B>>,\n value: &Tensor<Line<T>>,\n reverse: B,\n #[comptime] rank: u32,\n) {\n if ABSOLUTE_POS >= input.len() {\n terminate!();\n }\n\n let index_mask = index_offset_with_layout(mask, input, ABSOLUTE_POS, 0, rank, true);\n let index_value = index_offset_with_layout(value, input, ABSOLUTE_POS, 0, rank, true);\n\n input[ABSOLUTE_POS] = select(\n mask[index_mask] != Line::new(reverse),\n value[index_value],\n input[ABSOLUTE_POS],\n );\n}\n\n#[derive(Clone, Copy, Debug)]\n/// Define how to run the mask where kernel.\n///\n/// # Notes\n///\n/// All assertions should be done before choosing the strategy.\npub enum MaskWhereStrategy {\n /// Don't mutate any input.\n Readonly,\n /// Reuse the lhs tensor inplace.\n InplaceLhs,\n /// Reuse the rhs tensor inplace.\n InplaceRhs,\n}\n\n/// Execute the mask where kernel with the given strategy.\npub fn mask_where<R: CubeRuntime, E: CubeElement, BT: BoolElement>(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: CubeTensor<R>,\n strategy: MaskWhereStrategy,\n) -> CubeTensor<R> {\n match strategy {\n MaskWhereStrategy::Readonly => mask_where_readonly::<R, E, BT>(input, mask, value),\n MaskWhereStrategy::InplaceLhs => mask_where_inplace::<R, E, BT>(input, mask, value, false),\n MaskWhereStrategy::InplaceRhs => mask_where_inplace::<R, E, BT>(value, mask, input, true),\n }\n}\n\nfn mask_where_readonly<R: CubeRuntime, EI: CubeElement, EM: BoolElement>(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: CubeTensor<R>,\n) -> CubeTensor<R> {\n let ndims = input.shape.num_dims();\n let output = empty_device::<R, EI>(\n input.client.clone(),\n input.device.clone(),\n input.shape.clone(),\n );\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\n let vectorization = max_line_size(&input);\n\n mask_where_readonly_kernel::launch::<EI, EM, R>(\n &input.client,\n cube_count,\n cube_dim,\n input.as_tensor_arg::<EI>(vectorization),\n mask.as_tensor_arg::<EM>(vectorization),\n value.as_tensor_arg::<EI>(vectorization),\n output.as_tensor_arg::<EI>(vectorization),\n ndims as u32,\n );\n\n output\n}\n\nfn mask_where_inplace<R: CubeRuntime, EI: CubeElement, EM: BoolElement>(\n input: CubeTensor<R>,\n mask: CubeTensor<R>,\n value: CubeTensor<R>,\n reverse: bool,\n) -> CubeTensor<R> {\n let ndims = input.shape.num_dims();\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(input.shape.num_elements(), cube_dim);\n let vectorization = max_line_size(&input);\n\n mask_where_inplace_kernel::launch::<EI, EM, R>(\n &input.client,\n cube_count,\n cube_dim,\n input.as_tensor_arg::<EI>(vectorization),\n mask.as_tensor_arg::<EM>(vectorization),\n value.as_tensor_arg::<EI>(vectorization),\n ScalarArg::new(EM::new_bool(reverse)),\n ndims as u32,\n );\n\n input\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"input\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"mask\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"value\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 109,\n \"name\": \"mask_where_readonly\",\n \"signature\": \"fn mask_where_readonly(\\n input: CubeTensor<R>,\\n mask: CubeTensor<R>,\\n value: CubeTensor<R>,\\n) -> CubeTensor<R>\",\n \"start_line\": 81\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":195,"cells":{"function_name":{"kind":"string","value":"interpolate_nearest_backward_launch"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/interpolate/nearest_backward.rs"},"focal_code":{"kind":"string","value":"pub(crate) fn interpolate_nearest_backward_launch(\n out_grad: CubeTensor<R>,\n output: CubeTensor<R>,\n) -> CubeTensor<R> {\n let line_size = max_line_size(&out_grad);\n let out_shape = shape_divmod(&output);\n let out_layout = strided_layout(&output);\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(output.shape.num_elements() / line_size as usize, cube_dim);\n\n unsafe {\n interpolate_nearest_backward_kernel::launch_unchecked::<E, R>(\n &out_grad.client,\n cube_count,\n cube_dim,\n out_grad.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n out_shape,\n out_layout,\n )\n };\n\n output\n}"},"file_content":{"kind":"string","value":"use cubecl::{calculate_cube_count_elemwise, linalg::tensor::StridedLayout, prelude::*};\nuse cubecl_std::FastDivmod;\n\nuse crate::{\n CubeRuntime, FloatElement,\n kernel::utils::{shape_divmod, strided_layout},\n ops::max_line_size,\n tensor::CubeTensor,\n};\n\n#[cube(launch_unchecked)]\nfn interpolate_nearest_backward_kernel<F: Float>(\n grad: &Tensor<Line<F>>,\n output: &mut Tensor<Line<F>>,\n shape_out: Sequence<FastDivmod>,\n out_layout: StridedLayout,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n let line_size = grad.line_size();\n let out_idx = out_layout.index(output, ABSOLUTE_POS);\n\n let out_h = output.shape(1);\n let out_w = output.shape(2);\n let grad_h = grad.shape(1);\n let grad_w = grad.shape(2);\n\n let (rem, c) = shape_out.index(3).div_mod(ABSOLUTE_POS * line_size);\n let (rem, out_x) = shape_out.index(2).div_mod(rem);\n let (b, out_y) = shape_out.index(1).div_mod(rem);\n\n let grad_y_start = start_index::<F>(out_y, grad_h, out_h);\n let grad_y_end = end_index::<F>(out_y, grad_h, out_h);\n let grad_x_start = start_index::<F>(out_x, grad_w, out_w);\n let grad_x_end = end_index::<F>(out_x, grad_w, out_w);\n\n let index_grad_base = b * grad.stride(0) + c * grad.stride(3);\n\n let mut sum = Line::empty(line_size).fill(F::new(0.0));\n\n for grad_y in grad_y_start..grad_y_end {\n for grad_x in grad_x_start..grad_x_end {\n let index_grad = index_grad_base + grad_y * grad.stride(1) + grad_x * grad.stride(2);\n\n sum += grad[index_grad];\n }\n }\n\n output[out_idx] = sum;\n}\n\n#[cube]\nfn start_index<F: Float>(input_index: u32, output_size: u32, input_size: u32) -> u32 {\n let numerator = F::cast_from(input_index * output_size);\n let div: F = Ceil::ceil(numerator / F::cast_from(input_size));\n\n u32::cast_from(div)\n}\n\n#[cube]\nfn end_index<F: Float>(input_index: u32, output_size: u32, input_size: u32) -> u32 {\n let numerator = F::cast_from((input_index + 1) * output_size);\n let div: F = Ceil::ceil(numerator / F::cast_from(input_size));\n let index = u32::cast_from(div);\n\n Min::min(output_size, index)\n}\n\npub(crate) fn interpolate_nearest_backward_launch<R: CubeRuntime, E: FloatElement>(\n out_grad: CubeTensor<R>,\n output: CubeTensor<R>,\n) -> CubeTensor<R> {\n let line_size = max_line_size(&out_grad);\n let out_shape = shape_divmod(&output);\n let out_layout = strided_layout(&output);\n\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(output.shape.num_elements() / line_size as usize, cube_dim);\n\n unsafe {\n interpolate_nearest_backward_kernel::launch_unchecked::<E, R>(\n &out_grad.client,\n cube_count,\n cube_dim,\n out_grad.as_tensor_arg::<E>(line_size),\n output.as_tensor_arg::<E>(line_size),\n out_shape,\n out_layout,\n )\n };\n\n output\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"out_grad\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"output\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 96,\n \"name\": \"interpolate_nearest_backward_launch\",\n \"signature\": \"pub(crate) fn interpolate_nearest_backward_launch(\\n out_grad: CubeTensor<R>,\\n output: CubeTensor<R>,\\n) -> CubeTensor<R>\",\n \"start_line\": 71\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":196,"cells":{"function_name":{"kind":"string","value":"dequantize"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/quantization/dequantize.rs"},"focal_code":{"kind":"string","value":"pub fn dequantize(tensor: CubeTensor<R>) -> CubeTensor<R> {\n // The actual number of elements is 1/4 (four int8 values packed in a single u32)\n // so we choose a line size to match a valid input binding size.\n let num_out_elems = tensor.shape.num_elements();\n let num_elems = usize::div_ceil(num_out_elems, 4);\n let line_size_in = 1;\n let line_size_out = 1;\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size_in as usize, cube_dim);\n\n let client = tensor.client.clone();\n let handle = client.empty(num_out_elems * core::mem::size_of::<F>());\n\n let output = CubeTensor::new_contiguous(\n client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n handle,\n F::dtype(),\n );\n\n if let DType::QFloat(scheme) = tensor.dtype {\n match scheme {\n QuantizationScheme::PerTensor(QuantizationMode::Symmetric, QuantizationType::QInt8) => {\n unsafe {\n dequantize_per_tensor_symmetric_int8_kernel::launch_unchecked::<R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_array_arg::<u32>(line_size_in),\n output.as_tensor_arg::<F>(line_size_out),\n scheme,\n )\n };\n }\n }\n }\n\n output\n}"},"file_content":{"kind":"string","value":"use crate::tensor::CubeTensor;\nuse crate::{CubeElement, CubeRuntime};\nuse burn_tensor::DType;\nuse burn_tensor::quantization::{QuantizationMode, QuantizationScheme, QuantizationType};\nuse cubecl::calculate_cube_count_elemwise;\nuse cubecl::prelude::*;\n\nuse super::{QParams, QTensor};\n\n#[cube]\nfn dequantize_symmetric_int8<F: Float>(value: Line<i32>, scale: f32) -> Line<F> {\n // x = scale * x_q\n Line::cast_from(scale) * Line::cast_from(value)\n}\n\n#[cube]\nfn extract_i8(value: u32, offset: u32) -> i32 {\n // Extract 8-bit segment\n let value = (value >> offset) & 0xFF;\n // Check if the value is negative by inspecting the MSB and subtract 256 if it is\n // Subtract 0 or 256 to circumvent unsupported conditional assignment (let x = if {} else {};)\n let sub = i32::cast_from(value & 0x80 != 0) * 256;\n i32::cast_from(value) - sub\n}\n\n#[cube]\nfn unpack_i8s(value: u32) -> Line<i32> {\n let mut line = Line::empty(4_u32);\n // Extract each 8-bit segment\n line[0] = extract_i8(value, 0);\n line[1] = extract_i8(value, 8);\n line[2] = extract_i8(value, 16);\n line[3] = extract_i8(value, 24);\n\n line\n}\n\n#[cube(launch_unchecked)]\nfn dequantize_per_tensor_symmetric_int8_kernel(\n input: &QTensor,\n output: &mut Tensor<Line<f32>>,\n #[comptime] scheme: QuantizationScheme,\n) {\n // Last position contains the qparam\n if ABSOLUTE_POS >= input.len() - 1 {\n terminate!();\n }\n\n let qparams = QParams::new(scheme);\n let (scale, _) = qparams.values(input);\n\n let value = input[ABSOLUTE_POS];\n\n // Input line size is fixed to 1\n if comptime!(output.line_size() == 4) {\n output[ABSOLUTE_POS] = dequantize_symmetric_int8(unpack_i8s(value[0]), scale);\n } else {\n // For very small inputs where number of elements < 4, the output line size is 1\n let out = dequantize_symmetric_int8::<f32>(unpack_i8s(value[0]), scale);\n\n #[unroll]\n for j in 0..out.size() {\n output[ABSOLUTE_POS * out.size() + j] = Line::cast_from(out[j]);\n }\n }\n}\n\n/// Convert the tensor back to a higher precision data type.\npub fn dequantize<R, F>(tensor: CubeTensor<R>) -> CubeTensor<R>\nwhere\n R: CubeRuntime,\n F: CubeElement,\n{\n // The actual number of elements is 1/4 (four int8 values packed in a single u32)\n // so we choose a line size to match a valid input binding size.\n let num_out_elems = tensor.shape.num_elements();\n let num_elems = usize::div_ceil(num_out_elems, 4);\n let line_size_in = 1;\n let line_size_out = 1;\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(num_elems / line_size_in as usize, cube_dim);\n\n let client = tensor.client.clone();\n let handle = client.empty(num_out_elems * core::mem::size_of::<F>());\n\n let output = CubeTensor::new_contiguous(\n client.clone(),\n tensor.device.clone(),\n tensor.shape.clone(),\n handle,\n F::dtype(),\n );\n\n if let DType::QFloat(scheme) = tensor.dtype {\n match scheme {\n QuantizationScheme::PerTensor(QuantizationMode::Symmetric, QuantizationType::QInt8) => {\n unsafe {\n dequantize_per_tensor_symmetric_int8_kernel::launch_unchecked::<R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_array_arg::<u32>(line_size_in),\n output.as_tensor_arg::<F>(line_size_out),\n scheme,\n )\n };\n }\n }\n }\n\n output\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 112,\n \"name\": \"dequantize\",\n \"signature\": \"pub fn dequantize(tensor: CubeTensor<R>) -> CubeTensor<R>\",\n \"start_line\": 69\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":197,"cells":{"function_name":{"kind":"string","value":"create_quantized_output"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/quantization/quantize.rs"},"focal_code":{"kind":"string","value":"fn create_quantized_output(\n client: ComputeClient<R::Server, R::Channel>,\n num_input_elems: usize,\n device: R::Device,\n shape: Shape,\n scheme: QuantizationScheme,\n) -> CubeTensor<R> {\n // Output tensor contains 4x less elements (four int8 values packed in a single u32)\n let output_elems_size = usize::div_ceil(num_input_elems, 4) * core::mem::size_of::<u32>();\n\n // Scale and offset (optional) qparams are also packed in the tensor data\n let qparams_size = match &scheme {\n QuantizationScheme::PerTensor(mode, ..) => match mode {\n QuantizationMode::Symmetric => core::mem::size_of::<f32>(),\n },\n };\n\n let handle = client.empty(output_elems_size + qparams_size);\n CubeTensor::new_contiguous(\n client,\n device,\n shape,\n handle,\n burn_tensor::DType::QFloat(scheme),\n )\n}"},"file_content":{"kind":"string","value":"use crate::tensor::CubeTensor;\nuse crate::{CubeElement, CubeRuntime, IntElement};\nuse burn_tensor::Shape;\nuse burn_tensor::quantization::{QuantizationMode, QuantizationScheme, QuantizationType};\nuse cubecl::calculate_cube_count_elemwise;\nuse cubecl::prelude::*;\n\n#[cube]\nfn pack_i8s_to_u32s(value: Line<u32>) -> u32 {\n // NOTE: assuming line size of 4\n let line_size = value.size();\n let mut v_packed = 0;\n\n #[unroll]\n for i in 0..line_size {\n // Shift and combine into u32\n v_packed |= (value[i] & 0xFF) << (8 * i);\n }\n v_packed\n}\n\n#[cube]\nfn quantize_symmetric_int8<F: Float>(\n value: Line<F>,\n scale: f32,\n range_min: F,\n range_max: F,\n) -> Line<u32> {\n // x_q = clamp(round(x / scale), a, b)\n // NOTE: we add 256 before casting to unsigned to correctly represent negative values\n Line::cast_from(\n Line::clamp(\n Line::round(value / Line::cast_from(scale)),\n Line::new(range_min),\n Line::new(range_max),\n ) + Line::cast_from(comptime!(256f32)),\n )\n}\n\n#[cube]\nfn quantize_symmetric_int8_packed(\n input: Line<f32>,\n scale: f32,\n range_min: f32,\n range_max: f32,\n) -> u32 {\n // Assuming a line size of 4 (equal to the number of values packed)\n let value = quantize_symmetric_int8::<f32>(input, scale, range_min, range_max);\n // Shift and combine into u32\n pack_i8s_to_u32s(value)\n}\n\n#[cube(launch_unchecked)]\nfn quantize_per_tensor_symmetric_int8_kernel(\n input: &Tensor<Line<f32>>,\n scale: &Tensor<f32>,\n range_min: f32,\n range_max: f32,\n output: &mut Array<u32>,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n let scale = scale[0];\n\n // Cast the scale to u32 and write the value in the output\n if ABSOLUTE_POS == output.len() - 1 {\n output[ABSOLUTE_POS] = u32::reinterpret(scale);\n terminate!();\n }\n\n if comptime!(input.line_size() == 4) {\n output[ABSOLUTE_POS] =\n quantize_symmetric_int8_packed(input[ABSOLUTE_POS], scale, range_min, range_max);\n } else {\n // line size 1\n let num_packed = comptime!(4);\n let mut values = Line::<f32>::empty(num_packed);\n #[unroll]\n for i in 0..num_packed {\n values[i] = input[ABSOLUTE_POS * num_packed + i][0];\n }\n output[ABSOLUTE_POS] = quantize_symmetric_int8_packed(values, scale, range_min, range_max);\n }\n}\n\nfn create_quantized_output<R: CubeRuntime>(\n client: ComputeClient<R::Server, R::Channel>,\n num_input_elems: usize,\n device: R::Device,\n shape: Shape,\n scheme: QuantizationScheme,\n) -> CubeTensor<R> {\n // Output tensor contains 4x less elements (four int8 values packed in a single u32)\n let output_elems_size = usize::div_ceil(num_input_elems, 4) * core::mem::size_of::<u32>();\n\n // Scale and offset (optional) qparams are also packed in the tensor data\n let qparams_size = match &scheme {\n QuantizationScheme::PerTensor(mode, ..) => match mode {\n QuantizationMode::Symmetric => core::mem::size_of::<f32>(),\n },\n };\n\n let handle = client.empty(output_elems_size + qparams_size);\n CubeTensor::new_contiguous(\n client,\n device,\n shape,\n handle,\n burn_tensor::DType::QFloat(scheme),\n )\n}\n\n/// Convert the tensor to a lower precision data type based on the quantization scheme and parameters.\npub fn quantize<R, F, I>(\n tensor: CubeTensor<R>,\n scheme: &QuantizationScheme,\n scale: CubeTensor<R>,\n) -> CubeTensor<R>\nwhere\n R: CubeRuntime,\n F: CubeElement,\n I: IntElement,\n{\n let client = tensor.client.clone();\n // Output tensor contains 4x less elements (four int8 values packed in a single u32)\n let num_elems = tensor.shape.num_elements();\n\n // Force vectorization to process 4 quantized values packed for 1 output value\n let line_size: u8 = 1;\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems.div_ceil(line_size as usize), cube_dim);\n\n let output = create_quantized_output(\n client.clone(),\n num_elems,\n tensor.device.clone(),\n tensor.shape.clone(),\n *scheme,\n );\n\n match scheme {\n QuantizationScheme::PerTensor(mode, QuantizationType::QInt8) => {\n let ndims = tensor.shape.num_dims();\n let dummy_array = vec![1; ndims];\n\n match mode {\n QuantizationMode::Symmetric => {\n unsafe {\n quantize_per_tensor_symmetric_int8_kernel::launch_unchecked::<R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<F>(line_size),\n // Ignore shape and stride\n TensorArg::from_raw_parts::<F>(\n &scale.handle,\n &dummy_array,\n &dummy_array,\n 1,\n ),\n ScalarArg::new(-i8::MAX as f32),\n ScalarArg::new(i8::MAX as f32),\n output.as_array_arg::<u32>(1),\n )\n };\n }\n }\n }\n }\n\n output\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [],\n \"end_line\": 113,\n \"name\": \"create_quantized_output\",\n \"signature\": \"fn create_quantized_output(\\n client: ComputeClient<R::Server, R::Channel>,\\n num_input_elems: usize,\\n device: R::Device,\\n shape: Shape,\\n scheme: QuantizationScheme,\\n) -> CubeTensor<R>\",\n \"start_line\": 88\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":198,"cells":{"function_name":{"kind":"string","value":"quantize"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/quantization/quantize.rs"},"focal_code":{"kind":"string","value":"pub fn quantize(\n tensor: CubeTensor<R>,\n scheme: &QuantizationScheme,\n scale: CubeTensor<R>,\n) -> CubeTensor<R> {\n let client = tensor.client.clone();\n // Output tensor contains 4x less elements (four int8 values packed in a single u32)\n let num_elems = tensor.shape.num_elements();\n\n // Force vectorization to process 4 quantized values packed for 1 output value\n let line_size: u8 = 1;\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems.div_ceil(line_size as usize), cube_dim);\n\n let output = create_quantized_output(\n client.clone(),\n num_elems,\n tensor.device.clone(),\n tensor.shape.clone(),\n *scheme,\n );\n\n match scheme {\n QuantizationScheme::PerTensor(mode, QuantizationType::QInt8) => {\n let ndims = tensor.shape.num_dims();\n let dummy_array = vec![1; ndims];\n\n match mode {\n QuantizationMode::Symmetric => {\n unsafe {\n quantize_per_tensor_symmetric_int8_kernel::launch_unchecked::<R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<F>(line_size),\n // Ignore shape and stride\n TensorArg::from_raw_parts::<F>(\n &scale.handle,\n &dummy_array,\n &dummy_array,\n 1,\n ),\n ScalarArg::new(-i8::MAX as f32),\n ScalarArg::new(i8::MAX as f32),\n output.as_array_arg::<u32>(1),\n )\n };\n }\n }\n }\n }\n\n output\n}"},"file_content":{"kind":"string","value":"use crate::tensor::CubeTensor;\nuse crate::{CubeElement, CubeRuntime, IntElement};\nuse burn_tensor::Shape;\nuse burn_tensor::quantization::{QuantizationMode, QuantizationScheme, QuantizationType};\nuse cubecl::calculate_cube_count_elemwise;\nuse cubecl::prelude::*;\n\n#[cube]\nfn pack_i8s_to_u32s(value: Line<u32>) -> u32 {\n // NOTE: assuming line size of 4\n let line_size = value.size();\n let mut v_packed = 0;\n\n #[unroll]\n for i in 0..line_size {\n // Shift and combine into u32\n v_packed |= (value[i] & 0xFF) << (8 * i);\n }\n v_packed\n}\n\n#[cube]\nfn quantize_symmetric_int8<F: Float>(\n value: Line<F>,\n scale: f32,\n range_min: F,\n range_max: F,\n) -> Line<u32> {\n // x_q = clamp(round(x / scale), a, b)\n // NOTE: we add 256 before casting to unsigned to correctly represent negative values\n Line::cast_from(\n Line::clamp(\n Line::round(value / Line::cast_from(scale)),\n Line::new(range_min),\n Line::new(range_max),\n ) + Line::cast_from(comptime!(256f32)),\n )\n}\n\n#[cube]\nfn quantize_symmetric_int8_packed(\n input: Line<f32>,\n scale: f32,\n range_min: f32,\n range_max: f32,\n) -> u32 {\n // Assuming a line size of 4 (equal to the number of values packed)\n let value = quantize_symmetric_int8::<f32>(input, scale, range_min, range_max);\n // Shift and combine into u32\n pack_i8s_to_u32s(value)\n}\n\n#[cube(launch_unchecked)]\nfn quantize_per_tensor_symmetric_int8_kernel(\n input: &Tensor<Line<f32>>,\n scale: &Tensor<f32>,\n range_min: f32,\n range_max: f32,\n output: &mut Array<u32>,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n let scale = scale[0];\n\n // Cast the scale to u32 and write the value in the output\n if ABSOLUTE_POS == output.len() - 1 {\n output[ABSOLUTE_POS] = u32::reinterpret(scale);\n terminate!();\n }\n\n if comptime!(input.line_size() == 4) {\n output[ABSOLUTE_POS] =\n quantize_symmetric_int8_packed(input[ABSOLUTE_POS], scale, range_min, range_max);\n } else {\n // line size 1\n let num_packed = comptime!(4);\n let mut values = Line::<f32>::empty(num_packed);\n #[unroll]\n for i in 0..num_packed {\n values[i] = input[ABSOLUTE_POS * num_packed + i][0];\n }\n output[ABSOLUTE_POS] = quantize_symmetric_int8_packed(values, scale, range_min, range_max);\n }\n}\n\nfn create_quantized_output<R: CubeRuntime>(\n client: ComputeClient<R::Server, R::Channel>,\n num_input_elems: usize,\n device: R::Device,\n shape: Shape,\n scheme: QuantizationScheme,\n) -> CubeTensor<R> {\n // Output tensor contains 4x less elements (four int8 values packed in a single u32)\n let output_elems_size = usize::div_ceil(num_input_elems, 4) * core::mem::size_of::<u32>();\n\n // Scale and offset (optional) qparams are also packed in the tensor data\n let qparams_size = match &scheme {\n QuantizationScheme::PerTensor(mode, ..) => match mode {\n QuantizationMode::Symmetric => core::mem::size_of::<f32>(),\n },\n };\n\n let handle = client.empty(output_elems_size + qparams_size);\n CubeTensor::new_contiguous(\n client,\n device,\n shape,\n handle,\n burn_tensor::DType::QFloat(scheme),\n )\n}\n\n/// Convert the tensor to a lower precision data type based on the quantization scheme and parameters.\npub fn quantize<R, F, I>(\n tensor: CubeTensor<R>,\n scheme: &QuantizationScheme,\n scale: CubeTensor<R>,\n) -> CubeTensor<R>\nwhere\n R: CubeRuntime,\n F: CubeElement,\n I: IntElement,\n{\n let client = tensor.client.clone();\n // Output tensor contains 4x less elements (four int8 values packed in a single u32)\n let num_elems = tensor.shape.num_elements();\n\n // Force vectorization to process 4 quantized values packed for 1 output value\n let line_size: u8 = 1;\n let cube_dim = CubeDim::default();\n let cube_count =\n calculate_cube_count_elemwise(num_elems.div_ceil(line_size as usize), cube_dim);\n\n let output = create_quantized_output(\n client.clone(),\n num_elems,\n tensor.device.clone(),\n tensor.shape.clone(),\n *scheme,\n );\n\n match scheme {\n QuantizationScheme::PerTensor(mode, QuantizationType::QInt8) => {\n let ndims = tensor.shape.num_dims();\n let dummy_array = vec![1; ndims];\n\n match mode {\n QuantizationMode::Symmetric => {\n unsafe {\n quantize_per_tensor_symmetric_int8_kernel::launch_unchecked::<R>(\n &client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<F>(line_size),\n // Ignore shape and stride\n TensorArg::from_raw_parts::<F>(\n &scale.handle,\n &dummy_array,\n &dummy_array,\n 1,\n ),\n ScalarArg::new(-i8::MAX as f32),\n ScalarArg::new(i8::MAX as f32),\n output.as_array_arg::<u32>(1),\n )\n };\n }\n }\n }\n }\n\n output\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"scale\",\n \"type\": \"CubeTensor<R>\"\n }\n ],\n \"end_line\": 175,\n \"name\": \"quantize\",\n \"signature\": \"pub fn quantize(\\n tensor: CubeTensor<R>,\\n scheme: &QuantizationScheme,\\n scale: CubeTensor<R>,\\n) -> CubeTensor<R>\",\n \"start_line\": 116\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}},{"rowIdx":199,"cells":{"function_name":{"kind":"string","value":"slice"},"file_path":{"kind":"string","value":"burn-main/crates/burn-cubecl/src/kernel/index/slice.rs"},"focal_code":{"kind":"string","value":"pub fn slice(\n tensor: CubeTensor<R>,\n indices: &[Range<usize>],\n) -> CubeTensor<R> {\n let mut dims = tensor.shape.dims.clone();\n let mut offset_start = 0u64;\n let mut offset_end = 0u64;\n\n for i in 0..indices.len() {\n offset_start += (tensor.strides[i] * indices[i].start) as u64;\n offset_end += (tensor.strides[i] * (dims[i] - indices[i].end)) as u64;\n dims[i] = indices[i].end - indices[i].start;\n }\n\n let offset_start = offset_start * E::cube_elem().size() as u64;\n let offset_end = offset_end * E::cube_elem().size() as u64;\n\n let memory_offset_alignment = tensor.client.properties().memory_properties().alignment;\n\n if offset_start % memory_offset_alignment == 0u64\n && offset_end % memory_offset_alignment == 0u64\n {\n CubeTensor::new(\n tensor.client,\n tensor\n .handle\n .offset_start(offset_start)\n .offset_end(offset_end),\n Shape::from(dims),\n tensor.device,\n tensor.strides,\n tensor.dtype,\n )\n } else {\n let shape_output = Shape::from(dims);\n let output =\n empty_device::<R, E>(tensor.client.clone(), tensor.device.clone(), shape_output);\n slice_on_output::<R, E>(tensor, output, indices)\n }\n}"},"file_content":{"kind":"string","value":"use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};\nuse burn_tensor::Shape;\nuse cubecl::{calculate_cube_count_elemwise, prelude::*};\nuse std::ops::Range;\n\n/// Slice a jit tensor with a set of ranges\npub fn slice<R: CubeRuntime, E: CubeElement>(\n tensor: CubeTensor<R>,\n indices: &[Range<usize>],\n) -> CubeTensor<R> {\n let mut dims = tensor.shape.dims.clone();\n let mut offset_start = 0u64;\n let mut offset_end = 0u64;\n\n for i in 0..indices.len() {\n offset_start += (tensor.strides[i] * indices[i].start) as u64;\n offset_end += (tensor.strides[i] * (dims[i] - indices[i].end)) as u64;\n dims[i] = indices[i].end - indices[i].start;\n }\n\n let offset_start = offset_start * E::cube_elem().size() as u64;\n let offset_end = offset_end * E::cube_elem().size() as u64;\n\n let memory_offset_alignment = tensor.client.properties().memory_properties().alignment;\n\n if offset_start % memory_offset_alignment == 0u64\n && offset_end % memory_offset_alignment == 0u64\n {\n CubeTensor::new(\n tensor.client,\n tensor\n .handle\n .offset_start(offset_start)\n .offset_end(offset_end),\n Shape::from(dims),\n tensor.device,\n tensor.strides,\n tensor.dtype,\n )\n } else {\n let shape_output = Shape::from(dims);\n let output =\n empty_device::<R, E>(tensor.client.clone(), tensor.device.clone(), shape_output);\n slice_on_output::<R, E>(tensor, output, indices)\n }\n}\n\n#[cube(launch_unchecked)]\nfn slice_kernel<E: CubePrimitive>(\n input: &Tensor<E>,\n output: &mut Tensor<E>,\n indices: Sequence<u32>,\n #[comptime] rank: u32,\n) {\n if ABSOLUTE_POS >= output.len() {\n terminate!();\n }\n\n let mut offset_input = 0;\n\n #[unroll]\n for i in 0..rank {\n let range_start = *indices.index(i);\n let offset_local = ABSOLUTE_POS / output.stride(i) % output.shape(i) + range_start;\n\n offset_input += offset_local * input.stride(i);\n }\n\n output[ABSOLUTE_POS] = input[offset_input];\n}\n\npub(crate) fn slice_on_output<R: CubeRuntime, E: CubeElement>(\n tensor: CubeTensor<R>,\n output: CubeTensor<R>,\n indices: &[Range<usize>],\n) -> CubeTensor<R> {\n let ndims = tensor.shape.num_dims();\n let mut indices_sequence = SequenceArg::<R, u32>::new();\n\n for i in 0..ndims {\n let start = indices.get(i).map(|index| index.start).unwrap_or(0);\n indices_sequence.push(ScalarArg::new(start as u32));\n }\n\n let cube_dim = CubeDim::default();\n let cube_count = calculate_cube_count_elemwise(output.shape.num_elements(), cube_dim);\n\n unsafe {\n slice_kernel::launch_unchecked::<E, R>(\n &tensor.client,\n cube_count,\n cube_dim,\n tensor.as_tensor_arg::<E>(1),\n output.as_tensor_arg::<E>(1),\n indices_sequence,\n ndims as u32,\n )\n };\n\n output\n}\n"},"language":{"kind":"string","value":"rust"},"function_component":{"kind":"string","value":"{\n \"argument_definitions\": [\n {\n \"definitions\": [\n \"pub struct CubeTensor<R: CubeRuntime> {\\n /// Compute client for the [runtime](CubeRuntime).\\n pub client: ComputeClient<R::Server, R::Channel>,\\n /// The buffer where the data are stored.\\n pub handle: Handle,\\n /// The shape of the tensor.\\n pub shape: Shape,\\n /// The device of the tensor.\\n pub device: R::Device,\\n /// The strides of the tensor.\\n pub strides: Vec<usize>,\\n /// The datatype of the tensor.\\n pub dtype: DType,\\n}\"\n ],\n \"name\": \"tensor\",\n \"type\": \"CubeTensor<R>\"\n },\n {\n \"definitions\": [\n \"pub struct Range<Idx> {\\n /// The lower bound of the range (inclusive).\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n pub start: Idx,\\n /// The upper bound of the range (exclusive).\\n #[stable(feature = \\\"rust1\\\", since = \\\"1.0.0\\\")]\\n pub end: Idx,\\n}\"\n ],\n \"name\": \"indices\",\n \"type\": \"&[Range<usize>]\"\n }\n ],\n \"end_line\": 46,\n \"name\": \"slice\",\n \"signature\": \"pub fn slice(\\n tensor: CubeTensor<R>,\\n indices: &[Range<usize>],\\n) -> CubeTensor<R>\",\n \"start_line\": 7\n}"},"metadata":{"kind":"string","value":"{\n \"class_name\": \"\",\n \"class_signature\": \"\"\n}"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":1,"numItemsPerPage":100,"numTotalItems":374,"offset":100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MjA2NTM0MywianRpIjoiMzFkOTI2NjctM2FjZC00YjU4LWFlYmItNGMxYWY1YjEyYWQ3Iiwic3ViIjoiL2RhdGFzZXRzL2xxZHVueGd4MjAwNS90ZXNzZXJhLXJ1c3QiLCJleHAiOjE3ODIwNjg5NDMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Iw6aGXSi9zhbiWzT5Oe6u3aOAiWVPKvHswR8jpvaGtk4n7YrdtLm52P6jXo3QiaiHtIzYhV5h9vQvTqUSGyOAg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":374,"numBytesParquet":1956117}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
function_name stringlengths 3 35 | file_path stringlengths 28 76 | focal_code stringlengths 385 27.9k | file_content stringlengths 869 132k | language stringclasses 1
value | function_component dict | metadata dict |
|---|---|---|---|---|---|---|
float_neg | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_neg(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Neg;
retro_unary!(RetroNeg, B::float_neg);
impl<B: Backend> Backward<B, 1> for Neg {
type State = ();
fn backward(
self,
ops: Ops<Self::State,... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_recip | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_recip(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Recip;
retro_unary!(RetroRecip, B::float_recip);
impl<B: Backend> Backward<B, 1> for Recip {
type State = NodeID;
fn backward(
self,
ops: Op... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_swap_dims | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_swap_dims(tensor: FloatTensor<Self>, dim1: usize, dim2: usize) -> FloatTensor<Self> {
#[derive(Debug)]
struct SwapDim;
#[derive(new, Debug)]
struct RetroSwapDims<B: Backend> {
input_id: NodeID,
dim1: usize,
dim2: usize,
_backend: ... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_permute | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_permute(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {
#[derive(Debug)]
struct PermuteDim;
#[derive(new, Debug)]
struct RetroPermuteDims<B: Backend> {
input_id: NodeID,
axes: Vec<usize>,
_backend: PhantomData<B>,
}
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_flip | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_flip(tensor: FloatTensor<Self>, axes: &[usize]) -> FloatTensor<Self> {
#[derive(Debug)]
struct FlipDim;
#[derive(new, Debug)]
struct RetroFlipDims<B: Backend> {
input_id: NodeID,
axes: Vec<usize>,
_backend: PhantomData<B>,
}
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_reshape | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_reshape(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {
#[derive(Debug)]
struct ReshapeDim;
#[derive(new, Debug)]
struct RetroReshape<B: Backend> {
input_id: NodeID,
shape: Shape,
_backend: PhantomData<B>,
}
i... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_gather | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_gather(
dim: usize,
tensor: FloatTensor<Self>,
indices: IntTensor<B>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct Gather;
impl<B: Backend> Backward<B, 1> for Gather {
type State = (usize, IntTensor<B>, Shape, B::Device);
fn back... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_scatter | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_scatter(
dim: usize,
tensor: FloatTensor<Self>,
indices: IntTensor<B>,
value: FloatTensor<Self>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct Scatter;
impl<B: Backend> Backward<B, 2> for Scatter {
type State = (usize, IntTensor<B>, Sh... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_select | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_select(
tensor: FloatTensor<Self>,
dim: usize,
indices: IntTensor<B>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct Select;
#[derive(new, Debug)]
struct RetroSelect<B: Backend> {
input_id: NodeID,
dim: usize,
in... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_select_assign | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_select_assign(
tensor: FloatTensor<Self>,
dim: usize,
indices: IntTensor<B>,
value: FloatTensor<Self>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct IndexSelectDimAssign;
#[derive(new, Debug)]
struct RetroSelectAssign<B: Backend> {
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_slice | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_slice(
tensor: FloatTensor<Self>,
ranges: &[core::ops::Range<usize>],
) -> FloatTensor<Self> {
#[derive(Debug)]
struct Index;
#[derive(new, Debug)]
struct RetroSlice<B: Backend> {
tensor_id: NodeID,
ranges: Vec<core::ops::Range<usize>... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_slice_assign | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_slice_assign(
tensor: FloatTensor<Self>,
ranges: &[core::ops::Range<usize>],
value: FloatTensor<Self>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct SliceAssign;
#[derive(new, Debug)]
struct RetroSliceAssign<B: Backend> {
tensor_id: No... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_mask_where | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_mask_where(
tensor: FloatTensor<Self>,
mask: BoolTensor<Self>,
source: FloatTensor<Self>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct MaskWhere;
impl<B: Backend> Backward<B, 2> for MaskWhere {
type State = (BoolTensor<B>, Shape, Shape, B::De... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_mask_fill | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_mask_fill(
tensor: FloatTensor<Self>,
mask: BoolTensor<B>,
value: FloatElem<B>,
) -> FloatTensor<Self> {
#[derive(Debug)]
struct MaskFill;
impl<B: Backend> Backward<B, 1> for MaskFill {
type State = BoolTensor<B>;
fn backward(
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_mean | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_mean(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Mean;
impl<B: Backend> Backward<B, 1> for Mean {
type State = Shape;
fn backward(
self,
ops: Ops<Self::State, 1>,
grads: &mut Gradient... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_sum | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_sum(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Sum;
impl<B: Backend> Backward<B, 1> for Sum {
type State = Shape;
fn backward(
self,
ops: Ops<Self::State, 1>,
grads: &mut Gradients,
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_mean_dim | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_mean_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {
#[derive(Debug)]
struct MeanDim;
impl<B: Backend> Backward<B, 1> for MeanDim {
type State = (Shape, usize);
fn backward(
self,
ops: Ops<Self::State, 1>,
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_sum_dim | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_sum_dim(tensor: FloatTensor<Self>, dim: usize) -> FloatTensor<Self> {
#[derive(Debug)]
struct SumDim;
impl<B: Backend> Backward<B, 1> for SumDim {
type State = (Shape, usize);
fn backward(
self,
ops: Ops<Self::State, 1>,
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_exp | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_exp(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Exp;
retro_unary!(RetroExp, B::float_exp);
impl<B: Backend> Backward<B, 1> for Exp {
type State = NodeID;
fn backward(
self,
ops: Ops<Self::St... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_log | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_log(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Log;
retro_unary!(RetroLog, B::float_log);
impl<B: Backend> Backward<B, 1> for Log {
type State = NodeID;
fn backward(
self,
ops: Ops<Self::St... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_log1p | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_log1p(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Log1P;
retro_unary!(RetroLog1P, B::float_log1p);
impl<B: Backend> Backward<B, 1> for Log1P {
type State = NodeID;
fn backward(
self,
ops: Op... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_powf_scalar | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self> {
#[derive(Debug)]
struct PowfScalar;
#[derive(new, Debug)]
struct RetroPowfScalar<B: Backend> {
lhs_id: NodeID,
rhs: f32,
_backend: PhantomData<B>,
}
im... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_sqrt | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_sqrt(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Sqrt;
retro_unary!(RetroSqrt, B::float_sqrt);
impl<B: Backend> Backward<B, 1> for Sqrt {
type State = NodeID;
fn backward(
self,
ops: Ops<Sel... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_abs | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_abs(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Abs;
retro_unary!(RetroAbs, B::float_abs);
impl<B: Backend> Backward<B, 1> for Abs {
type State = NodeID;
fn backward(
self,
ops: Ops<Self::St... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_cos | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_cos(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Cos;
retro_unary!(RetroCos, B::float_cos);
impl<B: Backend> Backward<B, 1> for Cos {
type State = NodeID;
fn backward(
self,
ops: Ops<Self::St... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_sin | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_sin(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Sin;
retro_unary!(RetroSin, B::float_sin);
impl<B: Backend> Backward<B, 1> for Sin {
type State = NodeID;
fn backward(
self,
ops: Ops<Self::St... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_tanh | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_tanh(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Tanh;
retro_unary!(RetroTanh, B::float_tanh);
impl<B: Backend> Backward<B, 1> for Tanh {
type State = NodeID;
fn backward(
self,
ops: Ops<Sel... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_round | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_round(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Round;
retro_unary!(RetroRound, B::float_round);
impl<B: Backend> Backward<B, 1> for Round {
type State = (Shape, B::Device);
fn backward(
self,
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_floor | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_floor(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Floor;
retro_unary!(RetroFloor, B::float_floor);
impl<B: Backend> Backward<B, 1> for Floor {
type State = (Shape, B::Device);
fn backward(
self,
... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_ceil | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_ceil(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Ceil;
retro_unary!(RetroCeil, B::float_ceil);
impl<B: Backend> Backward<B, 1> for Ceil {
type State = (Shape, B::Device);
fn backward(
self,
o... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_erf | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_erf(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Erf;
retro_unary!(RetroErf, B::float_erf);
impl<B: Backend> Backward<B, 1> for Erf {
type State = NodeID;
fn backward(
self,
ops: Ops<Self::St... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_cat | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_cat(tensors: Vec<FloatTensor<Self>>, dim: usize) -> FloatTensor<Self> {
#[derive(new, Debug)]
struct CatStep<B: Backend> {
nodes: Vec<Option<NodeRef>>,
// The dimension of each tensor along the dim dimension.
// This indicates the number of dimension concaten... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct Vec<T, #[unstable(feature = \"allocator_api\", issue = \"32838\")] A: Allocator = Global> {\n buf: RawVec<T, A>,\n len: usize,\n}",
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn floa... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_powf | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_powf(lhs: FloatTensor<Self>, rhs: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct PowF;
retro_binary!(RetroPowf, B::float_powf);
impl<B: Backend> Backward<B, 2> for PowF {
type State = (NodeID, NodeID, BinaryOpsBroadcast);
fn backward... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_sign | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_sign(tensor: FloatTensor<Self>) -> FloatTensor<Self> {
#[derive(Debug)]
struct Sign;
retro_unary!(RetroSign, B::float_sign);
impl<B: Backend> Backward<B, 1> for Sign {
type State = ();
fn backward(
self,
ops: Ops<Self::S... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_expand | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_expand(tensor: FloatTensor<Self>, shape: Shape) -> FloatTensor<Self> {
// D1: tensor, D2: shape
#[derive(Debug)]
struct ExpandDim;
#[derive(new, Debug)]
struct RetroExpand<B: Backend> {
input_id: NodeID,
shape: Shape,
_backend: Phanto... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
float_repeat_dim | burn-main/crates/burn-autodiff/src/ops/tensor.rs | fn float_repeat_dim(tensor: FloatTensor<Self>, dim: usize, times: usize) -> FloatTensor<Self> {
#[derive(Debug)]
struct Repeat;
#[derive(new, Debug)]
struct RetroRepeat<B: Backend> {
tensor_id: NodeID,
dim: usize,
times: usize,
_backend: P... | use alloc::{boxed::Box, vec, vec::Vec};
use core::marker::PhantomData;
#[cfg(not(feature = "std"))]
#[allow(unused_imports, reason = "required on aarch64, unused on x86_64")]
use num_traits::float::Float;
use crate::{
Autodiff,
checkpoint::{
base::Checkpointer, builder::CheckpointerBuilder, retro_forw... | rust | {
"argument_definitions": [
{
"definitions": [
"impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn fl... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> FloatTensorOps<Self> for Autodiff<B, C> {\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n AutodiffTensor::new(B::float_from_data(data, device))\n }\n\n fn float_random(\n shape: Shape,\n distr... |
embedding | burn-main/crates/burn-autodiff/src/ops/module.rs | fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {
#[derive(Debug)]
struct Embedding;
impl<B: Backend> Backward<B, 1> for Embedding {
type State = (B::FloatTensorPrimitive, IntTensor<B>);
fn backward(
self,
... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "weights",
"type": "AutodiffTensor<B>"
}
],
"end_line": 47,
"name": "embe... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
conv1d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn conv1d(
x: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
bias: Option<AutodiffTensor<B>>,
options: ConvOptions<1>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct Conv1DWithBias;
#[derive(Debug)]
struct Conv1DNoBias;
impl<B: Backend> Backw... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
conv_transpose1d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn conv_transpose1d(
x: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
bias: Option<AutodiffTensor<B>>,
options: ConvTransposeOptions<1>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct ConvTranspose1DWithBias;
#[derive(Debug)]
struct ConvTranspose1DNo... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
conv2d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn conv2d(
x: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
bias: Option<AutodiffTensor<B>>,
options: ConvOptions<2>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct Conv2DWithBias;
#[derive(Debug)]
struct Conv2DNoBias;
impl<B: Backend> Backw... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
deform_conv2d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn deform_conv2d(
x: AutodiffTensor<B>,
offset: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
mask: Option<AutodiffTensor<B>>,
bias: Option<AutodiffTensor<B>>,
options: DeformConvOptions<2>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct DeformConv2D... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
conv_transpose2d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn conv_transpose2d(
x: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
bias: Option<AutodiffTensor<B>>,
options: ConvTransposeOptions<2>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct ConvTranspose2DWithBias;
#[derive(Debug)]
struct ConvTranspose2DNo... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
conv3d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn conv3d(
x: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
bias: Option<AutodiffTensor<B>>,
options: ConvOptions<3>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct Conv3DWithBias;
#[derive(Debug)]
struct Conv3DNoBias;
impl<B: Backend> Backw... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
conv_transpose3d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn conv_transpose3d(
x: AutodiffTensor<B>,
weight: AutodiffTensor<B>,
bias: Option<AutodiffTensor<B>>,
options: ConvTransposeOptions<3>,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct ConvTranspose3DWithBias;
#[derive(Debug)]
struct ConvTranspose3DNo... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
},
{
"definitions": [
"pub s... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
avg_pool1d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn avg_pool1d(
x: AutodiffTensor<B>,
kernel_size: usize,
stride: usize,
padding: usize,
count_include_pad: bool,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct AvgPool1D;
impl<B: Backend> Backward<B, 1> for AvgPool1D {
type State = (Node... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1257,
"name": "avg_pool... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
avg_pool2d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn avg_pool2d(
x: AutodiffTensor<B>,
kernel_size: [usize; 2],
stride: [usize; 2],
padding: [usize; 2],
count_include_pad: bool,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct AvgPool2D;
impl<B: Backend> Backward<B, 1> for AvgPool2D {
typ... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1323,
"name": "avg_pool... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
max_pool1d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn max_pool1d(
x: AutodiffTensor<B>,
kernel_size: usize,
stride: usize,
padding: usize,
dilation: usize,
) -> AutodiffTensor<B> {
match MaxPool1D
.prepare::<C>([x.node.clone()])
.compute_bound()
.stateful()
{
Ops... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1372,
"name": "max_pool... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
max_pool1d_with_indices | burn-main/crates/burn-autodiff/src/ops/module.rs | fn max_pool1d_with_indices(
x: AutodiffTensor<B>,
kernel_size: usize,
stride: usize,
padding: usize,
dilation: usize,
) -> MaxPool1dWithIndices<Self> {
match MaxPool1D
.prepare::<C>([x.node.clone()])
.compute_bound()
.stateful()
... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1413,
"name": "max_pool... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
max_pool2d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn max_pool2d(
x: AutodiffTensor<B>,
kernel_size: [usize; 2],
stride: [usize; 2],
padding: [usize; 2],
dilation: [usize; 2],
) -> AutodiffTensor<B> {
match MaxPool2D
.prepare::<C>([x.node.clone()])
.compute_bound()
.stateful()
... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1472,
"name": "max_pool... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
max_pool2d_with_indices | burn-main/crates/burn-autodiff/src/ops/module.rs | fn max_pool2d_with_indices(
x: AutodiffTensor<B>,
kernel_size: [usize; 2],
stride: [usize; 2],
padding: [usize; 2],
dilation: [usize; 2],
) -> MaxPool2dWithIndices<Self> {
match MaxPool2D
.prepare::<C>([x.node.clone()])
.compute_bound()
... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1514,
"name": "max_pool... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
adaptive_avg_pool1d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn adaptive_avg_pool1d(x: AutodiffTensor<B>, output_size: usize) -> AutodiffTensor<B> {
#[derive(Debug)]
struct AdaptiveAvgPool1D;
impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool1D {
type State = NodeID;
fn backward(
self,
ops: Ops<Se... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1564,
"name": "adaptive... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
adaptive_avg_pool2d | burn-main/crates/burn-autodiff/src/ops/module.rs | fn adaptive_avg_pool2d(x: AutodiffTensor<B>, output_size: [usize; 2]) -> AutodiffTensor<B> {
#[derive(Debug)]
struct AdaptiveAvgPool2D;
impl<B: Backend> Backward<B, 1> for AdaptiveAvgPool2D {
type State = NodeID;
fn backward(
self,
ops: O... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1603,
"name": "adaptive... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
interpolate | burn-main/crates/burn-autodiff/src/ops/module.rs | fn interpolate(
x: AutodiffTensor<B>,
output_size: [usize; 2],
options: InterpolateOptions,
) -> AutodiffTensor<B> {
#[derive(Debug)]
struct Interpolate;
impl<B: Backend> Backward<B, 1> for Interpolate {
type State = (NodeID, [usize; 2], InterpolateOptions... | use crate::Autodiff;
use crate::checkpoint::base::Checkpointer;
use crate::checkpoint::strategy::CheckpointStrategy;
use crate::grads::Gradients;
use crate::graph::NodeID;
use crate::ops::{Backward, Ops, unary};
use crate::tensor::AutodiffTensor;
use burn_tensor::backend::Backend;
use burn_tensor::ops::*;
use super::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct AutodiffTensor<B: Backend> {\n pub primitive: B::FloatTensorPrimitive,\n pub node: NodeRef,\n pub rc: NodeRefCount,\n}"
],
"name": "x",
"type": "AutodiffTensor<B>"
}
],
"end_line": 1655,
"name": "interpol... | {
"class_name": "impl<B: Backend, C: CheckpointStrategy> ModuleOps<Autodiff<B, C>> for Autodiff<B, C> {\n fn embedding(weights: AutodiffTensor<B>, indices: IntTensor<B>) -> AutodiffTensor<B> {\n #[derive(Debug)]\n struct Embedding;\n\n impl<B: Backend> Backward<B, 1> for Embedding {\n ... |
build | burn-main/crates/burn-autodiff/src/checkpoint/builder.rs | pub(crate) fn build(self, node_tree: NodeTree) -> Checkpointer {
let mut backward_states_map = HashMap::new();
let mut retro_forwards_map = HashMap::new();
// Find recursion stopping points
let stop_nodes: Vec<NodeID> = self.find_stop_nodes();
// We start by identifying how man... | use crate::{
collections::HashMap,
graph::{ComputingProperty, NodeID},
tensor::AutodiffTensor,
};
use alloc::{boxed::Box, sync::Arc, vec::Vec};
use burn_tensor::backend::Backend;
use core::any::Any;
use super::{
base::{Checkpointer, NodeTree},
retro_forward::{RetroForward, RetroForwards},
state... | rust | {
"argument_definitions": [
{
"definitions": [
"pub(crate) struct NodeTree {\n map: HashMap<NodeID, Vec<NodeID>>,\n}"
],
"name": "node_tree",
"type": "NodeTree"
}
],
"end_line": 133,
"name": "build",
"signature": "pub(crate) fn build(self, node_tree: NodeTree) -> Che... | {
"class_name": "impl CheckpointerBuilder {\n pub(crate) fn checkpoint<B: Backend>(\n &mut self,\n tensor: &AutodiffTensor<B>,\n action_type: ActionType,\n ) {\n let action_list = match action_type {\n ActionType::Explicit => &mut self.explicit_actions,\n Action... |
build_n_required_map | burn-main/crates/burn-autodiff/src/checkpoint/builder.rs | fn build_n_required_map(
&self,
node_tree: &NodeTree,
stop_nodes: Vec<NodeID>,
) -> HashMap<NodeID, usize> {
let mut n_required_map = HashMap::<NodeID, usize>::default();
for action in self.explicit_actions.iter() {
match action {
CheckpointingAct... | use crate::{
collections::HashMap,
graph::{ComputingProperty, NodeID},
tensor::AutodiffTensor,
};
use alloc::{boxed::Box, sync::Arc, vec::Vec};
use burn_tensor::backend::Backend;
use core::any::Any;
use super::{
base::{Checkpointer, NodeTree},
retro_forward::{RetroForward, RetroForwards},
state... | rust | {
"argument_definitions": [
{
"definitions": [
"pub(crate) struct NodeTree {\n map: HashMap<NodeID, Vec<NodeID>>,\n}"
],
"name": "node_tree",
"type": "&NodeTree"
},
{
"definitions": [
"pub struct Vec<T, #[unstable(feature = \"allocator_api\", issue = \"3283... | {
"class_name": "impl CheckpointerBuilder {\n pub(crate) fn checkpoint<B: Backend>(\n &mut self,\n tensor: &AutodiffTensor<B>,\n action_type: ActionType,\n ) {\n let action_list = match action_type {\n ActionType::Explicit => &mut self.explicit_actions,\n Action... |
topological_sort | burn-main/crates/burn-autodiff/src/checkpoint/base.rs | fn topological_sort(&self, node_id: NodeID) -> Vec<NodeID> {
match self.backward_states.get_state_ref(&node_id) {
Some(state) => match state {
State::Recompute { n_required: _ } => {
let mut sorted = Vec::new();
let parents = self.node_tree.par... | use super::{
retro_forward::RetroForwards,
state::{BackwardStates, State},
};
use crate::collections::HashMap;
use crate::graph::NodeID;
use alloc::{vec, vec::Vec};
#[derive(new, Debug)]
/// Links a [NodeID] to its autodiff graph [NodeRef]
pub(crate) struct NodeTree {
map: HashMap<NodeID, Vec<NodeID>>,
}
... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct NodeID {\n /// The integer representation of the id\n pub value: u64,\n}"
],
"name": "node_id",
"type": "NodeID"
}
],
"end_line": 76,
"name": "topological_sort",
"signature": "fn topological_sort(&self, no... | {
"class_name": "impl Checkpointer {\n /// Gives the output of the given node, by recursively asking parents to compute themselves\n /// or give their pre-computed tensors.\n pub fn retrieve_node_output<T>(&mut self, node_id: NodeID) -> T\n where\n T: Clone + Send + 'static,\n {\n self.to... |
backward | burn-main/crates/burn-autodiff/src/runtime/server.rs | pub fn backward(&mut self, grads: Gradients, node_id: NodeID) -> Gradients {
let step = self.steps.remove(&node_id).expect(
"Node should have a step registered, did you forget to call \
`Tensor::register_grad` on the tensor where you need gradients?",
);
let builder = se... | use super::memory_management::GraphMemoryManagement;
use crate::{
NodeID,
checkpoint::{
base::{Checkpointer, NodeTree},
builder::CheckpointerBuilder,
},
collections::HashMap,
grads::Gradients,
graph::{StepBoxed, traversal::BreadthFirstSearch},
tensor::NodeRefCount,
};
use all... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct Gradients {\n container: TensorContainer<GradID>,\n}"
],
"name": "grads",
"type": "Gradients"
},
{
"definitions": [
"pub struct NodeID {\n /// The integer representation of the id\n pub value:... | {
"class_name": "impl AutodiffServer {\n pub fn register(&mut self, rc: NodeRefCount, step: StepBoxed, actions: CheckpointerBuilder) {\n let parents = step.parents();\n let node_id = *rc.as_ref();\n\n self.memory_management.register(rc, parents);\n\n self.steps.insert(node_id, step);\n ... |
unavailable_propagation | burn-main/crates/burn-autodiff/src/runtime/memory_management.rs | fn unavailable_propagation(&mut self, node_id: NodeID) -> NodeMemoryStatus {
// If already visited
if let Some(status) = self.statuses.get(&node_id) {
return status.clone();
}
match self.nodes.get(&node_id).cloned() {
// If node exists and any of its parents is u... | use crate::{
NodeID,
collections::{HashMap, HashSet},
tensor::NodeRefCount,
};
use alloc::{borrow::ToOwned, sync::Arc, vec, vec::Vec};
use core::mem;
#[derive(Default, Debug)]
pub struct GraphMemoryManagement {
nodes: HashMap<NodeRefCount, Vec<NodeID>>,
leaves: HashSet<NodeID>,
statuses: HashMa... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct NodeID {\n /// The integer representation of the id\n pub value: u64,\n}"
],
"name": "node_id",
"type": "NodeID"
}
],
"end_line": 128,
"name": "unavailable_propagation",
"signature": "fn unavailable_propag... | {
"class_name": "impl GraphMemoryManagement {\n /// Register a new node with its parent.\n pub fn register(&mut self, node: NodeRefCount, parents: Vec<NodeID>) {\n let node_id = *node.as_ref();\n\n for parent_id in parents.iter() {\n self.leaves.remove(parent_id);\n }\n\n ... |
new | burn-main/crates/burn-cubecl-fusion/src/reduce/optimization.rs | pub fn new(
trace: FuseTrace,
trace_read_fallback: FuseTrace,
trace_write_fallback: FuseTrace,
client: ComputeClient<R::Server, R::Channel>,
device: R::Device,
len: usize,
reduce: FusedReduce,
fallback: Arc<dyn ReduceFallbackFn<R>>,
) -> Self {
... | use std::sync::Arc;
use burn_fusion::stream::Context;
use burn_ir::{ReduceDimOpIr, TensorStatus};
use burn_tensor::DType;
use cubecl::prelude::*;
use cubecl::reduce::instructions::{ReduceFn, ReduceFnConfig};
use cubecl::reduce::{BoundChecksInner, ReduceFamily, ReduceParams, ReduceStrategy, reduce_kernel};
use cubecl::... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct FuseTrace {\n pub blocks: Vec<FuseBlock>,\n pub resources: FuseResources,\n}"
],
"name": "trace",
"type": "FuseTrace"
},
{
"definitions": [
"pub struct FuseTrace {\n pub blocks: Vec<FuseBlock>... | {
"class_name": "impl<R: Runtime> ReduceOptimization<R> {\n pub fn new(\n trace: FuseTrace,\n trace_read_fallback: FuseTrace,\n trace_write_fallback: FuseTrace,\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n len: usize,\n reduce: FusedReduce,... |
new | burn-main/crates/burn-cubecl-fusion/src/reduce/builder.rs | pub fn new(
device: R::Device,
bool_precision: FusePrecision,
fallback: Arc<dyn ReduceFallbackFn<R>>,
) -> Self {
let client = R::client(&device);
let props = client.properties();
let max_bindings = props.hardware_properties().max_bindings;
let settings_read =... | use std::sync::Arc;
use super::optimization::ReduceInstruction;
use burn_fusion::{OptimizationBuilder, OptimizationStatus};
use burn_ir::{NumericOperationIr, OperationIr, ReduceDimOpIr};
use cubecl::{Runtime, reduce::ReduceStrategy};
use crate::{
CubeOptimization,
shared::{
builder::FuseOptimizationBu... | rust | {
"argument_definitions": [
{
"definitions": [
"pub enum FusePrecision {\n F32,\n Flex32,\n F16,\n BF16,\n I64,\n I32,\n I16,\n I8,\n U64,\n U32,\n U16,\n U8,\n Bool,\n}"
],
"name": "bool_precision",
"type": "FusePrecision"
},
{
... | {
"class_name": "impl<R: Runtime> ReduceBuilder<R> {\n pub fn new(\n device: R::Device,\n bool_precision: FusePrecision,\n fallback: Arc<dyn ReduceFallbackFn<R>>,\n ) -> Self {\n let client = R::client(&device);\n let props = client.properties();\n let max_bindings = pr... |
read | burn-main/crates/burn-cubecl-fusion/src/shared/io.rs | pub fn read(
inputs: &GlobalArgs,
outputs: &GlobalArgs,
locals: &LocalArgs,
ref_pos: u32,
#[comptime] arg: Arg,
#[comptime] config: &FuseBlockConfig,
) -> Line<C> {
match arg {
Arg::Input(pos, _precision, layout) => {
let global = inputs.tensors.index(pos);
le... | use super::{DYN_ELEM_ID, ir::*, tensor::GlobalTensor};
use cubecl::{
intrinsic,
ir::{ExpandElement, Variable},
prelude::*,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
pub enum Transform {
Reshape(Sequence<Arg>),
SwapD... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct GlobalArgs {\n pub tensors: Sequence<GlobalTensor>,\n pub scalars: Sequence<GlobalScalar>,\n pub reshapes: Sequence<u32>,\n}"
],
"name": "inputs",
"type": "&GlobalArgs"
},
{
"definitions": [
"... | {
"class_name": "",
"class_signature": ""
} |
read_input_aligned | burn-main/crates/burn-cubecl-fusion/src/shared/io.rs | pub fn read_input_aligned(
inputs: &GlobalArgs,
locals: &LocalArgs,
#[comptime] pos: u32,
ref_pos: u32,
#[comptime] layout: LayoutInfo,
#[comptime] config: &FuseBlockConfig,
#[comptime] transform: Option<Transform>,
) -> Line<C> {
let mut result: Line<C> = Line::<C>::empty(comptime![conf... | use super::{DYN_ELEM_ID, ir::*, tensor::GlobalTensor};
use cubecl::{
intrinsic,
ir::{ExpandElement, Variable},
prelude::*,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
pub enum Transform {
Reshape(Sequence<Arg>),
SwapD... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct GlobalArgs {\n pub tensors: Sequence<GlobalTensor>,\n pub scalars: Sequence<GlobalScalar>,\n pub reshapes: Sequence<u32>,\n}"
],
"name": "inputs",
"type": "&GlobalArgs"
},
{
"definitions": [
"... | {
"class_name": "",
"class_signature": ""
} |
index_offset_with_layout | burn-main/crates/burn-cubecl-fusion/src/shared/io.rs | fn index_offset_with_layout(
inputs: &GlobalArgs,
tensor: &GlobalTensor,
locals: &LocalArgs,
index: u32,
#[comptime] range: Option<(u32, u32)>,
#[comptime] rank: u32,
#[comptime] transform: Option<Transform>,
) -> u32 {
match comptime![transform.clone()] {
Some(Transform::Reshape... | use super::{DYN_ELEM_ID, ir::*, tensor::GlobalTensor};
use cubecl::{
intrinsic,
ir::{ExpandElement, Variable},
prelude::*,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
pub enum Transform {
Reshape(Sequence<Arg>),
SwapD... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct GlobalArgs {\n pub tensors: Sequence<GlobalTensor>,\n pub scalars: Sequence<GlobalScalar>,\n pub reshapes: Sequence<u32>,\n}"
],
"name": "inputs",
"type": "&GlobalArgs"
},
{
"definitions": [
"... | {
"class_name": "",
"class_signature": ""
} |
next_block | burn-main/crates/burn-cubecl-fusion/src/shared/builder.rs | pub fn next_block(
&mut self,
arguments: [&TensorIr; N],
settings: FuseSettings,
) -> Option<[Arg; N]> {
let mut is_success = true;
let args = arguments.map(|arg| {
// We need to register the argument as input in the current block so that we retrieve
/... | use super::{
ir::{Arg, BinaryFuseArgs, FuseOp, FusePrecision, UnaryFuseArgs},
settings::FuseSettings,
trace::{FuseTrace, FuseTraceBuilder},
};
use burn_fusion::{OptimizationBuilder, OptimizationProperties, OptimizationStatus};
use burn_ir::{
BaseOperationIr, BinaryOpIr, FloatOperationIr, NumericOperatio... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct FuseSettings {\n /// Enables broadcasting of shapes.\n pub broadcast: bool,\n /// Enables output shape updates.\n ///\n /// When broadcast is enabled, the output shape can become bigger after a fusion,\n /// therefore an up... | {
"class_name": "impl FuseOptimizationBuilder {\n /// Create a new builder.\n pub fn new(max_bindings: u32, bool_precision: FusePrecision, settings: FuseSettings) -> Self {\n Self {\n builder: TryFuseBuilder::new(max_bindings, bool_precision, settings),\n settings,\n num_... |
shape_ref | burn-main/crates/burn-cubecl-fusion/src/shared/ir.rs | pub fn shape_ref(&self, ref_layout: &RefLayout, rank: usize) -> Vec<usize> {
match ref_layout {
RefLayout::Concrete(arg) => self.shape(arg),
RefLayout::Virtual(layout) => match layout {
VirtualLayout::SwapDims(original, dims) => {
let mut shape = self.... | use burn_tensor::DType;
use cubecl::ir::Elem;
use cubecl::prelude::*;
use half::{bf16, f16};
use serde::{Deserialize, Serialize};
use super::tensor::{GlobalScalar, GlobalTensor};
#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
/// Argument to a [fuse operation](FuseOp).
pub enum ... | rust | {
"argument_definitions": [
{
"definitions": [
"pub enum RefLayout {\n Concrete(Arg),\n Virtual(VirtualLayout),\n}"
],
"name": "ref_layout",
"type": "&RefLayout"
}
],
"end_line": 209,
"name": "shape_ref",
"signature": "pub fn shape_ref(&self, ref_layout: &RefLayou... | {
"class_name": "impl<R: Runtime> GlobalArgsLaunch<'_, R> {\n /// Get the shape of the given [argument](Arg).\n ///\n /// # Panics\n ///\n /// If the argument doesn't have an handle.\n pub fn shape(&self, arg: &Arg) -> Vec<usize> {\n match self.resolve_arg(arg) {\n TensorArg::Handl... |
from | burn-main/crates/burn-cubecl-fusion/src/shared/ir.rs | fn from(value: Elem) -> Self {
match value {
Elem::Float(kind) => match kind {
cubecl::ir::FloatKind::F16 => Self::F16,
cubecl::ir::FloatKind::BF16 => Self::BF16,
cubecl::ir::FloatKind::F32 => Self::F32,
cubecl::ir::FloatKind::Flex32 =>... | use burn_tensor::DType;
use cubecl::ir::Elem;
use cubecl::prelude::*;
use half::{bf16, f16};
use serde::{Deserialize, Serialize};
use super::tensor::{GlobalScalar, GlobalTensor};
#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
/// Argument to a [fuse operation](FuseOp).
pub enum ... | rust | {
"argument_definitions": [],
"end_line": 380,
"name": "from",
"signature": "fn from(value: Elem) -> Self",
"start_line": 356
} | {
"class_name": "impl From<Elem> for FusePrecision {\n fn from(value: Elem) -> Self {\n match value {\n Elem::Float(kind) => match kind {\n cubecl::ir::FloatKind::F16 => Self::F16,\n cubecl::ir::FloatKind::BF16 => Self::BF16,\n cubecl::ir::FloatKind::F... |
build | burn-main/crates/burn-cubecl-fusion/src/shared/trace/builder.rs | pub fn build(&self, shape_ref: Vec<usize>) -> FuseTrace {
let mut resources = self.resources.clone();
let mut outputs = RegisteredTensors::default();
let mut blocks = Vec::new();
let mut register_block =
|block: &FuseBlockBuilder, shape_ref: &Vec<usize>, offset: usize| {
... | use super::{
super::{
ir::{Arg, FuseOp, FusePrecision, LayoutInfo},
settings::FuseSettings,
},
FuseResources,
block::FuseBlockBuilder,
};
use super::{FuseTrace, RegisteredTensors};
use burn_ir::TensorIr;
use burn_tensor::{DType, Element};
#[derive(Clone, Debug)]
/// It is responsible to... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct Vec<T, #[unstable(feature = \"allocator_api\", issue = \"32838\")] A: Allocator = Global> {\n buf: RawVec<T, A>,\n len: usize,\n}"
],
"name": "shape_ref",
"type": "Vec<usize>"
}
],
"end_line": 215,
"name": "... | {
"class_name": "impl FuseTraceBuilder {\n pub fn new(bool_precision: FusePrecision, settings: FuseSettings) -> Self {\n Self {\n settings,\n bool_precision,\n block_current: FuseBlockBuilder::new(bool_precision, settings),\n blocks_previous: Default::default(),\n... |
analyze_view | burn-main/crates/burn-cubecl-fusion/src/shared/trace/input.rs | fn analyze_view(
pos: usize,
tensor_relative: &'a TensorIr,
block: &FuseBlock,
block_plan: &mut BlockPlan<'a>,
view: &TensorView,
) -> bool {
match view {
TensorView::Reshape {
reshaped,
original,
reshape_pos... | use super::{BlockPlan, FuseResources, InputReference, TensorView, block::FuseBlock};
use crate::CubeFusionHandle;
use burn_fusion::stream::Context;
use burn_ir::{TensorIr, TensorStatus};
use cubecl::Runtime;
use std::marker::PhantomData;
use super::{HandleInput, LaunchPlan, PotentialInplace};
/// Fetch and register [... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct FuseBlock {\n pub settings: FuseSettings,\n pub ops: Vec<FuseOp>,\n pub shape_ref: Vec<usize>,\n pub reads: BTreeMap<TensorId, Vec<FuseOp>>,\n pub writes: BTreeMap<TensorId, FuseOp>,\n}"
],
"name": "block",
"... | {
"class_name": "impl<'a, R: Runtime> InputPlanner<'a, R> {\n pub fn new(resources: &'a FuseResources, blocks: &'a Vec<FuseBlock>) -> Self {\n Self {\n resources,\n blocks,\n _r: PhantomData,\n }\n }\n\n pub fn run(self, context: &mut Context<'_, CubeFusionHandl... |
format_eta | burn-main/crates/burn-train/src/renderer/tui/progress.rs | fn format_eta(eta_secs: u64) -> String {
let seconds = eta_secs % 60;
let minutes = eta_secs / MINUTE % 60;
let hours = eta_secs / HOUR % 24;
let days = eta_secs / DAY;
if days > 1 {
format!("{days} days")
} else if days == 1 {
"1 day".to_string()
} else if hours > 1 {
... | use super::TerminalFrame;
use crate::renderer::TrainingProgress;
use ratatui::{
prelude::{Alignment, Constraint, Direction, Layout, Rect},
style::{Color, Style, Stylize},
text::{Line, Span},
widgets::{Block, Borders, Gauge, Paragraph},
};
use std::time::{Duration, Instant};
/// Simple progress bar for ... | rust | {
"argument_definitions": [],
"end_line": 204,
"name": "format_eta",
"signature": "fn format_eta(eta_secs: u64) -> String",
"start_line": 181
} | {
"class_name": "",
"class_signature": ""
} |
new | burn-main/crates/burn-train/src/renderer/tui/renderer.rs | pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self {
let mut stdout = io::stdout();
execute!(stdout, EnterAlternateScreen).unwrap();
enable_raw_mode().unwrap();
let terminal = Terminal::new(CrosstermBackend::new(stdout)).unwrap();
// Reset the termina... | use crate::TrainingInterrupter;
use crate::renderer::{MetricState, TrainingProgress};
use crate::renderer::{MetricsRenderer, tui::NumericMetricsState};
use ratatui::{
Terminal,
crossterm::{
event::{self, Event, KeyCode},
execute,
terminal::{EnterAlternateScreen, LeaveAlternateScreen, dis... | rust | {
"argument_definitions": [],
"end_line": 125,
"name": "new",
"signature": "pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self",
"start_line": 95
} | {
"class_name": "impl TuiMetricsRenderer {\n /// Create a new terminal UI renderer.\n pub fn new(interuptor: TrainingInterrupter, checkpoint: Option<usize>) -> Self {\n let mut stdout = io::stdout();\n execute!(stdout, EnterAlternateScreen).unwrap();\n enable_raw_mode().unwrap();\n l... |
should_stop | burn-main/crates/burn-train/src/learner/early_stopping.rs | fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool {
let current_value =
match store.find_metric(&self.metric_name, epoch, self.aggregate, self.split) {
Some(value) => value,
None => {
log::warn!("Can't find metric for early ... | use crate::metric::{
Metric,
store::{Aggregate, Direction, EventStoreClient, Split},
};
/// The condition that [early stopping strategies](EarlyStoppingStrategy) should follow.
pub enum StoppingCondition {
/// When no improvement has happened since the given number of epochs.
NoImprovementSince {
... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct EventStoreClient {\n sender: mpsc::Sender<Message>,\n handler: Option<JoinHandle<()>>,\n}"
],
"name": "store",
"type": "&EventStoreClient"
}
],
"end_line": 81,
"name": "should_stop",
"signature": "fn shoul... | {
"class_name": "impl EarlyStoppingStrategy for MetricEarlyStoppingStrategy {\n fn should_stop(&mut self, epoch: usize, store: &EventStoreClient) -> bool {\n let current_value =\n match store.find_metric(&self.metric_name, epoch, self.aggregate, self.split) {\n Some(value) => value... |
build | burn-main/crates/burn-train/src/learner/builder.rs | pub fn build(
mut self,
model: M,
optim: O,
lr_scheduler: S,
) -> Learner<
LearnerComponentsMarker<
B,
S,
M,
O,
AsyncCheckpointer<M::Record, B>,
AsyncCheckpointer<O::Record, B>,
AsyncCheckpoin... | use std::collections::HashSet;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use super::Learner;
use crate::checkpoint::{
AsyncCheckpointer, CheckpointingStrategy, ComposedCheckpointingStrategy, FileCheckpointer,
KeepLastNCheckpoints, MetricCheckpointingStrategy,
};
use crate::components::LearnerComponen... | rust | {
"argument_definitions": [],
"end_line": 366,
"name": "build",
"signature": "pub fn build(\n mut self,\n model: M,\n optim: O,\n lr_scheduler: S,\n ) -> Learner<\n LearnerComponentsMarker<\n B,\n S,\n M,\n O,\n AsyncCh... | {
"class_name": "impl<B, T, V, M, O, S> LearnerBuilder<B, T, V, M, O, S>\nwhere\n B: AutodiffBackend,\n T: ItemLazy + 'static,\n V: ItemLazy + 'static,\n M: AutodiffModule<B> + core::fmt::Display + 'static,\n O: Optimizer<M, B>,\n S: LrScheduler,\n{\n /// Creates a new learner builder.\n ///\n... |
checkpointing | burn-main/crates/burn-train/src/checkpoint/strategy/metric.rs | fn checkpointing(
&mut self,
epoch: usize,
store: &EventStoreClient,
) -> Vec<CheckpointingAction> {
let best_epoch =
match store.find_epoch(&self.name, self.aggregate, self.direction, self.split) {
Some(epoch_best) => epoch_best,
None => e... | use super::CheckpointingStrategy;
use crate::{
checkpoint::CheckpointingAction,
metric::{
Metric,
store::{Aggregate, Direction, EventStoreClient, Split},
},
};
/// Keep the best checkpoint based on a metric.
pub struct MetricCheckpointingStrategy {
current: Option<usize>,
aggregate:... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct EventStoreClient {\n sender: mpsc::Sender<Message>,\n handler: Option<JoinHandle<()>>,\n}"
],
"name": "store",
"type": "&EventStoreClient"
}
],
"end_line": 62,
"name": "checkpointing",
"signature": "fn che... | {
"class_name": "impl CheckpointingStrategy for MetricCheckpointingStrategy {\n fn checkpointing(\n &mut self,\n epoch: usize,\n store: &EventStoreClient,\n ) -> Vec<CheckpointingAction> {\n let best_epoch =\n match store.find_epoch(&self.name, self.aggregate, self.directi... |
checkpointing | burn-main/crates/burn-train/src/checkpoint/strategy/composed.rs | fn checkpointing(
&mut self,
epoch: usize,
collector: &EventStoreClient,
) -> Vec<CheckpointingAction> {
let mut saved = false;
let mut actions = Vec::new();
let mut epochs_to_check = Vec::new();
for (i, strategy) in self.strategies.iter_mut().enumerate() {
... | use crate::metric::store::EventStoreClient;
use super::{CheckpointingAction, CheckpointingStrategy};
use std::collections::HashSet;
/// Compose multiple checkpointing strategy and only delete checkpoints when both strategy flag an
/// epoch to be deleted.
pub struct ComposedCheckpointingStrategy {
strategies: Vec... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct EventStoreClient {\n sender: mpsc::Sender<Message>,\n handler: Option<JoinHandle<()>>,\n}"
],
"name": "collector",
"type": "&EventStoreClient"
}
],
"end_line": 115,
"name": "checkpointing",
"signature": "f... | {
"class_name": "impl CheckpointingStrategy for ComposedCheckpointingStrategy {\n fn checkpointing(\n &mut self,\n epoch: usize,\n collector: &EventStoreClient,\n ) -> Vec<CheckpointingAction> {\n let mut saved = false;\n let mut actions = Vec::new();\n let mut epochs_t... |
aggregate | burn-main/crates/burn-train/src/metric/store/aggregate.rs | pub(crate) fn aggregate(
&mut self,
name: &str,
epoch: usize,
aggregate: Aggregate,
loggers: &mut [Box<dyn MetricLogger>],
) -> Option<f64> {
let key = Key::new(name.to_string(), epoch, aggregate);
if let Some(value) = self.value_for_each_epoch.get(&key) {
... | use crate::{logger::MetricLogger, metric::NumericEntry};
use std::collections::HashMap;
use super::{Aggregate, Direction};
/// Type that can be used to fetch and use numeric metric aggregates.
#[derive(Default, Debug)]
pub(crate) struct NumericMetricsAggregate {
value_for_each_epoch: HashMap<Key, f64>,
}
#[deriv... | rust | {
"argument_definitions": [
{
"definitions": [
"pub enum Aggregate {\n /// Compute the average.\n Mean,\n}"
],
"name": "aggregate",
"type": "Aggregate"
},
{
"definitions": [
"impl<T> Box<T> {\n /// Allocates memory on the heap and then places `x` into... | {
"class_name": "impl NumericMetricsAggregate {\n pub(crate) fn aggregate(\n &mut self,\n name: &str,\n epoch: usize,\n aggregate: Aggregate,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<f64> {\n let key = Key::new(name.to_string(), epoch, aggregate);\n\n ... |
find_epoch | burn-main/crates/burn-train/src/metric/store/aggregate.rs | pub(crate) fn find_epoch(
&mut self,
name: &str,
aggregate: Aggregate,
direction: Direction,
loggers: &mut [Box<dyn MetricLogger>],
) -> Option<usize> {
let mut data = Vec::new();
let mut current_epoch = 1;
while let Some(value) = self.aggregate(name,... | use crate::{logger::MetricLogger, metric::NumericEntry};
use std::collections::HashMap;
use super::{Aggregate, Direction};
/// Type that can be used to fetch and use numeric metric aggregates.
#[derive(Default, Debug)]
pub(crate) struct NumericMetricsAggregate {
value_for_each_epoch: HashMap<Key, f64>,
}
#[deriv... | rust | {
"argument_definitions": [
{
"definitions": [
"pub enum Aggregate {\n /// Compute the average.\n Mean,\n}"
],
"name": "aggregate",
"type": "Aggregate"
},
{
"definitions": [
"pub enum Direction {\n /// Lower is better.\n Lowest,\n /// Higher is ... | {
"class_name": "impl NumericMetricsAggregate {\n pub(crate) fn aggregate(\n &mut self,\n name: &str,\n epoch: usize,\n aggregate: Aggregate,\n loggers: &mut [Box<dyn MetricLogger>],\n ) -> Option<f64> {\n let key = Key::new(name.to_string(), epoch, aggregate);\n\n ... |
run | burn-main/crates/burn-cubecl/src/fusion.rs | fn run(
&self,
input: CubeFusionHandle<R>,
shape: &[usize],
axis: usize,
inst: &ReduceInstruction,
d_o: &DType,
d_a: &DType,
) -> CubeFusionHandle<R> {
let d_i = input.dtype;
let config = match inst {
ReduceInstruction::ArgMax => R... | use crate::BoolElement;
use crate::element::CubeElement;
use crate::{CubeBackend, CubeRuntime, FloatElement, IntElement, kernel, tensor::CubeTensor};
use burn_cubecl_fusion::CubeFusionHandle;
use burn_cubecl_fusion::elemwise::optimization::ElemwiseOptimization;
use burn_cubecl_fusion::matmul::MatmulFallbackFn;
use bur... | rust | {
"argument_definitions": [],
"end_line": 131,
"name": "run",
"signature": "fn run(\n &self,\n input: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n d_o: &DType,\n d_a: &DType,\n ) -> CubeFusionHandle<R>",
"start_line": ... | {
"class_name": "impl<R: CubeRuntime> ReduceFallbackFn<R> for FallbackReduce {\n fn run(\n &self,\n input: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n inst: &ReduceInstruction,\n d_o: &DType,\n d_a: &DType,\n ) -> CubeFusionHandle<R> {\n let d... |
reduce_dtype | burn-main/crates/burn-cubecl/src/fusion.rs | fn reduce_dtype(
input_handle: CubeFusionHandle<R>,
shape: &[usize],
axis: usize,
dtype_input: &DType,
dtype_output: &DType,
config: ReduceFnConfig,
) -> CubeFusionHandle<R> {
match dtype_input {
DType::F64 => {
reduce_dtype_output::<R, f64, Acc>(input_handle, shape, axis... | use crate::BoolElement;
use crate::element::CubeElement;
use crate::{CubeBackend, CubeRuntime, FloatElement, IntElement, kernel, tensor::CubeTensor};
use burn_cubecl_fusion::CubeFusionHandle;
use burn_cubecl_fusion::elemwise::optimization::ElemwiseOptimization;
use burn_cubecl_fusion::matmul::MatmulFallbackFn;
use bur... | rust | {
"argument_definitions": [],
"end_line": 214,
"name": "reduce_dtype",
"signature": "fn reduce_dtype(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n dtype_input: &DType,\n dtype_output: &DType,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R>",
"start_line": 167
... | {
"class_name": "",
"class_signature": ""
} |
reduce | burn-main/crates/burn-cubecl/src/fusion.rs | fn reduce(
input_handle: CubeFusionHandle<R>,
shape: &[usize],
axis: usize,
config: ReduceFnConfig,
) -> CubeFusionHandle<R> {
let input_tensor = into_tensor(
input_handle,
Shape {
dims: shape.to_vec(),
},
);
let out_tensor = crate::kernel::reduce::reduce_... | use crate::BoolElement;
use crate::element::CubeElement;
use crate::{CubeBackend, CubeRuntime, FloatElement, IntElement, kernel, tensor::CubeTensor};
use burn_cubecl_fusion::CubeFusionHandle;
use burn_cubecl_fusion::elemwise::optimization::ElemwiseOptimization;
use burn_cubecl_fusion::matmul::MatmulFallbackFn;
use bur... | rust | {
"argument_definitions": [],
"end_line": 265,
"name": "reduce",
"signature": "fn reduce(\n input_handle: CubeFusionHandle<R>,\n shape: &[usize],\n axis: usize,\n config: ReduceFnConfig,\n) -> CubeFusionHandle<R>",
"start_line": 238
} | {
"class_name": "",
"class_signature": ""
} |
expand | burn-main/crates/burn-cubecl/src/ops/base.rs | pub(crate) fn expand(tensor: CubeTensor<R>, target_shape: Shape) -> CubeTensor<R> {
let ndims_in = tensor.shape.num_dims();
let ndims_out = target_shape.num_dims();
// Initialize new strides with zeros
let mut new_strides = vec![0usize; ndims_out];
// Calculate the difference in dimensions
let... | use crate::{CubeRuntime, element::CubeElement, kernel, tensor::CubeTensor};
use burn_tensor::{Shape, TensorData};
use cubecl::tensor_vectorization_factor;
pub(crate) fn from_data<R: CubeRuntime>(data: TensorData, device: &R::Device) -> CubeTensor<R> {
let shape: Shape = (&data.shape).into();
let client = R::cl... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
float_powf_scalar | burn-main/crates/burn-cubecl/src/ops/float_ops.rs | fn float_powf_scalar(lhs: FloatTensor<Self>, rhs: f32) -> FloatTensor<Self> {
struct Powf;
#[cube]
impl<F: Float> FloatUnaryOp<F> for Powf {
type Options = F;
fn execute(input: Line<F>, options: &Self::Options) -> Line<F> {
Line::powf(input, Line::new(*o... | use super::{expand, numeric, permute};
use crate::kernel::prng::{random_bernoulli, random_normal, random_uniform};
use crate::kernel::unary_basic::BasicFloatUnaryKind;
use crate::kernel::{
self, FloatUnaryOp, FloatUnaryOpFamily, launch_unary_float, reduce, unary_basic,
};
use crate::{CubeBackend, execute_with_dtype... | rust | {
"argument_definitions": [
{
"definitions": [
"{\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n match data.dtype {\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\n super::from_data::<R>(data, device)\n ... | {
"class_name": "impl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\nwhere\n R: CubeRuntime,\n F: FloatElement,\n I: IntElement,\n BT: BoolElement,\n{\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n match data.dtype {\n DType::F6... |
float_cast | burn-main/crates/burn-cubecl/src/ops/float_ops.rs | fn float_cast(tensor: FloatTensor<Self>, dtype: FloatDType) -> FloatTensor<Self> {
match (tensor.dtype, dtype) {
(DType::F64, FloatDType::F64)
| (DType::F32, FloatDType::F32)
| (DType::BF16, FloatDType::BF16)
| (DType::F16, FloatDType::F16) => tensor,
... | use super::{expand, numeric, permute};
use crate::kernel::prng::{random_bernoulli, random_normal, random_uniform};
use crate::kernel::unary_basic::BasicFloatUnaryKind;
use crate::kernel::{
self, FloatUnaryOp, FloatUnaryOpFamily, launch_unary_float, reduce, unary_basic,
};
use crate::{CubeBackend, execute_with_dtype... | rust | {
"argument_definitions": [
{
"definitions": [
"{\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n match data.dtype {\n DType::F64 | DType::F32 | DType::F16 | DType::BF16 => {\n super::from_data::<R>(data, device)\n ... | {
"class_name": "impl<R, F, I, BT> FloatTensorOps<Self> for CubeBackend<R, F, I, BT>\nwhere\n R: CubeRuntime,\n F: FloatElement,\n I: IntElement,\n BT: BoolElement,\n{\n fn float_from_data(data: TensorData, device: &Device<Self>) -> FloatTensor<Self> {\n match data.dtype {\n DType::F6... |
new_contiguous | burn-main/crates/burn-cubecl/src/tensor/base.rs | pub fn new_contiguous(
client: ComputeClient<R::Server, R::Channel>,
device: R::Device,
shape: Shape,
handle: Handle,
dtype: DType,
) -> Self {
let ndims = shape.num_dims();
let mut strides = vec![0; ndims];
let mut current = 1;
shape
... | use crate::CubeRuntime;
use crate::element::CubeElement;
use crate::kernel::{NumericUnaryOp, NumericUnaryOpFamily, launch_unary_numeric};
use burn_common::tensor::is_contiguous;
use burn_tensor::quantization::QTensorPrimitive;
use burn_tensor::{DType, Shape, TensorMetadata};
use cubecl::client::ComputeClient;
use cubec... | rust | {
"argument_definitions": [],
"end_line": 312,
"name": "new_contiguous",
"signature": "pub fn new_contiguous(\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n shape: Shape,\n handle: Handle,\n dtype: DType,\n ) -> Self",
"start_line": 283
} | {
"class_name": "impl<R> CubeTensor<R>\nwhere\n R: CubeRuntime,\n{\n /// Create a new tensor with a contiguous memory layout.\n pub fn new_contiguous(\n client: ComputeClient<R::Server, R::Channel>,\n device: R::Device,\n shape: Shape,\n handle: Handle,\n dtype: DType,\n ... |
launch_binop | burn-main/crates/burn-cubecl/src/kernel/binary.rs | pub(crate) fn launch_binop(
lhs: CubeTensor<R>,
rhs: CubeTensor<R>,
) -> CubeTensor<R> {
let ndims = lhs.shape.num_dims();
let line_size_lhs = tensor_line_size_parallel(
R::line_size_elem(&E::as_elem_native_unchecked()),
&lhs.shape.dims,
&lhs.strides,
ndims - 1,
);
... | use std::marker::PhantomData;
use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};
use burn_tensor::Shape;
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
use super::into_contiguous;
pu... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_scalar_binop | burn-main/crates/burn-cubecl/src/kernel/binary.rs | pub(crate) fn launch_scalar_binop(
mut tensor: CubeTensor<R>,
scalar: E,
) -> CubeTensor<R> {
if !tensor.is_contiguous_buffer() {
tensor = into_contiguous(tensor);
}
// Vectorization is only enabled when the last dimension is contiguous.
let ndims = tensor.shape.num_dims();
let line... | use std::marker::PhantomData;
use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};
use burn_tensor::Shape;
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
use super::into_contiguous;
pu... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_cmp | burn-main/crates/burn-cubecl/src/kernel/comparison.rs | pub(crate) fn launch_cmp(
lhs: CubeTensor<R>,
rhs: CubeTensor<R>,
) -> CubeTensor<R> {
let ndims = lhs.shape.num_dims();
let vectorization_factor_lhs =
tensor_vectorization_factor(&[4, 2], &lhs.shape.dims, &lhs.strides, ndims - 1);
let vectorization_factor_rhs =
tensor_vectorization_... | use std::marker::PhantomData;
use crate::{
BoolElement, CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor,
};
use burn_tensor::Shape;
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_vectorization_factor,
};
use super... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_scalar_cmp | burn-main/crates/burn-cubecl/src/kernel/comparison.rs | pub(crate) fn launch_scalar_cmp(
mut tensor: CubeTensor<R>,
scalar: E,
) -> CubeTensor<R> {
if !tensor.is_contiguous_buffer() {
tensor = into_contiguous(tensor);
}
let ndims = tensor.shape.num_dims();
// Vectorization is only enabled when the last dimension is contiguous.
let vector... | use std::marker::PhantomData;
use crate::{
BoolElement, CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor,
};
use burn_tensor::Shape;
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_vectorization_factor,
};
use super... | rust | {
"argument_definitions": [],
"end_line": 288,
"name": "launch_scalar_cmp",
"signature": "pub(crate) fn launch_scalar_cmp(\n mut tensor: CubeTensor<R>,\n scalar: E,\n) -> CubeTensor<R>",
"start_line": 227
} | {
"class_name": "",
"class_signature": ""
} |
launch_unary_float | burn-main/crates/burn-cubecl/src/kernel/unary_float.rs | pub(crate) fn launch_unary_float(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R> {
let ndims = tensor.shape.num_dims();
let line_size = tensor_line_size_parallel(
R::line_size_elem(&E::as_elem_native_unchecked()),
&tensor.shape.dims,
&tensor.strides,
ndims - 1,
);
le... | use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
pub(crate) trait FloatUnaryOpFamily: 'static + Send + Sync {
type Options<F: Float... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_unary_int | burn-main/crates/burn-cubecl/src/kernel/unary_int.rs | pub(crate) fn launch_unary_int(tensor: CubeTensor<R>, args: Args) -> CubeTensor<R> {
let ndims = tensor.shape.num_dims();
let line_size = tensor_line_size_parallel(
R::line_size_elem(&E::as_elem_native_unchecked()),
&tensor.shape.dims,
&tensor.strides,
ndims - 1,
);
let c... | use crate::{CubeRuntime, IntElement, ops::numeric::empty_device, tensor::CubeTensor};
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
pub(crate) trait IntUnaryOpFamily: 'static + Send + Sync {
type Options<I: Int>: LaunchArg;
... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_unary_numeric | burn-main/crates/burn-cubecl/src/kernel/unary_numeric.rs | pub(crate) fn launch_unary_numeric(
tensor: CubeTensor<R>,
args: Args,
) -> CubeTensor<R> {
let ndims = tensor.shape.num_dims();
let line_size = tensor_line_size_parallel(
R::line_size_elem(&E::as_elem_native_unchecked()),
&tensor.shape.dims,
&tensor.strides,
ndims - 1,
... | use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
pub(crate) trait NumericUnaryOpFamily: 'static + Send + Sync {
type Options<N: Num... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_binop_int | burn-main/crates/burn-cubecl/src/kernel/binary_int.rs | pub(crate) fn launch_binop_int(
lhs: CubeTensor<R>,
rhs: CubeTensor<R>,
) -> CubeTensor<R> {
let ndims = lhs.shape.num_dims();
let line_size_lhs = tensor_line_size_parallel(
R::line_size_elem(&E::as_elem_native_unchecked()),
&lhs.shape.dims,
&lhs.strides,
ndims - 1,
)... | use crate::{CubeRuntime, IntElement, ops::numeric::empty_device, tensor::CubeTensor};
use burn_tensor::Shape;
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
use super::into_contiguous;
pub(crate) trait BinaryOpIntFamily: Send + ... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
launch_scalar_binop_int | burn-main/crates/burn-cubecl/src/kernel/binary_int.rs | pub(crate) fn launch_scalar_binop_int(
mut tensor: CubeTensor<R>,
scalar: E,
) -> CubeTensor<R> {
if !tensor.is_contiguous_buffer() {
tensor = into_contiguous(tensor);
}
// Vectorization is only enabled when the last dimension is contiguous.
let ndims = tensor.shape.num_dims();
let ... | use crate::{CubeRuntime, IntElement, ops::numeric::empty_device, tensor::CubeTensor};
use burn_tensor::Shape;
use cubecl::{
calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*,
tensor_line_size_parallel,
};
use super::into_contiguous;
pub(crate) trait BinaryOpIntFamily: Send + ... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
random | burn-main/crates/burn-cubecl/src/kernel/prng/base.rs | pub(crate) fn random(
shape: Shape,
device: &R::Device,
prng: P,
) -> CubeTensor<R> {
let client = R::client(device);
let output = empty_device::<R, E>(client.clone(), device.clone(), shape);
let seeds = get_seeds();
let args = prng.args();
let cube_dim = CubeDim::default();
let cub... | use cubecl::prelude::*;
use crate::{CubeElement, CubeRuntime, SEED, ops::numeric::empty_device, tensor::CubeTensor};
use burn_common::rand::get_seeded_rng;
use burn_tensor::Shape;
use rand::Rng;
pub(crate) const N_VALUES_PER_THREAD: usize = 128;
/// Pseudo-random generator
pub(crate) fn random<P: PrngRuntime<E>, R: ... | rust | {
"argument_definitions": [],
"end_line": 38,
"name": "random",
"signature": "pub(crate) fn random(\n shape: Shape,\n device: &R::Device,\n prng: P,\n) -> CubeTensor<R>",
"start_line": 11
} | {
"class_name": "",
"class_signature": ""
} |
mask_fill_readonly | burn-main/crates/burn-cubecl/src/kernel/mask/mask_fill.rs | fn mask_fill_readonly(
input: CubeTensor<R>,
mask: CubeTensor<R>,
value: EI,
) -> CubeTensor<R> {
let ndims = input.shape.num_dims();
let output = empty_device::<R, EI>(
input.client.clone(),
input.device.clone(),
input.shape.clone(),
);
let cube_dim = CubeDim::defau... | use cubecl::{calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*};
use crate::{
BoolElement, CubeRuntime,
element::CubeElement,
ops::{max_line_size, numeric::empty_device},
tensor::CubeTensor,
};
#[cube(launch)]
fn mask_fill_readonly_kernel<T: Numeric, B: Int>(
inpu... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
mask_where_readonly | burn-main/crates/burn-cubecl/src/kernel/mask/mask_where.rs | fn mask_where_readonly(
input: CubeTensor<R>,
mask: CubeTensor<R>,
value: CubeTensor<R>,
) -> CubeTensor<R> {
let ndims = input.shape.num_dims();
let output = empty_device::<R, EI>(
input.client.clone(),
input.device.clone(),
input.shape.clone(),
);
let cube_dim = Cu... | use cubecl::{calculate_cube_count_elemwise, linalg::tensor::index_offset_with_layout, prelude::*};
use crate::{
BoolElement, CubeRuntime,
element::CubeElement,
ops::{max_line_size, numeric::empty_device},
tensor::CubeTensor,
};
#[cube(launch)]
fn mask_where_readonly_kernel<T: CubePrimitive, B: Int>(
... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
interpolate_nearest_backward_launch | burn-main/crates/burn-cubecl/src/kernel/interpolate/nearest_backward.rs | pub(crate) fn interpolate_nearest_backward_launch(
out_grad: CubeTensor<R>,
output: CubeTensor<R>,
) -> CubeTensor<R> {
let line_size = max_line_size(&out_grad);
let out_shape = shape_divmod(&output);
let out_layout = strided_layout(&output);
let cube_dim = CubeDim::default();
let cube_coun... | use cubecl::{calculate_cube_count_elemwise, linalg::tensor::StridedLayout, prelude::*};
use cubecl_std::FastDivmod;
use crate::{
CubeRuntime, FloatElement,
kernel::utils::{shape_divmod, strided_layout},
ops::max_line_size,
tensor::CubeTensor,
};
#[cube(launch_unchecked)]
fn interpolate_nearest_backwar... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
dequantize | burn-main/crates/burn-cubecl/src/kernel/quantization/dequantize.rs | pub fn dequantize(tensor: CubeTensor<R>) -> CubeTensor<R> {
// The actual number of elements is 1/4 (four int8 values packed in a single u32)
// so we choose a line size to match a valid input binding size.
let num_out_elems = tensor.shape.num_elements();
let num_elems = usize::div_ceil(num_out_elems, 4... | use crate::tensor::CubeTensor;
use crate::{CubeElement, CubeRuntime};
use burn_tensor::DType;
use burn_tensor::quantization::{QuantizationMode, QuantizationScheme, QuantizationType};
use cubecl::calculate_cube_count_elemwise;
use cubecl::prelude::*;
use super::{QParams, QTensor};
#[cube]
fn dequantize_symmetric_int8<... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
create_quantized_output | burn-main/crates/burn-cubecl/src/kernel/quantization/quantize.rs | fn create_quantized_output(
client: ComputeClient<R::Server, R::Channel>,
num_input_elems: usize,
device: R::Device,
shape: Shape,
scheme: QuantizationScheme,
) -> CubeTensor<R> {
// Output tensor contains 4x less elements (four int8 values packed in a single u32)
let output_elems_size = usi... | use crate::tensor::CubeTensor;
use crate::{CubeElement, CubeRuntime, IntElement};
use burn_tensor::Shape;
use burn_tensor::quantization::{QuantizationMode, QuantizationScheme, QuantizationType};
use cubecl::calculate_cube_count_elemwise;
use cubecl::prelude::*;
#[cube]
fn pack_i8s_to_u32s(value: Line<u32>) -> u32 {
... | rust | {
"argument_definitions": [],
"end_line": 113,
"name": "create_quantized_output",
"signature": "fn create_quantized_output(\n client: ComputeClient<R::Server, R::Channel>,\n num_input_elems: usize,\n device: R::Device,\n shape: Shape,\n scheme: QuantizationScheme,\n) -> CubeTensor<R>",
"start_l... | {
"class_name": "",
"class_signature": ""
} |
quantize | burn-main/crates/burn-cubecl/src/kernel/quantization/quantize.rs | pub fn quantize(
tensor: CubeTensor<R>,
scheme: &QuantizationScheme,
scale: CubeTensor<R>,
) -> CubeTensor<R> {
let client = tensor.client.clone();
// Output tensor contains 4x less elements (four int8 values packed in a single u32)
let num_elems = tensor.shape.num_elements();
// Force vect... | use crate::tensor::CubeTensor;
use crate::{CubeElement, CubeRuntime, IntElement};
use burn_tensor::Shape;
use burn_tensor::quantization::{QuantizationMode, QuantizationScheme, QuantizationType};
use cubecl::calculate_cube_count_elemwise;
use cubecl::prelude::*;
#[cube]
fn pack_i8s_to_u32s(value: Line<u32>) -> u32 {
... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
slice | burn-main/crates/burn-cubecl/src/kernel/index/slice.rs | pub fn slice(
tensor: CubeTensor<R>,
indices: &[Range<usize>],
) -> CubeTensor<R> {
let mut dims = tensor.shape.dims.clone();
let mut offset_start = 0u64;
let mut offset_end = 0u64;
for i in 0..indices.len() {
offset_start += (tensor.strides[i] * indices[i].start) as u64;
offset... | use crate::{CubeRuntime, element::CubeElement, ops::numeric::empty_device, tensor::CubeTensor};
use burn_tensor::Shape;
use cubecl::{calculate_cube_count_elemwise, prelude::*};
use std::ops::Range;
/// Slice a jit tensor with a set of ranges
pub fn slice<R: CubeRuntime, E: CubeElement>(
tensor: CubeTensor<R>,
... | rust | {
"argument_definitions": [
{
"definitions": [
"pub struct CubeTensor<R: CubeRuntime> {\n /// Compute client for the [runtime](CubeRuntime).\n pub client: ComputeClient<R::Server, R::Channel>,\n /// The buffer where the data are stored.\n pub handle: Handle,\n /// The shape of the ten... | {
"class_name": "",
"class_signature": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.